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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#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/smartpointer.h>
#include <deal.II/base/point.h>
#include <iostream>
#include <vector>
#include <string>

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