discrete-space-descriptor.hpp

Go to the documentation of this file.

// -*- C++ -*-
#ifndef DISCRETE_SPACE_DESCRIPTOR_HPP
#define DISCRETE_SPACE_DESCRIPTOR_HPP
 
#include <iostream>
 
#include <list>
#include <map>
 
#include <boost/fusion/include/sequence.hpp>
#include <boost/fusion/include/map.hpp>
 
#include <basis.hpp>
 
namespace HArDCore2D {
 
  namespace DSL {
    
    typedef Family<GradientBasis<ShiftedBasis<MonomialScalarBasisCell> > > GolyCellType; 
    typedef Family<GolyComplBasisCell> GolyComplCellType; 
    typedef Family<MonomialScalarBasisCell> PolyCellType; 
    typedef Family<MonomialScalarBasisEdge> PolyEdgeType; 
    typedef TensorizedVectorFamily<PolyCellType, dimspace> PolynCellType; 
    typedef TensorizedVectorFamily<Family<MonomialScalarBasisEdge>, dimspace> PolynEdgeType; 
    typedef MatrixFamily<PolyCellType, dimspace> PolynxnCellType;
    typedef VectorRd RealnVertexType; 
    typedef MatrixRd RealnxnVertexType; 
    typedef double RealVertexType; 
    typedef Family<CurlBasis<ShiftedBasis<MonomialScalarBasisCell> > > RolyCellType; 
    typedef Family<RolyComplBasisCell> RolyComplCellType;
    // TODO: Family of basis functions corresponding to symmetric gradient operator
    // Idea 1: try to build symmetric gradient basis from gradient of basis in each dimension
    // typedef Family<GradientBasis<ShiftedBasis<TensorizedVectorFamily<PolyCellType, dimspace> > > > SymPolynxnCellType;
    // Idea 2: since dimension of R_s^{dxd} is equal to nchoosek(d+1,2),
    // encode the basis of P^k(T;R_s^{dxd}) as a vector v of length nchoosek(d+1,2) and then
    // "unpack" the matrix basis as [ v[0] , v[1] ; v[1] , v[2] ]
    typedef TensorizedVectorFamily<PolyCellType, static_cast<size_t>(dimspace+1)> SymPolynxnCellType;
    
    typedef boost::fusion::vector<PolyCellType, PolyEdgeType, PolynCellType, PolynxnCellType, PolynEdgeType, RolyCellType, RolyComplCellType, GolyCellType, GolyComplCellType, RealVertexType, RealnVertexType, RealnxnVertexType, SymPolynxnCellType> LocalPolynomialSpaces;
 
    //------------------------------------------------------------------------------
  
    class DiscreteSpaceDescriptor {
    public:
      struct LocalPolynomialSpaceDescriptor
      {
        LocalPolynomialSpaceDescriptor(
                                       std::string _name,
                                       size_t _degree,
                                       bool _is_dof
                                       ) :
          name(_name),
          degree(_degree),
          is_dof(_is_dof)
        {
          // Do nothing
        }
        
        std::string name;
        size_t degree;
        bool is_dof;
      };
      
      DiscreteSpaceDescriptor(
                              const std::string & name,
                              const Mesh & mesh,
                              std::ostream & output = std::cout
                              );
 
      inline const std::string & name() const {
        return m_name;
      }
    
      inline const Mesh & mesh() const {
        return m_mesh;
      }
 
