gmshreader.hh

// 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_IO_FILE_GMSHREADER_HH
#define DUNE_GRID_IO_FILE_GMSHREADER_HH
 
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <utility>
 
#include <dune/common/exceptions.hh>
 
#include <dune/grid/common/gridfactory.hh>
#include <dune/grid/io/file/gmsh/gmsh2parser.hh>
#include <dune/grid/io/file/gmsh/gmsh4reader.hh>
#include <dune/grid/io/file/gmsh/utility/version.hh>
 
namespace Dune
{
 
  struct [[deprecated]] GmshReaderOptions
  {
    enum GeometryOrder {
      firstOrder,
      secondOrder
    };
  };
 
  namespace Gmsh {
    enum class ReaderOptions
    {
      verbose = 1,
      insertBoundarySegments = 2,
      readElementData = 4,
      readBoundaryData = 8
    };
 
    constexpr ReaderOptions operator | (ReaderOptions a, ReaderOptions b)
    {
      return static_cast<ReaderOptions>(
        static_cast<int>(a) | static_cast<int>(b)
      );
    }
 
    constexpr bool operator & (ReaderOptions a, ReaderOptions b)
    {
      return static_cast<int>(a) & static_cast<int>(b);
    }
 
  } // end namespace Gmsh
 
  template <typename GridType>
  using GmshReaderParser [[deprecated("Use Impl::Gmsh::Gmsh2Parser directly")]] = Impl::Gmsh::Gmsh2Parser<GridType>;
 
  template<typename GridType>
  class GmshReader
  {
 
    static void doRead(Dune::GridFactory<GridType> &factory,
                       const std::string &fileName,
                       std::vector<int>& boundarySegmentToPhysicalEntity,
                       std::vector<int>& elementToPhysicalEntity,
                       bool verbose, bool insertBoundarySegments)
    {
      // register boundary segment to boundary segment factory for possible load balancing
      // this needs to be done on all cores since the type might not be known otherwise
      Impl::Gmsh::GmshReaderQuadraticBoundarySegment< Grid::dimension, Grid::dimensionworld >::registerFactory();
 
#ifndef NDEBUG
      // check that this method is called on all cores
      factory.comm().barrier();
#endif
 
      // create parse object and read grid on process 0
      if (factory.comm().rank() == 0)
      {
        Impl::Gmsh::Gmsh2Parser<Grid> parser(factory,verbose,insertBoundarySegments);
        parser.read(fileName);
 
        boundarySegmentToPhysicalEntity = std::move(parser.boundaryIdMap());
        elementToPhysicalEntity = std::move(parser.elementIndexMap());
      }
      else
      {
        boundarySegmentToPhysicalEntity = {};
        elementToPhysicalEntity = {};
      }
    }
 
 
    template<class T>
    static T &discarded(T &&value) { return static_cast<T&>(value); }
 
    struct DataArg {
      std::vector<int> *data_ = nullptr;
      DataArg(std::vector<int> &data) : data_(&data) {}
      DataArg(const decltype(std::ignore)&) {}
      DataArg() = default;
    };
 
    struct DataFlagArg : DataArg {
      bool flag_ = false;
      using DataArg::DataArg;
      DataFlagArg(bool flag) : flag_(flag) {}
    };
 
  public:
    typedef GridType Grid;
 
    static std::unique_ptr<Grid> read (const std::string& fileName, bool verbose = true, bool insertBoundarySegments=true)
    {
      // make a grid factory
      Dune::GridFactory<Grid> factory;
 
      read(factory, fileName, verbose, insertBoundarySegments);
 
      return factory.createGrid();
    }
 
    static std::unique_ptr<Grid> read (const std::string& fileName,
                       std::vector<int>& boundarySegmentToPhysicalEntity,
                       std::vector<int>& elementToPhysicalEntity,
                       bool verbose = true, bool insertBoundarySegments=true)
    {
      // make a grid factory
      Dune::GridFactory<Grid> factory;
 
      if (Impl::Gmsh::fileVersion(fileName)[0]==4)
      {
        Impl::Gmsh::Gmsh4Reader<Grid>::fillFactory(factory, fileName);
        return factory.createGrid();
      }
 
      doRead(
        factory, fileName, boundarySegmentToPhysicalEntity,
        elementToPhysicalEntity, verbose, insertBoundarySegments
      );
 
      return factory.createGrid();
    }
 
    static void read (Dune::GridFactory<Grid>& factory, const std::string& fileName,
                      bool verbose = true, bool insertBoundarySegments=true)
    {
      if (Impl::Gmsh::fileVersion(fileName)[0]==4)
      {
        Impl::Gmsh::Gmsh4Reader<Grid>::fillFactory(factory, fileName);
        return;
      }
 
      doRead(
        factory, fileName, discarded(std::vector<int>{}),
        discarded(std::vector<int>{}), verbose, insertBoundarySegments
      );
    }
 
 
    static void read (Dune::GridFactory<Grid> &factory,
                      const std::string &fileName,
                      DataFlagArg boundarySegmentData,
                      DataArg elementData,
                      bool verbose=true)
    {
      if (Impl::Gmsh::fileVersion(fileName)[0]==4)
      {
        Impl::Gmsh::Gmsh4Reader<Grid>::fillFactory(factory, fileName);
        return;
      }
 
      doRead(
        factory, fileName,
        boundarySegmentData.data_
          ? *boundarySegmentData.data_ : discarded(std::vector<int>{}),
        elementData.data_
          ? *elementData.data_ : discarded(std::vector<int>{}),
        verbose,
        boundarySegmentData.flag_ || boundarySegmentData.data_
      );
    }
 
