uggridfactory.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_UGGRID_FACTORY_HH
#define DUNE_UGGRID_FACTORY_HH
 
#include <array>
#include <memory>
#include <vector>
 
#include <dune/common/fvector.hh>
 
#include <dune/grid/common/boundarysegment.hh>
#include <dune/grid/common/gridfactory.hh>
#include <dune/grid/uggrid.hh>
 
namespace Dune {
 
 
  template <int dimworld>
  class GridFactory<UGGrid<dimworld> > : public GridFactoryInterface<UGGrid<dimworld> > {
 
    typedef typename UGGrid<dimworld>::ctype ctype;
 
    // UGGrid only in 2d and 3d
    static_assert(dimworld==2 || dimworld == 3, "UGGrid only in 2d and 3d");
 
  public:
 
    GridFactory();
 
    GridFactory(UGGrid<dimworld>* grid);
 
    ~GridFactory();
 
    virtual void insertVertex(const FieldVector<ctype,dimworld>& pos);
 
    virtual void insertElement(const GeometryType& type,
                               const std::vector<unsigned int>& vertices);
 
    void insertBoundarySegment(const std::vector<unsigned int>& vertices);
 
    void insertBoundarySegment(const std::vector<unsigned int>& vertices,
                               const std::shared_ptr<BoundarySegment<dimworld> > &boundarySegment);
 
 
    virtual std::unique_ptr<UGGrid<dimworld>> createGrid();
 
    static const int dimension = UGGrid<dimworld>::dimension;
 
    template< int codim >
    struct Codim
    {
      typedef typename UGGrid<dimworld>::template Codim< codim >::Entity Entity;
    };
 
    virtual unsigned int
    insertionIndex ( const typename Codim< 0 >::Entity &entity ) const
    {
      return UG_NS<dimension>::levelIndex(entity.impl().target_);
    }
 
    virtual unsigned int
    insertionIndex ( const typename Codim< dimension >::Entity &entity ) const
    {
      return UG_NS<dimension>::levelIndex(entity.impl().target_);
    }
 
    virtual unsigned int
    insertionIndex ( const typename UGGrid<dimworld>::LeafIntersection &intersection ) const
    {
      return intersection.boundarySegmentIndex();
    }
 
    virtual bool
    wasInserted ( const typename UGGrid<dimworld>::LeafIntersection &intersection ) const
    {
      return (insertionIndex( intersection ) < boundarySegmentVertices_.size());
    }
 
    using Communication = typename UGGrid<dimworld>::Communication;
 
    Communication comm() const
    {
        return grid_->comm();
    }
 
  private:
 
    // Initialize the grid structure in UG
    void createBegin();
 
    // Pointer to the grid being built
    UGGrid<dimworld>* grid_;
 
    // True if the factory allocated the grid itself, false if the
    // grid was handed over from the outside
    bool factoryOwnsGrid_;
 
    std::vector<std::array<int, dimworld*2-2> > boundarySegmentVertices_;
 
    std::vector<unsigned char> elementTypes_;
 
    std::vector<unsigned int> elementVertices_;
 
    std::vector<FieldVector<double, dimworld> > vertexPositions_;
 
  };
 
}
 
#endif