discrete-space.hpp

Go to the documentation of this file.

// -*- C++ -*-
#ifndef DISCRETE_SPACE_HPP
#define DISCRETE_SPACE_HPP
 
#include <iostream>
 
#include "global-dof-table.hpp"
 
namespace HArDCore2D {
 
  namespace DSL {
    
    //------------------------------------------------------------------------------
    
    bool compare_degrees(const DiscreteSpaceDescriptor::LocalPolynomialSpaceDescriptor & P1,
                         const DiscreteSpaceDescriptor::LocalPolynomialSpaceDescriptor & P2);
 
    //------------------------------------------------------------------------------
  
    class DiscreteSpace : public GlobalDOFTable {
    public:
      
      typedef std::vector<std::unique_ptr<PolyCellType> > PolyCellContainerType;
      typedef std::vector<std::unique_ptr<PolyEdgeType> > PolyEdgeContainerType;
      typedef std::vector<std::unique_ptr<PolynCellType> > PolynCellContainerType;
      typedef std::vector<std::unique_ptr<PolynxnCellType> > PolynxnCellContainerType;
      typedef std::vector<std::unique_ptr<PolynEdgeType> > PolynEdgeContainerType;
      typedef std::vector<std::unique_ptr<RolyCellType> > RolyCellContainerType;
      typedef std::vector<std::unique_ptr<RolyComplCellType> > RolyComplCellContainerType;
      typedef std::vector<std::unique_ptr<GolyCellType> > GolyCellContainerType;
      typedef std::vector<std::unique_ptr<GolyComplCellType> > GolyComplCellContainerType;
      typedef std::vector<std::unique_ptr<RealVertexType> > RealVertexContainerType;
      typedef std::vector<std::unique_ptr<RealnVertexType> > RealnVertexContainerType;
      typedef std::vector<std::unique_ptr<RealnxnVertexType> > RealnxnVertexContainerType;
      typedef std::vector<std::unique_ptr<SymPolynxnCellType> > SymPolynxnCellContainerType;
      typedef boost::fusion::map<
      boost::fusion::pair<PolyCellType, std::map<std::string, PolyCellContainerType> >,
      boost::fusion::pair<PolyEdgeType, std::map<std::string, PolyEdgeContainerType> >,
      boost::fusion::pair<PolynCellType, std::map<std::string, PolynCellContainerType> >,
      boost::fusion::pair<PolynxnCellType, std::map<std::string, PolynxnCellContainerType> >,
      boost::fusion::pair<PolynEdgeType, std::map<std::string, PolynEdgeContainerType> >,
      boost::fusion::pair<RolyCellType, std::map<std::string, RolyCellContainerType> >,
      boost::fusion::pair<RolyComplCellType, std::map<std::string, RolyComplCellContainerType> >,
      boost::fusion::pair<GolyCellType, std::map<std::string, GolyCellContainerType> >,
      boost::fusion::pair<GolyComplCellType, std::map<std::string, GolyComplCellContainerType> >,
      boost::fusion::pair<RealVertexType, std::map<std::string, RealVertexContainerType> >,
      boost::fusion::pair<RealnVertexType, std::map<std::string, RealnVertexContainerType> >,
      boost::fusion::pair<RealnxnVertexType, std::map<std::string, RealnxnVertexContainerType> >,
      boost::fusion::pair<SymPolynxnCellType, std::map<std::string, SymPolynxnCellContainerType> >
                          > LocalSpacesContainerType;
      
      DiscreteSpace(
                    const DiscreteSpaceDescriptor & descriptor,
                    bool use_threads = true,
                    std::ostream & output = std::cout
                    );
 
      const DiscreteSpaceDescriptor & descriptor() const
      {
        return m_descriptor;
      }
      
      const std::string & name() const
      {
        return m_descriptor.name();
      }
 
      const Mesh & mesh() const
      {
        return m_descriptor.mesh();
      }
 
      // Getters
      template<typename T>
      inline bool isAvailable(const std::string & name) const
      {
        if ( !boost::fusion::has_key<T>(m_local_spaces) ) {
          return false;
        }
        return boost::fusion::at_key<T>(m_local_spaces).contains(name);
      }
      
      template<typename T>
      inline const std::vector<std::unique_ptr<T> > & get(const std::string & name) const
      {
        return boost::fusion::at_key<T>(m_local_spaces).at(name);
      }
 
      template<typename T>
      std::vector<std::unique_ptr<T> > & get(const std::string & name)
      {
        return boost::fusion::at_key<T>(m_local_spaces)[name];
      }
      
      void _construct_cell_bases(size_t iT);
      void _construct_edge_bases(size_t iE);
 
    private:
      DiscreteSpaceDescriptor m_descriptor;
      bool m_use_threads;
      std::ostream & m_output;
 
      LocalSpacesContainerType m_local_spaces;
      
      size_t m_max_cell_degree;
      size_t m_max_edge_degree;
      
      std::unique_ptr<GlobalDOFTable> m_dof_map;
    };
 
    //------------------------------------------------------------------------------
 
    struct DiscreteSpaceError {
      DiscreteSpaceError(const std::string & _message)
        : message(_message)
      {
        // Do nothing
      }
      
      std::string message;
    };
  } // namespace DSL
} // namespace HArDCore2D
 
#endif