grid_in.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#ifndef dealii_grid_in_h
#define dealii_grid_in_h


#include <deal.II/base/config.h>

#include <deal.II/base/exceptions.h>
#include <deal.II/base/point.h>
#include <deal.II/base/smartpointer.h>

#include <iostream>
#include <string>
#include <vector>

DEAL_II_NAMESPACE_OPEN

template <int dim, int space_dim>
class Triangulation;
template <int dim>
struct CellData;

template <int dim, int spacedim = dim>
class GridIn
{
public:
  enum Format
  {
    Default,
    unv,
    ucd,
    abaqus,
    dbmesh,
    xda,
    msh,
    netcdf,
    tecplot,
    vtk,
    assimp,
  };

  GridIn();

  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_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_netcdf(const std::string &filename);

  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);

  static std::string
  default_suffix(const Format format);

  static Format
  parse_format(const std::string &format_name);

  static std::string
  get_format_names();

  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?");
  DeclException0(ExcNoTriangulationSelected);
  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"
                 << "3 Quadrilateral (4 nodes, 4 edges).\n"
                 << "5 Hexahedron (8 nodes, 12 edges, 6 faces) when in 3d.\n"
                 << "15 Point (1 node, ignored when read)");


  DeclException0(ExcGmshNoCellInformation);

protected:
  SmartPointer<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;
};

/* -------------- 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