    static void read (Dune::GridFactory<Grid>& factory,
                      const std::string& fileName,
                      std::vector<int>& boundarySegmentToPhysicalEntity,
                      std::vector<int>& elementToPhysicalEntity,
                      bool verbose, bool insertBoundarySegments)
    {
      if (Impl::Gmsh::fileVersion(fileName)[0]==4)
      {
        Impl::Gmsh::Gmsh4Reader<Grid>::fillFactory(factory, fileName);
        return;
      }
 
      doRead(
        factory, fileName, boundarySegmentToPhysicalEntity,
        elementToPhysicalEntity, verbose, insertBoundarySegments
      );
    }
 
    //\{
 
    using Opts = Gmsh::ReaderOptions;
 
    static constexpr Opts defaultOpts =
      Opts::verbose | Opts::insertBoundarySegments | Opts::readElementData | Opts::readBoundaryData;
 
 
    GmshReader(const std::string& fileName,
               Gmsh::ReaderOptions options = defaultOpts)
    {
      gridFactory_ = std::make_unique<Dune::GridFactory<Grid>>();
      readGridFile(fileName, *gridFactory_, options);
    }
 
    GmshReader(const std::string& fileName, GridFactory<Grid>& factory,
               Gmsh::ReaderOptions options = defaultOpts)
    {
      readGridFile(fileName, factory, options);
    }
 
    const std::vector<int>& elementData () const
    {
      checkElementData();
      return elementIndexToGmshPhysicalEntity_;
    }
 
    const std::vector<int>& boundaryData () const
    {
      checkBoundaryData();
      return boundarySegmentIndexToGmshPhysicalEntity_;
    }
 
    bool hasElementData () const
    { return hasElementData_ && !extractedElementData_; }
 
    bool hasBoundaryData () const
    { return hasBoundaryData_ && !extractedBoundaryData_; }
 
    std::vector<int> extractElementData ()
    {
      checkElementData();
      extractedElementData_ = true;
      return std::move(elementIndexToGmshPhysicalEntity_);
    }
 
    std::vector<int> extractBoundaryData ()
    {
      checkBoundaryData();
      extractedBoundaryData_ = true;
      return std::move(boundarySegmentIndexToGmshPhysicalEntity_);
    }
 
    std::unique_ptr<Grid> createGrid ()
    {
      if (!gridFactory_)
        DUNE_THROW(Dune::InvalidStateException,
          "This GmshReader has been constructed with a Dune::GridFactory. "
          << "This grid factory has been filled with all information to create a grid. "
          << "Please use this factory to create the grid by calling factory.createGrid(). "
          << "Alternatively use the constructor without passing the factory in combination with this member function."
        );
 
      return gridFactory_->createGrid();
    }
 
    //\}
 
  private:
    void checkElementData () const
    {
      if (!hasElementData_)
        DUNE_THROW(Dune::InvalidStateException,
          "This GmshReader has been constructed without the option 'readElementData'. "
          << "Please enable reading element data by passing the option 'Gmsh::ReaderOpts::readElementData' "
          << "to the constructor of this class."
        );
 
      if (extractedElementData_)
        DUNE_THROW(Dune::InvalidStateException,
          "The element data has already been extracted from this GmshReader "
          << "via a function call to reader.extractElementData(). Use the extracted data or "
          << "read the grid data from file again by constructing a new reader."
        );
    }
 
    void checkBoundaryData () const
    {
      if (!hasBoundaryData_)
        DUNE_THROW(Dune::InvalidStateException,
          "This GmshReader has been constructed without the option 'readBoundaryData'. "
          << "Please enable reading boundary data by passing the option 'Gmsh::ReaderOpts::readBoundaryData' "
          << "to the constructor of this class."
        );
 
      if (extractedBoundaryData_)
        DUNE_THROW(Dune::InvalidStateException,
          "The boundary data has already been extracted from this GmshReader "
          << "via a function call to reader.extractBoundaryData(). Use the extracted data or "
          << "read the grid data from file again by constructing a new reader."
        );
    }
 
    void readGridFile (const std::string& fileName, GridFactory<Grid>& factory, Gmsh::ReaderOptions options)
    {
      if (Impl::Gmsh::fileVersion(fileName)[0]==4)
      {
        Impl::Gmsh::Gmsh4Reader<Grid>::fillFactory(factory, fileName);
        return;
      }
 
      const bool verbose = options & Opts::verbose;
      const bool insertBoundarySegments = options & Opts::insertBoundarySegments;
      const bool readBoundaryData = options & Opts::readBoundaryData;
      const bool readElementData = options & Opts::readElementData;
 
      doRead(
        factory, fileName, boundarySegmentIndexToGmshPhysicalEntity_,
        elementIndexToGmshPhysicalEntity_, verbose,
        readBoundaryData || insertBoundarySegments
      );
 
      // clear unwanted data
      if (!readBoundaryData)
          boundarySegmentIndexToGmshPhysicalEntity_ = std::vector<int>{};
      if (!readElementData)
          elementIndexToGmshPhysicalEntity_ = std::vector<int>{};
 
      hasElementData_ = readElementData;
      hasBoundaryData_ = readBoundaryData;
    }
 
    std::unique_ptr<Dune::GridFactory<Grid>> gridFactory_;
 
    std::vector<int> elementIndexToGmshPhysicalEntity_;
    std::vector<int> boundarySegmentIndexToGmshPhysicalEntity_;
 
    bool hasElementData_ = false;
    bool hasBoundaryData_ = false;
 
    // for better error messages, we keep track of these separately
    bool extractedElementData_ = false;
    bool extractedBoundaryData_ = false;
  };
 
} // namespace Dune
 
#endif