alu2dgridfactory.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_ALU2DGRID_FACTORY_HH
#define DUNE_ALU2DGRID_FACTORY_HH
 
#if HAVE_ALUGRID
 
#include <dune/common/array.hh>
#include <dune/common/parallel/mpihelper.hh>
 
#include <dune/geometry/referenceelements.hh>
 
#include <dune/grid/common/gridfactory.hh>
 
#include <dune/grid/alugrid/common/persistentcontainer.hh>
#include <dune/grid/alugrid/common/transformation.hh>
#include <dune/grid/alugrid/2d/grid.hh>
 
namespace Dune
{
 
  template< class GridImp >
  class ALU2dGridFactory
    : public GridFactoryInterface< GridImp >
  {
    typedef GridFactoryInterface< GridImp > Base ;
  public:
    using Base :: insertElement ;
 
    typedef GridImp Grid;
 
    static const int dimension = Grid::dimension;
    static const int dimensionworld = Grid::dimensionworld;
 
    typedef DuneBoundaryProjection< dimensionworld >  DuneBoundaryProjectionType;
 
    template< int codim >
    struct Codim
    {
      typedef typename Grid::template Codim< codim >::Entity Entity;
    };
 
  private:
    typedef Dune::BoundarySegmentWrapper<2, dimensionworld> BoundarySegmentWrapperType;
 
    typedef ALU2dGridFactory< Grid > ThisType;
    typedef GridFactoryInterface< Grid > BaseType;
 
    typedef typename Grid::ctype ctype;
 
    static const ALU2DSPACE ElementType elementType = Grid::elementType;
    static const unsigned int numFaceCorners = 2;
 
    typedef FieldVector< ctype, dimensionworld > VertexType;
    typedef std::vector< unsigned int > ElementType;
    typedef array< unsigned int, numFaceCorners > FaceType;
 
    static const int periodicBndId = ALU2dImplTraits< dimensionworld, elementType >::HBndElType::general_periodic;
 
  public:
    typedef ALUGridTransformation< ctype, dimensionworld > Transformation;
 
    typedef typename Transformation::WorldVector WorldVector;
    typedef typename Transformation::WorldMatrix WorldMatrix;
 
  private:
    struct FaceLess;
 
    typedef std::vector< VertexType > VertexVector;
    typedef std::vector< ElementType > ElementVector;
    typedef std::vector< std::pair< FaceType, int > > BoundaryIdVector;
 
    typedef std::map< FaceType, const DuneBoundaryProjectionType* > BoundaryProjectionMap;
    typedef std::vector< const DuneBoundaryProjectionType* > BoundaryProjectionVector;
 
    typedef std::pair< unsigned int, int > SubEntity;
    typedef std::map< FaceType, SubEntity, FaceLess > FaceMap;
    typedef std::vector< Transformation > FaceTransformationVector;
    typedef std::map< FaceType, unsigned int, FaceLess > PeriodicNeighborMap;
 
    // copy vertex numbers and store smalled #dimension ones
    void copyAndSort(const std::vector<unsigned int>& vertices, FaceType& faceId) const
    {
      std::vector<unsigned int> tmp( vertices );
      std::sort( tmp.begin(), tmp.end() );
 
      // copy only the first dimension vertices (enough for key)
      for( size_t i = 0; i < faceId.size(); ++i ) faceId[ i ] = tmp[ i ];
    }
 
  public:
    explicit ALU2dGridFactory ( bool removeGeneratedFile = true );
 
    explicit ALU2dGridFactory ( const std::string &filename );
 
    virtual ~ALU2dGridFactory ();
 
    virtual void insertVertex ( const VertexType &pos );
 
    virtual void
    insertElement ( const GeometryType &geometry,
                    const std::vector< unsigned int > &vertices );
 
    virtual void
    insertBoundary ( const GeometryType &geometry,
                     const std::vector< unsigned int > &faceVertices,
                     const int id );
 
    virtual void insertBoundary ( const int element, const int face, const int id );
 
    virtual void
    insertBoundaryProjection ( const GeometryType &type,
                               const std::vector< unsigned int > &vertices,
                               const DuneBoundaryProjectionType *projection );
 
    virtual void
    insertBoundarySegment ( const std::vector< unsigned int >& vertices ) ;
 
    virtual void
    insertBoundarySegment ( const std::vector< unsigned int >& vertices,
                            const shared_ptr<BoundarySegment<2,dimensionworld> >& boundarySegment ) ;
 
    virtual void insertBoundaryProjection ( const DuneBoundaryProjectionType& bndProjection );
 
    void insertFaceTransformation ( const WorldMatrix &matrix, const WorldVector &shift );
 
    virtual unsigned int
    insertionIndex ( const typename Codim< 0 >::Entity &entity ) const
    {
      return Grid::getRealImplementation( entity ).getIndex();
    }
 
    virtual unsigned int
    insertionIndex ( const typename Codim< dimension >::Entity &entity ) const
    {
      return Grid::getRealImplementation( entity ).getIndex();
    }
 
    virtual unsigned int
    insertionIndex ( const typename Grid::LeafIntersection &intersection ) const
    {
      return intersection.boundarySegmentIndex();
    }
 
    virtual bool
    wasInserted ( const typename Grid::LeafIntersection &intersection ) const
    {
      return intersection.boundary() &&
             ( insertionIndex(intersection) < numFacesInserted_ );
    }
 
    Grid *createGrid ();
 
    Grid *createGrid ( const bool addMissingBoundaries, const std::string dgfName = "" );
 
    Grid *createGrid ( const bool addMissingBoundaries, bool temporary, const std::string dgfName = "" );
 
    void setTolerance ( const ctype &epsilon ) { epsilon_ = epsilon; }
 
  protected:
    virtual Grid* createGridObj( const bool temporary,
                                 const std::string& filename,
                                 std::istream& inFile,
                                 BoundaryProjectionVector* bndProjections )
    {
      return ( temporary ) ?
             new Grid( filename, inFile, globalProjection_, bndProjections, grdVerbose_ ) :
             new Grid( filename, globalProjection_ , bndProjections, grdVerbose_ );
    }
 
  public:
    void setVerbosity( const bool verbose ) { grdVerbose_ = verbose; }
 
  private:
    static void generateFace ( const ElementType &element, const int f, FaceType &face );
    void correctElementOrientation ();
    typename FaceMap::const_iterator findPeriodicNeighbor( const FaceMap &faceMap, const FaceType &key ) const;
    void reinsertBoundary ( const FaceMap &faceMap, const typename FaceMap::const_iterator &pos, const int id );
    void recreateBoundaryIds ( const int defaultId = 1 );
 
    VertexVector vertices_;
    ElementVector elements_;
    BoundaryIdVector boundaryIds_;
    const DuneBoundaryProjectionType* globalProjection_ ;
    BoundaryProjectionMap boundaryProjections_;
    unsigned int numFacesInserted_;
    bool grdVerbose_;
    FaceTransformationVector faceTransformations_;
    PeriodicNeighborMap periodicNeighborMap_;
    ctype epsilon_;
  };
 
 
  template< class GridImp >
  struct ALU2dGridFactory< GridImp >::FaceLess
    : public std::binary_function< FaceType, FaceType, bool >
  {
    bool operator() ( const FaceType &a, const FaceType &b ) const
    {
      for( unsigned int i = 0; i < numFaceCorners; ++i )
      {
        if( a[ i ] != b[ i ] )
          return (a[ i ] < b[ i ]);
      }
      return false;
    }
  };
 
 
  template<int dimw>
  class GridFactory< ALUConformGrid<2,dimw> >
    : public ALU2dGridFactory<ALUConformGrid<2, dimw> >
  {
  public:
    typedef ALUConformGrid< 2, dimw > Grid;
 
  protected:
    typedef GridFactory ThisType;
    typedef ALU2dGridFactory< Grid > BaseType;
 
  public:
    explicit GridFactory ( )
      : BaseType( )
    {}
 
    GridFactory ( const std::string &filename )
      : BaseType( filename )
    {}
 
    GridFactory ( const bool verbose )
      : BaseType( )
    {
      this->setVerbosity( verbose );
    }
  };
  template<int dimw>
  class GridFactory< ALUSimplexGrid<2,dimw> >
    : public ALU2dGridFactory<ALUSimplexGrid<2, dimw> >
  {
  public:
    typedef ALUSimplexGrid< 2, dimw > Grid;
 
  protected:
    typedef GridFactory ThisType;
    typedef ALU2dGridFactory< Grid > BaseType;
 
  public:
    explicit GridFactory ( )
      : BaseType( )
    {}
 
    GridFactory ( const std::string &filename )
      : BaseType( filename )
    {}
 
    GridFactory ( const bool verbose )
      : BaseType( )
    {
      this->setVerbosity( verbose );
    }
  };
 
