dgfparser.hh

 // -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_MMESH_GRID_DGFPARSER_HH
#define DUNE_MMESH_GRID_DGFPARSER_HH
 
// System includes
#include <memory>
#include <utility>
#include <vector>
 
// Dune includes
#include <dune/grid/common/intersection.hh>
#include <dune/grid/io/file/dgfparser/blocks/projection.hh>
#include <dune/grid/io/file/dgfparser/dgfparser.hh>
#include <dune/grid/io/file/dgfparser/parser.hh>
 
// MMesh includes
#include <dune/mmesh/grid/explicitgridfactory.hh>
 
namespace Dune
{
 
  // External Forward Declarations
  // -----------------------------
  template< class GridImp, class IntersectionImp >
  class Intersection;
 
  // DGFGridFactory for MMesh
  // ------------------------
  template< class HostGrid, int dim >
  struct DGFGridFactory< MMesh<HostGrid, dim> >
  {
    typedef MMesh<HostGrid, dim> Grid;
    const static int dimension = Grid::dimension;
    typedef MPIHelper::MPICommunicator MPICommunicatorType;
    typedef typename Grid::template Codim<0>::Entity Element;
    typedef typename Grid::template Codim<dimension>::Entity Vertex;
    typedef Dune::MMeshExplicitGridFactory<Grid> GridFactory;
 
    explicit DGFGridFactory ( std::istream &input,
                              MPICommunicatorType comm = MPIHelper::getCommunicator() );
    explicit DGFGridFactory ( const std::string &filename,
                              MPICommunicatorType comm = MPIHelper::getCommunicator() );
 
    Grid* grid() const
    {
      return grid_;
    }
 
    template< class Intersection >
    bool wasInserted ( const Intersection &intersection ) const
    {
      return factory_.wasInserted( intersection );
    }
 
    template< class Intersection >
    int boundaryId ( const Intersection &intersection ) const
    {
      return intersection.impl().boundaryId();
    }
 
    std::vector< double > &parameter ( const Element &element )
    {
       if( numParameters< 0 >() <= 0 )
      {
        DUNE_THROW( InvalidStateException,
                    "Calling DGFGridFactory::parameter is only allowed if there are parameters." );
      }
      return dgf_.elParams[ factory_.insertionIndex( element ) ];
    }
 
    std::vector< double > &parameter ( const Vertex &vertex )
    {
      if( numParameters< dimension >() <= 0 )
      {
        DUNE_THROW( InvalidStateException,
                    "Calling DGFGridFactory::parameter is only allowed if there are parameters." );
      }
      return dgf_.vtxParams[ factory_.insertionIndex( vertex ) ];
    }
 
    bool haveBoundaryParameters () const
    {
      return dgf_.haveBndParameters;
    }
 
    template < class GG, class II >
    const DGFBoundaryParameter::type
    boundaryParameter ( const Intersection< GG, II > & intersection ) const { return DGFBoundaryParameter::type(); }
 
    template< int codim >
    int numParameters () const { return 0; }
 
  private:
    bool generate( std::istream &input )
    {
      dgf_.element = DuneGridFormatParser::Simplex;
      dgf_.dimgrid = dimension;
      dgf_.dimw = dimension;
 
      if( !dgf_.readDuneGrid( input, dimension, dimension ) )
        return false;
 
      // Insert vertices
      for( int n = 0; n < dgf_.nofvtx; ++n )
      {
        typename GridFactory::WorldVector coord;
        for( std::size_t i = 0; i < dimension; ++i )
          coord[ i ] = dgf_.vtx[ n ][ i ];
        factory_.insertVertex( coord );
      }
 
      // Insert elements
      for( int n = 0; n < dgf_.nofelements; ++n )
        factory_.insertElement( GeometryTypes::simplex(dimension), dgf_.elements[ n ] );
 
      // Insert boundary segments and ids
      for( const auto& face : dgf_.facemap )
      {
        const auto& entityKey = face.first;
        const std::size_t boundaryId = face.second.first;
 
        std::vector< unsigned int > vertices;
        for( int i = 0; i < entityKey.size(); ++i )
          vertices.push_back( entityKey[i] );
 
        std::sort( vertices.begin(), vertices.end() );
 
        // insert boundary segment
        factory_.insertBoundarySegment( vertices );
 
        // insert boundary id
        std::size_t index = factory_.boundarySegments().size()-1;
        factory_.addBoundaryId( index, boundaryId );
      }
 
      grid_ = factory_.createGrid().release();
      return true;
    }
 
    Grid* grid_;
    GridFactory factory_;
    DuneGridFormatParser dgf_;
  };
 
 
  // DGFGridInfo for MMesh
  // ---------------------
 
  template< class HostGrid, int dim >
  struct DGFGridInfo< MMesh<HostGrid, dim> >
  {
    static int refineStepsForHalf ()
    {
      return 2;
    }
 
    static double refineWeight ()
    {
      return -1;
    }
  };
 
 
  // Implementation of DGFGridFactory for MMesh
  // ------------------------------------------
 
  template< class HostGrid, int dim >
  inline DGFGridFactory< MMesh<HostGrid, dim> >
  ::DGFGridFactory ( std::istream &input, MPICommunicatorType comm )
    : dgf_( 0, 1 )
  {
    input.clear();
    input.seekg( 0 );
    if( !input )
      DUNE_THROW(DGFException, "Error resetting input stream." );
    generate( input );
  }
 
  template< class HostGrid, int dim >
  inline DGFGridFactory< MMesh<HostGrid, dim> >
  ::DGFGridFactory ( const std::string &filename, MPICommunicatorType comm )
    : dgf_( 0, 1 )
  {
    std::ifstream input( filename.c_str() );
    if( !input )
      DUNE_THROW( DGFException, "Macrofile " << filename << " not found." );
    if( !generate( input ) )
      DUNE_THROW( DGFException, "Could not generate MMesh from macrofile " << filename );
    input.close();
  }
 
}  // namespace Dune
 
#endif