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