QuadratureRuleContainer.h

Go to the documentation of this file.

#ifndef dftefeQuadratureRuleContainer_h
#define dftefeQuadratureRuleContainer_h
 
#include <quadrature/QuadratureRule.h>
#include <quadrature/QuadratureAttributes.h>
#include <utils/TypeConfig.h>
#include <utils/Point.h>
#include <utils/ScalarSpatialFunction.h>
#include <basis/TriangulationBase.h>
#include <basis/CellMappingBase.h>
#include <basis/ParentToChildCellsManagerBase.h>
#include <memory>
#include <utils/MPITypes.h>
#include <utils/MPIWrapper.h>
#include <quadrature/Defaults.h>
#include <utils/MemoryStorage.h>
namespace dftefe
{
  namespace quadrature
  {
    template <utils::MemorySpace memorySpace>
    struct FuncEvalTag
    {};
 
    class QuadratureRuleContainer
    {
    public:
      QuadratureRuleContainer(
        const QuadratureRuleAttributes &      quadratureRuleAttributes,
        std::shared_ptr<const QuadratureRule> quadratureRule,
        std::shared_ptr<const basis::TriangulationBase> triangulation,
        const basis::CellMappingBase &                  cellMapping);
 
      QuadratureRuleContainer(
        const QuadratureRuleAttributes &quadratureRuleAttributes,
        std::vector<std::shared_ptr<const QuadratureRule>> quadratureRuleVec,
        std::shared_ptr<const basis::TriangulationBase>    triangulation,
        const basis::CellMappingBase &                     cellMapping);
 
      QuadratureRuleContainer(
        const QuadratureRuleAttributes &      quadratureRuleAttributes,
        std::shared_ptr<const QuadratureRule> baseQuadratureRule,
        std::shared_ptr<const basis::TriangulationBase> triangulation,
        const basis::CellMappingBase &                  cellMapping,
        basis::ParentToChildCellsManagerBase &parentToChildCellsManager,
        std::vector<std::shared_ptr<const utils::ScalarSpatialFunctionReal>>
                                   functions,
        const std::vector<double> &absoluteTolerances,
        const std::vector<double> &relativeTolerances,
        const std::vector<double> &integralThresholds,
        const double               smallestCellVolume =
          QuadratureRuleAdaptiveDefaults::SMALLEST_CELL_VOLUME,
        const dftefe::size_type maxRecursion =
          QuadratureRuleAdaptiveDefaults::MAX_RECURSION);
 
      template <utils::MemorySpace memorySpace>
      QuadratureRuleContainer(
        FuncEvalTag<memorySpace>,
        const QuadratureRuleAttributes &      quadratureRuleAttributes,
        std::shared_ptr<const QuadratureRule> baseQuadratureRule,
        std::shared_ptr<const basis::TriangulationBase> triangulation,
        const basis::CellMappingBase &                  cellMapping,
        basis::ParentToChildCellsManagerBase &parentToChildCellsManager,
        std::vector<std::shared_ptr<const utils::ScalarSpatialFunctionReal>>
                                   functions,
        const std::vector<double> &absoluteTolerances,
        const std::vector<double> &relativeTolerances,
        const std::vector<double> &integralThresholds,
        const double               smallestCellVolume =
          QuadratureRuleAdaptiveDefaults::SMALLEST_CELL_VOLUME,
        const dftefe::size_type maxRecursion =
          QuadratureRuleAdaptiveDefaults::MAX_RECURSION);
 
      QuadratureRuleContainer(
        const QuadratureRuleAttributes &quadratureRuleAttributes,
        const size_type                 order1DMin,
        const size_type                 order1DMax,
        const size_type                 copies1DMax,
        std::shared_ptr<const basis::TriangulationBase> triangulation,
        const basis::CellMappingBase &                  cellMapping,
        std::vector<std::shared_ptr<const utils::ScalarSpatialFunctionReal>>
                                   functions,
        const std::vector<double> &absoluteTolerances,
        const std::vector<double> &relativeTolerances,
        const quadrature::QuadratureRuleContainer
          &                        quadratureRuleContainerReference,
        const utils::mpi::MPIComm &comm);
 
      ~QuadratureRuleContainer() = default;
 
      const QuadratureRuleAttributes &
      getQuadratureRuleAttributes() const;
 
      size_type
      nCells() const;
 
      const std::vector<dftefe::utils::Point> &
      getRealPoints() const;
 
      std::vector<dftefe::utils::Point>
      getCellRealPoints(const dftefe::size_type cellId) const;
 
      const std::vector<dftefe::utils::Point> &
      getCellParametricPoints(const dftefe::size_type cellId) const;
 
      const std::vector<double> &
      getCellQuadratureWeights(const dftefe::size_type cellId) const;
 
      const std::vector<double> &
      getJxW() const;
 
      std::vector<double>
      getCellJxW(const dftefe::size_type cellId) const;
 
      const QuadratureRule &
      getQuadratureRule(const dftefe::size_type cellId) const;
 
      size_type
      nQuadraturePoints() const;
 
      size_type
      nCellQuadraturePoints(const dftefe::size_type cellId) const;
 
      const std::vector<size_type> &
      getCellQuadStartIds() const;
 
      size_type
      getCellQuadStartId(const size_type cellId) const;
 
      std::shared_ptr<const basis::TriangulationBase>
      getTriangulation() const;
 
      const basis::CellMappingBase &
      getCellMapping() const;
 
      template <utils::MemorySpace memorySpace>
      inline const double *
      getRealPointsPtr() const
      {
        if constexpr (memorySpace == utils::MemorySpace::HOST)
          {
            return d_realPointsHost.data();
          }
        else
          {
#ifdef DFTEFE_WITH_DEVICE
            if (d_realPointsDevice == nullptr)
              {
                d_realPointsDevice = std::make_unique<
                  utils::MemoryStorage<double, utils::MemorySpace::DEVICE>>(
                  d_realPointsHost.size());
                d_realPointsDevice->copyFrom(d_realPointsHost);
              }
            return d_realPointsDevice->data();
#else
            static_assert(memorySpace == utils::MemorySpace::HOST,
                          "Device memory not available");
#endif
          }
      }
 
    private:
      const QuadratureRuleAttributes &d_quadratureRuleAttributes;
      std::vector<std::shared_ptr<const QuadratureRule>> d_quadratureRuleVec;
      std::vector<size_type>                             d_numCellQuadPoints;
      std::vector<size_type>                             d_cellQuadStartIds;
      std::vector<dftefe::utils::Point>                  d_realPoints;
      std::vector<double>                                d_realPointsHost;
      std::vector<double>                                d_JxW;
      dftefe::size_type                                  d_dim;
      size_type                                          d_numQuadPoints;
      size_type                                          d_numCells;
      bool                                               d_storeJacobianInverse;
      std::shared_ptr<const basis::TriangulationBase>    d_triangulation;
      const basis::CellMappingBase &                     d_cellMapping;
 
#ifdef DFTEFE_WITH_DEVICE
      mutable std::unique_ptr<
        utils::MemoryStorage<double, utils::MemorySpace::DEVICE>>
        d_realPointsDevice;
#endif
    };
  } // end of namespace quadrature
 
} // end of namespace dftefe
 
#endif // dftefeQuadratureRuleContainer_h