exodusII_io_helper.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2018 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner

// This library is free software; you can 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.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef LIBMESH_EXODUSII_IO_HELPER_H
#define LIBMESH_EXODUSII_IO_HELPER_H

#include "libmesh/libmesh_config.h"

#ifdef LIBMESH_HAVE_EXODUS_API

// Local includes
#include "libmesh/parallel_object.h"
#include "libmesh/point.h"

#ifdef LIBMESH_FORWARD_DECLARE_ENUMS
namespace libMesh
{
enum ElemType : int;
}
#else
#include "libmesh/enum_elem_type.h"
#endif

// C++ includes
#include <iostream>
#include <string>
#include <vector>
#include <map>

// Macros to simplify checking Exodus error codes
#define EX_CHECK_ERR(code, msg)                 \
  do {                                          \
    if ((code) < 0) {                           \
      libmesh_error_msg((msg));                 \
    } } while (0)

#define EX_EXCEPTIONLESS_CHECK_ERR(code, msg)   \
  do {                                          \
    if ((code) < 0) {                           \
      libMesh::err << (msg) << std::endl;       \
      libmesh_exceptionless_error();            \
    } } while (0)



// Through several subsequent levels of includes, the exodusII.h
// header includes <errno.h>.  On very specific system/compiler combinations
// (currently GCC 5.2.0+ OSX Yosemite, El Capitan, possibly others) errno.h
// cannot be included while wrapped in a namespace (as we do with the exII
// namespace below).  A workaround for this is to simply include errno.h
// not in any namespace prior to including exodusII.h.
//
// The same is also true for string.h.
#ifdef LIBMESH_COMPILER_HAS_BROKEN_ERRNO_T
#include <errno.h>
#include <string.h>
#endif


#include <libmesh/ignore_warnings.h>
namespace exII {
extern "C" {
#include "exodusII.h" // defines MAX_LINE_LENGTH, MAX_STR_LENGTH used later
}
}
#include <libmesh/restore_warnings.h>

namespace libMesh
{

// Forward declarations
class MeshBase;

class ExodusII_IO_Helper : public ParallelObject
{
public:
  ExodusII_IO_Helper(const ParallelObject & parent,
                     bool v=false,
                     bool run_only_on_proc0=true,
                     bool single_precision=false);
  virtual ~ExodusII_IO_Helper();

  const char * get_elem_type() const;

  void open(const char * filename, bool read_only);

  void read_header();

  void read_qa_records();

  void print_header();

  void read_nodes();

  void read_node_num_map();

  void print_nodes(std::ostream & out = libMesh::out);

  void read_block_info();

  int get_block_id(int index);

  std::string get_block_name(int index);

  int get_side_set_id(int index);

  std::string get_side_set_name(int index);

  int get_node_set_id(int index);

  std::string get_node_set_name(int index);

  void read_elem_in_block(int block);

  void read_elem_num_map();

  void read_sideset_info();

  void read_nodeset_info();

  void read_sideset(int id, int offset);

  void read_nodeset(int id);

  void close();

  int inquire(int req_info, std::string error_msg="");

  void read_time_steps();

  void read_num_time_steps();

  void read_nodal_var_values(std::string nodal_var_name, int time_step);

  void read_elemental_var_values(std::string elemental_var_name,
                                 int time_step,
                                 std::map<dof_id_type, Real> & elem_var_value_map);

  virtual void create(std::string filename);

  virtual void initialize(std::string title, const MeshBase & mesh, bool use_discontinuous=false);

  virtual void write_nodal_coordinates(const MeshBase & mesh, bool use_discontinuous=false);

  virtual void write_elements(const MeshBase & mesh, bool use_discontinuous=false);

  virtual void write_sidesets(const MeshBase & mesh);

  virtual void write_nodesets(const MeshBase & mesh);

  virtual void initialize_element_variables(std::vector<std::string> names,
                                            const std::vector<std::set<subdomain_id_type>> & vars_active_subdomains);

  void initialize_nodal_variables(std::vector<std::string> names);

  void initialize_global_variables(std::vector<std::string> names);

  void write_timestep(int timestep, Real time);

  void write_element_values(const MeshBase & mesh,
                            const std::vector<Real> & values,
                            int timestep,
                            const std::vector<std::set<subdomain_id_type>> & vars_active_subdomains);

  void write_nodal_values(int var_id, const std::vector<Real> & values, int timestep);

  void write_information_records(const std::vector<std::string> & records);

