structuredgridfactory.hh

 // -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_MMESH_STRUCTURED_GRID_FACTORY_HH
#define DUNE_MMESH_STRUCTURED_GRID_FACTORY_HH
 
// System includes
#include <memory>
#include <utility>
#include <vector>
 
// Dune includes
#include <dune/common/parallel/mpihelper.hh>
#include <dune/grid/common/intersection.hh>
#include <dune/grid/utility/multiindex.hh>
 
// MMesh includes
#include <dune/mmesh/grid/implicitgridfactory.hh>
 
namespace Dune
{
 
  // External Forward Declarations
  // -----------------------------
  template< class GridImp, class IntersectionImp >
  class Intersection;
 
 
  // StructuredGridFactory for MMesh
  // -------------------------------
  template< class Grid >
  struct MMeshStructuredGridFactory
  {
    const static int dimworld = Grid::dimension;
    typedef MPIHelper::MPICommunicator MPICommunicatorType;
    typedef typename Grid::template Codim<0>::Entity Element;
    typedef typename Grid::template Codim<dimworld>::Entity Vertex;
    typedef typename Grid::FieldType FieldType;
    typedef FieldVector< FieldType, dimworld > GlobalPosition;
    typedef Dune::MMeshImplicitGridFactory<Grid> GridFactory;
 
    template <long unsigned int dim>
    explicit MMeshStructuredGridFactory (const GlobalPosition& lowerLeft,
                                         const GlobalPosition& upperRight,
                                         const std::array<unsigned int,dim>& elements,
                                         MPICommunicatorType comm = MPIHelper::getCommunicator() )
    {
        grid_ = createStructuredGrid (lowerLeft, upperRight, elements);
    }
 
    const std::shared_ptr<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
    {
      DUNE_THROW( NotImplemented, "BoundaryId in structured grid factory" );
    }
 
public:
 
    template <long unsigned int dim>
    static typename Grid::GridPtrType createStructuredGrid(const GlobalPosition& lowerLeft,
                                                          const GlobalPosition& upperRight,
                                                          const std::array<unsigned int,dim>& elements)
    {
      // The grid factory
      GridFactory factory;
 
      // Insert uniformly spaced vertices
      std::array<unsigned int,dim> vertices = elements;
      for( size_t i = 0; i < vertices.size(); ++i )
        vertices[i]++;
 
      FactoryUtilities::MultiIndex<dim> index(vertices);
 
      // Compute the total number of vertices to be created
      int numVertices = index.cycle();
 
      // Create vertices
      for (int i=0; i<numVertices; i++, ++index)
      {
        // scale the multiindex to obtain a world position
        GlobalPosition pos(0);
        for (std::size_t j=0; j<dim; j++)
          pos[j] = lowerLeft[j] + index[j] * (upperRight[j]-lowerLeft[j])/(vertices[j]-1);
        for (std::size_t j=dim; j<dimworld; j++)
          pos[j] = lowerLeft[j];
 
        factory.insertVertex(pos);
      }
 
      // Create the grid and hand it to the calling method
      return factory.createGrid();
 
    }
 
private:
    std::shared_ptr<Grid> grid_;
    GridFactory factory_;
  };
 
} // end namespace Dune
 
#endif // #ifndef DUNE_MMESH_STRUCTURED_GRID_FACTORY_HH