grid_in.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 1999 - 2025 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_grid_in_h
#define dealii_grid_in_h
 
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_GMSH_WITH_API
#  include <deal.II/base/mpi.h>
 
#  include <deal.II/distributed/fully_distributed_tria.h>
 
#  include <gmsh.h>
#endif
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/observer_pointer.h>
#include <deal.II/base/point.h>
 
#include <deal.II/lac/vector.h>
 
#include <iostream>
#include <map>
#include <string>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#ifndef DOXYGEN
template <int dim, int spacedim>
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
class Triangulation;
template <int dim>
struct CellData;
#endif
 
template <int dim, int spacedim = dim>
class GridIn
{
public:
  enum Format
  {
    Default,
    unv,
    ucd,
    abaqus,
    dbmesh,
    xda,
    msh,
    tecplot,
    vtk,
    vtu,
    assimp,
    exodusii,
    ugrid
  };
 
  GridIn();
 
  GridIn(Triangulation<dim, spacedim> &tria);
 
  void
  attach_triangulation(Triangulation<dim, spacedim> &tria);
 
  void
  read(std::istream &in, Format format = Default);
 
  void
  read(const std::string &in, Format format = Default);
 
  void
  read_vtk(std::istream &in);
 
  void
  read_vtu(std::istream &in);
 
  void
  read_unv(std::istream &in);
 
  void
  read_ucd(std::istream &in,
           const bool    apply_all_indicators_to_manifolds = false);
 
  void
  read_abaqus(std::istream &in,
              const bool    apply_all_indicators_to_manifolds = false);
 
  void
  read_dbmesh(std::istream &in);
 
  void
  read_xda(std::istream &in);
 
  void
  read_msh(std::istream &in);
 
  void
  read_msh(const std::string &filename);
 
  void
  read_partitioned_msh(const std::string &file_prefix,
                       const std::string &file_suffix = "msh");
 
  void
  read_comsol_mphtxt(std::istream &in);
 
  void
  read_tecplot(std::istream &in);
 
  void
  read_assimp(const std::string &filename,
              const unsigned int mesh_index = numbers::invalid_unsigned_int,
              const bool         remove_duplicates                = true,
              const double       tol                              = 1e-12,
              const bool         ignore_unsupported_element_types = true);
 
  void
  read_ugrid(std::istream &in);
 
  struct ExodusIIData
  {
    std::vector<std::vector<int>> id_to_sideset_ids;
  };
 
  ExodusIIData
  read_exodusii(const std::string &filename,
                const bool         apply_all_indicators_to_manifolds = false);
 
  static std::string
  default_suffix(const Format format);
 
  static Format
  parse_format(const std::string &format_name);
 
  static std::string
  get_format_names();
 
  const std::map<std::string, Vector<double>> &
  get_cell_data() const;
 
  DeclException1(ExcUnknownSectionType,
                 int,
                 << "The section type <" << arg1 << "> in an UNV "
                 << "input file is not implemented.");
 
  DeclException1(ExcUnknownElementType,
                 int,
                 << "The element type <" << arg1 << "> in an UNV "
                 << "input file is not implemented.");
 
  DeclException1(ExcUnknownIdentifier,
                 std::string,
                 << "The identifier <" << arg1 << "> as name of a "
                 << "part in an UCD input file is unknown or the "
                 << "respective input routine is not implemented. "
                 << "(Maybe the space dimension of triangulation and "
                 << "input file do not match?");
  DeclExceptionMsg(ExcNoTriangulationSelected,
                   "No Triangulation has been attached to this GridIn object "
                   "so that nothing can be filled during any read function "
                   "calls.  Please pass a reference to the Triangulation tria "
                   "to be  filled in the constructor GridIn(tria) or attach "
                   "it with the function call GridIn::attach_triangulation().");
  DeclException2(
    ExcInvalidVertexIndex,
    int,
    int,
    << "While creating cell " << arg1
    << ", you are referencing a vertex with index " << arg2
    << " but no vertex with this index has been described in the input file.");
  DeclException3(
    ExcInvalidVertexIndexGmsh,
    int,
    int,
    int,
    << "While creating cell " << arg1 << " (which is numbered as " << arg2
    << " in the input file), you are referencing a vertex with index " << arg3
    << " but no vertex with this index has been described in the input file.");
  DeclException0(ExcInvalidDBMeshFormat);
  DeclException1(ExcInvalidDBMESHInput,
                 std::string,
                 << "The string <" << arg1
                 << "> is not recognized at the present"
                 << " position of a DB Mesh file.");
 