  void write_global_values(const std::vector<Real> & values, int timestep);

  void read_global_values(std::vector<Real> & values, int timestep);

  void use_mesh_dimension_instead_of_spatial_dimension(bool val);

  void write_as_dimension(unsigned dim);

  void set_coordinate_offset(Point p);

  std::vector<std::string> get_complex_names(const std::vector<std::string> & names) const;

  std::vector<std::set<subdomain_id_type>> get_complex_vars_active_subdomains(
    const std::vector<std::set<subdomain_id_type>> & vars_active_subdomains) const;

  class Conversion;

  class ElementMaps;

  class NamesData;

  void message(const std::string & msg);

  void message(const std::string & msg, int i);

  // File identification flag
  int ex_id;

  // General error flag
  int ex_err;

  // Number of dimensions in the mesh
  int num_dim;

  // Number of global variables
  int num_global_vars;

  // Total number of nodes in the mesh
  int num_nodes;

  // Total number of elements in the mesh
  int num_elem;

  // Total number of element blocks
  int num_elem_blk;

  // Total number of node sets
  int num_node_sets;

  // Total number of element sets
  int num_side_sets;

  // Number of elements in this block
  int num_elem_this_blk;

  // Number of nodes in each element
  int num_nodes_per_elem;

  // Number of attributes for a given block
  int num_attr;

  // Total number of elements in all side sets
  int num_elem_all_sidesets;

  // Vector of the block identification numbers
  std::vector<int> block_ids;

  // Vector of nodes in an element
  std::vector<int> connect;

  // Vector of the sideset IDs
  std::vector<int> ss_ids;

  // Vector of the nodeset IDs
  std::vector<int> nodeset_ids;

  // Number of sides (edges/faces) in current set
  std::vector<int> num_sides_per_set;

  // Number of nodes in current set
  std::vector<int> num_nodes_per_set;

  // Number of distribution factors per set
  std::vector<int> num_df_per_set;

  // Number of distribution factors per set
  std::vector<int> num_node_df_per_set;

  // List of element numbers in all sidesets
  std::vector<int> elem_list;

  // Side (face/edge) number actually on the boundary
  std::vector<int> side_list;

  // Node number actually on the boundary
  std::vector<int> node_list;

  // Side (face/edge) id number
  std::vector<int> id_list;

  // Optional mapping from internal [0,num_nodes) to arbitrary indices
  std::vector<int> node_num_map;

  // Optional mapping from internal [0,num_elem) to arbitrary indices
  std::vector<int> elem_num_map;

  // x locations of node points
  std::vector<Real> x;

  // y locations of node points
  std::vector<Real> y;

  // z locations of node points
  std::vector<Real> z;

  //  Problem title (Use vector<char> to emulate a char *)
  std::vector<char> title;

  // Type of element in a given block
  std::vector<char> elem_type;

  // Maps libMesh element numbers to Exodus element numbers
  // gets filled in when write_elements gets called
  std::map<int, int> libmesh_elem_num_to_exodus;
  std::vector<int> exodus_elem_num_to_libmesh;

  // Map of all node numbers connected to local node numbers to their exodus numbering.
  // The exodus numbers are stored in here starting with 1
  std::map<int, int> libmesh_node_num_to_exodus;
  std::vector<int> exodus_node_num_to_libmesh;

  // The number of timesteps in the file, as returned by ex_inquire
  int num_time_steps;

  // The timesteps stored in the solution file, filled by read_time_steps()
  std::vector<Real> time_steps;

  // The number of nodal variables in the Exodus file
  int num_nodal_vars;

  // The names of the nodal variables stored in the Exodus file
  std::vector<std::string> nodal_var_names;

  // Holds the nodal variable values for a given variable, one value per node
  std::vector<Real> nodal_var_values;

  // The number of elemental variables in the Exodus file
  int num_elem_vars;

  // The names of the elemental variables stored in the Exodus file
  std::vector<std::string> elem_var_names;

  // Holds the elemental variable values for a given variable, one value per element
  std::vector<Real> elem_var_values;

  // The names of the global variables stored in the Exodus file
  std::vector<std::string> global_var_names;

  // Maps of Ids to named entities
  std::map<int, std::string> id_to_block_names;
  std::map<int, std::string> id_to_ss_names;
  std::map<int, std::string> id_to_ns_names;

  // On/Off message flag
  bool verbose;

