laxdiv.hpp

Go to the documentation of this file.

#ifndef LAXDIV_HPP
#define LAXDIV_HPP
 
#include <globaldofspace.hpp>
#include <xdiv.hpp>
#include <liealgebra.hpp>
 
namespace HArDCore3D
{
 
  class LAXDiv : public GlobalDOFSpace
  {
  public:
 
    typedef std::function<Eigen::Vector3d(const Eigen::Vector3d &)> FunctionType;
    typedef std::vector<FunctionType> LAFunctionType;
 
    struct LocalOperators
    {
      LocalOperators(
             const Eigen::MatrixXd & _divergence,     
             const Eigen::MatrixXd & _divergence_rhs, 
             const Eigen::MatrixXd & _potential       
             )
        : divergence(_divergence),
          divergence_rhs(_divergence_rhs),
          potential(_potential)
      {
          // Do nothing
      }
 
      Eigen::MatrixXd divergence;
      Eigen::MatrixXd divergence_rhs;
      Eigen::MatrixXd potential;
    };
 
    LAXDiv(const LieAlgebra & lie_algebra, const XDiv & xdiv, bool use_threads = true, std::ostream & output = std::cout);
 
    const Mesh & mesh() const
    {
      return m_xdiv.mesh();
    }
    
    const size_t & degree() const
    {
      return m_xdiv.degree();
    }
 
    Eigen::VectorXd interpolate(
          const LAFunctionType & v, 
          const int doe_cell = -1, 
          const int doe_face = -1 
                ) const;
    
    inline const LocalOperators & cellOperators(size_t iT) const
    {
      return *m_cell_operators[iT];
    }
 
    inline const LocalOperators & cellOperators(const Cell & T) const
    {
      return * m_cell_operators[T.global_index()];  
    }
 
    inline const DDRCore::CellBases & cellBases(size_t iT) const
    {
      return m_xdiv.cellBases(iT);
    }
 
    inline const DDRCore::CellBases & cellBases(const Cell & T) const
    {
      return m_xdiv.cellBases(T.global_index());
    }
    
    inline const DDRCore::FaceBases & faceBases(size_t iF) const
    {
      return m_xdiv.faceBases(iF);
    }
 
    inline const DDRCore::FaceBases & faceBases(const Face & F) const
    {
      return m_xdiv.faceBases(F.global_index());
    }
    
    // The mass matrix of P^k(T)^3 is the most expensive mass matrix in the calculation of this norm, which
    // is why there's the option of passing it as parameter if it's been already pre-computed when the norm is called.
    Eigen::MatrixXd computeL2Product(
                                     const size_t iT, 
                                     const double & penalty_factor = 1., 
                                     const Eigen::MatrixXd & mass_Pk3_T = Eigen::MatrixXd::Zero(1,1), 
                                     const IntegralWeight & weight = IntegralWeight(1.) 
                                     ) const;
                                     
    Eigen::MatrixXd computeL2ProductCurl(
                                     const size_t iT, 
                                     const XCurl & x_curl, 
                                     const std::string & side, 
                                     const double & penalty_factor = 1., 
                                     const Eigen::MatrixXd & mass_Pk3_T = Eigen::MatrixXd::Zero(1,1), 
                                     const IntegralWeight & weight = IntegralWeight(1.) 
                                     ) const;
 
  protected:
    LocalOperators _compute_cell_divergence_potential(size_t iT);
 
    const LieAlgebra & m_lie_algebra;
    const XDiv & m_xdiv;
    bool m_use_threads;
    std::ostream & m_output;
 
    // Containers for local operators
    std::vector<std::unique_ptr<LocalOperators> > m_cell_operators;
  };
} // end of namespace HArDCore3D
 
#endif