Poster of Linux kernelThe best gift for a Linux geek
Nemesis_IO_Helper

Nemesis_IO_Helper

Section: C Library Functions (3) Updated: Thu Apr 7 2011
Local index Up
 

NAME

Nemesis_IO_Helper -  

SYNOPSIS


#include <nemesis_io_helper.h>

Inherits ExodusII_IO_Helper.  

Public Member Functions


Nemesis_IO_Helper (bool verbose=false)

~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 ()

bool created ()

void verbose (bool set_verbosity)

int get_num_dim () const

int get_num_nodes () const

int get_num_elem () const

int get_num_elem_blk () const

int get_num_elem_this_blk () const

int get_num_nodes_per_elem () const

int get_num_side_sets () const

int get_num_node_sets () const

int get_connect (int i) const

int get_num_sides_per_set (int i) const

int get_num_nodes_per_set (int i) const

const std::vector< int > & get_elem_list () const

const std::vector< int > & get_side_list () const

const std::vector< int > & get_node_list () const

int get_nodeset_id (unsigned int i) const

const std::vector< int > & get_id_list () const

const char * get_elem_type () const

double get_x (int i) const

double get_y (int i) const

double get_z (int i) const

void open (const char *filename)

void read_header ()

void print_header ()

void read_nodes ()

void read_node_num_map ()

void print_nodes ()

void read_block_info ()

int get_block_id (int block)

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 print_sideset_info ()

void print_nodeset_info ()

void close ()

int inquire (int req_info, std::string error_msg='')

const std::vector< double > & get_time_steps ()

int get_num_nodal_vars ()

const std::vector< std::string > & get_nodal_var_names ()

const std::vector< double > & get_nodal_var_values (std::string nodal_var_name, int time_step)

void create (std::string filename)

void initialize (std::string title, const MeshBase &mesh)

void write_nodal_coordinates (const MeshBase &mesh)

void write_elements (const MeshBase &mesh)

void write_sidesets (const MeshBase &mesh)

void write_nodesets (const MeshBase &mesh)

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

void write_timestep (int timestep, double time)

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

void check_err (const int error, const std::string msg)

void message (const std::string msg)

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

Public Attributes


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

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

int comp_ws

int io_ws

int ex_id

int ex_err

int num_dim

int num_nodes

int num_elem

int num_elem_blk

int num_node_sets

int num_side_sets

int num_elem_this_blk

int num_nodes_per_elem

int num_attr

int req_info

int ret_int

int num_elem_all_sidesets

std::vector< int > block_ids

std::vector< int > connect

std::vector< int > ss_ids

std::vector< int > nodeset_ids

std::vector< int > num_sides_per_set

std::vector< int > num_nodes_per_set

std::vector< int > num_df_per_set

std::vector< int > num_node_df_per_set

std::vector< int > elem_list

std::vector< int > side_list

std::vector< int > node_list

std::vector< int > id_list

std::vector< int > node_num_map

std::vector< int > elem_num_map

float ex_version

float ret_float

std::vector< double > x

std::vector< double > y

std::vector< double > z

char ret_char

std::vector< char > title

std::vector< char > elem_type

std::map< int, int > libmesh_elem_num_to_exodus

int num_time_steps

std::vector< double > time_steps

int num_nodal_vars

std::vector< std::string > nodal_var_names

std::vector< double > nodal_var_values

std::vector< std::vector< char > > vvc

std::vector< char * > strings
 

Protected Attributes


bool _created

bool _verbose
 

Detailed Description

This is the Nemesis_IO_Helper class. Think of it as a big struct with storage for all the stuff one might want to pull from a Nemesis file. Also contains an ExodusII_IO_Helper object, since Nemesis is based on the same file format.

Author:

Johw W. Peterson, 2008.

Definition at line 48 of file nemesis_io_helper.h.  

Constructor & Destructor Documentation

 

Nemesis_IO_Helper::Nemesis_IO_Helper (boolverbose = false)Constructor.

Definition at line 28 of file nemesis_io_helper.C.

                                                 :
  ExodusII_IO_Helper(verbose),
  nemesis_err_flag(0),
  num_nodes_global(0),
  num_elems_global(0),
  num_elem_blks_global(0),
  num_node_sets_global(0),
  num_side_sets_global(0),
  num_proc(0),
  num_proc_in_file(0),
  ftype(' '),
  num_internal_nodes(0),
  num_border_nodes(0),
  num_external_nodes(0),
  num_internal_elems(0),
  num_border_elems(0),
  num_node_cmaps(0),
  num_elem_cmaps(0)
{
  // Warn about using untested code!
  libmesh_experimental();
}
 

Nemesis_IO_Helper::~Nemesis_IO_Helper ()Destructor.

Definition at line 52 of file nemesis_io_helper.C.

{
}
 

Member Function Documentation

 

void ExodusII_IO_Helper::check_err (const interror, const std::stringmsg) [inherited]All of the ExodusII API functions return an int error value. This function checks to see if the error has been set, and if it has, prints the error message contained in msg.

Definition at line 116 of file exodusII_io_helper.C.

Referenced by ExodusII_IO_Helper::close(), ExodusII_IO_Helper::create(), get_cmap_params(), get_eb_info_global(), get_elem_cmap(), get_elem_map(), get_init_global(), get_init_info(), get_loadbal_param(), get_node_cmap(), get_node_map(), get_ns_param_global(), get_ss_param_global(), ExodusII_IO_Helper::initialize(), ExodusII_IO_Helper::initialize_nodal_variables(), ExodusII_IO_Helper::inquire(), ExodusII_IO_Helper::open(), ExodusII_IO_Helper::read_block_info(), ExodusII_IO_Helper::read_elem_in_block(), ExodusII_IO_Helper::read_elem_num_map(), ExodusII_IO_Helper::read_header(), ExodusII_IO_Helper::read_node_num_map(), ExodusII_IO_Helper::read_nodes(), ExodusII_IO_Helper::read_nodeset(), ExodusII_IO_Helper::read_nodeset_info(), ExodusII_IO_Helper::read_sideset(), ExodusII_IO_Helper::read_sideset_info(), ExodusII_IO_Helper::write_elements(), ExodusII_IO_Helper::write_nodal_coordinates(), ExodusII_IO_Helper::write_nodal_values(), ExodusII_IO_Helper::write_nodesets(), ExodusII_IO_Helper::write_sidesets(), and ExodusII_IO_Helper::write_timestep().

{
  if (err < 0)
    {
      std::cout << msg << std::endl;
      libmesh_error();
    }
}
 

void ExodusII_IO_Helper::close () [inherited]Closes the ExodusII mesh file.

Definition at line 435 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, and ExodusII_IO_Helper::message().

Referenced by ExodusII_IO::~ExodusII_IO().

{
  ex_err = exII::ex_close(ex_id);
  check_err(ex_err, 'Error closing Exodus file.');
  message('Exodus file closed successfully.'); 
}
 

void ExodusII_IO_Helper::create (std::stringfilename) [inherited]Opens an ExodusII mesh file named filename for writing.

Definition at line 538 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_created, ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::comp_ws, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::ex_version, and ExodusII_IO_Helper::io_ws.

{
  //Store things as doubles
  comp_ws = 8;
  io_ws = 8;
    
  ex_id = exII::ex_create(filename.c_str(), EX_CLOBBER, &comp_ws, &io_ws);
    
  ex_id = exII::ex_open(filename.c_str(),
                        EX_WRITE,
                        &comp_ws,
                        &io_ws,
                        &ex_version);
  
  check_err(ex_id, 'Error creating ExodusII mesh file.');
  if (_verbose) std::cout << 'File created successfully.' << std::endl;

  _created = true;
}
 

bool ExodusII_IO_Helper::created () [inherited]Returns true once create() has been successfully called, and false otherwise.

Definition at line 819 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_created.

{
  return _created;
}
 

int ExodusII_IO_Helper::get_block_id (intblock) [inherited]Get's the block number for the given block.

Definition at line 256 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::block_ids.

Referenced by ExodusII_IO::read().

{
  libmesh_assert (static_cast<unsigned int>(block) < block_ids.size());
    
  return block_ids[block];
}
 

void Nemesis_IO_Helper::get_cmap_params ()

Definition at line 304 of file nemesis_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), elem_cmap_elem_cnts, elem_cmap_ids, ExodusII_IO_Helper::ex_id, nemesis_err_flag, node_cmap_ids, node_cmap_node_cnts, num_elem_cmaps, num_node_cmaps, and libMesh::processor_id().

Referenced by Nemesis_IO::read().

{
  node_cmap_ids.resize(num_node_cmaps);
  node_cmap_node_cnts.resize(num_node_cmaps);
  elem_cmap_ids.resize(num_elem_cmaps);
  elem_cmap_elem_cnts.resize(num_elem_cmaps);
  
  nemesis_err_flag =
    Nemesis::ne_get_cmap_params(ex_id,
                                node_cmap_ids.empty()       ? NULL : &node_cmap_ids[0],
                                node_cmap_node_cnts.empty() ? NULL : &node_cmap_node_cnts[0],
                                elem_cmap_ids.empty()       ? NULL : &elem_cmap_ids[0],
                                elem_cmap_elem_cnts.empty() ? NULL : &elem_cmap_elem_cnts[0],
                                libMesh::processor_id());
  this->check_err(nemesis_err_flag, 'Error reading cmap parameters!');


  if (_verbose)
    {
      std::cout << '[' << libMesh::processor_id() << '] ';
      for (unsigned int i=0; i<node_cmap_ids.size(); ++i)
        std::cout << 'node_cmap_ids['<<i<<']=' << node_cmap_ids[i] << ' ';
      std::cout << std::endl;
        
      std::cout << '[' << libMesh::processor_id() << '] ';
      for (unsigned int i=0; i<node_cmap_node_cnts.size(); ++i)
        std::cout << 'node_cmap_node_cnts['<<i<<']=' << node_cmap_node_cnts[i] << ' ';
      std::cout << std::endl;

      std::cout << '[' << libMesh::processor_id() << '] ';
      for (unsigned int i=0; i<elem_cmap_ids.size(); ++i)
        std::cout << 'elem_cmap_ids['<<i<<']=' << elem_cmap_ids[i] << ' ';
      std::cout << std::endl;

      std::cout << '[' << libMesh::processor_id() << '] ';
      for (unsigned int i=0; i<elem_cmap_elem_cnts.size(); ++i)
        std::cout << 'elem_cmap_elem_cnts['<<i<<']=' << elem_cmap_elem_cnts[i] << ' ';
      std::cout << std::endl;
    }
}
 

int ExodusII_IO_Helper::get_connect (inti) const [inline, inherited]Returns:

the number of elements in all the sidesets. Effectively returns the total number of elements on the ExodusII mesh boundary.

the $ i^{th} $ node number in the element connectivity list for a given element.

Definition at line 174 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::connect.

Referenced by ExodusII_IO::read().

{ return connect[i]; }
 

void Nemesis_IO_Helper::get_eb_info_global ()

Definition at line 156 of file nemesis_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_id, global_elem_blk_cnts, global_elem_blk_ids, nemesis_err_flag, num_elem_blks_global, and libMesh::processor_id().

Referenced by Nemesis_IO::read().

{
  global_elem_blk_ids.resize(num_elem_blks_global);
  global_elem_blk_cnts.resize(num_elem_blks_global);
  
  nemesis_err_flag =
    Nemesis::ne_get_eb_info_global(ex_id,
                                   global_elem_blk_ids.empty()  ? NULL : &global_elem_blk_ids[0],
                                   global_elem_blk_cnts.empty() ? NULL : &global_elem_blk_cnts[0]);                       
  this->check_err(nemesis_err_flag, 'Error reading global element block info!');

  if (_verbose)
    {
      std::cout << '[' << libMesh::processor_id() << '] ' << 'Global Element Block IDs and Counts:' << std::endl;
      for (unsigned int bn=0; bn<global_elem_blk_ids.size(); ++bn)
        {
          std::cout << '  [' << libMesh::processor_id() << '] '
                    << 'global_elem_blk_ids['<<bn<<']=' << global_elem_blk_ids[bn]
                    << ', global_elem_blk_cnts['<<bn<<']=' << global_elem_blk_cnts[bn]
                    << std::endl;
        }
    }
}
 

void Nemesis_IO_Helper::get_elem_cmap ()

Definition at line 384 of file nemesis_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), elem_cmap_elem_cnts, elem_cmap_elem_ids, elem_cmap_ids, elem_cmap_proc_ids, elem_cmap_side_ids, ExodusII_IO_Helper::ex_id, nemesis_err_flag, num_elem_cmaps, and libMesh::processor_id().

Referenced by Nemesis_IO::read().

