elementquad.hpp

Go to the documentation of this file.

// Class to create and store values of cell and edge basis functions on quadrature points
//
//
// Author: Jerome Droniou (jerome.droniou@monash.edu)
//
 
/*
 *
 *  This library was developed around HHO methods, although some parts of it have a more
 * general purpose. If you use this code or part of it in a scientific publication, 
 * please mention the following book as a reference for the underlying principles
 * of HHO schemes:
 *
 * The Hybrid High-Order Method for Polytopal Meshes: Design, Analysis, and Applications. 
 *  D. A. Di Pietro and J. Droniou. Modeling, Simulation and Applications, vol. 19. 
 *  Springer International Publishing, 2020, xxxi + 525p. doi: 10.1007/978-3-030-37203-3. 
 *  url: https://hal.archives-ouvertes.fr/hal-02151813.
 *
 */
 
#ifndef ELEMENTQUAD_HPP
#define ELEMENTQUAD_HPP
 
#include <iostream>
#include <Eigen/Dense>
#include <hybridcore.hpp>
#include <quadraturerule.hpp>
 
 
namespace HArDCore2D {
 
  // ----------------------------------------------------------------------------
  //                            Class definition
  // ----------------------------------------------------------------------------
 
  class ElementQuad {
 
  public:
    ElementQuad(
        const HybridCore& hho, 
        const size_t iT, 
        const size_t doeT, 
        const size_t doeF 
        ); 
 
    inline const QuadratureRule & get_quadT() const 
      { 
        return m_quadT; 
      };
 
    inline const QuadratureRule & get_quadF(size_t ilF) const
      {
        return m_quadF[ilF]; 
      };
 
    inline const boost::multi_array<double, 2> & get_phiT_quadT() const
    { 
      return m_phiT_quadT; 
    };
 
    inline const boost::multi_array<VectorRd, 2> & get_dphiT_quadT() const
    {
      return m_dphiT_quadT;
    };
 
    inline const boost::multi_array<double, 2> & get_phiT_quadF(size_t ilF) const
    {
      return m_phiT_quadF[ilF];
    };
 
    inline const boost::multi_array<double, 2> get_phiF_quadF(size_t ilF) const
    { 
      return m_phiF_quadF[ilF];       
    };
 
    inline const boost::multi_array<VectorRd, 2> & get_dphiT_quadF(size_t ilF) const
    {
      return m_dphiT_quadF[ilF];
    };
 
 
    boost::multi_array<VectorRd, 2> get_vec_phiT_quadT(
      size_t degree   
    ) const; 
 
    boost::multi_array<VectorRd, 2> get_vec_phiT_quadF(
        size_t ilF,   
        size_t degree   
    ) const; 
 
    boost::multi_array<VectorRd, 2> get_vec_phiF_quadF(
        size_t ilF,   
        size_t degree   
     ) const; 
 
 
  private:
    const HybridCore& m_hcore;  // reference to the hybridcore instance
    const size_t m_iT; // cell number
    const size_t m_doeT; // degree of exactness of cell quadrature rules
    const size_t m_doeF; // degree of exactness of edge quadrature rules
 
    const Cell& m_T;
    QuadratureRule m_quadT;
 
    boost::multi_array<double, 2> m_phiT_quadT;
    boost::multi_array<VectorRd, 2> m_dphiT_quadT;
    boost::multi_array<VectorRd, 2> m_vec_phiT_quadT;
 
    std::vector<QuadratureRule> m_quadF;
 
    std::vector<boost::multi_array<double, 2>> m_phiT_quadF;
    std::vector<boost::multi_array<double, 2>> m_phiF_quadF;
    std::vector<boost::multi_array<VectorRd, 2>> m_dphiT_quadF;
    std::vector<boost::multi_array<VectorRd, 2>> m_vec_phiT_quadF;
    std::vector<boost::multi_array<VectorRd, 2>> m_vec_phiF_quadF;
 
  };
 
 
 
}  // end of namespace HArDCore2D
 
#endif /* ELEMENTQUAD_HPP */