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>
namespace dftefe
{
  namespace quadrature
  {
    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 unsigned int 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 unsigned int cellId) const;
 
      const std::vector<dftefe::utils::Point> &
      getCellParametricPoints(const unsigned int cellId) const;
 
      const std::vector<double> &
      getCellQuadratureWeights(const unsigned int cellId) const;
 
      const std::vector<double> &
      getJxW() const;
 
      std::vector<double>
      getCellJxW(const unsigned int cellId) const;
 
      const QuadratureRule &
      getQuadratureRule(const unsigned int cellId) const;
 
      size_type
      nQuadraturePoints() const;
 
      size_type
      nCellQuadraturePoints(const unsigned int 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;
 
    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_JxW;
      unsigned int                                       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;
    };
  } // end of namespace quadrature
 
} // end of namespace dftefe
 
#endif // dftefeQuadratureRuleContainer_h