{
  elem_cmap_elem_ids.resize(num_elem_cmaps);
  elem_cmap_side_ids.resize(num_elem_cmaps);
  elem_cmap_proc_ids.resize(num_elem_cmaps);
          
  for (unsigned int i=0; i<elem_cmap_elem_ids.size(); ++i)
    {
      elem_cmap_elem_ids[i].resize(elem_cmap_elem_cnts[i]);
      elem_cmap_side_ids[i].resize(elem_cmap_elem_cnts[i]);
      elem_cmap_proc_ids[i].resize(elem_cmap_elem_cnts[i]);

      nemesis_err_flag =
        Nemesis::ne_get_elem_cmap(ex_id,
                                  elem_cmap_ids.empty()         ? NULL : elem_cmap_ids[i],
                                  elem_cmap_elem_ids[i].empty() ? NULL : &elem_cmap_elem_ids[i][0],
                                  elem_cmap_side_ids[i].empty() ? NULL : &elem_cmap_side_ids[i][0],
                                  elem_cmap_proc_ids[i].empty() ? NULL : &elem_cmap_proc_ids[i][0],
                                  libMesh::processor_id());
      this->check_err(nemesis_err_flag, 'Error reading elem cmap elem, side, and processor ids!');


      if (_verbose)
        {
          std::cout << '[' << libMesh::processor_id() << '] elem_cmap_elem_ids['<<i<<']=';
          for (unsigned int j=0; j<elem_cmap_elem_ids[i].size(); ++j)
            std::cout << elem_cmap_elem_ids[i][j] << ' ';
          std::cout << std::endl;

          // These must be the (local) side IDs (in the ExodusII face numbering scheme)
          // of the sides shared across processors.
          std::cout << '[' << libMesh::processor_id() << '] elem_cmap_side_ids['<<i<<']=';
          for (unsigned int j=0; j<elem_cmap_side_ids[i].size(); ++j)
            std::cout << elem_cmap_side_ids[i][j] << ' ';
          std::cout << std::endl;

          // This is basically a vector, all entries of which are = elem_cmap_ids[i]
          // Not sure if it's always guaranteed to be that or what...
          std::cout << '[' << libMesh::processor_id() << '] elem_cmap_proc_ids['<<i<<']=';
          for (unsigned int j=0; j<elem_cmap_proc_ids[i].size(); ++j)
            std::cout << elem_cmap_proc_ids[i][j] << ' ';
          std::cout << std::endl;
        }
    }
}
 

const std::vector<int>& ExodusII_IO_Helper::get_elem_list () const [inline, inherited]Returns:

the $ i^{th} $ entry in the element list. The element list contains the numbers of all elements on the boundary.

a constant reference to the elem_list.

Definition at line 202 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::elem_list.

Referenced by ExodusII_IO::read().

{ return elem_list; }
 

void Nemesis_IO_Helper::get_elem_map ()

Definition at line 231 of file nemesis_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), elem_mapb, elem_mapi, ExodusII_IO_Helper::ex_id, std::min(), nemesis_err_flag, num_border_elems, num_internal_elems, and libMesh::processor_id().

{
  elem_mapi.resize(num_internal_elems);
  elem_mapb.resize(num_border_elems);
  
  nemesis_err_flag =
    Nemesis::ne_get_elem_map(ex_id,
                             elem_mapi.empty() ? NULL : &elem_mapi[0],
                             elem_mapb.empty() ? NULL : &elem_mapb[0],
                             libMesh::processor_id()
                             );
  this->check_err(nemesis_err_flag, 'Error reading element maps!');


  if (_verbose)
    {
      // These are not contiguous ranges....
      //std::cout << '[' << libMesh::processor_id() << '] ' << 'first interior elem id=' << elem_mapi[0] << std::endl;
      //std::cout << '[' << libMesh::processor_id() << '] ' << 'last interior elem id=' << elem_mapi.back() << std::endl;
      //std::cout << '[' << libMesh::processor_id() << '] ' << 'first boundary elem id=' << elem_mapb[0] << std::endl;
      //std::cout << '[' << libMesh::processor_id() << '] ' << 'last boundary elem id=' << elem_mapb.back() << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] elem_mapi[i] = ';
      for (unsigned int i=0; i< static_cast<unsigned int>(num_internal_elems-1); ++i)
        std::cout << elem_mapi[i] << ', ';
      std::cout << '... ' << elem_mapi.back() << std::endl;

      std::cout << '[' << libMesh::processor_id() << '] elem_mapb[i] = ';
      for (unsigned int i=0; i< static_cast<unsigned int>(std::min(10, num_border_elems-1)); ++i)
        std::cout << elem_mapb[i] << ', ';
      std::cout << '... ' << elem_mapb.back() << std::endl;
    }
}
 

const char* ExodusII_IO_Helper::get_elem_type () const [inline, inherited]Returns:

the current element type. Note: the default behavior is for this value to be in all capital letters, e.g. HEX27.

Definition at line 249 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::elem_type.

Referenced by ExodusII_IO::read().

{ return &elem_type[0]; }
 

const std::vector<int>& ExodusII_IO_Helper::get_id_list () const [inline, inherited]Returns:

the $ i^{th} $ entry in the id list. This is the id for the ith face on the boundary.

a constant reference to the id_list.

Definition at line 239 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::id_list.

Referenced by ExodusII_IO::read().

{ return id_list; }
 

void Nemesis_IO_Helper::get_init_global ()Set the flag indicationg if we should be verbose.

Definition at line 68 of file nemesis_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_id, nemesis_err_flag, num_elem_blks_global, num_elems_global, num_node_sets_global, num_nodes_global, num_side_sets_global, and libMesh::processor_id().

Referenced by Nemesis_IO::read().

{
  nemesis_err_flag =
    Nemesis::ne_get_init_global(ex_id,
                                &num_nodes_global,
                                &num_elems_global,
                                &num_elem_blks_global,
                                &num_node_sets_global,
                                &num_side_sets_global);
  this->check_err(nemesis_err_flag, 'Error reading initial global data!');

  if (_verbose)
    {
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_nodes_global=' << num_nodes_global << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_elems_global=' << num_elems_global << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_elem_blks_global=' << num_elem_blks_global << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_node_sets_global=' << num_node_sets_global << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_side_sets_global=' << num_side_sets_global << std::endl;
    }
}
 

void Nemesis_IO_Helper::get_init_info ()

Definition at line 182 of file nemesis_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_id, ftype, nemesis_err_flag, num_proc, num_proc_in_file, and libMesh::processor_id().

{
  nemesis_err_flag =
    Nemesis::ne_get_init_info(ex_id,
                              &num_proc,
                              &num_proc_in_file,
                              &ftype);
  this->check_err(nemesis_err_flag, 'Error reading initial info!');

  if (_verbose)
    {
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_proc=' << num_proc << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_proc_in_file=' << num_proc_in_file << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'ftype=' << ftype << std::endl;
    }
}
 

void Nemesis_IO_Helper::get_loadbal_param ()

Definition at line 201 of file nemesis_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_id, nemesis_err_flag, num_border_elems, num_border_nodes, num_elem_cmaps, num_external_nodes, num_internal_elems, num_internal_nodes, num_node_cmaps, and libMesh::processor_id().

Referenced by Nemesis_IO::read().

{
  nemesis_err_flag =
    Nemesis::ne_get_loadbal_param(ex_id,
                                  &num_internal_nodes,
                                  &num_border_nodes,
                                  &num_external_nodes,
                                  &num_internal_elems,
                                  &num_border_elems,
                                  &num_node_cmaps,
                                  &num_elem_cmaps,
                                  libMesh::processor_id() // The ID of the processor for which info is to be read
                                  );
  this->check_err(nemesis_err_flag, 'Error reading load balance parameters!');
        

  if (_verbose)
    {
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_internal_nodes=' << num_internal_nodes << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_border_nodes=' << num_border_nodes << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_external_nodes=' << num_external_nodes << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_internal_elems=' << num_internal_elems << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_border_elems=' << num_border_elems << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_node_cmaps=' << num_node_cmaps << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'num_elem_cmaps=' << num_elem_cmaps << std::endl;
    }
}
 

const std::vector< std::string > & ExodusII_IO_Helper::get_nodal_var_names () [inherited]

Definition at line 464 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::nodal_var_names, ExodusII_IO_Helper::num_nodal_vars, ExodusII_IO_Helper::strings, and ExodusII_IO_Helper::vvc.

Referenced by ExodusII_IO_Helper::get_nodal_var_values().

{
  // Allocate enough space for our variable name strings.
  nodal_var_names.resize(num_nodal_vars);
    
  // Use the vvc and strings objects to emulate the behavior of
  // a char** object.
  vvc.resize(num_nodal_vars);
  strings.resize(num_nodal_vars);
  for (int i=0;i<num_nodal_vars;i++)
    vvc[i].resize(MAX_STR_LENGTH+1);

  for (int i=0;i<num_nodal_vars;i++)
    strings[i]=&(vvc[i][0]); // set pointer into vvc only *after* all resizing is complete
    
  exII::ex_get_var_names(ex_id,
                         'n',
                         num_nodal_vars,
                         &strings[0]//var_names
                         );

  if (_verbose)
    {
      std::cout << 'Read the variable(s) from the file:' << std::endl;
      for (int i=0; i<num_nodal_vars; i++)
        std::cout << 'strings[' << i << ']=' << strings[i] << std::endl;
    }

  
  // Copy the char buffers into strings.  
  for (int i=0;i<num_nodal_vars;i++)
    nodal_var_names[i]=strings[i]; // calls string::op=(const char*)

  
  return nodal_var_names;
}
 

const std::vector< double > & ExodusII_IO_Helper::get_nodal_var_values (std::stringnodal_var_name, inttime_step) [inherited]

Definition at line 504 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::get_nodal_var_names(), ExodusII_IO_Helper::nodal_var_names, ExodusII_IO_Helper::nodal_var_values, and ExodusII_IO_Helper::num_nodes.

{
  nodal_var_values.resize(num_nodes);
    
  this->get_nodal_var_names();

  //See if we can find the variable we are looking for
  unsigned int var_index = 0;
  bool found = false;

  found = nodal_var_names[var_index] == nodal_var_name;
    
  while(!found && var_index < nodal_var_names.size())
    {
      var_index++;
      found = nodal_var_names[var_index] == nodal_var_name;
    }

  if(!found)
    {
      std::cerr << 'Unable to locate variable named: ' << nodal_var_name << std::endl;
      return nodal_var_values;
    }

  exII::ex_get_nodal_var(ex_id, time_step, var_index+1, num_nodes, &nodal_var_values[0]);
  
  return nodal_var_values;
}
 

void Nemesis_IO_Helper::get_node_cmap ()

Definition at line 347 of file nemesis_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_id, nemesis_err_flag, node_cmap_ids, node_cmap_node_cnts, node_cmap_node_ids, node_cmap_proc_ids, num_node_cmaps, and libMesh::processor_id().

Referenced by Nemesis_IO::read().

{
  node_cmap_node_ids.resize(num_node_cmaps);
  node_cmap_proc_ids.resize(num_node_cmaps);
  
  for (unsigned int i=0; i<node_cmap_node_ids.size(); ++i)
    {
      node_cmap_node_ids[i].resize(node_cmap_node_cnts[i]);
      node_cmap_proc_ids[i].resize(node_cmap_node_cnts[i]);

      nemesis_err_flag =
        Nemesis::ne_get_node_cmap(ex_id,
                                  node_cmap_ids.empty()         ? NULL : node_cmap_ids[i],
                                  node_cmap_node_ids[i].empty() ? NULL : &node_cmap_node_ids[i][0],
                                  node_cmap_proc_ids[i].empty() ? NULL : &node_cmap_proc_ids[i][0],
                                  libMesh::processor_id());
      this->check_err(nemesis_err_flag, 'Error reading node cmap node and processor ids!');

      if (_verbose)
        {
          std::cout << '[' << libMesh::processor_id() << '] node_cmap_node_ids['<<i<<']=';
          for (unsigned int j=0; j<node_cmap_node_ids[i].size(); ++j)
            std::cout << node_cmap_node_ids[i][j] << ' ';
          std::cout << std::endl;

          // This is basically a vector, all entries of which are = node_cmap_ids[i]
          // Not sure if it's always guaranteed to be that or what...
          std::cout << '[' << libMesh::processor_id() << '] node_cmap_proc_ids['<<i<<']=';
          for (unsigned int j=0; j<node_cmap_proc_ids[i].size(); ++j)
            std::cout << node_cmap_proc_ids[i][j] << ' ';
          std::cout << std::endl;
        }
    }
}
 

const std::vector<int>& ExodusII_IO_Helper::get_node_list () const [inline, inherited]Returns:

a constant reference to the node_list.

Definition at line 222 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::node_list.

Referenced by ExodusII_IO::read().

{ return node_list; }
 

void Nemesis_IO_Helper::get_node_map ()

Definition at line 267 of file nemesis_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_id, nemesis_err_flag, node_mapb, node_mape, node_mapi, num_border_nodes, num_external_nodes, num_internal_nodes, and libMesh::processor_id().

Referenced by Nemesis_IO::read().

