gridfactory.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_FACTORY_HH
#define DUNE_GRID_FACTORY_HH
 
#include <vector>
 
#include <dune/common/function.hh>
#include <dune/common/fvector.hh>
#include <dune/common/shared_ptr.hh>
 
#include <dune/geometry/type.hh>
 
#include <dune/grid/common/boundarysegment.hh>
#include <dune/grid/common/grid.hh>
 
namespace Dune
{
 
  template <class GridType>
  class GridFactoryInterface
  {
 
  protected:
    static const int dimension = GridType::dimension;
 
    enum {dimworld = GridType::dimensionworld};
 
    typedef typename GridType::ctype ctype;
 
  public:
    template< int codim >
    struct Codim
    {
      typedef typename GridType::template Codim< codim >::Entity Entity;
    };
 
    GridFactoryInterface()
    {}
 
    virtual ~GridFactoryInterface ()
    {}
 
    virtual void insertVertex(const FieldVector<ctype,dimworld>& pos) = 0;
 
    virtual void insertElement(const GeometryType& type,
                               const std::vector<unsigned int>& vertices) = 0;
 
    virtual void insertElement(const GeometryType& type,
                               const std::vector<unsigned int>& vertices,
                               const shared_ptr<VirtualFunction<FieldVector<ctype,dimension>,FieldVector<ctype,dimworld> > >& elementParametrization)
    {
      DUNE_THROW(GridError, "This grid does not support parametrized elements!");
    }
 
    virtual void insertBoundarySegment(const std::vector<unsigned int>& vertices) = 0;
 
    virtual void insertBoundarySegment(const std::vector<unsigned int>& vertices,
                                       const shared_ptr<BoundarySegment<dimension,dimworld> >& boundarySegment)
    {
      DUNE_THROW(GridError, "This grid does not support parametrized boundary segments!");
    }
 
    virtual GridType* createGrid() = 0;
 
    virtual unsigned int
    insertionIndex ( const typename Codim< 0 >::Entity &entity ) const
    {
      DUNE_THROW( NotImplemented, "insertion indices have not yet been implemented." );
    }
 
    virtual unsigned int
    insertionIndex ( const typename Codim< dimension >::Entity &entity ) const
    {
      DUNE_THROW( NotImplemented, "insertion indices have not yet been implemented." );
    }
 
    virtual unsigned int
    insertionIndex ( const typename GridType::LeafIntersection &intersection ) const
    {
      DUNE_THROW( NotImplemented, "insertion indices have not yet been implemented." );
    }
 
 
    virtual bool
    wasInserted ( const typename GridType::LeafIntersection &intersection ) const
    {
      DUNE_THROW( NotImplemented, "insertion indices have not yet been implemented." );
    }
 
  };
 
 
  template <class GridType>
  class GridFactory : public GridFactoryInterface<GridType> {
 
    enum {dimworld = GridType::dimensionworld};
 
    typedef typename GridType::ctype ctype;
 
  public:
 
    GridFactory() {
      DUNE_THROW(GridError, "There is no grid factory for this grid type!");
    }
 
    virtual void insertVertex(const FieldVector<ctype,dimworld>& pos) {
      DUNE_THROW(GridError, "There is no grid factory for this grid type!");
    }
 
    virtual void insertElement(const GeometryType& type,
                               const std::vector<unsigned int>& vertices) {
      DUNE_THROW(GridError, "There is no grid factory for this grid type!");
    }
 
    virtual void insertBoundarySegment(const std::vector<unsigned int>& vertices) {
      DUNE_THROW(GridError, "There is no grid factory for this grid type!");
    }
 
    virtual GridType* createGrid() {
      DUNE_THROW(GridError, "There is no grid factory for this grid type!");
    }
 
  };
 
}
 
#endif