nemesis_io_helper.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2019 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_NEMESIS_IO_HELPER_H
#define LIBMESH_NEMESIS_IO_HELPER_H
 
#include "libmesh/libmesh_config.h"
 
#if defined(LIBMESH_HAVE_NEMESIS_API) && defined(LIBMESH_HAVE_EXODUS_API)
 
// Local headers
#include "libmesh/exodusII_io_helper.h"
 
// C++ headers
#include <set>
#include <vector>
 
namespace libMesh
{
 
// Forward declarations
class EquationSystems;
template <typename T> class NumericVector;
 
// The Nemesis API header file.  Should already be
// correctly extern C'd but it doesn't hurt :)
namespace Nemesis {
extern "C" {
  // this include guard gets set by exodus, but we included it
  // in a namespace, so nemesis will not properly resolve e.g.
  // ex_entity_id in the global namespace.  undefine the guard
  // to get ne_nemesisI.h to properly include the typedefs
#  ifdef EXODUS_II_HDR
#    undef EXODUS_II_HDR
#  endif
#  include "ne_nemesisI.h"
}
}
 
 
class Nemesis_IO_Helper : public ExodusII_IO_Helper
{
public:
  explicit
  Nemesis_IO_Helper(const ParallelObject & parent,
                    bool verbose=false, bool single_precision=false);
 
  virtual ~Nemesis_IO_Helper();
 
  void get_init_global();
 
  void get_ss_param_global();
  void get_ns_param_global();
  void get_eb_info_global();
  void get_init_info();
  void get_loadbal_param();
  void get_elem_map();
  void get_node_map();
  void get_cmap_params();
  void get_node_cmap();
  void get_elem_cmap();
 
  void put_init_info(unsigned num_proc,
                     unsigned num_proc_in_file,
                     const char * ftype);
 
  void put_init_global(dof_id_type num_nodes_global,
                       dof_id_type num_elems_global,
                       unsigned num_elem_blks_global,
                       unsigned num_node_sets_global,
                       unsigned num_side_sets_global);
 
  void put_eb_info_global(std::vector<int> & global_elem_blk_ids,
                          std::vector<int> & global_elem_blk_cnts);
 
  void put_ns_param_global(std::vector<int> & global_nodeset_ids,
                           std::vector<int> & num_global_node_counts,
                           std::vector<int> & num_global_node_df_counts);
 
  void put_ss_param_global(std::vector<int> & global_sideset_ids,
                           std::vector<int> & num_global_side_counts,
                           std::vector<int> & num_global_side_df_counts);
 
 
 
  void put_loadbal_param(unsigned num_internal_nodes,
                         unsigned num_border_nodes,
                         unsigned num_external_nodes,
                         unsigned num_internal_elems,
                         unsigned num_border_elems,
                         unsigned num_node_cmaps,
                         unsigned num_elem_cmaps);
 
  void put_cmap_params(std::vector<int> & node_cmap_ids,
                       std::vector<int> & node_cmap_node_cnts,
                       std::vector<int> & elem_cmap_ids,
                       std::vector<int> & elem_cmap_elem_cnts);
 
  void put_node_cmap(std::vector<std::vector<int>> & node_cmap_node_ids,
                     std::vector<std::vector<int>> & node_cmap_proc_ids);
 
  void put_node_map(std::vector<int> & node_mapi,
                    std::vector<int> & node_mapb,
                    std::vector<int> & node_mape);
 
  void put_elem_cmap(std::vector<std::vector<int>> & elem_cmap_elem_ids,
                     std::vector<std::vector<int>> & elem_cmap_side_ids,
                     std::vector<std::vector<int>> & elem_cmap_proc_ids);
 
  void put_elem_map(std::vector<int> & elem_mapi,
                    std::vector<int> & elem_mapb);
 
  void put_n_coord(unsigned start_node_num,
                   unsigned num_nodes,
                   std::vector<Real> & x_coor,
                   std::vector<Real> & y_coor,
                   std::vector<Real> & z_coor);
 
 
  virtual void write_nodal_coordinates(const MeshBase & mesh, bool use_discontinuous=false) override;
 
  virtual void write_elements(const MeshBase & mesh, bool use_discontinuous=false) override;
 
  virtual void write_sidesets(const MeshBase & mesh) override;
 
  virtual void write_nodesets(const MeshBase & mesh) override;
 
  virtual void create(std::string filename) override;
 
  virtual void initialize(std::string title, const MeshBase & mesh, bool use_discontinuous=false) override;
 
  void write_nodal_solution(const NumericVector<Number> & parallel_soln,
                            const std::vector<std::string> & names,
                            int timestep,
                            const std::vector<std::string> & output_names);
 