{
  node_mapi.resize(num_internal_nodes);
  node_mapb.resize(num_border_nodes);
  node_mape.resize(num_external_nodes);
  
  nemesis_err_flag =
    Nemesis::ne_get_node_map(ex_id,
                             node_mapi.empty() ? NULL : &node_mapi[0],
                             node_mapb.empty() ? NULL : &node_mapb[0],
                             node_mape.empty() ? NULL : &node_mape[0], 
                             libMesh::processor_id()
                             );
  this->check_err(nemesis_err_flag, 'Error reading node maps!');

  if (_verbose)
    {
      // Remark: The Exodus/Nemesis node numbring is always (?) 1-based!  This means the first interior node id will
      // always be == 1.
      std::cout << '[' << libMesh::processor_id() << '] ' << 'first interior node id=' << node_mapi[0] << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'last interior node id=' << node_mapi.back() << std::endl;

      std::cout << '[' << libMesh::processor_id() << '] ' << 'first boundary node id=' << node_mapb[0] << std::endl;
      std::cout << '[' << libMesh::processor_id() << '] ' << 'last boundary node id=' << node_mapb.back() << std::endl;

      // The number of external nodes is sometimes zero, don't try to access
      // node_mape.back() in this case!
      if (num_external_nodes > 0)
        {
          std::cout << '[' << libMesh::processor_id() << '] ' << 'first external node id=' << node_mape[0] << std::endl;
          std::cout << '[' << libMesh::processor_id() << '] ' << 'last external node id=' << node_mape.back() << std::endl;
        }
    }
}
 

int ExodusII_IO_Helper::get_nodeset_id (unsigned inti) const [inline, inherited]Returns:

the nodeset id corresponding to the ith nodeset.

Definition at line 227 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::nodeset_ids.

Referenced by ExodusII_IO::read().

{ return nodeset_ids[i]; }
 

void Nemesis_IO_Helper::get_ns_param_global ()

Definition at line 124 of file nemesis_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_id, global_nodeset_ids, nemesis_err_flag, num_global_node_counts, num_global_node_df_counts, num_node_sets_global, and libMesh::processor_id().

{
  if (num_node_sets_global > 0)
    {
      global_nodeset_ids.resize(num_node_sets_global);
      num_global_node_counts.resize(num_node_sets_global);
      num_global_node_df_counts.resize(num_node_sets_global);
      
      nemesis_err_flag =
        Nemesis::ne_get_ns_param_global(ex_id,
                                        global_nodeset_ids.empty()        ? NULL : &global_nodeset_ids[0],
                                        num_global_node_counts.empty()    ? NULL : &num_global_node_counts[0],
                                        num_global_node_df_counts.empty() ? NULL : &num_global_node_df_counts[0]);
      this->check_err(nemesis_err_flag, 'Error reading global nodeset parameters!');

      if (_verbose)
        {
          std::cout << '[' << libMesh::processor_id() << '] ' << 'Global Nodeset IDs, Node Counts, and DF counts:' << std::endl;
          for (unsigned int bn=0; bn<global_nodeset_ids.size(); ++bn)
            {
              std::cout << '  [' << libMesh::processor_id() << '] '
                        << 'global_nodeset_ids['<<bn<<']=' << global_nodeset_ids[bn]
                        << ', num_global_node_counts['<<bn<<']=' << num_global_node_counts[bn]
                        << ', num_global_node_df_counts['<<bn<<']=' << num_global_node_df_counts[bn]
                        << std::endl;
            }
        }
    }
}
 

int ExodusII_IO_Helper::get_num_dim () const [inline, inherited]Returns:

the ExodusII mesh dimension.

Definition at line 107 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::num_dim.

{ return num_dim; }
 

int ExodusII_IO_Helper::get_num_elem () const [inline, inherited]Returns:

the total number of elements in the ExodusII mesh.

Definition at line 120 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::num_elem.

Referenced by ExodusII_IO::read().

{ return num_elem; }
 

int ExodusII_IO_Helper::get_num_elem_blk () const [inline, inherited]Returns:

the total number of element blocks in the ExodusII mesh.

Definition at line 127 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::num_elem_blk.

Referenced by ExodusII_IO::read().

{ return num_elem_blk; }
 

int ExodusII_IO_Helper::get_num_elem_this_blk () const [inline, inherited]For a given block, returns the total number of elements.

Definition at line 134 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::num_elem_this_blk.

Referenced by ExodusII_IO::read().

{ return num_elem_this_blk; }
 

int ExodusII_IO_Helper::get_num_nodal_vars () [inline, inherited]

Definition at line 407 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::num_nodal_vars.

{ return num_nodal_vars; }
 

int ExodusII_IO_Helper::get_num_node_sets () const [inline, inherited]Returns:

the total number of nodesets in the ExodusII mesh.

Definition at line 157 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::num_node_sets.

Referenced by ExodusII_IO::read().

{ return num_node_sets; }
 

int ExodusII_IO_Helper::get_num_nodes () const [inline, inherited]Returns:

the total number of nodes in the ExodusII mesh.

Definition at line 113 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::num_nodes.

Referenced by ExodusII_IO::read().

{ return num_nodes; }
 

int ExodusII_IO_Helper::get_num_nodes_per_elem () const [inline, inherited]Returns:

the number of nodes per element in a given block. e.g. for HEX27 it returns 27.

Definition at line 142 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::num_nodes_per_elem.

Referenced by ExodusII_IO::read().

{ return num_nodes_per_elem; }
 

int ExodusII_IO_Helper::get_num_nodes_per_set (inti) const [inline, inherited]For a single nodeset, returns the total number of nodes in the nodeset.

Definition at line 188 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::num_nodes_per_set.

{ return num_nodes_per_set[i]; }
 

int ExodusII_IO_Helper::get_num_side_sets () const [inline, inherited]Returns:

the total number of sidesets in the ExodusII mesh. Each sideset contains only one type of element.

Definition at line 150 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::num_side_sets.

Referenced by ExodusII_IO::read().

{ return num_side_sets; }
 

int ExodusII_IO_Helper::get_num_sides_per_set (inti) const [inline, inherited]For a single sideset, returns the total number of elements in the sideset.

Definition at line 181 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::num_sides_per_set.

Referenced by ExodusII_IO::read().

{ return num_sides_per_set[i]; }
 

const std::vector<int>& ExodusII_IO_Helper::get_side_list () const [inline, inherited]Returns:

the $ i^{th} $ entry in the side list. This is effectively the 'side' (face in 3D or edge in 2D) number which lies on the boundary.

a constant reference to the side_list.

Definition at line 217 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::side_list.

Referenced by ExodusII_IO::read().

{ return side_list; }
 

void Nemesis_IO_Helper::get_ss_param_global ()

Definition at line 91 of file nemesis_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_id, global_sideset_ids, nemesis_err_flag, num_global_side_counts, num_global_side_df_counts, num_side_sets_global, and libMesh::processor_id().

{
  if (num_side_sets_global > 0)
    {
      global_sideset_ids.resize(num_side_sets_global);
      num_global_side_counts.resize(num_side_sets_global);
      num_global_side_df_counts.resize(num_side_sets_global);
      
      nemesis_err_flag =
        Nemesis::ne_get_ss_param_global(ex_id,
                                        global_sideset_ids.empty()        ? NULL : &global_sideset_ids[0],
                                        num_global_side_counts.empty()    ? NULL : &num_global_side_counts[0],
                                        num_global_side_df_counts.empty() ? NULL : &num_global_side_df_counts[0]);
      this->check_err(nemesis_err_flag, 'Error reading global sideset parameters!');

      if (_verbose)
        {
          std::cout << '[' << libMesh::processor_id() << '] ' << 'Global Sideset IDs, Side Counts, and DF counts:' << std::endl;
          for (unsigned int bn=0; bn<global_sideset_ids.size(); ++bn)
            {
              std::cout << '  [' << libMesh::processor_id() << '] '
                        << 'global_sideset_ids['<<bn<<']=' << global_sideset_ids[bn]
                        << ', num_global_side_counts['<<bn<<']=' << num_global_side_counts[bn]
                        << ', num_global_side_df_counts['<<bn<<']=' << num_global_side_df_counts[bn]
                        << std::endl;
            }
        }
    }
}
 

const std::vector< double > & ExodusII_IO_Helper::get_time_steps () [inherited]

Definition at line 455 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::num_time_steps, and ExodusII_IO_Helper::time_steps.

{
  time_steps.resize(num_time_steps);
  exII::ex_get_all_times(ex_id, time_steps.empty() ? NULL : &time_steps[0]);
  return time_steps;
}
 

double ExodusII_IO_Helper::get_x (inti) const [inline, inherited]Returns:

the $ i^{th} $ node's x-coordinate.

Definition at line 255 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::x.

Referenced by ExodusII_IO::read().

{ return x[i]; }
 

double ExodusII_IO_Helper::get_y (inti) const [inline, inherited]Returns:

the $ i^{th} $ node's y-coordinate.

Definition at line 261 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::y.

Referenced by ExodusII_IO::read().

{ return y[i]; }
 

double ExodusII_IO_Helper::get_z (inti) const [inline, inherited]Returns:

the $ i^{th} $ node's z-coordinate.

Definition at line 267 of file exodusII_io_helper.h.

References ExodusII_IO_Helper::z.

Referenced by ExodusII_IO::read().

{ return z[i]; }
 

void ExodusII_IO_Helper::initialize (std::stringtitle, const MeshBase &mesh) [inherited]Initializes the Exodus file

Definition at line 560 of file exodusII_io_helper.C.