      inline std::ostream & output() {
        return m_output;
      }
 
      
      DiscreteSpaceDescriptor & addPolyCell(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addPolyCell(const std::string & name,size_t degree,  bool is_dof = false);
      
      DiscreteSpaceDescriptor & addPolyEdge(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addPolyEdge(const std::string & name,size_t degree,  bool is_dof = false);
      
      DiscreteSpaceDescriptor & addPolynCell(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addPolynCell(const std::string & name,size_t degree,  bool is_dof = false);
      
      DiscreteSpaceDescriptor & addPolynxnCell(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addPolynxnCell(const std::string & name,size_t degree,  bool is_dof = false);
      
      DiscreteSpaceDescriptor & addPolynEdge(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addPolynEdge(const std::string & name,size_t degree,  bool is_dof = false);
      
      DiscreteSpaceDescriptor & addRolyCell(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addRolyCell(const std::string & name,size_t degree,  bool is_dof = false);
      
      DiscreteSpaceDescriptor & addRolyComplCell(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addRolyComplCell(const std::string & name,size_t degree,  bool is_dof = false);
      
      DiscreteSpaceDescriptor & addGolyCell(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addGolyCell(const std::string & name,size_t degree,  bool is_dof = false);
      
      DiscreteSpaceDescriptor & addGolyComplCell(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addGolyComplCell(const std::string & name,size_t degree,  bool is_dof = false);
      
      DiscreteSpaceDescriptor & addRealVertex(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addRealVertex(const std::string & name, bool is_dof = false);
      
      DiscreteSpaceDescriptor & addRealnVertex(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addRealnVertex(const std::string & name, bool is_dof = false);
      
      DiscreteSpaceDescriptor & addRealnxnVertex(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addRealnxnVertex(const std::string & name, bool is_dof = false);
      
      DiscreteSpaceDescriptor & addSymPolynxnCell(const LocalPolynomialSpaceDescriptor & descriptor);
      
      DiscreteSpaceDescriptor & addSymPolynxnCell(const std::string & name, size_t degree, bool is_dof = false);
      
 
      size_t numberOfLocalCellDofs() const
      {
        return m_n_cell_dofs;
      }
 
      size_t numberOfLocalCellDofs(const std::string & dof_name) const
      {
        return m_cell_dofs.at(dof_name);
      }
      
      size_t numberOfLocalEdgeDofs() const
      {
        return m_n_edge_dofs;
      }
 
      size_t numberOfLocalEdgeDofs(const std::string & dof_name) const
      {
        return m_edge_dofs.at(dof_name);
      }
 
      size_t numberOfLocalVertexDofs() const
      {
        return m_n_vertex_dofs;
      }
      
      size_t numberOfLocalVertexDofs(const std::string & dof_name) const
      {
        return m_vertex_dofs.at(dof_name);
      }      
 
      template<typename T>
      const std::list<LocalPolynomialSpaceDescriptor> & getDescriptor() const
      {
        return boost::fusion::at_key<T>(m_dofs);
      }
 
      const std::map<std::string, size_t> & cellDofs() const {
        return m_cell_dofs;
      }
 
      const std::map<std::string, size_t> & edgeDofs() const {
        return m_edge_dofs;      
      }
 
      const std::map<std::string, size_t> & vertexDofs() const {
        return m_vertex_dofs;
      }
 
    private:
      std::string m_name;
      const Mesh & m_mesh;
      std::ostream & m_output;
 
      std::map<std::string, size_t> m_cell_dofs;
      std::map<std::string, size_t> m_edge_dofs;
      std::map<std::string, size_t> m_vertex_dofs;
 
      // TO BE REMOVED WHEN THE NEW IMPLEMENTATION IS COMPLETE
      size_t m_n_cell_dofs;
      size_t m_n_edge_dofs;
      size_t m_n_vertex_dofs;
 
      boost::fusion::map<
                         boost::fusion::pair<PolyCellType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<PolyEdgeType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<PolynCellType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<PolynxnCellType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<PolynEdgeType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<RolyCellType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<RolyComplCellType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<GolyCellType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<GolyComplCellType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<RealVertexType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<RealnVertexType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<RealnxnVertexType, std::list<LocalPolynomialSpaceDescriptor> >,
                         boost::fusion::pair<SymPolynxnCellType, std::list<LocalPolynomialSpaceDescriptor> >
                         > m_dofs;
    };
 
    DiscreteSpaceDescriptor::LocalPolynomialSpaceDescriptor make_dof(const std::string name, size_t degree);
 
  } // namespace DSL
} // namespace HArDCore2D
#endif