  void write_nodal_solution(const EquationSystems & es,
                            const std::vector<std::pair<unsigned int, unsigned int>> & var_nums,
                            int timestep,
                            const std::vector<std::string> & output_names);
 
  void write_nodal_solution(const std::vector<Number> & values,
                            const std::vector<std::string> & names,
                            int timestep);
 
  virtual
  void initialize_element_variables(std::vector<std::string> names,
                                    const std::vector<std::set<subdomain_id_type>> & vars_active_subdomains) override;
  void write_element_values(const MeshBase & mesh,
                            const EquationSystems & es,
                            const std::vector<std::pair<unsigned int, unsigned int>> &var_nums,
                            int timestep,
                            const std::vector<std::set<subdomain_id_type>> & vars_active_subdomains);
 
  std::string construct_nemesis_filename(const std::string & base_filename);
 
  int nemesis_err_flag;
 
  int num_nodes_global;
  int num_elems_global;
  int num_elem_blks_global;
  int num_node_sets_global;
  int num_side_sets_global;
 
  int num_proc;
 
  int num_proc_in_file;
 
  char ftype;
 
  std::vector<int> global_sideset_ids;
  std::vector<int> num_global_side_counts;
  std::vector<int> num_global_side_df_counts;
 
 
  std::vector<int> global_nodeset_ids;
  std::vector<int> num_global_node_counts;
  std::vector<int> num_global_node_df_counts;
 
 
  std::vector<int> global_elem_blk_ids;
  std::vector<int> global_elem_blk_cnts;
 
  std::set<int> nodes_attached_to_local_elems;
 
  std::map<subdomain_id_type, std::vector<dof_id_type>> subdomain_map;
 
  std::map<int, std::vector<int>> block_id_to_elem_connectivity;
 
  int num_internal_nodes;
 
  int num_border_nodes;
 
  int num_external_nodes;
 
  int num_internal_elems;
 
  int num_border_elems;
 
  int num_node_cmaps;
 
  int num_elem_cmaps;
 
 
 
  std::vector<int> elem_mapi;
 
  std::vector<int> elem_mapb;
 
 
 
  std::vector<int> node_mapi;
 
  std::vector<int> node_mapb;
 
  std::vector<int> node_mape;
 
 
  std::vector<int> node_cmap_ids;
  std::vector<int> node_cmap_node_cnts;
  std::vector<int> elem_cmap_ids;
  std::vector<int> elem_cmap_elem_cnts;
 
 
  std::vector<std::vector<int>> node_cmap_node_ids;
  std::vector<std::vector<int>> node_cmap_proc_ids;
 
 
  std::vector<std::vector<int>> elem_cmap_elem_ids;
  std::vector<std::vector<int>> elem_cmap_side_ids;
  std::vector<std::vector<int>> elem_cmap_proc_ids;
 
 
private:
  std::map<subdomain_id_type, unsigned> local_subdomain_counts;
 
  std::set<unsigned> border_node_ids;
 
  std::map<unsigned, std::set<unsigned>> proc_nodes_touched_intersections;
 
  typedef std::map<unsigned, std::set<unsigned>>::iterator proc_nodes_touched_iterator;
 
  std::map<unsigned, std::set<std::pair<unsigned,unsigned>>> proc_border_elem_sets;
 
  typedef std::map<unsigned, std::set<std::pair<unsigned,unsigned>>>::iterator proc_border_elem_sets_iterator;
 
  std::set<unsigned> internal_node_ids;
 
  std::set<unsigned> internal_elem_ids;
 
  std::set<unsigned> border_elem_ids;
 
  void compute_num_global_elem_blocks(const MeshBase & pmesh);
 
  void compute_num_global_nodesets(const MeshBase & pmesh);
 
  void compute_num_global_sidesets(const MeshBase & pmesh);
 
  void build_element_and_node_maps(const MeshBase & pmesh);
 
  void compute_border_node_ids(const MeshBase & pmesh);
 
  void compute_internal_and_border_elems_and_internal_nodes(const MeshBase & pmesh);
 
  void compute_communication_map_parameters();
 
  void compute_node_communication_maps();
 
  void compute_node_maps();
 
  void compute_elem_communication_maps();
 
  void compute_element_maps();
 
  void write_exodus_initialization_info(const MeshBase & pmesh,
                                        const std::string & title);
};
 
} // namespace libMesh
 
#endif // #if defined(LIBMESH_HAVE_NEMESIS_API) && defined(LIBMESH_HAVE_EXODUS_API)
#endif // LIBMESH_NEMESIS_IO_HELPER_H