xrot.hpp

Go to the documentation of this file.

#ifndef XROT_HPP
#define XROT_HPP
 
#include <globaldofspace.hpp>
#include <ddrcore.hpp>
#include <integralweight.hpp>
#include <xrotrot.hpp>
 
namespace HArDCore2D
{
  class XRot : public GlobalDOFSpace
  {
  public:
    typedef std::function<double(const Eigen::Vector2d &)> FunctionType;
 
    struct LocalOperators
    {
      LocalOperators(
                     const Eigen::MatrixXd & _rotor,     
                     const Eigen::MatrixXd & _rotor_rhs, 
                     const Eigen::MatrixXd & _potential  
                     )
        : rotor(_rotor),
      rotor_rhs(_rotor_rhs),
          potential(_potential)
      {
        // Do nothing
      }
      
      Eigen::MatrixXd rotor;
      Eigen::MatrixXd rotor_rhs;
      Eigen::MatrixXd potential;
    };
    
    XRot(const DDRCore & ddr_core, bool use_threads = true, std::ostream & output = std::cout);
 
    const Mesh & mesh() const
    {
      return m_ddr_core.mesh();
    }
 
    const bool useThreads() const
    {
      return m_use_threads;
    }
    
    const size_t & degree() const
    {
      return m_ddr_core.degree();
    }
    
    Eigen::VectorXd interpolate(
                                const FunctionType & q, 
                                const int deg_quad = -1 
                                ) const;
 
    inline const Eigen::MatrixXd & edgePotential(size_t iE) const
    {
      return *m_edge_potentials[iE];
    }
 
    inline const Eigen::MatrixXd & edgePotential(const Edge& E) const
    {
      return *m_edge_potentials[E.global_index()];
    }
 
    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_ddr_core.cellBases(iT);
    }
 
    inline const DDRCore::CellBases & cellBases(const Cell & T) const
    {
      return m_ddr_core.cellBases(T.global_index());
    }
    
    inline const DDRCore::EdgeBases & edgeBases(size_t iE) const
    {
      return m_ddr_core.edgeBases(iE);
    }
 
    inline const DDRCore::EdgeBases & edgeBases(const Edge & E) const
    {
      return m_ddr_core.edgeBases(E.global_index());
    }
 
    Eigen::MatrixXd computeRotorL2Product(
                      const size_t iT,                         
                      const double & penalty_factor_cell = 1., 
                                          const double & penalty_factor_edge = 1.  
                                          
                      ) const;
 
    double computeRotorL2Norm(const Eigen::VectorXd & v) const;
    
  private:    
    Eigen::MatrixXd _compute_edge_potential(size_t iE);
    LocalOperators  _compute_cell_operators(size_t iT);
 
    const DDRCore & m_ddr_core;
    bool m_use_threads;
    std::ostream & m_output;
 
    // Containers for local operators
    std::vector<std::unique_ptr<Eigen::MatrixXd> > m_edge_potentials;
    std::vector<std::unique_ptr<LocalOperators> > m_cell_operators;
  };
   
} // end of namespace HArDCore2D
 
#endif