  template<int dimw>
  class GridFactory< ALUCubeGrid<2,dimw> >
    : public ALU2dGridFactory<ALUCubeGrid<2,dimw> >
  {
  public:
    typedef ALUCubeGrid< 2, dimw > Grid;
 
  protected:
    typedef GridFactory ThisType;
    typedef ALU2dGridFactory< Grid > BaseType;
 
  public:
    explicit GridFactory ( )
      : BaseType( )
    {}
 
    GridFactory ( const std::string &filename )
      : BaseType( filename )
    {}
 
    GridFactory ( const bool verbose )
      : BaseType( )
    {
      this->setVerbosity( verbose );
    }
  };
 
  template<int dimw, ALUGridElementType eltype, ALUGridRefinementType refinementtype, class Comm>
  class GridFactory< ALUGrid<2, dimw, eltype, refinementtype, Comm > >
    : public ALU2dGridFactory< ALUGrid<2, dimw, eltype, refinementtype, Comm > >
  {
  public:
    typedef ALUGrid<2, dimw, eltype, refinementtype, Comm > Grid;
 
  protected:
    typedef GridFactory ThisType;
    typedef ALU2dGridFactory< Grid > BaseType;
 
  public:
    explicit GridFactory ( )
      : BaseType( )
    {}
 
    GridFactory ( const std::string &filename )
      : BaseType( filename )
    {}
 
    GridFactory ( const bool verbose )
      : BaseType( )
    {
      this->setVerbosity( verbose );
    }
  };
 
 
 
