gridcreatorinterface.hh

#pragma once
 
#include <cstdint>
#include <string>
#include <tuple>
#include <vector>
 
#include <dune/grid/common/gridfactory.hh>
 
namespace Dune
{
  namespace Gmsh4
  {
 
    template <class G, class Derived>
    class GridCreatorInterface
    {
    public:
      using Grid = G;
      using GlobalCoordinate = typename Grid::template Codim<0>::Entity::Geometry::GlobalCoordinate;
 
    public:
      GridCreatorInterface (GridFactory<Grid>& factory)
        : factory_(&factory)
      {}
 
      template <class NodeAttributes>
      void insertVertices (std::size_t numNodes,
        std::pair<std::size_t,std::size_t> nodeTagRange,
        std::vector<NodeAttributes> const& entityBlocks)
      {
        asDerived().insertVerticesImpl(numNodes, nodeTagRange, entityBlocks);
      }
 
      template <class ElementAttributes, class BoundaryEntities>
      void insertElements (std::size_t numElements,
        std::pair<std::size_t,std::size_t> elementTagRange,
        std::vector<ElementAttributes> const& entityBlocks,
        BoundaryEntities const& boundaryEntities)
      {
        asDerived().insertElementsImpl(numElements, elementTagRange, entityBlocks, boundaryEntities);
      }
 
      void insertPieces (std::vector<std::string> const& pieces)
      {
        asDerived().insertPiecesImpl(pieces);
      }
 
      GridFactory<Grid>& factory ()
      {
        return *factory_;
      }
 
      GridFactory<Grid> const& factory () const
      {
        return *factory_;
      }
 
      auto comm () const
      {
        return MPIHelper::getCommunication();
      }
 
    protected: // cast to derived type
 
      Derived& asDerived ()
      {
        return static_cast<Derived&>(*this);
      }
 
      const Derived& asDerived () const
      {
        return static_cast<const Derived&>(*this);
      }
 
    public: // default implementations
 
      template <class NodeAttributes>
      void insertVerticesImpl (std::size_t numNodes,
        std::pair<std::size_t,std::size_t> nodeTagRange,
        std::vector<NodeAttributes> const& entityBlocks)
      {
        /* do nothing */
      }
 
      template <class ElementAttributes, class BoundaryEntities>
      void insertElementsImpl (std::size_t numElements,
        std::pair<std::size_t,std::size_t> elementTagRange,
        std::vector<ElementAttributes> const& entityBlocks,
        BoundaryEntities const& boundaryEntities)
      {
        /* do nothing */
      }
 
      void insertPiecesImpl (std::vector<std::string> const&)
      {
        /* do nothing */;
      }
 
    protected:
      GridFactory<Grid>* factory_;
    };
 
  } // end namespace Gmsh4
} // end namespace Dune