nemesis_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_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 declaration
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 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 NumericVector<Number> & parallel_soln,
                            const std::vector<std::string> & names,
                            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