  DeclException1(
    ExcDBMESHWrongDimension,
    int,
    << "The specified dimension " << arg1
    << " is not the same as that of the triangulation to be created.");
 
  DeclException1(ExcInvalidGMSHInput,
                 std::string,
                 << "The string <" << arg1
                 << "> is not recognized at the present"
                 << " position of a Gmsh Mesh file.");
 
  DeclException1(ExcGmshUnsupportedGeometry,
                 int,
                 << "The Element Identifier <" << arg1 << "> is not "
                 << "supported in the deal.II library when "
                 << "reading meshes in " << dim << " dimensions.\n"
                 << "Supported elements are: \n"
                 << "ELM-TYPE\n"
                 << "1 Line (2 nodes, 1 edge).\n"
                 << "2 Triangle (3 nodes, 3 edges).\n"
                 << "3 Quadrilateral (4 nodes, 4 edges).\n"
                 << "4 Tetrahedron (4 nodes, 6 edges, 4 faces) when in 3d.\n"
                 << "5 Hexahedron (8 nodes, 12 edges, 6 faces) when in 3d.\n"
                 << "15 Point (1 node, ignored when read).");
 
 
  DeclException2(
    ExcGmshNoCellInformation,
    unsigned int,
    unsigned int,
    "While reading a gmsh file, the reader function did not find "
    "any cells. This sometimes happens if the file only contains a "
    "surface mesh, but not a volume mesh."
    "\n\n"
    "The reader function did find " +
      std::to_string(arg1) + " lines and " + std::to_string(arg2) +
      " facets (surface triangles or quadrilaterals).");
 
protected:
  ObserverPointer<Triangulation<dim, spacedim>, GridIn<dim, spacedim>> tria;
 
  static void
  debug_output_grid(const std::vector<CellData<dim>>   &cells,
                    const std::vector<Point<spacedim>> &vertices,
                    std::ostream                       &out);
 
private:
  static void
  skip_empty_lines(std::istream &in);
 
  static void
  skip_comment_lines(std::istream &in, const char comment_start);
 
  static void
  parse_tecplot_header(std::string               &header,
                       std::vector<unsigned int> &tecplot2deal,
                       unsigned int              &n_vars,
                       unsigned int              &n_vertices,
                       unsigned int              &n_cells,
                       std::vector<unsigned int> &IJK,
                       bool                      &structured,
                       bool                      &blocked);
 
  Format default_format;
 
  std::map<std::string, Vector<double>> cell_data;
};
 
/* -------------- declaration of explicit specializations ------------- */
 
#ifndef DOXYGEN
 
template <>
void
GridIn<2>::debug_output_grid(const std::vector<CellData<2>> &cells,
                             const std::vector<Point<2>>    &vertices,
                             std::ostream                   &out);
 
 
template <>
void
GridIn<2, 3>::debug_output_grid(const std::vector<CellData<2>> &cells,
                                const std::vector<Point<3>>    &vertices,
                                std::ostream                   &out);
template <>
void
GridIn<3>::debug_output_grid(const std::vector<CellData<3>> &cells,
                             const std::vector<Point<3>>    &vertices,
                             std::ostream                   &out);
#endif // DOXYGEN
 
DEAL_II_NAMESPACE_CLOSE
 
#endif