References MeshBase::boundary_info, ExodusII_IO_Helper::check_err(), MeshBase::elem(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, DofObject::id(), MeshBase::n_elem(), MeshBase::n_nodes(), ExodusII_IO_Helper::num_dim, ExodusII_IO_Helper::num_elem, ExodusII_IO_Helper::num_elem_blk, ExodusII_IO_Helper::num_node_sets, ExodusII_IO_Helper::num_nodes, ExodusII_IO_Helper::num_side_sets, MeshBase::spatial_dimension(), and Elem::subdomain_id().

{
  num_dim = mesh.spatial_dimension();
  num_nodes = mesh.n_nodes();
  num_elem = mesh.n_elem();

  std::vector<short int> unique_side_boundaries;
  std::vector<short int> unique_node_boundaries;

  mesh.boundary_info->build_side_boundary_ids(unique_side_boundaries);
  mesh.boundary_info->build_node_boundary_ids(unique_node_boundaries);

  num_side_sets = unique_side_boundaries.size();
  num_node_sets = unique_node_boundaries.size();
  
  //loop through element and map between block and element vector
  std::map<subdomain_id_type, std::vector<unsigned int>  > subdomain_map;
  for(int i=0;i<num_elem;i++)
    {
      Elem * elem = mesh.elem(i);
      subdomain_id_type cur_subdomain = elem->subdomain_id();
     
      subdomain_map[cur_subdomain].push_back(elem->id());
    }
  num_elem_blk = subdomain_map.size();

  std::cout<<'Num elem block: '<<num_elem_blk<<std::endl;

  ex_err = exII::ex_put_init(ex_id,
                             str_title.c_str(),
                             num_dim,
                             num_nodes,
                             num_elem,
                             num_elem_blk,
                             num_node_sets,
                             num_side_sets);
    
  check_err(ex_err, 'Error initializing new Exodus file.');
}
 

void ExodusII_IO_Helper::initialize_nodal_variables (std::vector< std::string >names) [inherited]Sets up the nodal variables

Definition at line 762 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::num_nodal_vars, ExodusII_IO_Helper::strings, and ExodusII_IO_Helper::vvc.

{
  num_nodal_vars = names.size();

  ex_err = exII::ex_put_var_param(ex_id, 'n', num_nodal_vars);
  check_err(ex_err, 'Error setting number of nodal vars.');

  // Use the vvc and strings objects to emulate the behavior of
  // a char** object.
  vvc.resize(num_nodal_vars);
  strings.resize(num_nodal_vars);

  // For each string in names, allocate enough space in vvc and copy from
  // the C++ string into vvc for passing to the C interface.
  for (int i=0; i<num_nodal_vars; i++)
    {
      vvc[i].resize(names[i].size()+1);
      std::strcpy(&(vvc[i][0]), names[i].c_str());
    }

  for (int i=0; i<num_nodal_vars; i++)
    strings[i] = &(vvc[i][0]); // set pointer into vvc only *after* all resizing is complete

  if (_verbose)
    {
      std::cout << 'Writing variable name(s) to file: ' << std::endl;
      for (int i=0;i<num_nodal_vars;i++)
        std::cout << 'strings[' << i << ']=' << strings[i] << std::endl;
    }
    
  ex_err = exII::ex_put_var_names(ex_id,
                                  'n',
                                  num_nodal_vars,
                                  &strings[0]//var_names
                                  );
    
  check_err(ex_err, 'Error setting nodal variable names.');
}
 

int ExodusII_IO_Helper::inquire (intreq_info, std::stringerror_msg = '') [inherited]Generic inquiry, returns the value

Definition at line 442 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::ret_char, ExodusII_IO_Helper::ret_float, and ExodusII_IO_Helper::ret_int.

Referenced by ExodusII_IO_Helper::read_header().

{
  ex_err = exII::ex_inquire(ex_id,
                            req_info,
                            &ret_int,
                            &ret_float,
                            &ret_char);
    
  check_err(ex_err, error_msg);

  return ret_int;
}
 

void ExodusII_IO_Helper::message (const std::stringmsg, inti) [inherited]Prints the message defined in msg to std::cout and appends the number i to the end of the message. Useful for printing messages in loops. Can be turned off if verbosity is set to 0.

Definition at line 134 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_verbose.

{
  if (_verbose) std::cout << msg << i << '.' << std::endl;
}
 

void ExodusII_IO_Helper::message (const std::stringmsg) [inherited]Prints the message defined in msg to std::cout. Can be turned off if verbosity is set to 0.

Definition at line 127 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_verbose.

Referenced by ExodusII_IO_Helper::close(), ExodusII_IO_Helper::read_block_info(), ExodusII_IO_Helper::read_elem_in_block(), ExodusII_IO_Helper::read_elem_num_map(), ExodusII_IO_Helper::read_header(), ExodusII_IO_Helper::read_node_num_map(), ExodusII_IO_Helper::read_nodes(), ExodusII_IO_Helper::read_nodeset(), ExodusII_IO_Helper::read_nodeset_info(), ExodusII_IO_Helper::read_sideset(), and ExodusII_IO_Helper::read_sideset_info().

{
  if (_verbose) std::cout << msg << std::endl;
}
 

void ExodusII_IO_Helper::open (const char *filename) [inherited]Opens an ExodusII mesh file named filename for reading.

Definition at line 141 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::comp_ws, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::ex_version, and ExodusII_IO_Helper::io_ws.

Referenced by Nemesis_IO::read(), and ExodusII_IO::read().

{
  ex_id = exII::ex_open(filename,
                        EX_READ,
                        &comp_ws,
                        &io_ws,
                        &ex_version);
  
  check_err(ex_id, 'Error opening ExodusII mesh file.');
  if (_verbose) std::cout << 'File opened successfully.' << std::endl;
}
 

void ExodusII_IO_Helper::print_header () [inherited]Prints the ExodusII mesh file header, which includes the mesh title, the number of nodes, number of elements, mesh dimension, number of sidesets, and number of nodesets

Definition at line 178 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::num_dim, ExodusII_IO_Helper::num_elem, ExodusII_IO_Helper::num_elem_blk, ExodusII_IO_Helper::num_node_sets, ExodusII_IO_Helper::num_nodes, ExodusII_IO_Helper::num_side_sets, and ExodusII_IO_Helper::title.

Referenced by Nemesis_IO::read(), and ExodusII_IO::read().

{
  if (_verbose)
    std::cout << 'Title: 	' << &title[0] << std::endl
              << 'Mesh Dimension: 	'   << num_dim << std::endl
              << 'Number of Nodes: 	' << num_nodes << std::endl
              << 'Number of elements: 	' << num_elem << std::endl
              << 'Number of elt blocks: 	' << num_elem_blk << std::endl
              << 'Number of node sets: 	' << num_node_sets << std::endl
              << 'Number of side sets: 	' << num_side_sets << std::endl;
}
 

void ExodusII_IO_Helper::print_nodes () [inherited]Prints the nodal information to std::cout.

Definition at line 229 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::num_nodes, ExodusII_IO_Helper::x, ExodusII_IO_Helper::y, and ExodusII_IO_Helper::z.

{
  for (int i=0; i<num_nodes; i++)
    {
      std::cout << '(' << x[i] << ', ' << y[i] << ', ' << z[i] << ')' << std::endl;
    }
}
 

void ExodusII_IO_Helper::print_nodeset_info () [inherited]Prints information about all the nodesets.

 

void ExodusII_IO_Helper::print_sideset_info () [inherited]Prints information about all the sidesets.

Definition at line 425 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::elem_list, ExodusII_IO_Helper::num_elem_all_sidesets, and ExodusII_IO_Helper::side_list.

{
  for (int i=0; i<num_elem_all_sidesets; i++)
    {
      std::cout << elem_list[i] << ' ' << side_list[i] << std::endl;
    }
}
 

void ExodusII_IO_Helper::read_block_info () [inherited]Reads information for all of the blocks in the ExodusII mesh file.

Definition at line 239 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::block_ids, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::message(), and ExodusII_IO_Helper::num_elem_blk.

Referenced by Nemesis_IO::read(), and ExodusII_IO::read().

{
  block_ids.resize(num_elem_blk);
  // Get all element block IDs.
  ex_err = exII::ex_get_elem_blk_ids(ex_id,
                                     block_ids.empty() ? NULL : &block_ids[0]);
  // Usually, there is only one
  // block since there is only
  // one type of element.
  // However, there could be more.

  check_err(ex_err, 'Error getting block IDs.');
  message('All block IDs retrieved successfully.'); 
}
 

void ExodusII_IO_Helper::read_elem_in_block (intblock) [inherited]Reads all of the element connectivity for block block in the ExodusII mesh file.

Definition at line 265 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::block_ids, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::connect, ExodusII_IO_Helper::elem_type, ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::message(), ExodusII_IO_Helper::num_attr, ExodusII_IO_Helper::num_elem_this_blk, and ExodusII_IO_Helper::num_nodes_per_elem.

Referenced by Nemesis_IO::read(), and ExodusII_IO::read().

{
  libmesh_assert (static_cast<unsigned int>(block) < block_ids.size());
  
  ex_err = exII::ex_get_elem_block(ex_id,
                                   block_ids[block],
                                   &elem_type[0],
                                   &num_elem_this_blk,
                                   &num_nodes_per_elem,
                                   &num_attr);
  if (_verbose)
    std::cout << 'Reading a block of ' << num_elem_this_blk
              << ' ' << &elem_type[0] << '(s)'
              << ' having ' << num_nodes_per_elem
              << ' nodes per element.' << std::endl;
      
  check_err(ex_err, 'Error getting block info.');
  message('Info retrieved successfully for block: ', block); 
  
  
  
  // Read in the connectivity of the elements of this block,
  // watching out for the case where we actually have no
  // elements in this block (possible with parallel files)
  connect.resize(num_nodes_per_elem*num_elem_this_blk);

  if (!connect.empty())
    {
      ex_err = exII::ex_get_elem_conn(ex_id,
                                      block_ids[block],
                                      &connect[0]);
  
      check_err(ex_err, 'Error reading block connectivity.');
      message('Connectivity retrieved successfully for block: ', block);
    }
}
 

void ExodusII_IO_Helper::read_elem_num_map () [inherited]Reads the optional node_num_map from the ExodusII mesh file.

Definition at line 304 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::elem_num_map, ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::message(), std::min(), ExodusII_IO_Helper::num_elem, and libMesh::processor_id().

Referenced by Nemesis_IO::read().

{
  elem_num_map.resize(num_elem);

  ex_err = exII::ex_get_elem_num_map (ex_id,
                                      elem_num_map.empty() ? NULL : &elem_num_map[0]);
                                      
  check_err(ex_err, 'Error retrieving element number map.');
  message('Element numbering map retrieved successfully.'); 


  if (_verbose)
    {
      std::cout << '[' << libMesh::processor_id() << '] elem_num_map[i] = ';
      for (unsigned int i=0; i< static_cast<unsigned int>(std::min(10, num_elem-1)); ++i)
        std::cout << elem_num_map[i] << ', ';
      std::cout << '... ' << elem_num_map.back() << std::endl;
    }
}
 

void ExodusII_IO_Helper::read_header () [inherited]Reads an ExodusII mesh file header.

Definition at line 155 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::inquire(), ExodusII_IO_Helper::message(), ExodusII_IO_Helper::num_dim, ExodusII_IO_Helper::num_elem, ExodusII_IO_Helper::num_elem_blk, ExodusII_IO_Helper::num_nodal_vars, ExodusII_IO_Helper::num_node_sets, ExodusII_IO_Helper::num_nodes, ExodusII_IO_Helper::num_side_sets, ExodusII_IO_Helper::num_time_steps, and ExodusII_IO_Helper::title.

Referenced by Nemesis_IO::read(), and ExodusII_IO::read().

{
  ex_err = exII::ex_get_init(ex_id,
                             title.empty() ? NULL : &title[0],
                             &num_dim,
                             &num_nodes,
                             &num_elem,
                             &num_elem_blk,
                             &num_node_sets,
                             &num_side_sets);

  check_err(ex_err, 'Error retrieving header info.');

  num_time_steps = inquire(exII::EX_INQ_TIME, 'Error retrieving time steps');

  exII::ex_get_var_param(ex_id, 'n', &num_nodal_vars);

  message('Exodus header info retrieved successfully.');
}
 

void ExodusII_IO_Helper::read_node_num_map () [inherited]Reads the optional node_num_map from the ExodusII mesh file.

Definition at line 209 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_verbose, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::message(), std::min(), ExodusII_IO_Helper::node_num_map, ExodusII_IO_Helper::num_nodes, and libMesh::processor_id().

Referenced by Nemesis_IO::read().

{
  node_num_map.resize(num_nodes);

  ex_err = exII::ex_get_node_num_map (ex_id,
                                      node_num_map.empty() ? NULL : &node_num_map[0]);
                                      
  check_err(ex_err, 'Error retrieving nodal number map.');
  message('Nodal numbering map retrieved successfully.'); 

  if (_verbose)
    {
      std::cout << '[' << libMesh::processor_id() << '] node_num_map[i] = ';
      for (unsigned int i=0; i< static_cast<unsigned int>(std::min(10, num_nodes-1)); ++i)
        std::cout << node_num_map[i] << ', ';
      std::cout << '... ' << node_num_map.back() << std::endl;
    }
}
 

void ExodusII_IO_Helper::read_nodes () [inherited]Reads the nodal data (x,y,z coordinates) from the ExodusII mesh file.

Definition at line 192 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::message(), ExodusII_IO_Helper::num_nodes, ExodusII_IO_Helper::x, ExodusII_IO_Helper::y, and ExodusII_IO_Helper::z.

Referenced by Nemesis_IO::read(), and ExodusII_IO::read().

{
  x.resize(num_nodes);
  y.resize(num_nodes); 
  z.resize(num_nodes); 

  ex_err = exII::ex_get_coord(ex_id,
                              static_cast<void*>(&x[0]),
                              static_cast<void*>(&y[0]),
                              static_cast<void*>(&z[0]));
  
  check_err(ex_err, 'Error retrieving nodal data.');
  message('Nodal data retrieved successfully.'); 
}
 

void ExodusII_IO_Helper::read_nodeset (intid) [inherited]Reads information about nodeset id and inserts it into the global nodeset array at the position offset.

Definition at line 401 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::message(), ExodusII_IO_Helper::node_list, ExodusII_IO_Helper::nodeset_ids, ExodusII_IO_Helper::num_node_df_per_set, and ExodusII_IO_Helper::num_nodes_per_set.

Referenced by ExodusII_IO::read().

{
  libmesh_assert (static_cast<unsigned int>(id) < nodeset_ids.size());
  libmesh_assert (static_cast<unsigned int>(id) < num_nodes_per_set.size());
  libmesh_assert (static_cast<unsigned int>(id) < num_node_df_per_set.size());
  
  ex_err = exII::ex_get_node_set_param(ex_id,
                                       nodeset_ids[id],
                                       &num_nodes_per_set[id],
                                       &num_node_df_per_set[id]);
  check_err(ex_err, 'Error retrieving nodeset parameters.');
  message('Parameters retrieved successfully for nodeset: ', id);

  node_list.resize(num_nodes_per_set[id]);

  ex_err = exII::ex_get_node_set(ex_id,
                                 nodeset_ids[id],
                                 &node_list[0]);
  
  check_err(ex_err, 'Error retrieving nodeset data.');
  message('Data retrieved successfully for nodeset: ', id);
}
 

void ExodusII_IO_Helper::read_nodeset_info () [inherited]Reads information about all of the nodesets in the ExodusII mesh file.

Definition at line 358 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::message(), ExodusII_IO_Helper::nodeset_ids, ExodusII_IO_Helper::num_node_df_per_set, ExodusII_IO_Helper::num_node_sets, and ExodusII_IO_Helper::num_nodes_per_set.

Referenced by ExodusII_IO::read().

{
  nodeset_ids.resize(num_node_sets);
  if (num_node_sets > 0)
    {
      ex_err = exII::ex_get_node_set_ids(ex_id,
                                         &nodeset_ids[0]);
      check_err(ex_err, 'Error retrieving nodeset information.');
      message('All nodeset information retrieved successfully.'); 

      // Resize appropriate data structures -- only do this once outnode the loop
      num_nodes_per_set.resize(num_node_sets);
      num_node_df_per_set.resize(num_node_sets);
    }
}
 

void ExodusII_IO_Helper::read_sideset (intid, intoffset) [inherited]Reads information about sideset id and inserts it into the global sideset array at the position offset.

Definition at line 375 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::elem_list, ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::id_list, ExodusII_IO_Helper::message(), ExodusII_IO_Helper::num_df_per_set, ExodusII_IO_Helper::num_sides_per_set, ExodusII_IO_Helper::side_list, and ExodusII_IO_Helper::ss_ids.

Referenced by ExodusII_IO::read().

{
  libmesh_assert (static_cast<unsigned int>(id) < ss_ids.size());
  libmesh_assert (static_cast<unsigned int>(id) < num_sides_per_set.size());
  libmesh_assert (static_cast<unsigned int>(id) < num_df_per_set.size());
  libmesh_assert (static_cast<unsigned int>(offset) < elem_list.size());
  libmesh_assert (static_cast<unsigned int>(offset) < side_list.size());
  
  ex_err = exII::ex_get_side_set_param(ex_id,
                                       ss_ids[id],
                                       &num_sides_per_set[id],
                                       &num_df_per_set[id]);
  check_err(ex_err, 'Error retrieving sideset parameters.');
  message('Parameters retrieved successfully for sideset: ', id);

  ex_err = exII::ex_get_side_set(ex_id,
                                 ss_ids[id],
                                 &elem_list[offset],
                                 &side_list[offset]);
  check_err(ex_err, 'Error retrieving sideset data.');
  message('Data retrieved successfully for sideset: ', id);

  for (int i=0; i<num_sides_per_set[id]; i++)
    id_list[i+offset] = ss_ids[id];
}
 

void ExodusII_IO_Helper::read_sideset_info () [inherited]Reads information about all of the sidesets in the ExodusII mesh file.

Definition at line 326 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::elem_list, ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::id_list, ExodusII_IO_Helper::message(), ExodusII_IO_Helper::num_df_per_set, ExodusII_IO_Helper::num_elem_all_sidesets, ExodusII_IO_Helper::num_side_sets, ExodusII_IO_Helper::num_sides_per_set, ExodusII_IO_Helper::req_info, ExodusII_IO_Helper::ret_char, ExodusII_IO_Helper::ret_float, ExodusII_IO_Helper::ret_int, ExodusII_IO_Helper::side_list, and ExodusII_IO_Helper::ss_ids.

Referenced by ExodusII_IO::read().

{
  ss_ids.resize(num_side_sets);
  if (num_side_sets > 0)
    {
      ex_err = exII::ex_get_side_set_ids(ex_id,
                                         &ss_ids[0]);
      check_err(ex_err, 'Error retrieving sideset information.');
      message('All sideset information retrieved successfully.'); 

      // Resize appropriate data structures -- only do this once outside the loop
      num_sides_per_set.resize(num_side_sets);
      num_df_per_set.resize(num_side_sets);

      // Inquire about the length of the
      // concatenated side sets element list
      req_info = exII::EX_INQ_SS_ELEM_LEN; 
      ex_err = exII::ex_inquire(ex_id,
                                req_info,
                                &ret_int,
                                &ret_float,
                                &ret_char);
      check_err(ex_err, 'Error inquiring about side set element list length.');

      //std::cout << 'Value returned by ex_inquire was: ' << ret_int << std::endl;
      num_elem_all_sidesets = ret_int;  
      elem_list.resize (num_elem_all_sidesets);
      side_list.resize (num_elem_all_sidesets);
      id_list.resize   (num_elem_all_sidesets);
    }
}
 

void ExodusII_IO_Helper::verbose (boolset_verbosity) [inherited]Get/set flag telling whether message printing is on or off.

Definition at line 109 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_verbose.

Referenced by Nemesis_IO::verbose(), and ExodusII_IO::verbose().

{
  _verbose = set_verbosity;
}
 

void ExodusII_IO_Helper::write_elements (const MeshBase &mesh) [inherited]Writes the elements contained in 'mesh' FIXME: This only works for Mesh's having a single type of element!

Definition at line 623 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::_verbose, Elem::active(), ExodusII_IO_Helper::ElementMaps::assign_conversion(), ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::connect, MeshBase::elem(), ExodusII_IO_Helper::elem_num_map, ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::Conversion::exodus_elem_type(), ExodusII_IO_Helper::Conversion::get_node_map(), DofObject::id(), ExodusII_IO_Helper::libmesh_elem_num_to_exodus, Elem::n_nodes(), Elem::node(), ExodusII_IO_Helper::num_elem, ExodusII_IO_Helper::num_nodes_per_elem, Elem::subdomain_id(), and Elem::type().

{
  std::map<unsigned int, std::vector<unsigned int>  > subdomain_map;
  
  //loop through element and map between block and element vector
  for(unsigned int i=0; i<static_cast<unsigned int>(num_elem); i++)
    {
      Elem * elem = mesh.elem(i);

      //Only write out the active elements
      if(elem->active())
      {
        unsigned int cur_subdomain = elem->subdomain_id();
     
        subdomain_map[cur_subdomain].push_back(elem->id());
      }
    }

  std::vector<int> elem_num_map;

  std::map<unsigned int, std::vector<unsigned int>  >::iterator it;
  
  for(it = subdomain_map.begin() ; it != subdomain_map.end(); it++)
    {
      std::vector<unsigned int> & tmp_vec = (*it).second;

      ExodusII_IO_Helper::ElementMaps em;

      //Use the first element in this block to get representative information.
      //Note that Exodus assumes all elements in a block are of the same type!
      //We are using that same assumption here!
      const ExodusII_IO_Helper::Conversion conv = em.assign_conversion(mesh.elem(tmp_vec[0])->type());
      num_nodes_per_elem = mesh.elem(tmp_vec[0])->n_nodes();
    
      ex_err = exII::ex_put_elem_block(ex_id, (*it).first, conv.exodus_elem_type().c_str(), tmp_vec.size(),num_nodes_per_elem,0);
    
      check_err(ex_err, 'Error writing element block.');
  
      connect.resize(tmp_vec.size()*num_nodes_per_elem);

      for (unsigned int i=0; i<tmp_vec.size(); i++)
        {
          unsigned int elem_id = tmp_vec[i];
          elem_num_map.push_back(elem_id);
          libmesh_elem_num_to_exodus[elem_id] = elem_num_map.size();
          
          Elem * elem = mesh.elem(elem_id);
          
          for (unsigned int j=0; j < static_cast<unsigned int>(num_nodes_per_elem); j++)
            {  
              const unsigned int connect_index   = (i*num_nodes_per_elem)+j;
              const unsigned int elem_node_index = conv.get_node_map(j);
              if (_verbose)
                {
                  std::cout << 'Exodus node index: ' << j
                            << '=LibMesh node index ' << elem_node_index << std::endl;
                }
              connect[connect_index] = elem->node(elem_node_index)+1;
            }
        }
    ex_err = exII::ex_put_elem_conn(ex_id, (*it).first, &connect[0]);
    check_err(ex_err, 'Error writing element connectivities');
  }

//  ex_err = exII::ex_put_elem_num_map(ex_id, &elem_num_map[0]);
  check_err(ex_err, 'Error writing element connectivities');
}
 

void ExodusII_IO_Helper::write_nodal_coordinates (const MeshBase &mesh) [inherited]Writes the nodal coordinates contained in 'mesh'

Definition at line 600 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, MeshBase::node_ptr(), ExodusII_IO_Helper::num_nodes, ExodusII_IO_Helper::x, ExodusII_IO_Helper::y, and ExodusII_IO_Helper::z.

{
  x.resize(num_nodes);
  y.resize(num_nodes);
  z.resize(num_nodes);

  for (/* unsigned */ int i=0; i<num_nodes; ++i)
    {
      x[i]=(*mesh.node_ptr(i))(0);
      y[i]=(*mesh.node_ptr(i))(1);
      z[i]=(*mesh.node_ptr(i))(2);
    }

  ex_err = exII::ex_put_coord(ex_id,
                              x.empty() ? NULL : &x[0],
                              y.empty() ? NULL : &y[0],
                              z.empty() ? NULL : &z[0]);

  check_err(ex_err, 'Error writing coordinates to Exodus file.');
}
 

void ExodusII_IO_Helper::write_nodal_values (intvar_id, const std::vector< Number > &values, inttimestep) [inherited]Writes the vector of values to a nodal variable.

Definition at line 811 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, and ExodusII_IO_Helper::num_nodes.

{
  ex_err = exII::ex_put_nodal_var(ex_id, timestep, var_id, num_nodes, &values[0]);
  check_err(ex_err, 'Error writing nodal values.');
}  
 

void ExodusII_IO_Helper::write_nodesets (const MeshBase &mesh) [inherited]Writes the nodesets contained in 'mesh'

Definition at line 730 of file exodusII_io_helper.C.

References MeshBase::boundary_info, ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, and ExodusII_IO_Helper::ex_id.

{
  ExodusII_IO_Helper::ElementMaps em;

  std::vector< unsigned int > nl;
  std::vector< short int > il;
      
  mesh.boundary_info->build_node_list(nl, il);

  //Maps from nodeset id to the nodes
  std::map<short int, std::vector<int> > node;

  //Accumulate the vectors to pass into ex_put_node_set
  for(unsigned int i = 0; i < nl.size(); i++)
    node[il[i]].push_back(nl[i]);    
  
  std::vector<short int> node_boundary_ids;
  mesh.boundary_info->build_node_boundary_ids(node_boundary_ids);
  
  for(unsigned int i = 0; i < node_boundary_ids.size(); i++)
  {
    int nodeset_id = node_boundary_ids[i];

    ex_err = exII::ex_put_node_set_param(ex_id, nodeset_id, node[nodeset_id].size(), 0);
    check_err(ex_err, 'Error writing nodeset parameters');

    ex_err = exII::ex_put_node_set(ex_id, nodeset_id, &node[nodeset_id][0]);
    check_err(ex_err, 'Error writing nodesets');
  }
}
 

void ExodusII_IO_Helper::write_sidesets (const MeshBase &mesh) [inherited]Writes the sidesets contained in 'mesh'

Definition at line 691 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::ElementMaps::assign_conversion(), MeshBase::boundary_info, ExodusII_IO_Helper::check_err(), MeshBase::elem(), ExodusII_IO_Helper::ex_err, ExodusII_IO_Helper::ex_id, ExodusII_IO_Helper::Conversion::get_inverse_side_map(), and Elem::type().

{
  ExodusII_IO_Helper::ElementMaps em;

  std::vector< unsigned int > el;
  std::vector< unsigned short int > sl;
  std::vector< short int > il;
      
  mesh.boundary_info->build_side_list(el, sl, il);

  //Maps from sideset id to the element and sides
  std::map<int, std::vector<int> > elem;
  std::map<int, std::vector<int> > side;

  //Accumulate the vectors to pass into ex_put_side_set
  for(unsigned int i = 0; i < el.size(); i++)
  {
    const ExodusII_IO_Helper::Conversion conv = em.assign_conversion(mesh.elem(el[i])->type());

    elem[il[i]].push_back(el[i]+1);
    side[il[i]].push_back(conv.get_inverse_side_map(sl[i]));    
  }
  
  std::vector<short int> side_boundary_ids;
  mesh.boundary_info->build_side_boundary_ids(side_boundary_ids);
  
  for(unsigned int i = 0; i < side_boundary_ids.size(); i++)
  {
    int ss_id = side_boundary_ids[i];

    ex_err = exII::ex_put_side_set_param(ex_id, ss_id, elem[ss_id].size(), 4);
    check_err(ex_err, 'Error writing sideset parameters');
    
    ex_err = exII::ex_put_side_set(ex_id, ss_id, &elem[ss_id][0], &side[ss_id][0]);
    check_err(ex_err, 'Error writing sidesets');
  }
}
 

void ExodusII_IO_Helper::write_timestep (inttimestep, doubletime) [inherited]Writes the time for the timestep

Definition at line 803 of file exodusII_io_helper.C.

References ExodusII_IO_Helper::check_err(), ExodusII_IO_Helper::ex_err, and ExodusII_IO_Helper::ex_id.

{
  ex_err = exII::ex_put_time(ex_id, timestep, &time);
  check_err(ex_err, 'Error writing timestep.');
}
 

Member Data Documentation

 

bool ExodusII_IO_Helper::_created [protected, inherited]

Definition at line 581 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::create(), and ExodusII_IO_Helper::created().  

bool ExodusII_IO_Helper::_verbose [protected, inherited]

Definition at line 582 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::create(), get_cmap_params(), get_eb_info_global(), get_elem_cmap(), get_elem_map(), get_init_global(), get_init_info(), get_loadbal_param(), ExodusII_IO_Helper::get_nodal_var_names(), get_node_cmap(), get_node_map(), get_ns_param_global(), get_ss_param_global(), ExodusII_IO_Helper::initialize_nodal_variables(), ExodusII_IO_Helper::message(), ExodusII_IO_Helper::open(), ExodusII_IO_Helper::print_header(), ExodusII_IO_Helper::read_elem_in_block(), ExodusII_IO_Helper::read_elem_num_map(), ExodusII_IO_Helper::read_node_num_map(), ExodusII_IO_Helper::verbose(), and ExodusII_IO_Helper::write_elements().  

std::vector<int> ExodusII_IO_Helper::block_ids [inherited]

Definition at line 539 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_block_id(), Nemesis_IO::read(), ExodusII_IO_Helper::read_block_info(), and ExodusII_IO_Helper::read_elem_in_block().  

int ExodusII_IO_Helper::comp_ws [inherited]

Definition at line 523 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::create(), and ExodusII_IO_Helper::open().  

std::vector<int> ExodusII_IO_Helper::connect [inherited]

Definition at line 540 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_connect(), Nemesis_IO::read(), ExodusII_IO_Helper::read_elem_in_block(), and ExodusII_IO_Helper::write_elements().  

std::vector<int> Nemesis_IO_Helper::elem_cmap_elem_cnts

Definition at line 261 of file nemesis_io_helper.h.

Referenced by get_cmap_params(), and get_elem_cmap().  

std::vector<std::vector<int> > Nemesis_IO_Helper::elem_cmap_elem_ids3 vectors of vectors for storing element communication IDs for this processor. There will be num_elem_cmaps rows, row i will have elem_cmap_elem_cnts[i] entries. To be used with Nemesis::ne_get_elem_cmap().

Definition at line 281 of file nemesis_io_helper.h.

Referenced by get_elem_cmap().  

std::vector<int> Nemesis_IO_Helper::elem_cmap_ids

Definition at line 260 of file nemesis_io_helper.h.

Referenced by get_cmap_params(), and get_elem_cmap().  

std::vector<std::vector<int> > Nemesis_IO_Helper::elem_cmap_proc_ids

Definition at line 283 of file nemesis_io_helper.h.

Referenced by get_elem_cmap().  

std::vector<std::vector<int> > Nemesis_IO_Helper::elem_cmap_side_ids

Definition at line 282 of file nemesis_io_helper.h.

Referenced by get_elem_cmap().  

std::vector<int> ExodusII_IO_Helper::elem_list [inherited]

Definition at line 547 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_elem_list(), ExodusII_IO_Helper::print_sideset_info(), ExodusII_IO_Helper::read_sideset(), and ExodusII_IO_Helper::read_sideset_info().  

std::vector<int> Nemesis_IO_Helper::elem_mapbVector which stores border element IDs. Will have length num_border_elems. To be used with Nemesis::ne_get_elem_map().

Definition at line 226 of file nemesis_io_helper.h.

Referenced by get_elem_map().  

std::vector<int> Nemesis_IO_Helper::elem_mapiVector which stores internal element IDs. Will have length num_internal_elems. To be used with Nemesis::ne_get_elem_map().

Definition at line 219 of file nemesis_io_helper.h.

Referenced by get_elem_map().  

std::vector<int> ExodusII_IO_Helper::elem_num_map [inherited]

Definition at line 552 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::read_elem_num_map(), and ExodusII_IO_Helper::write_elements().  

std::vector<char> ExodusII_IO_Helper::elem_type [inherited]

Definition at line 561 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::ExodusII_IO_Helper(), ExodusII_IO_Helper::get_elem_type(), Nemesis_IO::read(), and ExodusII_IO_Helper::read_elem_in_block().  

int ExodusII_IO_Helper::ex_err [inherited]

Definition at line 526 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::close(), ExodusII_IO_Helper::initialize(), ExodusII_IO_Helper::initialize_nodal_variables(), ExodusII_IO_Helper::inquire(), ExodusII_IO_Helper::read_block_info(), ExodusII_IO_Helper::read_elem_in_block(), ExodusII_IO_Helper::read_elem_num_map(), ExodusII_IO_Helper::read_header(), ExodusII_IO_Helper::read_node_num_map(), ExodusII_IO_Helper::read_nodes(), ExodusII_IO_Helper::read_nodeset(), ExodusII_IO_Helper::read_nodeset_info(), ExodusII_IO_Helper::read_sideset(), ExodusII_IO_Helper::read_sideset_info(), ExodusII_IO_Helper::write_elements(), ExodusII_IO_Helper::write_nodal_coordinates(), ExodusII_IO_Helper::write_nodal_values(), ExodusII_IO_Helper::write_nodesets(), ExodusII_IO_Helper::write_sidesets(), and ExodusII_IO_Helper::write_timestep().  

int ExodusII_IO_Helper::ex_id [inherited]

Definition at line 525 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::close(), ExodusII_IO_Helper::create(), get_cmap_params(), get_eb_info_global(), get_elem_cmap(), get_elem_map(), get_init_global(), get_init_info(), get_loadbal_param(), ExodusII_IO_Helper::get_nodal_var_names(), ExodusII_IO_Helper::get_nodal_var_values(), get_node_cmap(), get_node_map(), get_ns_param_global(), get_ss_param_global(), ExodusII_IO_Helper::get_time_steps(), ExodusII_IO_Helper::initialize(), ExodusII_IO_Helper::initialize_nodal_variables(), ExodusII_IO_Helper::inquire(), ExodusII_IO_Helper::open(), ExodusII_IO_Helper::read_block_info(), ExodusII_IO_Helper::read_elem_in_block(), ExodusII_IO_Helper::read_elem_num_map(), ExodusII_IO_Helper::read_header(), ExodusII_IO_Helper::read_node_num_map(), ExodusII_IO_Helper::read_nodes(), ExodusII_IO_Helper::read_nodeset(), ExodusII_IO_Helper::read_nodeset_info(), ExodusII_IO_Helper::read_sideset(), ExodusII_IO_Helper::read_sideset_info(), ExodusII_IO_Helper::write_elements(), ExodusII_IO_Helper::write_nodal_coordinates(), ExodusII_IO_Helper::write_nodal_values(), ExodusII_IO_Helper::write_nodesets(), ExodusII_IO_Helper::write_sidesets(), and ExodusII_IO_Helper::write_timestep().  

float ExodusII_IO_Helper::ex_version [inherited]

Definition at line 553 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::create(), and ExodusII_IO_Helper::open().  

char Nemesis_IO_Helper::ftypeThe type of file to be written. Either 's', for a scalar load-balance file, or 'p' for a parallel file. To be used with Nemesis::ne_get_init_info().

Definition at line 126 of file nemesis_io_helper.h.

Referenced by get_init_info().  

std::vector<int> Nemesis_IO_Helper::global_elem_blk_cnts

Definition at line 158 of file nemesis_io_helper.h.

Referenced by get_eb_info_global().  

std::vector<int> Nemesis_IO_Helper::global_elem_blk_idsRead the global element block IDs and counts. These vectors will eventually have num_elem_blks_global entries. To be used with Nemesis::ne_get_eb_info_global().

Definition at line 157 of file nemesis_io_helper.h.

Referenced by get_eb_info_global().  

std::vector<int> Nemesis_IO_Helper::global_nodeset_idsContainers for reading global nodeset information. One vector entry per nodeset. Each vector will eventually have num_node_sets_global entries, and will be used in calls to Nemesis::ne_get_ns_param_global().

It's an error to call ne_get_ns_param_global when num_node_sets_global==0

Definition at line 147 of file nemesis_io_helper.h.

Referenced by get_ns_param_global().  

std::vector<int> Nemesis_IO_Helper::global_sideset_idsContainers for reading global sideset (boundary conditions) information. Each vector will eventually have num_side_sets_global entries, and be used in calls to Nemesis::ne_get_ss_param_global().

It's an error to call ne_get_ss_param_global when num_side_sets_global==0

Definition at line 135 of file nemesis_io_helper.h.

Referenced by get_ss_param_global().  

std::vector<int> ExodusII_IO_Helper::id_list [inherited]

Definition at line 550 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_id_list(), ExodusII_IO_Helper::read_sideset(), and ExodusII_IO_Helper::read_sideset_info().  

int ExodusII_IO_Helper::io_ws [inherited]

Definition at line 524 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::create(), and ExodusII_IO_Helper::open().  

std::map<int, int> ExodusII_IO_Helper::libmesh_elem_num_to_exodus [inherited]

Definition at line 565 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::write_elements().  

int Nemesis_IO_Helper::nemesis_err_flagInstance of the Exodus IO Helper. We call the Exodus API through this object. Instead of creating forwarding functions for everything in the ExodusII_IO_Helper class, just call them directly through this object! All (?) Nemesis functions return an int. If it's negative that signals an error! Internally, we use the ExodusII_IO_Helper::check_err() function to check for errors.

Definition at line 96 of file nemesis_io_helper.h.

Referenced by get_cmap_params(), get_eb_info_global(), get_elem_cmap(), get_elem_map(), get_init_global(), get_init_info(), get_loadbal_param(), get_node_cmap(), get_node_map(), get_ns_param_global(), and get_ss_param_global().  

std::vector<std::string> ExodusII_IO_Helper::nodal_var_names [inherited]

Definition at line 571 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_nodal_var_names(), and ExodusII_IO_Helper::get_nodal_var_values().  

std::vector<double> ExodusII_IO_Helper::nodal_var_values [inherited]

Definition at line 572 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_nodal_var_values().  

std::vector<int> Nemesis_IO_Helper::node_cmap_idsVectors for storing the communication map parameters. Each will eventually have length num_node_cmaps OR num_elem_cmaps as appropriate. For use with Nemesis::ne_get_cmap_params().

Definition at line 258 of file nemesis_io_helper.h.

Referenced by get_cmap_params(), get_node_cmap(), and Nemesis_IO::read().  

std::vector<int> Nemesis_IO_Helper::node_cmap_node_cnts

Definition at line 259 of file nemesis_io_helper.h.

Referenced by get_cmap_params(), get_node_cmap(), and Nemesis_IO::read().  

std::vector<std::vector<int> > Nemesis_IO_Helper::node_cmap_node_ids2 vectors of vectors for storing the node communication IDs for this processor. There will be num_node_cmaps rows, row i will have node_cmap_node_cnts[i] entries. To be used with Nemesis::ne_get_node_cmap().

Remark: node_cmap_proc_ids is a vector, all entries of which are = node_cmap_ids[i] Not sure what the point of that is...

Definition at line 272 of file nemesis_io_helper.h.

Referenced by get_node_cmap(), and Nemesis_IO::read().  

std::vector<std::vector<int> > Nemesis_IO_Helper::node_cmap_proc_ids

Definition at line 273 of file nemesis_io_helper.h.

Referenced by get_node_cmap(), and Nemesis_IO::read().  

std::vector<int> ExodusII_IO_Helper::node_list [inherited]

Definition at line 549 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_node_list(), and ExodusII_IO_Helper::read_nodeset().  

std::vector<int> Nemesis_IO_Helper::node_mapbVector which stores border node IDs. Will have length num_border_nodes. To be used with Nemesis::ne_get_node_map().

Definition at line 242 of file nemesis_io_helper.h.

Referenced by get_node_map(), and Nemesis_IO::read().  

std::vector<int> Nemesis_IO_Helper::node_mapeVector which stores external node IDs. Will have length num_external_nodes. To be used with Nemesis::ne_get_node_map().

Definition at line 249 of file nemesis_io_helper.h.

Referenced by get_node_map(), and Nemesis_IO::read().  

std::vector<int> Nemesis_IO_Helper::node_mapiVector which stores internal node IDs. Will have length num_internal_nodes. To be used with Nemesis::ne_get_node_map().

Definition at line 235 of file nemesis_io_helper.h.

Referenced by get_node_map(), and Nemesis_IO::read().  

std::vector<int> ExodusII_IO_Helper::node_num_map [inherited]

Definition at line 551 of file exodusII_io_helper.h.

Referenced by Nemesis_IO::read(), and ExodusII_IO_Helper::read_node_num_map().  

std::vector<int> ExodusII_IO_Helper::nodeset_ids [inherited]

Definition at line 542 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_nodeset_id(), ExodusII_IO_Helper::read_nodeset(), and ExodusII_IO_Helper::read_nodeset_info().  

int ExodusII_IO_Helper::num_attr [inherited]

Definition at line 535 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::read_elem_in_block().  

int Nemesis_IO_Helper::num_border_elemsThe number of border FEM elements. Elements local to this processor but whose FEM nodes reside on other processors as well. To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 196 of file nemesis_io_helper.h.

Referenced by get_elem_map(), get_loadbal_param(), and Nemesis_IO::read().  

int Nemesis_IO_Helper::num_border_nodesThe number of FEM nodes local to a processor but residing in an element which also has FEM nodes on other processors. To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 176 of file nemesis_io_helper.h.

Referenced by get_loadbal_param(), get_node_map(), and Nemesis_IO::read().  

std::vector<int> ExodusII_IO_Helper::num_df_per_set [inherited]

Definition at line 545 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::read_sideset(), and ExodusII_IO_Helper::read_sideset_info().  

int ExodusII_IO_Helper::num_dim [inherited]

Definition at line 527 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_num_dim(), ExodusII_IO_Helper::initialize(), ExodusII_IO_Helper::print_header(), Nemesis_IO::read(), and ExodusII_IO_Helper::read_header().  

int ExodusII_IO_Helper::num_elem [inherited]

Definition at line 529 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_num_elem(), ExodusII_IO_Helper::initialize(), ExodusII_IO_Helper::print_header(), Nemesis_IO::read(), ExodusII_IO_Helper::read_elem_num_map(), ExodusII_IO_Helper::read_header(), and ExodusII_IO_Helper::write_elements().  

int ExodusII_IO_Helper::num_elem_all_sidesets [inherited]

Definition at line 538 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::print_sideset_info(), and ExodusII_IO_Helper::read_sideset_info().  

int ExodusII_IO_Helper::num_elem_blk [inherited]

Definition at line 530 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_num_elem_blk(), ExodusII_IO_Helper::initialize(), ExodusII_IO_Helper::print_header(), Nemesis_IO::read(), ExodusII_IO_Helper::read_block_info(), and ExodusII_IO_Helper::read_header().  

int Nemesis_IO_Helper::num_elem_blks_global

Definition at line 104 of file nemesis_io_helper.h.

Referenced by get_eb_info_global(), and get_init_global().  

int Nemesis_IO_Helper::num_elem_cmapsThe number of elemental communication maps for this processor. (One per neighboring proc?) To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 210 of file nemesis_io_helper.h.

Referenced by get_cmap_params(), get_elem_cmap(), get_loadbal_param(), and Nemesis_IO::read().  

int ExodusII_IO_Helper::num_elem_this_blk [inherited]

Definition at line 533 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_num_elem_this_blk(), Nemesis_IO::read(), and ExodusII_IO_Helper::read_elem_in_block().  

int Nemesis_IO_Helper::num_elems_global

Definition at line 103 of file nemesis_io_helper.h.

Referenced by get_init_global(), and Nemesis_IO::read().  

int Nemesis_IO_Helper::num_external_nodesThe number of FEM nodes that reside on another processor but whose element partially resides on the current processor. To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 183 of file nemesis_io_helper.h.

Referenced by get_loadbal_param(), get_node_map(), and Nemesis_IO::read().  

std::vector<int> Nemesis_IO_Helper::num_global_node_counts

Definition at line 148 of file nemesis_io_helper.h.

Referenced by get_ns_param_global().  

std::vector<int> Nemesis_IO_Helper::num_global_node_df_counts

Definition at line 149 of file nemesis_io_helper.h.

Referenced by get_ns_param_global().  

std::vector<int> Nemesis_IO_Helper::num_global_side_counts

Definition at line 136 of file nemesis_io_helper.h.

Referenced by get_ss_param_global().  

std::vector<int> Nemesis_IO_Helper::num_global_side_df_counts

Definition at line 137 of file nemesis_io_helper.h.

Referenced by get_ss_param_global().  

int Nemesis_IO_Helper::num_internal_elemsThe number of internal FEM elements. Elements local to this processor. To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 189 of file nemesis_io_helper.h.

Referenced by get_elem_map(), get_loadbal_param(), and Nemesis_IO::read().  

int Nemesis_IO_Helper::num_internal_nodesTo be used with the Nemesis::ne_get_loadbal_param() routine. The number of FEM nodes contained in FEM elements wholly owned by the current processor. To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 169 of file nemesis_io_helper.h.

Referenced by get_loadbal_param(), get_node_map(), and Nemesis_IO::read().  

int ExodusII_IO_Helper::num_nodal_vars [inherited]

Definition at line 570 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_nodal_var_names(), ExodusII_IO_Helper::get_num_nodal_vars(), ExodusII_IO_Helper::initialize_nodal_variables(), and ExodusII_IO_Helper::read_header().  

int Nemesis_IO_Helper::num_node_cmapsThe number of nodal communication maps for this processor. (One per neighboring proc?) To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 203 of file nemesis_io_helper.h.

Referenced by get_cmap_params(), get_loadbal_param(), get_node_cmap(), and Nemesis_IO::read().  

std::vector<int> ExodusII_IO_Helper::num_node_df_per_set [inherited]

Definition at line 546 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::read_nodeset(), and ExodusII_IO_Helper::read_nodeset_info().  

int ExodusII_IO_Helper::num_node_sets [inherited]

Definition at line 531 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_num_node_sets(), ExodusII_IO_Helper::initialize(), ExodusII_IO_Helper::print_header(), ExodusII_IO_Helper::read_header(), and ExodusII_IO_Helper::read_nodeset_info().  

int Nemesis_IO_Helper::num_node_sets_global

Definition at line 105 of file nemesis_io_helper.h.

Referenced by get_init_global(), and get_ns_param_global().  

int ExodusII_IO_Helper::num_nodes [inherited]

Definition at line 528 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_nodal_var_values(), ExodusII_IO_Helper::get_num_nodes(), ExodusII_IO_Helper::initialize(), ExodusII_IO_Helper::print_header(), ExodusII_IO_Helper::print_nodes(), Nemesis_IO::read(), ExodusII_IO_Helper::read_header(), ExodusII_IO_Helper::read_node_num_map(), ExodusII_IO_Helper::read_nodes(), ExodusII_IO_Helper::write_nodal_coordinates(), and ExodusII_IO_Helper::write_nodal_values().  

int Nemesis_IO_Helper::num_nodes_globalGlobal initial information. The names are self-explanatory for the most part. Used with Nemesis::ne_get_init_global().

Definition at line 102 of file nemesis_io_helper.h.

Referenced by get_init_global(), and Nemesis_IO::read().  

int ExodusII_IO_Helper::num_nodes_per_elem [inherited]

Definition at line 534 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_num_nodes_per_elem(), Nemesis_IO::read(), ExodusII_IO_Helper::read_elem_in_block(), and ExodusII_IO_Helper::write_elements().  

std::vector<int> ExodusII_IO_Helper::num_nodes_per_set [inherited]

Definition at line 544 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_num_nodes_per_set(), ExodusII_IO_Helper::read_nodeset(), and ExodusII_IO_Helper::read_nodeset_info().  

int Nemesis_IO_Helper::num_procThe number of processors for which the NEMESIS I file was created. To be used with Nemesis::ne_get_init_info().

Definition at line 112 of file nemesis_io_helper.h.

Referenced by get_init_info().  

int Nemesis_IO_Helper::num_proc_in_fileThe number of processors for which the NEMESIS I file stores information. This is generally equal to 1 (1 CPU/file) at least for the splitting Derek gave us. To be used with Nemesis::ne_get_init_info().

Definition at line 119 of file nemesis_io_helper.h.

Referenced by get_init_info().  

int ExodusII_IO_Helper::num_side_sets [inherited]

Definition at line 532 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_num_side_sets(), ExodusII_IO_Helper::initialize(), ExodusII_IO_Helper::print_header(), ExodusII_IO_Helper::read_header(), and ExodusII_IO_Helper::read_sideset_info().  

int Nemesis_IO_Helper::num_side_sets_global

Definition at line 106 of file nemesis_io_helper.h.

Referenced by get_init_global(), and get_ss_param_global().  

std::vector<int> ExodusII_IO_Helper::num_sides_per_set [inherited]

Definition at line 543 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_num_sides_per_set(), ExodusII_IO_Helper::read_sideset(), and ExodusII_IO_Helper::read_sideset_info().  

int ExodusII_IO_Helper::num_time_steps [inherited]

Definition at line 568 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_time_steps(), and ExodusII_IO_Helper::read_header().  

int ExodusII_IO_Helper::req_info [inherited]

Definition at line 536 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::read_sideset_info().  

char ExodusII_IO_Helper::ret_char [inherited]

Definition at line 558 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::inquire(), and ExodusII_IO_Helper::read_sideset_info().  

float ExodusII_IO_Helper::ret_float [inherited]

Definition at line 554 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::inquire(), and ExodusII_IO_Helper::read_sideset_info().  

int ExodusII_IO_Helper::ret_int [inherited]

Definition at line 537 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::inquire(), and ExodusII_IO_Helper::read_sideset_info().  

std::vector<int> ExodusII_IO_Helper::side_list [inherited]

Definition at line 548 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_side_list(), ExodusII_IO_Helper::print_sideset_info(), ExodusII_IO_Helper::read_sideset(), and ExodusII_IO_Helper::read_sideset_info().  

std::vector<int> ExodusII_IO_Helper::ss_ids [inherited]

Definition at line 541 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::read_sideset(), and ExodusII_IO_Helper::read_sideset_info().  

std::vector<char*> ExodusII_IO_Helper::strings [inherited]

Definition at line 578 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_nodal_var_names(), and ExodusII_IO_Helper::initialize_nodal_variables().  

std::vector<double> ExodusII_IO_Helper::time_steps [inherited]

Definition at line 569 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_time_steps().  

std::vector<char> ExodusII_IO_Helper::title [inherited]

Definition at line 560 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::ExodusII_IO_Helper(), ExodusII_IO_Helper::print_header(), and ExodusII_IO_Helper::read_header().  

std::vector<std::vector<char> > ExodusII_IO_Helper::vvc [inherited]

Definition at line 577 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_nodal_var_names(), and ExodusII_IO_Helper::initialize_nodal_variables().  

std::vector<double> ExodusII_IO_Helper::x [inherited]

Definition at line 555 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_x(), ExodusII_IO_Helper::print_nodes(), Nemesis_IO::read(), ExodusII_IO_Helper::read_nodes(), and ExodusII_IO_Helper::write_nodal_coordinates().  

std::vector<double> ExodusII_IO_Helper::y [inherited]

Definition at line 556 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_y(), ExodusII_IO_Helper::print_nodes(), Nemesis_IO::read(), ExodusII_IO_Helper::read_nodes(), and ExodusII_IO_Helper::write_nodal_coordinates().  

std::vector<double> ExodusII_IO_Helper::z [inherited]

Definition at line 557 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper::get_z(), ExodusII_IO_Helper::print_nodes(), Nemesis_IO::read(), ExodusII_IO_Helper::read_nodes(), and ExodusII_IO_Helper::write_nodal_coordinates().

 

Author

Generated automatically by Doxygen for libMesh from the source code.


 

Index

NAME
SYNOPSIS
Public Member Functions
Public Attributes
Protected Attributes
Detailed Description
Constructor & Destructor Documentation
Nemesis_IO_Helper::Nemesis_IO_Helper (boolverbose = false)Constructor.
Nemesis_IO_Helper::~Nemesis_IO_Helper ()Destructor.
Member Function Documentation
void ExodusII_IO_Helper::check_err (const interror, const std::stringmsg) [inherited]All of the ExodusII API functions return an int error value. This function checks to see if the error has been set, and if it has, prints the error message contained in msg.
void ExodusII_IO_Helper::close () [inherited]Closes the ExodusII mesh file.
void ExodusII_IO_Helper::create (std::stringfilename) [inherited]Opens an ExodusII mesh file named filename for writing.
bool ExodusII_IO_Helper::created () [inherited]Returns true once create() has been successfully called, and false otherwise.
int ExodusII_IO_Helper::get_block_id (intblock) [inherited]Get's the block number for the given block.
void Nemesis_IO_Helper::get_cmap_params ()
int ExodusII_IO_Helper::get_connect (inti) const [inline, inherited]Returns:
void Nemesis_IO_Helper::get_eb_info_global ()
void Nemesis_IO_Helper::get_elem_cmap ()
const std::vector<int>& ExodusII_IO_Helper::get_elem_list () const [inline, inherited]Returns:
void Nemesis_IO_Helper::get_elem_map ()
const char* ExodusII_IO_Helper::get_elem_type () const [inline, inherited]Returns:
const std::vector<int>& ExodusII_IO_Helper::get_id_list () const [inline, inherited]Returns:
void Nemesis_IO_Helper::get_init_global ()Set the flag indicationg if we should be verbose.
void Nemesis_IO_Helper::get_init_info ()
void Nemesis_IO_Helper::get_loadbal_param ()
const std::vector< std::string > & ExodusII_IO_Helper::get_nodal_var_names () [inherited]
const std::vector< double > & ExodusII_IO_Helper::get_nodal_var_values (std::stringnodal_var_name, inttime_step) [inherited]
void Nemesis_IO_Helper::get_node_cmap ()
const std::vector<int>& ExodusII_IO_Helper::get_node_list () const [inline, inherited]Returns:
void Nemesis_IO_Helper::get_node_map ()
int ExodusII_IO_Helper::get_nodeset_id (unsigned inti) const [inline, inherited]Returns:
void Nemesis_IO_Helper::get_ns_param_global ()
int ExodusII_IO_Helper::get_num_dim () const [inline, inherited]Returns:
int ExodusII_IO_Helper::get_num_elem () const [inline, inherited]Returns:
int ExodusII_IO_Helper::get_num_elem_blk () const [inline, inherited]Returns:
int ExodusII_IO_Helper::get_num_elem_this_blk () const [inline, inherited]For a given block, returns the total number of elements.
int ExodusII_IO_Helper::get_num_nodal_vars () [inline, inherited]
int ExodusII_IO_Helper::get_num_node_sets () const [inline, inherited]Returns:
int ExodusII_IO_Helper::get_num_nodes () const [inline, inherited]Returns:
int ExodusII_IO_Helper::get_num_nodes_per_elem () const [inline, inherited]Returns:
int ExodusII_IO_Helper::get_num_nodes_per_set (inti) const [inline, inherited]For a single nodeset, returns the total number of nodes in the nodeset.
int ExodusII_IO_Helper::get_num_side_sets () const [inline, inherited]Returns:
int ExodusII_IO_Helper::get_num_sides_per_set (inti) const [inline, inherited]For a single sideset, returns the total number of elements in the sideset.
const std::vector<int>& ExodusII_IO_Helper::get_side_list () const [inline, inherited]Returns:
void Nemesis_IO_Helper::get_ss_param_global ()
const std::vector< double > & ExodusII_IO_Helper::get_time_steps () [inherited]
double ExodusII_IO_Helper::get_x (inti) const [inline, inherited]Returns:
double ExodusII_IO_Helper::get_y (inti) const [inline, inherited]Returns:
double ExodusII_IO_Helper::get_z (inti) const [inline, inherited]Returns:
void ExodusII_IO_Helper::initialize (std::stringtitle, const MeshBase &mesh) [inherited]Initializes the Exodus file
void ExodusII_IO_Helper::initialize_nodal_variables (std::vector< std::string >names) [inherited]Sets up the nodal variables
int ExodusII_IO_Helper::inquire (intreq_info, std::stringerror_msg = '') [inherited]Generic inquiry, returns the value
void ExodusII_IO_Helper::message (const std::stringmsg, inti) [inherited]Prints the message defined in msg to std::cout and appends the number i to the end of the message. Useful for printing messages in loops. Can be turned off if verbosity is set to 0.
void ExodusII_IO_Helper::message (const std::stringmsg) [inherited]Prints the message defined in msg to std::cout. Can be turned off if verbosity is set to 0.
void ExodusII_IO_Helper::open (const char *filename) [inherited]Opens an ExodusII mesh file named filename for reading.
void ExodusII_IO_Helper::print_header () [inherited]Prints the ExodusII mesh file header, which includes the mesh title, the number of nodes, number of elements, mesh dimension, number of sidesets, and number of nodesets
void ExodusII_IO_Helper::print_nodes () [inherited]Prints the nodal information to std::cout.
void ExodusII_IO_Helper::print_nodeset_info () [inherited]Prints information about all the nodesets.
void ExodusII_IO_Helper::print_sideset_info () [inherited]Prints information about all the sidesets.
void ExodusII_IO_Helper::read_block_info () [inherited]Reads information for all of the blocks in the ExodusII mesh file.
void ExodusII_IO_Helper::read_elem_in_block (intblock) [inherited]Reads all of the element connectivity for block block in the ExodusII mesh file.
void ExodusII_IO_Helper::read_elem_num_map () [inherited]Reads the optional node_num_map from the ExodusII mesh file.
void ExodusII_IO_Helper::read_header () [inherited]Reads an ExodusII mesh file header.
void ExodusII_IO_Helper::read_node_num_map () [inherited]Reads the optional node_num_map from the ExodusII mesh file.
void ExodusII_IO_Helper::read_nodes () [inherited]Reads the nodal data (x,y,z coordinates) from the ExodusII mesh file.
void ExodusII_IO_Helper::read_nodeset (intid) [inherited]Reads information about nodeset id and inserts it into the global nodeset array at the position offset.
void ExodusII_IO_Helper::read_nodeset_info () [inherited]Reads information about all of the nodesets in the ExodusII mesh file.
void ExodusII_IO_Helper::read_sideset (intid, intoffset) [inherited]Reads information about sideset id and inserts it into the global sideset array at the position offset.
void ExodusII_IO_Helper::read_sideset_info () [inherited]Reads information about all of the sidesets in the ExodusII mesh file.
void ExodusII_IO_Helper::verbose (boolset_verbosity) [inherited]Get/set flag telling whether message printing is on or off.
void ExodusII_IO_Helper::write_elements (const MeshBase &mesh) [inherited]Writes the elements contained in 'mesh' FIXME: This only works for Mesh's having a single type of element!
void ExodusII_IO_Helper::write_nodal_coordinates (const MeshBase &mesh) [inherited]Writes the nodal coordinates contained in 'mesh'
void ExodusII_IO_Helper::write_nodal_values (intvar_id, const std::vector< Number > &values, inttimestep) [inherited]Writes the vector of values to a nodal variable.
void ExodusII_IO_Helper::write_nodesets (const MeshBase &mesh) [inherited]Writes the nodesets contained in 'mesh'
void ExodusII_IO_Helper::write_sidesets (const MeshBase &mesh) [inherited]Writes the sidesets contained in 'mesh'
void ExodusII_IO_Helper::write_timestep (inttimestep, doubletime) [inherited]Writes the time for the timestep
Member Data Documentation
bool ExodusII_IO_Helper::_created [protected, inherited]
bool ExodusII_IO_Helper::_verbose [protected, inherited]
std::vector<int> ExodusII_IO_Helper::block_ids [inherited]
int ExodusII_IO_Helper::comp_ws [inherited]
std::vector<int> ExodusII_IO_Helper::connect [inherited]
std::vector<int> Nemesis_IO_Helper::elem_cmap_elem_cnts
std::vector<std::vector<int> > Nemesis_IO_Helper::elem_cmap_elem_ids3 vectors of vectors for storing element communication IDs for this processor. There will be num_elem_cmaps rows, row i will have elem_cmap_elem_cnts[i] entries. To be used with Nemesis::ne_get_elem_cmap().
std::vector<int> Nemesis_IO_Helper::elem_cmap_ids
std::vector<std::vector<int> > Nemesis_IO_Helper::elem_cmap_proc_ids
std::vector<std::vector<int> > Nemesis_IO_Helper::elem_cmap_side_ids
std::vector<int> ExodusII_IO_Helper::elem_list [inherited]
std::vector<int> Nemesis_IO_Helper::elem_mapbVector which stores border element IDs. Will have length num_border_elems. To be used with Nemesis::ne_get_elem_map().
std::vector<int> Nemesis_IO_Helper::elem_mapiVector which stores internal element IDs. Will have length num_internal_elems. To be used with Nemesis::ne_get_elem_map().
std::vector<int> ExodusII_IO_Helper::elem_num_map [inherited]
std::vector<char> ExodusII_IO_Helper::elem_type [inherited]
int ExodusII_IO_Helper::ex_err [inherited]
int ExodusII_IO_Helper::ex_id [inherited]
float ExodusII_IO_Helper::ex_version [inherited]
char Nemesis_IO_Helper::ftypeThe type of file to be written. Either 's', for a scalar load-balance file, or 'p' for a parallel file. To be used with Nemesis::ne_get_init_info().
std::vector<int> Nemesis_IO_Helper::global_elem_blk_cnts
std::vector<int> Nemesis_IO_Helper::global_elem_blk_idsRead the global element block IDs and counts. These vectors will eventually have num_elem_blks_global entries. To be used with Nemesis::ne_get_eb_info_global().
std::vector<int> Nemesis_IO_Helper::global_nodeset_idsContainers for reading global nodeset information. One vector entry per nodeset. Each vector will eventually have num_node_sets_global entries, and will be used in calls to Nemesis::ne_get_ns_param_global().
std::vector<int> Nemesis_IO_Helper::global_sideset_idsContainers for reading global sideset (boundary conditions) information. Each vector will eventually have num_side_sets_global entries, and be used in calls to Nemesis::ne_get_ss_param_global().
std::vector<int> ExodusII_IO_Helper::id_list [inherited]
int ExodusII_IO_Helper::io_ws [inherited]
std::map<int, int> ExodusII_IO_Helper::libmesh_elem_num_to_exodus [inherited]
int Nemesis_IO_Helper::nemesis_err_flagInstance of the Exodus IO Helper. We call the Exodus API through this object. Instead of creating forwarding functions for everything in the ExodusII_IO_Helper class, just call them directly through this object! All (?) Nemesis functions return an int. If it's negative that signals an error! Internally, we use the ExodusII_IO_Helper::check_err() function to check for errors.
std::vector<std::string> ExodusII_IO_Helper::nodal_var_names [inherited]
std::vector<double> ExodusII_IO_Helper::nodal_var_values [inherited]
std::vector<int> Nemesis_IO_Helper::node_cmap_idsVectors for storing the communication map parameters. Each will eventually have length num_node_cmaps OR num_elem_cmaps as appropriate. For use with Nemesis::ne_get_cmap_params().
std::vector<int> Nemesis_IO_Helper::node_cmap_node_cnts
std::vector<std::vector<int> > Nemesis_IO_Helper::node_cmap_node_ids2 vectors of vectors for storing the node communication IDs for this processor. There will be num_node_cmaps rows, row i will have node_cmap_node_cnts[i] entries. To be used with Nemesis::ne_get_node_cmap().
std::vector<std::vector<int> > Nemesis_IO_Helper::node_cmap_proc_ids
std::vector<int> ExodusII_IO_Helper::node_list [inherited]
std::vector<int> Nemesis_IO_Helper::node_mapbVector which stores border node IDs. Will have length num_border_nodes. To be used with Nemesis::ne_get_node_map().
std::vector<int> Nemesis_IO_Helper::node_mapeVector which stores external node IDs. Will have length num_external_nodes. To be used with Nemesis::ne_get_node_map().
std::vector<int> Nemesis_IO_Helper::node_mapiVector which stores internal node IDs. Will have length num_internal_nodes. To be used with Nemesis::ne_get_node_map().
std::vector<int> ExodusII_IO_Helper::node_num_map [inherited]
std::vector<int> ExodusII_IO_Helper::nodeset_ids [inherited]
int ExodusII_IO_Helper::num_attr [inherited]
int Nemesis_IO_Helper::num_border_elemsThe number of border FEM elements. Elements local to this processor but whose FEM nodes reside on other processors as well. To be used with the Nemesis::ne_get_loadbal_param() routine.
int Nemesis_IO_Helper::num_border_nodesThe number of FEM nodes local to a processor but residing in an element which also has FEM nodes on other processors. To be used with the Nemesis::ne_get_loadbal_param() routine.
std::vector<int> ExodusII_IO_Helper::num_df_per_set [inherited]
int ExodusII_IO_Helper::num_dim [inherited]
int ExodusII_IO_Helper::num_elem [inherited]
int ExodusII_IO_Helper::num_elem_all_sidesets [inherited]
int ExodusII_IO_Helper::num_elem_blk [inherited]
int Nemesis_IO_Helper::num_elem_blks_global
int Nemesis_IO_Helper::num_elem_cmapsThe number of elemental communication maps for this processor. (One per neighboring proc?) To be used with the Nemesis::ne_get_loadbal_param() routine.
int ExodusII_IO_Helper::num_elem_this_blk [inherited]
int Nemesis_IO_Helper::num_elems_global
int Nemesis_IO_Helper::num_external_nodesThe number of FEM nodes that reside on another processor but whose element partially resides on the current processor. To be used with the Nemesis::ne_get_loadbal_param() routine.
std::vector<int> Nemesis_IO_Helper::num_global_node_counts
std::vector<int> Nemesis_IO_Helper::num_global_node_df_counts
std::vector<int> Nemesis_IO_Helper::num_global_side_counts
std::vector<int> Nemesis_IO_Helper::num_global_side_df_counts
int Nemesis_IO_Helper::num_internal_elemsThe number of internal FEM elements. Elements local to this processor. To be used with the Nemesis::ne_get_loadbal_param() routine.
int Nemesis_IO_Helper::num_internal_nodesTo be used with the Nemesis::ne_get_loadbal_param() routine. The number of FEM nodes contained in FEM elements wholly owned by the current processor. To be used with the Nemesis::ne_get_loadbal_param() routine.
int ExodusII_IO_Helper::num_nodal_vars [inherited]
int Nemesis_IO_Helper::num_node_cmapsThe number of nodal communication maps for this processor. (One per neighboring proc?) To be used with the Nemesis::ne_get_loadbal_param() routine.
std::vector<int> ExodusII_IO_Helper::num_node_df_per_set [inherited]
int ExodusII_IO_Helper::num_node_sets [inherited]
int Nemesis_IO_Helper::num_node_sets_global
int ExodusII_IO_Helper::num_nodes [inherited]
int Nemesis_IO_Helper::num_nodes_globalGlobal initial information. The names are self-explanatory for the most part. Used with Nemesis::ne_get_init_global().
int ExodusII_IO_Helper::num_nodes_per_elem [inherited]
std::vector<int> ExodusII_IO_Helper::num_nodes_per_set [inherited]
int Nemesis_IO_Helper::num_procThe number of processors for which the NEMESIS I file was created. To be used with Nemesis::ne_get_init_info().
int Nemesis_IO_Helper::num_proc_in_fileThe number of processors for which the NEMESIS I file stores information. This is generally equal to 1 (1 CPU/file) at least for the splitting Derek gave us. To be used with Nemesis::ne_get_init_info().
int ExodusII_IO_Helper::num_side_sets [inherited]
int Nemesis_IO_Helper::num_side_sets_global
std::vector<int> ExodusII_IO_Helper::num_sides_per_set [inherited]
int ExodusII_IO_Helper::num_time_steps [inherited]
int ExodusII_IO_Helper::req_info [inherited]
char ExodusII_IO_Helper::ret_char [inherited]
float ExodusII_IO_Helper::ret_float [inherited]
int ExodusII_IO_Helper::ret_int [inherited]
std::vector<int> ExodusII_IO_Helper::side_list [inherited]
std::vector<int> ExodusII_IO_Helper::ss_ids [inherited]
std::vector<char*> ExodusII_IO_Helper::strings [inherited]
std::vector<double> ExodusII_IO_Helper::time_steps [inherited]
std::vector<char> ExodusII_IO_Helper::title [inherited]
std::vector<std::vector<char> > ExodusII_IO_Helper::vvc [inherited]
std::vector<double> ExodusII_IO_Helper::x [inherited]
std::vector<double> ExodusII_IO_Helper::y [inherited]
std::vector<double> ExodusII_IO_Helper::z [inherited]
Author

This document was created by man2html, using the manual pages.
Time: 21:50:53 GMT, April 16, 2011