common/gridfactory.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_COMMON_GRIDFACTORY_HH
#define DUNE_GRID_COMMON_GRIDFACTORY_HH

#include <memory>
#include <vector>

#include <dune/common/fvector.hh>
#include <dune/common/parallel/mpihelper.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;

    constexpr static int 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*/,
                  std::function<FieldVector<ctype,dimworld>
                                  (FieldVector<ctype,dimension>)>
                       /*elementParametrization*/)
    {
      DUNE_THROW(GridError, "There is no grid factory for this grid type!");
    }

    virtual void insertBoundarySegment(const std::vector<unsigned int>& vertices) = 0;

    virtual void insertBoundarySegment([[maybe_unused]] const std::vector<unsigned int>& vertices,
                                       [[maybe_unused]] const std::shared_ptr<BoundarySegment<dimension,dimworld> >& boundarySegment)
    {
      DUNE_THROW(GridError, "This grid does not support parametrized boundary segments!");
    }

    virtual std::unique_ptr<GridType> createGrid() = 0;

    virtual unsigned int
    insertionIndex ( [[maybe_unused]] const typename Codim< 0 >::Entity &entity ) const
    {
      DUNE_THROW( NotImplemented, "insertion indices have not yet been implemented." );
    }

    virtual unsigned int
    insertionIndex ( [[maybe_unused]] const typename Codim< dimension >::Entity &entity ) const
    {
      DUNE_THROW( NotImplemented, "insertion indices have not yet been implemented." );
    }

    virtual unsigned int
    insertionIndex ( [[maybe_unused]] const typename GridType::LeafIntersection &intersection ) const
    {
      DUNE_THROW( NotImplemented, "insertion indices have not yet been implemented." );
    }


    virtual bool
    wasInserted ( [[maybe_unused]] const typename GridType::LeafIntersection &intersection ) const
    {
      DUNE_THROW( NotImplemented, "insertion indices have not yet been implemented." );
    }

    using Communication = Dune::Communication<typename MPIHelper::MPICommunicator>;

    Communication comm() const
    {
      return Communication(MPIHelper::getLocalCommunicator());
    }
  };


  template <class GridType>
  class GridFactory : public GridFactoryInterface<GridType> {

    typedef GridFactoryInterface<GridType> Base;

    constexpr static int dimworld = GridType::dimensionworld;

    typedef typename GridType::ctype ctype;

  public:

    // use default implementation from base class
    using Base::insertBoundarySegment;

    GridFactory() {
      DUNE_THROW(GridError, "There is no grid factory for this grid type!");
    }

    virtual void insertVertex([[maybe_unused]] const FieldVector<ctype,dimworld>& pos) {
      DUNE_THROW(GridError, "There is no grid factory for this grid type!");
    }

    virtual void insertElement([[maybe_unused]] const GeometryType& type,
                               [[maybe_unused]] const std::vector<unsigned int>& vertices) {
      DUNE_THROW(GridError, "There is no grid factory for this grid type!");
    }

    virtual void insertBoundarySegment([[maybe_unused]] const std::vector<unsigned int>& vertices) {
      DUNE_THROW(GridError, "There is no grid factory for this grid type!");
    }

    virtual std::unique_ptr<GridType> createGrid() {
      DUNE_THROW(GridError, "There is no grid factory for this grid type!");
    }

  };

}

#endif