  // Inline Implementations
  // ----------------------
 
  template< class GridImp >
  inline ALU2dGridFactory< GridImp >::ALU2dGridFactory ( bool removeGeneratedFile )
    : globalProjection_ ( 0 ),
      numFacesInserted_ ( 0 ),
      grdVerbose_( true ),
      epsilon_( 1e-8 )
  {}
 
 
  template< class GridImp >
  inline ALU2dGridFactory< GridImp >::ALU2dGridFactory ( const std::string &filename )
    : globalProjection_ ( 0 ),
      numFacesInserted_ ( 0 ),
      grdVerbose_( true ),
      epsilon_( 1e-8 )
  {}
 
 
  template< class GridImp >
  inline ALU2dGridFactory< GridImp >::~ALU2dGridFactory ()
  {}
 
 
  template< class GridImp >
  inline GridImp *ALU2dGridFactory< GridImp >::createGrid ()
  {
    return createGrid( true, true, "" );
  }
 
 
  template< class GridImp >
  inline GridImp *ALU2dGridFactory< GridImp >
  ::createGrid ( const bool addMissingBoundaries, const std::string dgfName )
  {
    return createGrid( addMissingBoundaries, true, dgfName );
  }
 
}
 
#endif // #if HAVE_ALUGRID
 
#endif // #ifndef DUNE_ALU2DGRID_FACTORY_HH