laxcurl.hpp

Go to the documentation of this file.

#ifndef LAXCURL_HPP
#define LAXCURL_HPP
 
#include <globaldofspace.hpp>
#include <xcurl.hpp>
#include <liealgebra.hpp>
 
namespace HArDCore3D
{
 
  class LAXCurl : public GlobalDOFSpace
  {
  public:
    typedef std::function<Eigen::Vector3d(const Eigen::Vector3d &)> FunctionType;
    typedef std::vector<FunctionType> LAFunctionType;
 
    inline const LieAlgebra & lieAlgebra() const
    {
      return m_lie_algebra;
    }
    inline const XCurl & xCurl() const
    {
      return m_xcurl;
    }
 
     struct LocalOperators
     {
       LocalOperators(
                      const Eigen::MatrixXd & _curl,     
                      const Eigen::MatrixXd & _potential 
                      )
         : curl(_curl),
           potential(_potential)
       {
         // Do nothing
     }
       Eigen::MatrixXd curl;
       Eigen::MatrixXd potential;
     };
 
    LAXCurl(const LieAlgebra & lie_algebra, const XCurl & xcurl, bool use_threads = true, std::ostream & output = std::cout);
    
    const Mesh & mesh() const
    {
      return m_xcurl.mesh();
    }
    
    const size_t & degree() const
    {
      return m_xcurl.degree();
    }
    
    Eigen::VectorXd interpolate(
                                const LAFunctionType & v, 
                                const int doe_cell = -1, 
                                const int doe_face = -1, 
                                const int doe_edge = -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 LocalOperators & faceOperators(size_t iF) const
    {
      return *m_face_operators[iF];
    }
 
    inline const LocalOperators & faceOperators(const Face & F) const
    {
      return * m_face_operators[F.global_index()];  
    }
 
    inline const DDRCore::CellBases & cellBases(size_t iT) const
    {
      return m_xcurl.cellBases(iT);
    }
 
    inline const DDRCore::CellBases & cellBases(const Cell & T) const
    {
      return m_xcurl.cellBases(T.global_index());
    }
    
    inline const DDRCore::FaceBases & faceBases(size_t iF) const
    {
      return m_xcurl.faceBases(iF);
    }
 
    inline const DDRCore::FaceBases & faceBases(const Face & F) const
    {
      return m_xcurl.faceBases(F.global_index());
    }
    
    inline const DDRCore::EdgeBases & edgeBases(size_t iE) const
    {
      return m_xcurl.edgeBases(iE);
    }
 
    inline const DDRCore::EdgeBases & edgeBases(const Edge & E) const
    {
      return m_xcurl.edgeBases(E.global_index());
    }
 
    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 computeL2ProductGradient(
                                      const size_t iT, 
                                      const XGrad & x_grad, 
                                      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;
 
  private:
    LocalOperators _compute_face_curl_potential(size_t iF);
    LocalOperators _compute_cell_curl_potential(size_t iT);
 
    const XCurl & m_xcurl;
    const LieAlgebra & m_lie_algebra;
    bool m_use_threads;
    std::ostream & m_output;
 
    // Containers for local operators
    std::vector<std::unique_ptr<LocalOperators> > m_cell_operators;
    std::vector<std::unique_ptr<LocalOperators> > m_face_operators;
 
  };
 
}// end of namespace HArDCore3D
 
#endif