  // This flag gets set after the Exodus file has been successfully opened for writing.
  // Both the create() and open() (if called with EX_WRITE) functions may set this flag.
  bool opened_for_writing;

  // This flag gets set after the open() function has been successfully called.
  // We call open() to open an ExodusII file for reading.
  bool opened_for_reading;

  // When either create() or open() is called, the Helper stores the
  // name of the opened file as current_filename.  This way, the
  // ExodusII_IO object can check to see if, on subsequent writes, the
  // user is asking to write to a *different* filename from the one
  // that is currently open, and signal an error.  The current
  // ExodusII_IO implementation is designed to work with a single file
  // only, so if you want to write to multiple Exodus files, use a
  // different ExodusII_IO object for each one.
  std::string current_filename;

  enum ExodusVarType {NODAL=0, ELEMENTAL=1, GLOBAL=2};
  void read_var_names(ExodusVarType type);

protected:
  void check_existing_vars(ExodusVarType type, std::vector<std::string> & names, std::vector<std::string> & names_from_file);

  void write_var_names(ExodusVarType type, std::vector<std::string> & names);

  // If true, whenever there is an I/O operation, only perform if if we are on processor 0.
  bool _run_only_on_proc0;

  // True once the elem vars are initialized
  bool _elem_vars_initialized;

  // True once the global vars are initialized
  bool _global_vars_initialized;

  // True once the nodal vars are initialized
  bool _nodal_vars_initialized;

  // If true, use the Mesh's dimension (as determined by the dimension
  // of the elements comprising the mesh) instead of the mesh's
  // spatial dimension, when writing.  By default this is false.
  bool _use_mesh_dimension_instead_of_spatial_dimension;

  // Use this for num_dim when writing the Exodus file.  If non-zero, supersedes
  // any value set in _use_mesh_dimension_instead_of_spatial_dimension.
  unsigned _write_as_dimension;

  // On output, shift every point by _coordinate_offset
  Point _coordinate_offset;

  // If true, forces single precision I/O
  bool _single_precision;

private:

  void read_var_names_impl(const char * var_type,
                           int & count,
                           std::vector<std::string> & result);

  void write_var_names_impl(const char * var_type,
                            int & count,
                            std::vector<std::string> & names);
};








class ExodusII_IO_Helper::Conversion
{
public:

  Conversion(const int * nm,       // node_map
             size_t nm_size,
             const int * inm,      // inverse_node_map
             size_t inm_size,
             const int * sm,       // side_map
             size_t sm_size,
             const int * ism,      // inverse_side_map
             size_t ism_size,
             const ElemType ct,   // "canonical" aka libmesh element type
             std::string ex_type) // string representing the Exodus element type
    : node_map(nm),
      node_map_size(nm_size),
      inverse_node_map(inm),
      inverse_node_map_size(inm_size),
      side_map(sm),
      side_map_size(sm_size),
      inverse_side_map(ism),
      inverse_side_map_size(ism_size),
      shellface_map(nullptr),
      shellface_map_size(0),
      inverse_shellface_map(nullptr),
      inverse_shellface_map_size(0),
      shellface_index_offset(0),
      canonical_type(ct),
      exodus_type(ex_type)
  {}

  Conversion(const int * nm,       // node_map
             size_t nm_size,
             const int * inm,      // inverse_node_map
             size_t inm_size,
             const int * sm,       // side_map
             size_t sm_size,
             const int * ism,      // inverse_side_map
             size_t ism_size,
             const int * sfm,      // shellface_map
             size_t sfm_size,
             const int * isfm,     // inverse_shellface_map
             size_t isfm_size,
             size_t sfi_offset,
             const ElemType ct,   // "canonical" aka libmesh element type
             std::string ex_type) // string representing the Exodus element type
    : node_map(nm),
      node_map_size(nm_size),
      inverse_node_map(inm),
      inverse_node_map_size(inm_size),
      side_map(sm),
      side_map_size(sm_size),
      inverse_side_map(ism),
      inverse_side_map_size(ism_size),
      shellface_map(sfm),
      shellface_map_size(sfm_size),
      inverse_shellface_map(isfm),
      inverse_shellface_map_size(isfm_size),
      shellface_index_offset(sfi_offset),
      canonical_type(ct),
      exodus_type(ex_type)
  {
    // libmesh_ignore variables that are only used in asserts to avoid
    // compiler warnings.
    libmesh_ignore(node_map_size,
                   inverse_node_map_size,
                   inverse_side_map_size,
                   shellface_map_size,
                   inverse_shellface_map_size);
  }

  int get_node_map(int i) const
  {
    libmesh_assert_less (static_cast<size_t>(i), node_map_size);
    return node_map[i];
  }

  int get_inverse_node_map(int i) const
  {
    libmesh_assert_less (static_cast<size_t>(i), inverse_node_map_size);
    return inverse_node_map[i];
  }

  int get_side_map(int i) const;

  int get_inverse_side_map(int i) const
  {
    libmesh_assert_less (static_cast<size_t>(i), inverse_side_map_size);
    return inverse_side_map[i];
  }

  int get_shellface_map(int i) const
  {
    libmesh_assert_less (static_cast<size_t>(i), shellface_map_size);
    return shellface_map[i];
  }

  int get_inverse_shellface_map(int i) const
  {
    libmesh_assert_less (static_cast<size_t>(i), inverse_shellface_map_size);
    return inverse_shellface_map[i];
  }

  ElemType get_canonical_type()    const { return canonical_type; }

  std::string exodus_elem_type() const { return exodus_type; }

  std::size_t get_shellface_index_offset() const { return shellface_index_offset; }

  static const int invalid_id;

private:
  const int * node_map;

  size_t node_map_size;

  const int * inverse_node_map;

  size_t inverse_node_map_size;

  const int * side_map;

  size_t side_map_size;

  const int * inverse_side_map;

  size_t inverse_side_map_size;

  const int * shellface_map;

  size_t shellface_map_size;

  const int * inverse_shellface_map;

  size_t inverse_shellface_map_size;

  size_t shellface_index_offset;

  const ElemType canonical_type;

  const std::string exodus_type;
};






class ExodusII_IO_Helper::ElementMaps
{
public:

  ElementMaps() {}

public:

  static const int nodeelem_node_map[1];

  static const int edge2_node_map[2];

  static const int edge3_node_map[3];

  // FIXME: This notion may or may not be defined in ExodusII

  static const int edge_edge_map[2];

  static const int edge_inverse_edge_map[2];

  static const int quad4_node_map[4];

  static const int quad8_node_map[8];

  static const int quad9_node_map[9];

  static const int tri3_node_map[3];

  static const int tri6_node_map[6];

  static const int tri_edge_map[3];

  static const int trishell3_edge_map[3];
  static const int trishell3_inverse_edge_map[3];

  static const int quad_edge_map[4];

  static const int quadshell4_edge_map[4];
  static const int quadshell4_inverse_edge_map[4];

  static const int tri_inverse_edge_map[3];

  static const int quad_inverse_edge_map[4];

  static const int hex8_node_map[8];

  static const int hex20_node_map[20];

  static const int hex27_node_map[27];

  static const int hex27_inverse_node_map[27];

  static const int tet4_node_map[4];

  static const int tet10_node_map[10];

  static const int prism6_node_map[6];

  static const int prism15_node_map[15];

  static const int prism18_node_map[18];

  static const int pyramid5_node_map[5];

  static const int pyramid13_node_map[13];

  static const int pyramid14_node_map[14];


  static const int trishell3_shellface_map[2];
  static const int trishell3_inverse_shellface_map[2];

  static const int quadshell4_shellface_map[2];
  static const int quadshell4_inverse_shellface_map[2];

  static const int hex_face_map[6];

  static const int hex27_face_map[6];

  static const int tet_face_map[4];

  static const int prism_face_map[5];

  static const int pyramid_face_map[5];

  static const int hex_inverse_face_map[6];

  static const int hex27_inverse_face_map[6];

  static const int tet_inverse_face_map[4];

  static const int prism_inverse_face_map[5];

  static const int pyramid_inverse_face_map[5];

  ExodusII_IO_Helper::Conversion assign_conversion(std::string type_str);

  ExodusII_IO_Helper::Conversion assign_conversion(const ElemType type);
};



class ExodusII_IO_Helper::NamesData
{
public:
  explicit
  NamesData(size_t n_strings, size_t string_length);

  void push_back_entry(const std::string & name);

  char ** get_char_star_star();

  char * get_char_star(int i);

private:
  // C++ data structures for managing string memory
  std::vector<std::vector<char>> data_table;
  std::vector<char *> data_table_pointers;

  size_t counter;
  size_t table_size;
};


} // namespace libMesh

#endif // LIBMESH_HAVE_EXODUS_API

#endif // LIBMESH_EXODUSII_IO_HELPER_H