libMesh::Nemesis_IO_Helper Class Reference

#include <nemesis_io_helper.h>

Inheritance diagram for libMesh::Nemesis_IO_Helper:

[legend]

List of all members.

Public Member Functions
	Nemesis_IO_Helper (bool verbose=false)
virtual	~Nemesis_IO_Helper ()
void	get_init_global ()
void	get_ss_param_global ()
void	get_ns_param_global ()
void	get_eb_info_global ()
void	get_init_info ()
void	get_loadbal_param ()
void	get_elem_map ()
void	get_node_map ()
void	get_cmap_params ()
void	get_node_cmap ()
void	get_elem_cmap ()
void	put_init_info (unsigned num_proc, unsigned num_proc_in_file, const char *ftype)
void	put_init_global (dof_id_type num_nodes_global, dof_id_type num_elems_global, unsigned num_elem_blks_global, unsigned num_node_sets_global, unsigned num_side_sets_global)
void	put_eb_info_global (std::vector< int > &global_elem_blk_ids, std::vector< int > &global_elem_blk_cnts)
void	put_ns_param_global (std::vector< int > &global_nodeset_ids, std::vector< int > &num_global_node_counts, std::vector< int > &num_global_node_df_counts)
void	put_ss_param_global (std::vector< int > &global_sideset_ids, std::vector< int > &num_global_side_counts, std::vector< int > &num_global_side_df_counts)
void	put_loadbal_param (unsigned num_internal_nodes, unsigned num_border_nodes, unsigned num_external_nodes, unsigned num_internal_elems, unsigned num_border_elems, unsigned num_node_cmaps, unsigned num_elem_cmaps)
void	put_cmap_params (std::vector< int > &node_cmap_ids, std::vector< int > &node_cmap_node_cnts, std::vector< int > &elem_cmap_ids, std::vector< int > &elem_cmap_elem_cnts)
void	put_node_cmap (std::vector< std::vector< int > > &node_cmap_node_ids, std::vector< std::vector< int > > &node_cmap_proc_ids)
void	put_node_map (std::vector< int > &node_mapi, std::vector< int > &node_mapb, std::vector< int > &node_mape)
void	put_elem_cmap (std::vector< std::vector< int > > &elem_cmap_elem_ids, std::vector< std::vector< int > > &elem_cmap_side_ids, std::vector< std::vector< int > > &elem_cmap_proc_ids)
void	put_elem_map (std::vector< int > &elem_mapi, std::vector< int > &elem_mapb)
void	put_n_coord (unsigned start_node_num, unsigned num_nodes, std::vector< Real > &x_coor, std::vector< Real > &y_coor, std::vector< Real > &z_coor)
virtual void	write_nodal_coordinates (const MeshBase &mesh)
virtual void	write_elements (const MeshBase &mesh)
virtual void	write_sidesets (const MeshBase &mesh)
virtual void	write_nodesets (const MeshBase &mesh)
virtual void	create (std::string filename)
virtual void	initialize (std::string title, const MeshBase &mesh)
void	write_nodal_solution (const std::vector< Number > &values, const std::vector< std::string > names, int timestep)
std::string	construct_nemesis_filename (const std::string &base_filename)
bool	created ()
void	verbose (bool set_verbosity)
int	get_num_dim () const
int	get_num_globals () 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
Real	get_x (int i) const
Real	get_y (int i) const
Real	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 (std::ostream &out=libMesh::out)
void	read_block_info ()
int	get_block_id (int index)
std::string	get_block_name (int index)
int	get_side_set_id (int index)
std::string	get_side_set_name (int index)
int	get_node_set_id (int index)
std::string	get_node_set_name (int index)
void	read_elem_in_block (int block)
void	read_elem_num_map ()
void	read_sideset_info ()
void	read_nodeset_info ()
void	read_sideset (int id, int offset)
void	read_nodeset (int id)
void	print_sideset_info ()
void	print_nodeset_info ()
void	close ()
int	inquire (int req_info, std::string error_msg="")
const std::vector< Real > &	get_time_steps ()
int	get_num_nodal_vars ()
const std::vector< std::string > &	get_nodal_var_names ()
const std::vector< Real > &	get_nodal_var_values (std::string nodal_var_name, int time_step)
void	initialize_discontinuous (std::string title, const MeshBase &mesh)
void	write_nodal_coordinates_discontinuous (const MeshBase &mesh)
void	write_elements_discontinuous (const MeshBase &mesh)
void	initialize_element_variables (const MeshBase &mesh, std::vector< std::string > names)
void	initialize_nodal_variables (std::vector< std::string > names)
void	initialize_global_variables (const std::vector< std::string > &names)
void	write_timestep (int timestep, Real time)
void	write_element_values (const MeshBase &mesh, const std::vector< Number > &values, int timestep)
void	write_nodal_values (int var_id, const std::vector< Number > &values, int timestep)
void	write_information_records (const std::vector< std::string > &records)
void	write_global_values (const std::vector< Number > &values, int timestep)
void	use_mesh_dimension_instead_of_spatial_dimension (bool val)
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
std::set< int >	nodes_attached_to_local_elems
std::map< subdomain_id_type, std::vector< unsigned int > >	subdomain_map
std::map< int, std::vector< int > >	block_id_to_elem_connectivity
int	num_internal_nodes
int	num_border_nodes
int	num_external_nodes
int	num_internal_elems
int	num_border_elems
int	num_node_cmaps
int	num_elem_cmaps
std::vector< int >	elem_mapi
std::vector< int >	elem_mapb
std::vector< int >	node_mapi
std::vector< int >	node_mapb
std::vector< int >	node_mape
std::vector< int >	node_cmap_ids
std::vector< int >	node_cmap_node_cnts
std::vector< int >	elem_cmap_ids
std::vector< int >	elem_cmap_elem_cnts
std::vector< std::vector< int > >	node_cmap_node_ids
std::vector< std::vector< int > >	node_cmap_proc_ids
std::vector< std::vector< int > >	elem_cmap_elem_ids
std::vector< std::vector< int > >	elem_cmap_side_ids
std::vector< std::vector< int > >	elem_cmap_proc_ids
int	comp_ws
int	io_ws
int	ex_id
int	ex_err
int	num_dim
int	num_globals
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< Real >	x
std::vector< Real >	y
std::vector< Real >	z
char	ret_char
std::vector< char >	title
std::vector< char >	elem_type
std::map< int, int >	libmesh_elem_num_to_exodus
std::vector< int >	exodus_elem_num_to_libmesh
std::map< int, int >	libmesh_node_num_to_exodus
std::vector< int >	exodus_node_num_to_libmesh
int	num_time_steps
std::vector< Real >	time_steps
int	num_nodal_vars
std::vector< std::string >	nodal_var_names
std::vector< Real >	nodal_var_values
int	num_elem_vars
std::vector< std::vector< char > >	vvc
std::vector< char * >	strings
std::map< int, std::string >	id_to_block_names
std::map< int, std::string >	id_to_ss_names
std::map< int, std::string >	id_to_ns_names
Protected Attributes
bool	_created
bool	_verbose
bool	_run_only_on_proc0
bool	_elem_vars_initialized
bool	_global_vars_initialized
bool	_use_mesh_dimension_instead_of_spatial_dimension
Private Types
typedef std::map< unsigned, std::set< unsigned > >::iterator	proc_nodes_touched_iterator
typedef std::map< unsigned, std::set< std::pair< unsigned, unsigned > > >::iterator	proc_border_elem_sets_iterator
Private Member Functions
void	compute_num_global_elem_blocks (const MeshBase &pmesh)
void	compute_num_global_nodesets (const MeshBase &pmesh)
void	compute_num_global_sidesets (const MeshBase &pmesh)
void	build_element_and_node_maps (const MeshBase &pmesh)
void	compute_border_node_ids (const MeshBase &pmesh)
void	compute_internal_and_border_elems_and_internal_nodes (const MeshBase &pmesh)
void	compute_communication_map_parameters ()
void	compute_node_communication_maps ()
void	compute_node_maps ()
void	compute_elem_communication_maps ()
void	compute_element_maps ()
void	write_exodus_initialization_info (const MeshBase &pmesh, const std::string &title)
Private Attributes
std::map< subdomain_id_type, unsigned >	local_subdomain_counts
std::set< unsigned >	border_node_ids
std::map< unsigned, std::set < unsigned > >	proc_nodes_touched_intersections
std::map< unsigned, std::set < std::pair< unsigned, unsigned > > >	proc_border_elem_sets
std::set< unsigned >	internal_node_ids
std::set< unsigned >	internal_elem_ids
std::set< unsigned >	border_elem_ids

---

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. Derived from ExodusII_IO_Helper object, since Nemesis is based on the same file format.

Author:

John W. Peterson, 2008.

Definition at line 53 of file nemesis_io_helper.h.

---

Member Typedef Documentation

typedef std::map<unsigned, std::set<std::pair<unsigned,unsigned> > >::iterator libMesh::Nemesis_IO_Helper::proc_border_elem_sets_iterator [private]

Typedef for an iterator into the data structure above.

Definition at line 553 of file nemesis_io_helper.h.

typedef std::map<unsigned, std::set<unsigned> >::iterator libMesh::Nemesis_IO_Helper::proc_nodes_touched_iterator [private]

Typedef for an iterator into the data structure above.

Definition at line 543 of file nemesis_io_helper.h.

---

Constructor & Destructor Documentation

libMesh::Nemesis_IO_Helper::Nemesis_IO_Helper

(

bool

verbose = false

)

[explicit]

Constructor.

Definition at line 42 of file nemesis_io_helper.C.

                                                    :
  ExodusII_IO_Helper(verbose_in, /*run_only_on_proc0=*/false),
  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('\0'),
  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();
}

libMesh::Nemesis_IO_Helper::~Nemesis_IO_Helper

(

)

[virtual]

Destructor.

Definition at line 66 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::close(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, and ex_update().

{
  // Our destructor is called from Nemesis_IO.  We close the Exodus file here since we have
  // responsibility for managing the file's lifetime.
  this->ex_err = exII::ex_update(this->ex_id);
  this->check_err(ex_err, "Error flushing buffers to file.");
  this->close();
}

---

Member Function Documentation

void libMesh::Nemesis_IO_Helper::build_element_and_node_maps

(

const MeshBase &

pmesh

)

[private]

This function builds the libmesh -> exodus and exodus -> libmesh node and element maps. These maps allow us to have a consistent numbering scheme within an Exodus file, given an existing globally consistent numbering scheme from LibMesh.

Definition at line 1678 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::MeshBase::active_local_elements_begin(), libMesh::MeshBase::active_local_elements_end(), libMesh::ExodusII_IO_Helper::ElementMaps::assign_conversion(), block_id_to_elem_connectivity, libMesh::ExodusII_IO_Helper::block_ids, libMesh::Elem::build(), libMesh::MeshBase::elem(), elem_id, libMesh::err, libMesh::ExodusII_IO_Helper::exodus_elem_num_to_libmesh, libMesh::ExodusII_IO_Helper::exodus_node_num_to_libmesh, libMesh::ExodusII_IO_Helper::Conversion::get_canonical_type(), libMesh::ExodusII_IO_Helper::Conversion::get_node_map(), libMesh::DofObject::id(), libMesh::ExodusII_IO_Helper::libmesh_elem_num_to_exodus, libMesh::ExodusII_IO_Helper::libmesh_node_num_to_exodus, local_subdomain_counts, n_nodes, libMesh::Elem::n_nodes(), libMesh::Elem::node(), nodes_attached_to_local_elems, libMesh::ExodusII_IO_Helper::num_nodes, libMesh::ExodusII_IO_Helper::num_nodes_per_elem, libMesh::out, libMesh::processor_id(), libMesh::Elem::subdomain_id(), subdomain_map, and libMesh::Elem::type().

Referenced by initialize().

{
  // If we don't have any local subdomains, it had better be because
  // we don't have any local elements
#ifdef DEBUG
  if (local_subdomain_counts.empty())
    {
      libmesh_assert(pmesh.active_local_elements_begin() ==
                     pmesh.active_local_elements_end());
      libmesh_assert(this->nodes_attached_to_local_elems.empty());
    }
#endif

  // Elements have to be numbered contiguously based on what block
  // number they are in.  Therefore we have to do a bit of work to get
  // the block (ie subdomain) numbers first and store them off as
  // block_ids.

  // Make sure there is no leftover information in the subdomain_map, and reserve
  // enough space to store the elements we need.
  this->subdomain_map.clear();
  for (std::map<subdomain_id_type, unsigned>::iterator it=this->local_subdomain_counts.begin();
       it != this->local_subdomain_counts.end();
       ++it)
    {
      subdomain_id_type cur_subdomain = (*it).first;

/*
      // We can't have a zero subdomain ID in Exodus (for some reason?)
      // so map zero subdomains to a max value...
      if (cur_subdomain == 0)
        cur_subdomain = std::numeric_limits<subdomain_id_type>::max();
*/

      if (_verbose)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] "
                       << "local_subdomain_counts [" << static_cast<unsigned>(cur_subdomain) << "]= "
                       << (*it).second
                       << std::endl;
        }

      // *it.first is the subodmain ID, *it.second is the number of elements it contains
      this->subdomain_map[ cur_subdomain ].reserve( (*it).second );
    }


  // First loop over the elements to figure out which elements are in which subdomain
  MeshBase::const_element_iterator elem_it = pmesh.active_local_elements_begin();
  MeshBase::const_element_iterator elem_end = pmesh.active_local_elements_end();

  for (; elem_it != elem_end; ++elem_it)
    {
      const Elem * elem = *elem_it;

      // Grab the nodes while we're here.
      for (unsigned int n=0; n<elem->n_nodes(); ++n)
        this->nodes_attached_to_local_elems.insert( elem->node(n) );

      unsigned int cur_subdomain = elem->subdomain_id();

/*
      // We can't have a zero subdomain ID in Exodus (for some reason?)
      // so map zero subdomains to a max value...
      if(cur_subdomain == 0)
        cur_subdomain = std::numeric_limits<subdomain_id_type>::max();
*/

      this->subdomain_map[cur_subdomain].push_back(elem->id());
    }

  // Set num_nodes which is used by exodusII_io_helper
  this->num_nodes = this->nodes_attached_to_local_elems.size();

  // Now come up with a 1-based numbering for these nodes
  this->exodus_node_num_to_libmesh.clear(); // Make sure it's empty
  this->exodus_node_num_to_libmesh.reserve(this->nodes_attached_to_local_elems.size());

  // Also make sure there's no leftover information in the map which goes the
  // other direction.
  this->libmesh_node_num_to_exodus.clear();

  // Set the map for nodes
  for(std::set<int>::iterator it = this->nodes_attached_to_local_elems.begin();
      it != this->nodes_attached_to_local_elems.end();
      ++it)
    {
      // I.e. given exodus_node_id,
      // exodus_node_num_to_libmesh[ exodus_node_id ] returns the libmesh ID for that node.
      // Note that even though most of Exodus is 1-based, this code will map an Exodus ID of
      // zero to some libmesh node ID.  Is that a problem?
      this->exodus_node_num_to_libmesh.push_back(*it);

      // Likewise, given libmesh_node_id,
      // libmesh_node_num_to_exodus[ libmesh_node_id ] returns the *Exodus* ID for that node.
      // Unlike the exodus_node_num_to_libmesh vector above, this one is a std::map
      this->libmesh_node_num_to_exodus[*it] = this->exodus_node_num_to_libmesh.size(); // should never be zero...
    }

  // Now we're going to loop over the subdomain map and build a few things right
  // now that we'll use later.

  // First make sure our data structures don't have any leftover data...
  this->exodus_elem_num_to_libmesh.clear();
  this->block_ids.clear();
  this->libmesh_elem_num_to_exodus.clear();

  // Now loop over each subdomain and get a unique numbering for the elements
  for(std::map<subdomain_id_type, std::vector<unsigned int> >::iterator it = this->subdomain_map.begin();
      it != this->subdomain_map.end();
      ++it)
    {
      block_ids.push_back((*it).first);

      // Vector of element IDs for this subdomain
      std::vector<unsigned int>& elem_ids_this_subdomain = (*it).second;

      // The code below assumes this subdomain block is not empty, make sure that's the case!
      if (elem_ids_this_subdomain.size() == 0)
        {
          libMesh::err << "Error, no element IDs found in subdomain " << (*it).first << std::endl;
          libmesh_error();
        }

      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(pmesh.elem(elem_ids_this_subdomain[0])->type());
      this->num_nodes_per_elem = pmesh.elem(elem_ids_this_subdomain[0])->n_nodes();

      // Get a reference to the connectivity vector for this subdomain.  This vector
      // is most likely empty, we are going to fill it up now.
      std::vector<int>& current_block_connectivity = this->block_id_to_elem_connectivity[(*it).first];

      // Just in case it's not already empty...
      current_block_connectivity.clear();
      current_block_connectivity.resize(elem_ids_this_subdomain.size() * this->num_nodes_per_elem);

      for (unsigned int i=0; i<elem_ids_this_subdomain.size(); i++)
        {
          unsigned int elem_id = elem_ids_this_subdomain[i];

          // Set the number map for elements
          this->exodus_elem_num_to_libmesh.push_back(elem_id);
          this->libmesh_elem_num_to_exodus[elem_id] = this->exodus_elem_num_to_libmesh.size();

          const Elem * elem = pmesh.elem(elem_id);

          // Exodus/Nemesis want every block to have the same element type
          // libmesh_assert_equal_to (elem->type(), conv.get_canonical_type());

          // But we can get away with writing e.g. HEX8 and INFHEX8 in
          // the same block...
          libmesh_assert_equal_to (elem->n_nodes(), Elem::build(conv.get_canonical_type(), NULL)->n_nodes());

          for (unsigned int j=0; j < static_cast<unsigned int>(this->num_nodes_per_elem); j++)
            {
              const unsigned int connect_index   = (i*this->num_nodes_per_elem)+j;
              const unsigned int elem_node_index = conv.get_node_map(j);
              current_block_connectivity[connect_index] = this->libmesh_node_num_to_exodus[elem->node(elem_node_index)];
            }
        } // End loop over elems in this subdomain
    } // end loop over subdomain_map
}

void libMesh::ExodusII_IO_Helper::check_err	(	const int	error,
		const std::string	msg
	)			[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 230 of file exodusII_io_helper.C.

References libMesh::err.

Referenced by libMesh::ExodusII_IO_Helper::close(), create(), libMesh::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(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::ExodusII_IO_Helper::inquire(), libMesh::ExodusII_IO_Helper::open(), put_cmap_params(), put_eb_info_global(), put_elem_cmap(), put_elem_map(), put_init_global(), put_init_info(), put_loadbal_param(), put_n_coord(), put_node_cmap(), put_node_map(), put_ns_param_global(), put_ss_param_global(), libMesh::ExodusII_IO_Helper::read_block_info(), libMesh::ExodusII_IO_Helper::read_elem_in_block(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_header(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::ExodusII_IO_Helper::read_nodes(), libMesh::ExodusII_IO_Helper::read_nodeset(), libMesh::ExodusII_IO_Helper::read_nodeset_info(), libMesh::ExodusII_IO_Helper::read_sideset(), libMesh::ExodusII_IO_Helper::read_sideset_info(), libMesh::ExodusII_IO_Helper::write_element_values(), write_elements(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements_discontinuous(), write_exodus_initialization_info(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::ExodusII_IO_Helper::write_information_records(), write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_timestep(), and ~Nemesis_IO_Helper().

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

void libMesh::ExodusII_IO_Helper::close

(

)

[inherited]

Closes the ExodusII mesh file.

Definition at line 649 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::check_err(), ex_close(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::message(), and libMesh::processor_id().

Referenced by libMesh::ExodusII_IO::~ExodusII_IO(), and ~Nemesis_IO_Helper().

{
  // Always call close on processor 0.
  // If we're running on multiple processors, i.e. as one of several Nemesis files,
  // we call close on all processors...
  if ((libMesh::processor_id() == 0) || (!_run_only_on_proc0))
    {
      ex_err = exII::ex_close(ex_id);
      check_err(ex_err, "Error closing Exodus file.");
      message("Exodus file closed successfully.");
    }
}

void libMesh::Nemesis_IO_Helper::compute_border_node_ids

(

const MeshBase &

pmesh

)

[private]

This function constructs the set of border node IDs present on the current mesh. These are nodes which live on the "border" between elements which live on different processors.

Definition at line 1849 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), border_node_ids, libMesh::Elem::n_nodes(), libMesh::n_processors(), libMesh::Elem::node(), num_border_nodes, num_node_cmaps, libMesh::out, proc_nodes_touched_intersections, libMesh::processor_id(), libMesh::DofObject::processor_id(), and libMesh::Parallel::set_union().

Referenced by initialize().

{
  // The set which will eventually contain the IDs of "border nodes".  These are nodes
  // that lie on the boundary between one or more processors.
  //std::set<unsigned> border_node_ids;

  // map from processor ID to set of nodes which elements from this processor "touch",
  // that is,
  // proc_nodes_touched[p] = (set all node IDs found in elements owned by processor p)
  std::map<unsigned, std::set<unsigned> > proc_nodes_touched;


  // We are going to create a lot of intermediate data structures here, so make sure
  // as many as possible all cleaned up by creating scope!
  {
    // Loop over active (not just active local) elements, make sets of node IDs for each
    // processor which has an element that "touches" a node.
    {
      MeshBase::const_element_iterator elem_it = pmesh.active_elements_begin();
      MeshBase::const_element_iterator elem_end = pmesh.active_elements_end();

      for (; elem_it != elem_end; ++elem_it)
        {
          const Elem* elem = *elem_it;

          // Get reference to the set for this processor.  If it does not exist
          // it will be created.
          std::set<unsigned>& set_p = proc_nodes_touched[ elem->processor_id() ];

          // Insert all nodes touched by this element into the set
          for (unsigned int node=0; node<elem->n_nodes(); ++node)
            set_p.insert(elem->node(node));
        }
    }

    // The number of node communication maps is the number of other processors
    // with which we share nodes. (I think.) This is just the size of the map we just
    // created, minus 1.
    this->num_node_cmaps = proc_nodes_touched.size() - 1;

    // If we've got no elements on this processor and haven't touched
    // any nodes, however, then that's 0 other processors with which
    // we share nodes, not -1.
    if (this->num_node_cmaps == -1)
      {
        libmesh_assert (pmesh.active_elements_begin() == pmesh.active_elements_end());
        this->num_node_cmaps = 0;
      }

    // We can't be connecting to more processors than exist outside
    // ourselves
    libmesh_assert_less (static_cast<unsigned>(this->num_node_cmaps), libMesh::n_processors());

    if (_verbose)
      {
        libMesh::out << "[" << libMesh::processor_id()
                     << "] proc_nodes_touched contains "
                     << proc_nodes_touched.size()
                     << " sets of nodes."
                     << std::endl;

        for (proc_nodes_touched_iterator it = proc_nodes_touched.begin();
             it != proc_nodes_touched.end();
             ++it)
          {
            libMesh::out << "[" << libMesh::processor_id()
                         << "] proc_nodes_touched[" << (*it).first << "] has "
                         << (*it).second.size()
                         << " entries."
                         << std::endl;
          }
      }


    // Loop over all the sets we just created and compute intersections with the
    // this processor's set.  Obviously, don't intersect with ourself.
    for (proc_nodes_touched_iterator it = proc_nodes_touched.begin();
         it != proc_nodes_touched.end();
         ++it)
      {
        // Don't compute intersections with ourself
        if ((*it).first == libMesh::processor_id())
          continue;

        // Otherwise, compute intersection with other processor and ourself
        std::set<unsigned>& my_set = proc_nodes_touched[libMesh::processor_id()];
        std::set<unsigned>& other_set = (*it).second;
        std::set<unsigned>& result_set = this->proc_nodes_touched_intersections[ (*it).first ]; // created if does not exist

        std::set_intersection(my_set.begin(), my_set.end(),
                              other_set.begin(), other_set.end(),
                              std::inserter(result_set, result_set.end()));
      }

    if (_verbose)
      {
        for (proc_nodes_touched_iterator it = this->proc_nodes_touched_intersections.begin();
             it != this->proc_nodes_touched_intersections.end();
             ++it)
          {
            libMesh::out << "[" << libMesh::processor_id()
                         << "] this->proc_nodes_touched_intersections[" << (*it).first << "] has "
                         << (*it).second.size()
                         << " entries."
                         << std::endl;
          }
      }

    // Compute the set_union of all the preceding intersections.  This will be the set of
    // border node IDs for this processor.
    for (proc_nodes_touched_iterator it = this->proc_nodes_touched_intersections.begin();
         it != this->proc_nodes_touched_intersections.end();
         ++it)
      {
        std::set<unsigned>& other_set = (*it).second;
        std::set<unsigned> intermediate_result; // Don't think we can insert into one of the sets we're unioning...

        std::set_union(this->border_node_ids.begin(), this->border_node_ids.end(),
                       other_set.begin(), other_set.end(),
                       std::inserter(intermediate_result, intermediate_result.end()));

        // Swap our intermediate result into the final set
        this->border_node_ids.swap(intermediate_result);
      }

    if (_verbose)
      {
        libMesh::out << "[" << libMesh::processor_id()
                     << "] border_node_ids.size()=" << this->border_node_ids.size()
                     << std::endl;
      }
  } // end scope for border node ID creation

  // Store the number of border node IDs to be written to Nemesis file
  this->num_border_nodes = this->border_node_ids.size();
}

void libMesh::Nemesis_IO_Helper::compute_communication_map_parameters

(

)

[private]

This function determines the communication map parameters which will eventually be written to file

Definition at line 1132 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, elem_cmap_elem_cnts, elem_cmap_ids, node_cmap_ids, node_cmap_node_cnts, num_elem_cmaps, num_node_cmaps, libMesh::out, proc_border_elem_sets, proc_nodes_touched_intersections, and libMesh::processor_id().

Referenced by initialize().

{
  // For the nodes, these are the number of entries in the sets in proc_nodes_touched_intersections
  // map computed above.  Note: this map does not contain self-intersections so we can loop over it
  // directly.
  this->node_cmap_node_cnts.clear(); // Make sure we don't have any leftover information...
  this->node_cmap_ids.clear();       // Make sure we don't have any leftover information...
  this->node_cmap_node_cnts.resize(this->num_node_cmaps);
  this->node_cmap_ids.resize(this->num_node_cmaps);

  {
    unsigned cnt=0; // Index into the vector
    for (proc_nodes_touched_iterator it = this->proc_nodes_touched_intersections.begin();
         it != this->proc_nodes_touched_intersections.end();
         ++it)
      {
        this->node_cmap_ids[cnt] = (*it).first; // The ID of the proc we communicate with
        this->node_cmap_node_cnts[cnt] = (*it).second.size(); // The number of nodes we communicate
        cnt++; // increment vector index!
      }
  }

  // Print the packed vectors we just filled
  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] node_cmap_node_cnts = ";
      for (unsigned i=0; i<node_cmap_node_cnts.size(); ++i)
        libMesh::out << node_cmap_node_cnts[i] << ", ";
      libMesh::out << std::endl;

      libMesh::out << "[" << libMesh::processor_id() << "] node_cmap_ids = ";
      for (unsigned i=0; i<node_cmap_ids.size(); ++i)
        libMesh::out << node_cmap_ids[i] << ", ";
      libMesh::out << std::endl;
    }

  // For the elements, we have not yet computed all this information..
  this->elem_cmap_elem_cnts.clear(); // Make sure we don't have any leftover information...
  this->elem_cmap_ids.clear();       // Make sure we don't have any leftover information...
  this->elem_cmap_elem_cnts.resize(this->num_elem_cmaps);
  this->elem_cmap_ids.resize(this->num_elem_cmaps);

  // Pack the elem_cmap_ids and elem_cmap_elem_cnts vectors
  {
    unsigned cnt=0; // Index into the vectors we're filling
    for (proc_border_elem_sets_iterator it = this->proc_border_elem_sets.begin();
         it != this->proc_border_elem_sets.end();
         ++it)
      {
        this->elem_cmap_ids[cnt] = (*it).first; // The ID of the proc we communicate with
        this->elem_cmap_elem_cnts[cnt] = (*it).second.size(); // The number of elems we communicate to/from that proc
        cnt++; // increment vector index!
      }
  }

  // Print the packed vectors we just filled
  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] elem_cmap_elem_cnts = ";
      for (unsigned i=0; i<elem_cmap_elem_cnts.size(); ++i)
        libMesh::out << elem_cmap_elem_cnts[i] << ", ";
      libMesh::out << std::endl;

      libMesh::out << "[" << libMesh::processor_id() << "] elem_cmap_ids = ";
      for (unsigned i=0; i<elem_cmap_ids.size(); ++i)
        libMesh::out << elem_cmap_ids[i] << ", ";
      libMesh::out << std::endl;
    }
}

void libMesh::Nemesis_IO_Helper::compute_elem_communication_maps

(

)

[private]

This function computes element communication maps (really just packs vectors) in preparation for writing them to file.

Definition at line 979 of file nemesis_io_helper.C.

References elem_cmap_elem_ids, elem_cmap_ids, elem_cmap_proc_ids, elem_cmap_side_ids, libMesh::ExodusII_IO_Helper::libmesh_elem_num_to_exodus, num_elem_cmaps, and proc_border_elem_sets.

Referenced by initialize().

{
  // Make sure there is no leftover information
  this->elem_cmap_elem_ids.clear();
  this->elem_cmap_side_ids.clear();
  this->elem_cmap_proc_ids.clear();

  // Allocate enough space for all our element maps
  this->elem_cmap_elem_ids.resize(this->num_elem_cmaps);
  this->elem_cmap_side_ids.resize(this->num_elem_cmaps);
  this->elem_cmap_proc_ids.resize(this->num_elem_cmaps);
  {
    unsigned cnt=0; // Index into vectors
    for (proc_border_elem_sets_iterator it=this->proc_border_elem_sets.begin();
         it != this->proc_border_elem_sets.end();
         ++it)
      {
        // Make sure the current elem_cmap_id matches the index in our map of node intersections
        libmesh_assert_equal_to ( static_cast<unsigned>(this->elem_cmap_ids[cnt]), (*it).first );

        // Get reference to the set of IDs to be packed into the vector
        std::set<std::pair<unsigned,unsigned> >& elem_set = (*it).second;

        // Resize the vectors to receive their payload
        this->elem_cmap_elem_ids[cnt].resize(elem_set.size());
        this->elem_cmap_side_ids[cnt].resize(elem_set.size());
        this->elem_cmap_proc_ids[cnt].resize(elem_set.size());

        std::set<std::pair<unsigned,unsigned> >::iterator elem_set_iter = elem_set.begin();

        // Pack the vectors with elem IDs, side IDs, and processor IDs.
        for (unsigned j=0; j<this->elem_cmap_elem_ids[cnt].size(); ++j, ++elem_set_iter)
          {
            this->elem_cmap_elem_ids[cnt][j] = libmesh_elem_num_to_exodus[(*elem_set_iter).first];//  + 1; // Elem ID, Exodus is 1-based
            this->elem_cmap_side_ids[cnt][j] = (*elem_set_iter).second;     // Side ID, this has already been converted above
            this->elem_cmap_proc_ids[cnt][j] = (*it).first; // All have the same processor ID
          }

        cnt++;// increment vector index to go to next processor
      }
  } // end scope for packing
}

void libMesh::Nemesis_IO_Helper::compute_element_maps

(

)

[private]

This function computes element maps (really just packs vectors) which map the elements to internal and border elements.

Definition at line 950 of file nemesis_io_helper.C.

References border_elem_ids, elem_mapb, elem_mapi, internal_elem_ids, and libMesh::ExodusII_IO_Helper::libmesh_elem_num_to_exodus.

Referenced by initialize().

{
  // Make sure we don't have any leftover info
  this->elem_mapi.clear();
  this->elem_mapb.clear();

  // Copy set contents into vectors
  this->elem_mapi.resize(this->internal_elem_ids.size());
  this->elem_mapb.resize(this->border_elem_ids.size());

  {
    unsigned cnt = 0;
    for (std::set<unsigned>::iterator it=this->internal_elem_ids.begin();
         it != this->internal_elem_ids.end();
         ++it, ++cnt)
      this->elem_mapi[cnt] = libmesh_elem_num_to_exodus[(*it)]; // + 1; // Exodus is 1-based!
  }

  {
    unsigned cnt = 0;
    for (std::set<unsigned>::iterator it=this->border_elem_ids.begin();
         it != this->border_elem_ids.end();
         ++it, ++cnt)
      this->elem_mapb[cnt] = libmesh_elem_num_to_exodus[(*it)]; // + 1; // Exodus is 1-based!
  }
}

void libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes

(

const MeshBase &

pmesh

)

[private]

This function constructs the set of border and internal element IDs and internal node IDs present on the current mesh.

Definition at line 1206 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::MeshBase::active_local_elements_begin(), libMesh::MeshBase::active_local_elements_end(), libMesh::ExodusII_IO_Helper::ElementMaps::assign_conversion(), border_elem_ids, border_node_ids, libMesh::ExodusII_IO_Helper::Conversion::get_inverse_side_map(), libMesh::DofObject::id(), internal_elem_ids, internal_node_ids, libMesh::Elem::n_neighbors(), libMesh::Elem::n_nodes(), libMesh::Elem::neighbor(), libMesh::Elem::node(), nodes_attached_to_local_elems, num_border_elems, num_border_nodes, num_elem_cmaps, num_internal_elems, num_internal_nodes, libMesh::out, proc_border_elem_sets, libMesh::processor_id(), libMesh::DofObject::processor_id(), and libMesh::Elem::type().

Referenced by initialize().

{
  // Set of all local, active element IDs.  After we have identified border element
  // IDs, the set_difference between this set and the border_elem_ids set will give us
  // the set of internal_elem_ids.
  std::set<unsigned> all_elem_ids;

  // A set of processor IDs which elements on this processor have as
  // neighbors.  The size of this set will determine the number of
  // element communication maps in Exodus.
  std::set<unsigned> neighboring_processor_ids;

  // Will be used to create conversion objects capable of mapping libmesh
  // element numberings into Nemesis numberings.
  ExodusII_IO_Helper::ElementMaps element_mapper;

  MeshBase::const_element_iterator elem_it = pmesh.active_local_elements_begin();
  MeshBase::const_element_iterator elem_end = pmesh.active_local_elements_end();

  for (; elem_it != elem_end; ++elem_it)
    {
      const Elem* elem = *elem_it;

      // Add this Elem's ID to all_elem_ids, later we will take the difference
      // between this set and the set of border_elem_ids, to get the set of
      // internal_elem_ids.
      all_elem_ids.insert(elem->id());

      // Will be set to true if element is determined to be a border element
      bool is_border_elem = false;

      // Construct a conversion object for this Element.  This will help us map
      // Libmesh numberings into Nemesis numberings for sides.
      ExodusII_IO_Helper::Conversion conv = element_mapper.assign_conversion(elem->type());

      // Add all this element's node IDs to the set of all node IDs.
      // The set of internal_node_ids will be the set difference between
      // the set of all nodes and the set of border nodes.
      //
      // In addition, if any node of a local node is listed in the
      // border nodes list, then this element goes into the proc_border_elem_sets.
      // Note that there is not a 1:1 correspondence between
      // border_elem_ids and the entries which go into proc_border_elem_sets.
      // The latter is for communication purposes, ie determining which elements
      // should be shared between processors.
      for (unsigned int node=0; node<elem->n_nodes(); ++node)
        {
          this->nodes_attached_to_local_elems.insert(elem->node(node));
        } // end loop over element's nodes

      // Loop over element's neighbors, see if it has a neighbor which is off-processor
      for (unsigned int n=0; n<elem->n_neighbors(); ++n)
        {
          if (elem->neighbor(n) != NULL)
            {
              unsigned neighbor_proc_id = elem->neighbor(n)->processor_id();

              // If my neighbor has a different processor ID, I must be a border element.
              // Also track the neighboring processor ID if it is are different from our processor ID
              if (neighbor_proc_id != libMesh::processor_id())
                {
                  is_border_elem = true;
                  neighboring_processor_ids.insert(neighbor_proc_id);

                  // Convert libmesh side(n) of this element into a side ID for Nemesis
                  unsigned nemesis_side_id = conv.get_inverse_side_map(n);

                  if (_verbose)
                    libMesh::out << "[" << libMesh::processor_id() << "] LibMesh side "
                                 << n
                                 << " mapped to (1-based) Exodus side "
                                 << nemesis_side_id
                                 << std::endl;

                  // Add this element's ID and the ID of the side which is on the boundary
                  // to the set of border elements for this processor.
                  // Note: if the set does not already exist, this creates it.
                  this->proc_border_elem_sets[ neighbor_proc_id ].insert( std::make_pair(elem->id(), nemesis_side_id) );
                }
            }
        } // end for loop over neighbors

      // If we're on a border element, add it to the set
      if (is_border_elem)
        this->border_elem_ids.insert( elem->id() );

    } // end for loop over active local elements

  // Take the set_difference between all elements and border elements to get internal
  // element IDs
  std::set_difference(all_elem_ids.begin(), all_elem_ids.end(),
                      this->border_elem_ids.begin(), this->border_elem_ids.end(),
                      std::inserter(this->internal_elem_ids, this->internal_elem_ids.end()));

  // Take the set_difference between all nodes and border nodes to get internal nodes
  std::set_difference(this->nodes_attached_to_local_elems.begin(), this->nodes_attached_to_local_elems.end(),
                      this->border_node_ids.begin(), this->border_node_ids.end(),
                      std::inserter(this->internal_node_ids, this->internal_node_ids.end()));

  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] neighboring_processor_ids = ";
      for (std::set<unsigned>::iterator it = neighboring_processor_ids.begin();
           it != neighboring_processor_ids.end();
           ++it)
        {
          libMesh::out << *it << " ";
        }
      libMesh::out << std::endl;
    }

  // The size of the neighboring_processor_ids set should be the number of element communication maps
  this->num_elem_cmaps = neighboring_processor_ids.size();

  if (_verbose)
    libMesh::out << "[" << libMesh::processor_id() << "] "
                 << "Number of neighboring processor IDs="
                 << this->num_elem_cmaps
                 << std::endl;

  if (_verbose)
    {
      // Print out counts of border elements for each processor
      for (proc_border_elem_sets_iterator it=this->proc_border_elem_sets.begin();
           it != this->proc_border_elem_sets.end(); ++it)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] "
                       << "Proc "
                       << (*it).first << " communicates "
                       << (*it).second.size() << " elements." << std::endl;
        }
    }

  // Store the number of internal and border elements, and the number of internal nodes,
  // to be written to the Nemesis file.
  this->num_internal_elems = this->internal_elem_ids.size();
  this->num_border_elems = this->border_elem_ids.size();
  this->num_internal_nodes = this->internal_node_ids.size();

  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] num_internal_nodes=" << this->num_internal_nodes << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] num_border_nodes=" << this->num_border_nodes << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] num_border_elems=" << this->num_border_elems << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] num_internal_elems=" << this->num_internal_elems << std::endl;
    }
}

void libMesh::Nemesis_IO_Helper::compute_node_communication_maps

(

)

[private]

Compute the node communcation maps (really just pack vectors) in preparation for writing them to file.

Definition at line 1063 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::ExodusII_IO_Helper::libmesh_node_num_to_exodus, node_cmap_ids, node_cmap_node_ids, node_cmap_proc_ids, num_node_cmaps, libMesh::out, proc_nodes_touched_intersections, and libMesh::processor_id().

Referenced by initialize().

{
  // Make sure there's no left-over information
  this->node_cmap_node_ids.clear();
  this->node_cmap_proc_ids.clear();

  // Allocate enough space for all our node maps
  this->node_cmap_node_ids.resize(this->num_node_cmaps);
  this->node_cmap_proc_ids.resize(this->num_node_cmaps);
  {
    unsigned cnt=0; // Index into vectors
    for (proc_nodes_touched_iterator it = this->proc_nodes_touched_intersections.begin();
         it != this->proc_nodes_touched_intersections.end();
         ++it)
      {
        // Make sure the current node_cmap_id matches the index in our map of node intersections
        libmesh_assert_equal_to ( static_cast<unsigned>(this->node_cmap_ids[cnt]), (*it).first );

        // Get reference to the set of IDs to be packed into the vector.
        std::set<unsigned>& node_set = (*it).second;

        //std::cout << "[" << libMesh::processor_id() << "] node_set.size()=" << node_set.size() << std::endl;

        // Resize the vectors to receive their payload
        this->node_cmap_node_ids[cnt].resize(node_set.size());
        this->node_cmap_proc_ids[cnt].resize(node_set.size());

        std::set<unsigned>::iterator node_set_iter = node_set.begin();

        // Pack the vectors with node IDs and processor IDs.
        for (unsigned j=0; j<this->node_cmap_node_ids[cnt].size(); ++j, ++node_set_iter)
          {
            this->node_cmap_node_ids[cnt][j] = this->libmesh_node_num_to_exodus[*node_set_iter];//(*node_set_iter) + 1; // Exodus is 1-based
            this->node_cmap_proc_ids[cnt][j] = (*it).first;
          }

        cnt++;// increment vector index to go to next processor
      }
  } // end scope for packing

  // if (_verbose)
  //   libMesh::out << "Done packing." << std::endl;

  // Print out the vectors we just packed
  if (_verbose)
    {
      for (unsigned i=0; i<this->node_cmap_node_ids.size(); ++i)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] nodes communicated to proc "
                       << this->node_cmap_ids[i]
                       << " = ";
          for (unsigned j=0; j<this->node_cmap_node_ids[i].size(); ++j)
            libMesh::out << this->node_cmap_node_ids[i][j] << " ";
          libMesh::out << std::endl;
        }

      for (unsigned i=0; i<this->node_cmap_node_ids.size(); ++i)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] processor ID node communicated to = ";
          for (unsigned j=0; j<this->node_cmap_proc_ids[i].size(); ++j)
            libMesh::out << this->node_cmap_proc_ids[i][j] << " ";
          libMesh::out << std::endl;
        }
    }
}

void libMesh::Nemesis_IO_Helper::compute_node_maps

(

)

[private]

Compute the node maps (really just pack vectors) which map the nodes to internal, border, and external nodes in the file.

Definition at line 1026 of file nemesis_io_helper.C.

References border_node_ids, internal_node_ids, libMesh::ExodusII_IO_Helper::libmesh_node_num_to_exodus, node_mapb, node_mape, and node_mapi.

Referenced by initialize().

{
  // Make sure we don't have any leftover information
  this->node_mapi.clear();
  this->node_mapb.clear();
  this->node_mape.clear();

  // Make sure there's enough space to hold all our node IDs
  this->node_mapi.resize(this->internal_node_ids.size());
  this->node_mapb.resize(this->border_node_ids.size());

  // Copy set contents into vectors
  //
  // Can't use insert, since we are copying unsigned's into vector<int>...
  // this->node_mapi.insert(internal_node_ids.begin(), internal_node_ids.end());
  // this->node_mapb.insert(boundary_node_ids.begin(), boundary_node_ids.end());
  {
    unsigned cnt = 0;
    for (std::set<unsigned>::iterator it=this->internal_node_ids.begin();
         it != this->internal_node_ids.end();
         ++it, ++cnt)
      this->node_mapi[cnt] = this->libmesh_node_num_to_exodus[*it];// + 1; // Exodus is 1-based!
  }

  {
    unsigned cnt=0;
    for (std::set<unsigned>::iterator it=this->border_node_ids.begin();
         it != this->border_node_ids.end();
         ++it, ++cnt)
      this->node_mapb[cnt] = this->libmesh_node_num_to_exodus[*it];// + 1; // Exodus is 1-based!
  }
}

void libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks

(

const MeshBase &

pmesh

)

[private]

This function uses global communication routines to determine the number of element blocks across the entire mesh.

Definition at line 1569 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::MeshBase::active_local_elements_begin(), libMesh::MeshBase::active_local_elements_end(), libMesh::Parallel::Communicator::allgather(), libMesh::CommWorld, global_elem_blk_cnts, global_elem_blk_ids, local_subdomain_counts, num_elem_blks_global, libMesh::out, libMesh::processor_id(), libMesh::Elem::subdomain_id(), and libMesh::Parallel::Communicator::sum().

Referenced by initialize().

{
  // 1.) Loop over active local elements, build up set of subdomain IDs.
  std::set<subdomain_id_type> global_subdomain_ids;

  // This map keeps track of the number of elements in each subdomain over all processors
  std::map<subdomain_id_type, unsigned> global_subdomain_counts;

  MeshBase::const_element_iterator elem_it = pmesh.active_local_elements_begin();
  MeshBase::const_element_iterator elem_end = pmesh.active_local_elements_end();

  for (; elem_it != elem_end; ++elem_it)
    {
      const Elem* elem = *elem_it;

      subdomain_id_type cur_subdomain = elem->subdomain_id();

/*
      // We can't have a zero subdomain ID in Exodus (for some reason?)
      // so map zero subdomains to a max value...
      if (cur_subdomain == 0)
        cur_subdomain = std::numeric_limits<subdomain_id_type>::max();
*/

      global_subdomain_ids.insert(cur_subdomain);

      // Increment the count of elements in this subdomain
      global_subdomain_counts[cur_subdomain]++;
    }

  // We're next going to CommWorld.sum the subdomain counts, so save the local counts
  this->local_subdomain_counts = global_subdomain_counts;

  {
    // 2.) Copy local subdomain IDs into a vector for communication
    std::vector<subdomain_id_type> global_subdomain_ids_vector(global_subdomain_ids.begin(),
                                                               global_subdomain_ids.end());

    // 3.) Gather them into an enlarged vector
    CommWorld.allgather(global_subdomain_ids_vector);

    // 4.) Insert any new IDs into the set (any duplicates will be dropped)
    global_subdomain_ids.insert(global_subdomain_ids_vector.begin(),
                                global_subdomain_ids_vector.end());
  }

  // 5.) Now global_subdomain_ids actually contains a global list of all subdomain IDs
  this->num_elem_blks_global = global_subdomain_ids.size();

  // Print the number of elements found locally in each subdomain
  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] ";
      for (std::map<subdomain_id_type, unsigned>::iterator it=global_subdomain_counts.begin();
           it != global_subdomain_counts.end();
           ++it)
        {
          libMesh::out << "ID: "
                       << static_cast<unsigned>((*it).first)
                       << ", Count: " << (*it).second << ", ";
        }
      libMesh::out << std::endl;
    }

  // 6.) CommWorld.sum up the number of elements in each block.  We know the global
  // subdomain IDs, so pack them into a vector one by one.  Use a vector of int since
  // that is what Nemesis wants
  this->global_elem_blk_cnts.resize(global_subdomain_ids.size());

  unsigned cnt=0;
  for (std::set<subdomain_id_type>::iterator it=global_subdomain_ids.begin();
       it != global_subdomain_ids.end(); ++it)
    {
      // Find the entry in the local map, note: if not found, will be created with 0 default value, which is OK...
      this->global_elem_blk_cnts[cnt++] = global_subdomain_counts[*it];
    }

  // Sum up subdomain counts from all processors
  CommWorld.sum(this->global_elem_blk_cnts);

  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] global_elem_blk_cnts = ";
      for (unsigned i=0; i<this->global_elem_blk_cnts.size(); ++i)
        libMesh::out << this->global_elem_blk_cnts[i] << ", ";
      libMesh::out << std::endl;
    }

  // 7.) Create a vector<int> from the global_subdomain_ids set, for passing to Nemesis
  this->global_elem_blk_ids.clear();
  this->global_elem_blk_ids.insert(this->global_elem_blk_ids.end(), // pos
                                   global_subdomain_ids.begin(),
                                   global_subdomain_ids.end());

  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] global_elem_blk_ids = ";
      for (unsigned i=0; i<this->global_elem_blk_ids.size(); ++i)
        libMesh::out << this->global_elem_blk_ids[i] << ", ";
      libMesh::out << std::endl;
    }


  // 8.) We will call put_eb_info_global later, it must be called after this->put_init_global().
}

void libMesh::Nemesis_IO_Helper::compute_num_global_nodesets

(

const MeshBase &

pmesh

)

[private]

This function uses global communication routines to determine the number of nodesets across the entire mesh.

Definition at line 1457 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::MeshBase::boundary_info, libMesh::CommWorld, global_nodeset_ids, libMesh::MeshBase::node_ptr(), num_global_node_counts, num_node_sets_global, libMesh::out, libMesh::DofObject::processor_id(), libMesh::processor_id(), libMesh::Parallel::Communicator::set_union(), libMesh::Parallel::Communicator::sum(), and swap().

Referenced by initialize().

{
  std::set<boundary_id_type> local_node_boundary_ids;

  // 1.) Get reference to the set of node boundary IDs *for this processor*
  std::set<boundary_id_type> global_node_boundary_ids
    (pmesh.boundary_info->get_node_boundary_ids().begin(),
     pmesh.boundary_info->get_node_boundary_ids().end());

  // Save a copy of the local_node_boundary_ids...
  local_node_boundary_ids = global_node_boundary_ids;

  // 2.) Gather boundary node IDs from other processors
  CommWorld.set_union(global_node_boundary_ids);

  // 3.) Now global_node_boundary_ids actually contains a global list of all node boundary IDs
  this->num_node_sets_global = global_node_boundary_ids.size();

  // 4.) Create a vector<int> from the global_node_boundary_ids set
  this->global_nodeset_ids.clear();
  this->global_nodeset_ids.insert(this->global_nodeset_ids.end(),
                                  global_node_boundary_ids.begin(),
                                  global_node_boundary_ids.end());

  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] global_nodeset_ids = ";
      for (unsigned i=0; i<global_nodeset_ids.size(); ++i)
        libMesh::out << global_nodeset_ids[i] << ", ";
      libMesh::out << std::endl;

      libMesh::out << "[" << libMesh::processor_id() << "] local_node_boundary_ids = ";
      for (std::set<boundary_id_type>::iterator it = local_node_boundary_ids.begin();
           it != local_node_boundary_ids.end();
           ++it)
        libMesh::out << *it << ", ";
      libMesh::out << std::endl;
    }

  // 7.) We also need to know the number of nodes which is in each of the nodesets, globally.
  // There is probably a better way to do this...
  std::vector<dof_id_type> boundary_node_list;
  std::vector<boundary_id_type> boundary_node_boundary_id_list;
  pmesh.boundary_info->build_node_list(boundary_node_list, boundary_node_boundary_id_list);

  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] boundary_node_list.size()="
                   << boundary_node_list.size() << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] (boundary_node_id, boundary_id) = ";
      for (unsigned i=0; i<boundary_node_list.size(); ++i)
        {
          libMesh::out << "(" << boundary_node_list[i] << ", " << boundary_node_boundary_id_list[i] << ") ";
        }
      libMesh::out << std::endl;
    }

  // Now get the global information.  In this case, we only want to count boundary
  // information for nodes *owned* by this processor, so there are no duplicates.

  // Make sure we don't have any left over information
  this->num_global_node_counts.clear();
  this->num_global_node_counts.resize(this->global_nodeset_ids.size());

  // Unfortunately, we can't just count up all occurrences of a given id,
  // that would give us duplicate entries when we do the parallel summation.
  // So instead, only count entries for nodes owned by this processor.
  // Start by getting rid of all non-local node entries from the vectors.
  std::vector<dof_id_type>::iterator it_node=boundary_node_list.begin();
  std::vector<boundary_id_type>::iterator it_id=boundary_node_boundary_id_list.begin();
  for ( ; it_node != boundary_node_list.end(); )
    {
      if (pmesh.node_ptr( *it_node )->processor_id() != libMesh::processor_id())
        {
          // Get rid of this node, but do it efficiently for a vector, by popping
          // it off the back.
          std::swap (*it_node, boundary_node_list.back() );
          std::swap (*it_id, boundary_node_boundary_id_list.back() );

          boundary_node_list.pop_back();
          boundary_node_boundary_id_list.pop_back();
        }
      else // node is local, go to next
        {
          ++it_node;
          ++it_id;
        }
    }

  // Now we can do the local count for each ID...
  for (unsigned i=0; i<global_nodeset_ids.size(); ++i)
    {
      this->num_global_node_counts[i] = std::count(boundary_node_boundary_id_list.begin(),
                                                   boundary_node_boundary_id_list.end(),
                                                   this->global_nodeset_ids[i]);
    }

  // And finally we can sum them up
  CommWorld.sum(this->num_global_node_counts);

  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] num_global_node_counts = ";
      for (unsigned i=0; i<num_global_node_counts.size(); ++i)
        libMesh::out << num_global_node_counts[i] << ", ";
      libMesh::out << std::endl;
    }
}

void libMesh::Nemesis_IO_Helper::compute_num_global_sidesets

(

const MeshBase &

pmesh

)

[private]

This function uses global communication routines to determine the number of sidesets across the entire mesh.

Definition at line 1356 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::MeshBase::boundary_info, libMesh::CommWorld, libMesh::MeshBase::elem(), global_sideset_ids, num_global_side_counts, num_side_sets_global, libMesh::out, libMesh::DofObject::processor_id(), libMesh::processor_id(), libMesh::Parallel::Communicator::set_union(), libMesh::Parallel::Communicator::sum(), and swap().

Referenced by initialize().

{
  std::set<boundary_id_type> local_side_boundary_ids;

  // 1.) Get reference to the set of side boundary IDs
  std::set<boundary_id_type> global_side_boundary_ids
    (pmesh.boundary_info->get_side_boundary_ids().begin(),
     pmesh.boundary_info->get_side_boundary_ids().end());

  // Save this set of local boundary side IDs for later
  local_side_boundary_ids = global_side_boundary_ids;

  // 2.) Gather boundary side IDs from other processors
  CommWorld.set_union(global_side_boundary_ids);

  // 3.) Now global_side_boundary_ids actually contains a global list of all side boundary IDs
  this->num_side_sets_global = global_side_boundary_ids.size();

  // 4.) Pack these sidesets into a vector so they can be written by Nemesis
  this->global_sideset_ids.clear(); // Make sure there is no leftover information
  this->global_sideset_ids.insert(this->global_sideset_ids.end(),
                                  global_side_boundary_ids.begin(),
                                  global_side_boundary_ids.end());

  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] global_sideset_ids = ";
      for (unsigned i=0; i<this->global_sideset_ids.size(); ++i)
        libMesh::out << this->global_sideset_ids[i] << ", ";
      libMesh::out << std::endl;
    }

  // We also need global counts of sides in each of the sidesets.  Again, there may be a
  // better way to do this...
  std::vector<dof_id_type> bndry_elem_list;
  std::vector<unsigned short int> bndry_side_list;
  std::vector<boundary_id_type> bndry_id_list;
  pmesh.boundary_info->build_side_list(bndry_elem_list, bndry_side_list, bndry_id_list);

  // Similarly to the nodes, we can't count any sides for elements which aren't local
  std::vector<dof_id_type>::iterator it_elem=bndry_elem_list.begin();
  std::vector<unsigned short>::iterator it_side=bndry_side_list.begin();
  std::vector<boundary_id_type>::iterator it_id=bndry_id_list.begin();
  for ( ; it_elem != bndry_elem_list.end(); )
    {
      if (pmesh.elem( *it_elem )->processor_id() != libMesh::processor_id())
        {
          // Get rid of this elem, but do it efficiently for a vector, by popping
          // it off the back.
          std::swap (*it_elem, bndry_elem_list.back() );
          std::swap (*it_side, bndry_side_list.back() );
          std::swap (*it_id, bndry_id_list.back() );

          bndry_elem_list.pop_back();
          bndry_side_list.pop_back();
          bndry_id_list.pop_back();
        }
      else // elem is local, go to next
        {
          ++it_elem;
          ++it_side;
          ++it_id;
        }
    }

  this->num_global_side_counts.clear(); // Make sure we don't have any leftover information
  this->num_global_side_counts.resize(this->global_sideset_ids.size());

  // Get the count for each global sideset ID
  for (unsigned i=0; i<global_sideset_ids.size(); ++i)
    {
      this->num_global_side_counts[i] = std::count(bndry_id_list.begin(),
                                                   bndry_id_list.end(),
                                                   this->global_sideset_ids[i]);
    }

  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] num_global_side_counts = ";
      for (unsigned i=0; i<this->num_global_side_counts.size(); ++i)
        libMesh::out << this->num_global_side_counts[i] << ", ";
      libMesh::out << std::endl;
    }

  // Finally sum up the result
  CommWorld.sum(this->num_global_side_counts);

  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] num_global_side_counts = ";
      for (unsigned i=0; i<this->num_global_side_counts.size(); ++i)
        libMesh::out << this->num_global_side_counts[i] << ", ";
      libMesh::out << std::endl;
    }
}

std::string libMesh::Nemesis_IO_Helper::construct_nemesis_filename

(

const std::string &

base_filename

)

Given base_filename, foo.e, constructs the Nemesis filename foo.e.X.Y, where X=n. CPUs and Y=processor ID

Definition at line 2408 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::n_processors(), libMesh::out, and libMesh::processor_id().

Referenced by libMesh::Nemesis_IO::read(), libMesh::Nemesis_IO::write(), and libMesh::Nemesis_IO::write_nodal_data().

{
  // Build a filename for this processor.  This code is cut-n-pasted from the read function
  // and should probably be put into a separate function...
  std::ostringstream file_oss;

  // We have to be a little careful here: Nemesis left pads its file
  // numbers based on the number of processors, so for example on 10
  // processors, we'd have:
  // mesh.e.10.00
  // mesh.e.10.01
  // mesh.e.10.02
  // ...
  // mesh.e.10.09

  // And on 100 you'd have:
  // mesh.e.100.000
  // mesh.e.100.001
  // ...
  // mesh.e.128.099

  // Find the length of the highest processor ID
  file_oss << (libMesh::n_processors());
  unsigned field_width = file_oss.str().size();

  if (_verbose)
    libMesh::out << "field_width=" << field_width << std::endl;

  file_oss.str(""); // reset the string stream
  file_oss << base_filename
           << '.' << libMesh::n_processors()
           << '.' << std::setfill('0') << std::setw(field_width) << libMesh::processor_id();

  // Return the resulting string
  return file_oss.str();
}

void libMesh::Nemesis_IO_Helper::create

(

std::string

filename

)

[virtual]

This function is specialized from ExodusII_IO_Helper to create the nodal coordinates stored on the local piece of the Mesh.

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 718 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_created, libMesh::ExodusII_IO_Helper::_verbose, libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::comp_ws, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::io_ws, std::min(), libMesh::out, and libMesh::Real.

Referenced by libMesh::Nemesis_IO::write(), and libMesh::Nemesis_IO::write_nodal_data().

{
  // Fall back on double precision when necessary since ExodusII
  // doesn't seem to support long double
  comp_ws = libmesh_cast_int<int>
    (std::min(sizeof(Real),sizeof(double)));
  io_ws = libmesh_cast_int<int>
    (std::min(sizeof(Real),sizeof(double)));

  this->ex_id = exII::ex_create(filename.c_str(), EX_CLOBBER, &comp_ws, &io_ws);

  check_err(ex_id, "Error creating Nemesis mesh file.");

  if (_verbose)
    libMesh::out << "File created successfully." << std::endl;

  this->_created = true;
}

bool libMesh::ExodusII_IO_Helper::created

(

)

[inherited]

Returns true once create() has been successfully called, and false otherwise.

Definition at line 1604 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_created.

Referenced by libMesh::Nemesis_IO::write_global_data(), libMesh::Nemesis_IO::write_information_records(), libMesh::Nemesis_IO::write_nodal_data(), and libMesh::ExodusII_IO::write_nodal_data_discontinuous().

{
  return _created;
}

int libMesh::ExodusII_IO_Helper::get_block_id

(

int

index

)

[inherited]

Get the block number for the given block index.

Definition at line 379 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::block_ids.

Referenced by libMesh::ExodusII_IO::read(), and libMesh::ExodusII_IO_Helper::write_element_values().

{
  libmesh_assert_less (static_cast<unsigned int>(index), block_ids.size());

  return block_ids[index];
}

std::string libMesh::ExodusII_IO_Helper::get_block_name

(

int

index

)

[inherited]

Get the block name for the given block index if supplied in the mesh file. Otherwise an empty string is returned.

Definition at line 388 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::block_ids, and libMesh::ExodusII_IO_Helper::id_to_block_names.

Referenced by libMesh::ExodusII_IO::read().

{
  libmesh_assert_less (static_cast<unsigned int>(index), block_ids.size());

  return id_to_block_names[block_ids[index]];
}

void libMesh::Nemesis_IO_Helper::get_cmap_params

(

)

Definition at line 326 of file nemesis_io_helper.C.

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

Referenced by libMesh::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)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] ";
      for (unsigned int i=0; i<node_cmap_ids.size(); ++i)
        libMesh::out << "node_cmap_ids["<<i<<"]=" << node_cmap_ids[i] << " ";
      libMesh::out << std::endl;

      libMesh::out << "[" << libMesh::processor_id() << "] ";
      for (unsigned int i=0; i<node_cmap_node_cnts.size(); ++i)
        libMesh::out << "node_cmap_node_cnts["<<i<<"]=" << node_cmap_node_cnts[i] << " ";
      libMesh::out << std::endl;

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

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

int libMesh::ExodusII_IO_Helper::get_connect

(

int

i

)

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 node number in the element connectivity list for a given element.

Definition at line 191 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::connect.

Referenced by libMesh::ExodusII_IO::read().

{ return connect[i]; }

void libMesh::Nemesis_IO_Helper::get_eb_info_global

(

)

Definition at line 178 of file nemesis_io_helper.C.

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

Referenced by libMesh::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)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] " << "Global Element Block IDs and Counts:" << std::endl;
      for (unsigned int bn=0; bn<global_elem_blk_ids.size(); ++bn)
        {
          libMesh::out << "  [" << 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 libMesh::Nemesis_IO_Helper::get_elem_cmap

(

)

Definition at line 406 of file nemesis_io_helper.C.

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

Referenced by libMesh::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()         ? 0    : 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)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] elem_cmap_elem_ids["<<i<<"]=";
          for (unsigned int j=0; j<elem_cmap_elem_ids[i].size(); ++j)
            libMesh::out << elem_cmap_elem_ids[i][j] << " ";
          libMesh::out << std::endl;

          // These must be the (local) side IDs (in the ExodusII face numbering scheme)
          // of the sides shared across processors.
          libMesh::out << "[" << libMesh::processor_id() << "] elem_cmap_side_ids["<<i<<"]=";
          for (unsigned int j=0; j<elem_cmap_side_ids[i].size(); ++j)
            libMesh::out << elem_cmap_side_ids[i][j] << " ";
          libMesh::out << 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...
          libMesh::out << "[" << libMesh::processor_id() << "] elem_cmap_proc_ids["<<i<<"]=";
          for (unsigned int j=0; j<elem_cmap_proc_ids[i].size(); ++j)
            libMesh::out << elem_cmap_proc_ids[i][j] << " ";
          libMesh::out << std::endl;
        }
    }
}

const std::vector<int>& libMesh::ExodusII_IO_Helper::get_elem_list

(

)

const [inline, inherited]

Returns:

the 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 219 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::elem_list.

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

{ return elem_list; }

void libMesh::Nemesis_IO_Helper::get_elem_map

(

)

Definition at line 253 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::ExodusII_IO_Helper::check_err(), elem_mapb, elem_mapi, libMesh::ExodusII_IO_Helper::ex_id, std::min(), nemesis_err_flag, num_border_elems, num_internal_elems, libMesh::out, 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....
      //libMesh::out << "[" << libMesh::processor_id() << "] " << "first interior elem id=" << elem_mapi[0] << std::endl;
      //libMesh::out << "[" << libMesh::processor_id() << "] " << "last interior elem id=" << elem_mapi.back() << std::endl;
      //libMesh::out << "[" << libMesh::processor_id() << "] " << "first boundary elem id=" << elem_mapb[0] << std::endl;
      //libMesh::out << "[" << libMesh::processor_id() << "] " << "last boundary elem id=" << elem_mapb.back() << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] elem_mapi[i] = ";
      for (unsigned int i=0; i< static_cast<unsigned int>(num_internal_elems-1); ++i)
        libMesh::out << elem_mapi[i] << ", ";
      libMesh::out << "... " << elem_mapi.back() << std::endl;

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

const char* libMesh::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 266 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::elem_type.

Referenced by libMesh::ExodusII_IO::read().

{ return &elem_type[0]; }

const std::vector<int>& libMesh::ExodusII_IO_Helper::get_id_list

(

)

const [inline, inherited]

Returns:

the 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 256 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::id_list.

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

{ return id_list; }

void libMesh::Nemesis_IO_Helper::get_init_global

(

)

Set the flag indicationg if we should be verbose. Reading functions. These just allocate memory for you and call the Nemesis routines of the same name. They also handle error checking for the Nemesis return value. Be careful calling these at random, some depend on others being called first... Fills: num_nodes_global, num_elems_global, num_elem_blks_global, num_node_sets_global, num_side_sets_global Call after: read_header() Call before: Any other get_* function from this class

Definition at line 87 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::ExodusII_IO_Helper::check_err(), libMesh::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, libMesh::out, and libMesh::processor_id().

Referenced by libMesh::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)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_nodes_global=" << num_nodes_global << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_elems_global=" << num_elems_global << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_elem_blks_global=" << num_elem_blks_global << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_node_sets_global=" << num_node_sets_global << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_side_sets_global=" << num_side_sets_global << std::endl;
    }
}

void libMesh::Nemesis_IO_Helper::get_init_info

(

)

Definition at line 204 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, ftype, nemesis_err_flag, num_proc, num_proc_in_file, libMesh::out, 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)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_proc=" << num_proc << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_proc_in_file=" << num_proc_in_file << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "ftype=" << ftype << std::endl;
    }
}

void libMesh::Nemesis_IO_Helper::get_loadbal_param

(

)

Definition at line 223 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::ExodusII_IO_Helper::check_err(), libMesh::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, libMesh::out, and libMesh::processor_id().

Referenced by libMesh::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)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_internal_nodes=" << num_internal_nodes << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_border_nodes=" << num_border_nodes << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_external_nodes=" << num_external_nodes << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_internal_elems=" << num_internal_elems << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_border_elems=" << num_border_elems << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_node_cmaps=" << num_node_cmaps << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "num_elem_cmaps=" << num_elem_cmaps << std::endl;
    }
}

const std::vector< std::string > & libMesh::ExodusII_IO_Helper::get_nodal_var_names

(

)

[inherited]

Definition at line 688 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, ex_get_var_names(), libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::nodal_var_names, libMesh::ExodusII_IO_Helper::num_nodal_vars, libMesh::out, libMesh::ExodusII_IO_Helper::strings, and libMesh::ExodusII_IO_Helper::vvc.

Referenced by libMesh::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)
    {
      libMesh::out << "Read the variable(s) from the file:" << std::endl;
      for (int i=0; i<num_nodal_vars; i++)
        libMesh::out << "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< Real > & libMesh::ExodusII_IO_Helper::get_nodal_var_values	(	std::string	nodal_var_name,
		int	time_step
	)			[inherited]

Definition at line 728 of file exodusII_io_helper.C.

References libMesh::err, ex_get_nodal_var(), libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::get_nodal_var_names(), libMesh::ExodusII_IO_Helper::nodal_var_names, libMesh::ExodusII_IO_Helper::nodal_var_values, and libMesh::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;

  // Do a linear search for nodal_var_name in nodal_var_names
  for (; var_index<nodal_var_names.size(); ++var_index)
    {
      found = (nodal_var_names[var_index] == nodal_var_name);
      if (found)
        break;
    }

  if (!found)
    {
      libMesh::err << "Unable to locate variable named: " << nodal_var_name << std::endl;
      libMesh::err << "Available variables: " << std::endl;
      for (unsigned int i=0; i<nodal_var_names.size(); ++i)
        libMesh::err << nodal_var_names[i] << std::endl;

      libmesh_error();
    }

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

  return nodal_var_values;
}

void libMesh::Nemesis_IO_Helper::get_node_cmap

(

)

Definition at line 369 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::ExodusII_IO_Helper::check_err(), libMesh::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, libMesh::out, and libMesh::processor_id().

Referenced by libMesh::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()         ? 0    : 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)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] node_cmap_node_ids["<<i<<"]=";
          for (unsigned int j=0; j<node_cmap_node_ids[i].size(); ++j)
            libMesh::out << node_cmap_node_ids[i][j] << " ";
          libMesh::out << 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...
          libMesh::out << "[" << libMesh::processor_id() << "] node_cmap_proc_ids["<<i<<"]=";
          for (unsigned int j=0; j<node_cmap_proc_ids[i].size(); ++j)
            libMesh::out << node_cmap_proc_ids[i][j] << " ";
          libMesh::out << std::endl;
        }
    }
}

const std::vector<int>& libMesh::ExodusII_IO_Helper::get_node_list

(

)

const [inline, inherited]

Returns:

a constant reference to the node_list.

Definition at line 239 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::node_list.

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

{ return node_list; }

void libMesh::Nemesis_IO_Helper::get_node_map

(

)

Definition at line 289 of file nemesis_io_helper.C.

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

Referenced by libMesh::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.
      libMesh::out << "[" << libMesh::processor_id() << "] " << "first interior node id=" << node_mapi[0] << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] " << "last interior node id=" << node_mapi.back() << std::endl;

      libMesh::out << "[" << libMesh::processor_id() << "] " << "first boundary node id=" << node_mapb[0] << std::endl;
      libMesh::out << "[" << 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)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] " << "first external node id=" << node_mape[0] << std::endl;
          libMesh::out << "[" << libMesh::processor_id() << "] " << "last external node id=" << node_mape.back() << std::endl;
        }
    }
}

int libMesh::ExodusII_IO_Helper::get_node_set_id

(

int

index

)

[inherited]

Get the node set id for the given node set index.

Definition at line 415 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::nodeset_ids.

{
  libmesh_assert_less (static_cast<unsigned int>(index), nodeset_ids.size());

  return nodeset_ids[index];
}

std::string libMesh::ExodusII_IO_Helper::get_node_set_name

(

int

index

)

[inherited]

Get the node set name for the given node set index if supplied in the mesh file. Otherwise an empty string is returned.

Definition at line 424 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::id_to_ns_names, and libMesh::ExodusII_IO_Helper::nodeset_ids.

Referenced by libMesh::ExodusII_IO::read().

{
  libmesh_assert_less (static_cast<unsigned int>(index), nodeset_ids.size());

  return id_to_ns_names[nodeset_ids[index]];
}

int libMesh::ExodusII_IO_Helper::get_nodeset_id

(

unsigned int

i

)

const [inline, inherited]

Returns:

the nodeset id corresponding to the ith nodeset.

Definition at line 244 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::nodeset_ids.

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

{ return nodeset_ids[i]; }

void libMesh::Nemesis_IO_Helper::get_ns_param_global

(

)

Definition at line 146 of file nemesis_io_helper.C.

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

Referenced by libMesh::Nemesis_IO::read().

{
  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)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] " << "Global Nodeset IDs, Node Counts, and DF counts:" << std::endl;
          for (unsigned int bn=0; bn<global_nodeset_ids.size(); ++bn)
            {
              libMesh::out << "  [" << 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 libMesh::ExodusII_IO_Helper::get_num_dim

(

)

const [inline, inherited]

Returns:

the ExodusII mesh dimension.

Definition at line 118 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_dim.

{ return num_dim; }

int libMesh::ExodusII_IO_Helper::get_num_elem

(

)

const [inline, inherited]

Returns:

the total number of elements in the ExodusII mesh.

Definition at line 137 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_elem.

Referenced by libMesh::ExodusII_IO::read().

{ return num_elem; }

int libMesh::ExodusII_IO_Helper::get_num_elem_blk

(

)

const [inline, inherited]

Returns:

the total number of element blocks in the ExodusII mesh.

Definition at line 144 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_elem_blk.

Referenced by libMesh::ExodusII_IO::read().

{ return num_elem_blk; }

int libMesh::ExodusII_IO_Helper::get_num_elem_this_blk

(

)

const [inline, inherited]

For a given block, returns the total number of elements.

Definition at line 151 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_elem_this_blk.

Referenced by libMesh::ExodusII_IO::read().

{ return num_elem_this_blk; }

int libMesh::ExodusII_IO_Helper::get_num_globals

(

)

const [inline, inherited]

Returns:

the total number of global variables.

Definition at line 124 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_globals.

{ return num_globals; }

int libMesh::ExodusII_IO_Helper::get_num_nodal_vars

(

)

[inline, inherited]

Definition at line 454 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_nodal_vars.

{ return num_nodal_vars; }

int libMesh::ExodusII_IO_Helper::get_num_node_sets

(

)

const [inline, inherited]

Returns:

the total number of nodesets in the ExodusII mesh.

Definition at line 174 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_node_sets.

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

{ return num_node_sets; }

int libMesh::ExodusII_IO_Helper::get_num_nodes

(

)

const [inline, inherited]

Returns:

the total number of nodes in the ExodusII mesh.

Definition at line 130 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_nodes.

Referenced by libMesh::ExodusII_IO::read().

{ return num_nodes; }

int libMesh::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 159 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_nodes_per_elem.

Referenced by libMesh::ExodusII_IO::read().

{ return num_nodes_per_elem; }

int libMesh::ExodusII_IO_Helper::get_num_nodes_per_set

(

int

i

)

const [inline, inherited]

For a single nodeset, returns the total number of nodes in the nodeset.

Definition at line 205 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_nodes_per_set.

{ return num_nodes_per_set[i]; }

int libMesh::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 167 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_side_sets.

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

{ return num_side_sets; }

int libMesh::ExodusII_IO_Helper::get_num_sides_per_set

(

int

i

)

const [inline, inherited]

For a single sideset, returns the total number of elements in the sideset.

Definition at line 198 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::num_sides_per_set.

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

{ return num_sides_per_set[i]; }

const std::vector<int>& libMesh::ExodusII_IO_Helper::get_side_list

(

)

const [inline, inherited]

Returns:

the 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 234 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::side_list.

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

{ return side_list; }

int libMesh::ExodusII_IO_Helper::get_side_set_id

(

int

index

)

[inherited]

Get the side set id for the given side set index.

Definition at line 397 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::ss_ids.

Referenced by libMesh::ExodusII_IO::read().

{
  libmesh_assert_less (static_cast<unsigned int>(index), ss_ids.size());

  return ss_ids[index];
}

std::string libMesh::ExodusII_IO_Helper::get_side_set_name

(

int

index

)

[inherited]

Get the side set name for the given side set index if supplied in the mesh file. Otherwise an empty string is returned.

Definition at line 406 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::id_to_ss_names, and libMesh::ExodusII_IO_Helper::ss_ids.

Referenced by libMesh::ExodusII_IO::read().

{
  libmesh_assert_less (static_cast<unsigned int>(index), ss_ids.size());

  return id_to_ss_names[ss_ids[index]];
}

void libMesh::Nemesis_IO_Helper::get_ss_param_global

(

)

Fills: global_sideset_ids, num_global_side_counts, num_global_side_df_counts Call after: get_init_global()

Definition at line 110 of file nemesis_io_helper.C.

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

Referenced by libMesh::Nemesis_IO::read().

{
  if (num_side_sets_global > 0)
    {
      global_sideset_ids.resize(num_side_sets_global);
      num_global_side_counts.resize(num_side_sets_global);

      // df = "distribution factor", not really sure what that is.  I don't yet have a file
      // which has distribution factors so I guess we'll worry about it later...
      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)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] " << "Global Sideset IDs, Side Counts, and DF counts:" << std::endl;
          for (unsigned int bn=0; bn<global_sideset_ids.size(); ++bn)
            {
              libMesh::out << "  [" << 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< Real > & libMesh::ExodusII_IO_Helper::get_time_steps

(

)

[inherited]

Definition at line 679 of file exodusII_io_helper.C.

References ex_get_all_times(), libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::num_time_steps, and libMesh::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;
}

Real libMesh::ExodusII_IO_Helper::get_x

(

int

i

)

const [inline, inherited]

Returns:

the node's x-coordinate.

Definition at line 272 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::x.

Referenced by libMesh::ExodusII_IO::read().

{ return x[i]; }

Real libMesh::ExodusII_IO_Helper::get_y

(

int

i

)

const [inline, inherited]

Returns:

the node's y-coordinate.

Definition at line 278 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::y.

Referenced by libMesh::ExodusII_IO::read().

{ return y[i]; }

Real libMesh::ExodusII_IO_Helper::get_z

(

int

i

)

const [inline, inherited]

Returns:

the node's z-coordinate.

Definition at line 284 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::z.

Referenced by libMesh::ExodusII_IO::read().

{ return z[i]; }

void libMesh::Nemesis_IO_Helper::initialize	(	std::string	title,
		const MeshBase &	mesh
	)			[virtual]

Specialization of the initialize function from ExodusII_IO_Helper that also writes global initial data to file.

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 744 of file nemesis_io_helper.C.

References build_element_and_node_maps(), compute_border_node_ids(), compute_communication_map_parameters(), compute_elem_communication_maps(), compute_element_maps(), compute_internal_and_border_elems_and_internal_nodes(), compute_node_communication_maps(), compute_node_maps(), compute_num_global_elem_blocks(), compute_num_global_nodesets(), compute_num_global_sidesets(), elem_cmap_elem_cnts, elem_cmap_elem_ids, elem_cmap_ids, elem_cmap_proc_ids, elem_cmap_side_ids, elem_mapb, elem_mapi, global_elem_blk_cnts, global_elem_blk_ids, global_nodeset_ids, global_sideset_ids, libMesh::n_processors(), node_cmap_ids, node_cmap_node_cnts, node_cmap_node_ids, node_cmap_proc_ids, node_mapb, node_mape, node_mapi, num_border_elems, num_border_nodes, num_elem_blks_global, num_elem_cmaps, num_external_nodes, num_global_node_counts, num_global_node_df_counts, num_global_side_counts, num_global_side_df_counts, num_internal_elems, num_internal_nodes, num_node_cmaps, num_node_sets_global, num_side_sets_global, libMesh::MeshBase::parallel_n_elem(), libMesh::MeshBase::parallel_n_nodes(), put_cmap_params(), put_eb_info_global(), put_elem_cmap(), put_elem_map(), put_init_global(), put_init_info(), put_loadbal_param(), put_node_cmap(), put_node_map(), put_ns_param_global(), put_ss_param_global(), and write_exodus_initialization_info().

Referenced by libMesh::Nemesis_IO::write(), and libMesh::Nemesis_IO::write_nodal_data().

{
  // Make sure that the reference passed in is really a ParallelMesh
  // const ParallelMesh& pmesh = libmesh_cast_ref<const ParallelMesh&>(mesh);
  const MeshBase& pmesh = mesh;

  // According to Nemesis documentation, first call when writing should be to
  // ne_put_init_info().  Our reader doesn't actually call this, but we should
  // strive to be as close to a normal nemesis file as possible...
  this->put_init_info(libMesh::n_processors(), 1, "p");


  // Gather global "initial" information for Nemesis.  This consists of
  // three parts labelled I, II, and III below...

  //
  // I.) Need to compute the number of global element blocks.  To be consistent with
  // Exodus, we also incorrectly associate the number of element blocks with the
  // number of libmesh subdomains...
  //
  this->compute_num_global_elem_blocks(pmesh);

  //
  // II.) Determine the global number of nodesets by communication.
  // This code relies on BoundaryInfo storing side and node
  // boundary IDs separately at the time they are added to the
  // BoundaryInfo object.
  //
  this->compute_num_global_nodesets(pmesh);

  //
  // III.) Need to compute the global number of sidesets by communication:
  // This code relies on BoundaryInfo storing side and node
  // boundary IDs separately at the time they are added to the
  // BoundaryInfo object.
  //
  this->compute_num_global_sidesets(pmesh);

  // Now write the global data obtained in steps I, II, and III to the Nemesis file
  this->put_init_global(pmesh.parallel_n_nodes(),
                        pmesh.parallel_n_elem(),
                        this->num_elem_blks_global, /* I.   */
                        this->num_node_sets_global, /* II.  */
                        this->num_side_sets_global  /* III. */
                        );

  // Next, we'll write global element block information to the file.  This was already
  // gathered in step I. above
  this->put_eb_info_global(this->global_elem_blk_ids,
                           this->global_elem_blk_cnts);


  // Next, write global nodeset information to the file.  This was already gathered in
  // step II. above.
  this->num_global_node_df_counts.clear();
  this->num_global_node_df_counts.resize(this->global_nodeset_ids.size()); // distribution factors all zero...
  this->put_ns_param_global(this->global_nodeset_ids,
                            this->num_global_node_counts,
                            this->num_global_node_df_counts);


  // Next, write global sideset information to the file.  This was already gathered in
  // step III. above.
  this->num_global_side_df_counts.clear();
  this->num_global_side_df_counts.resize(this->global_sideset_ids.size()); // distribution factors all zero...
  this->put_ss_param_global(this->global_sideset_ids,
                            this->num_global_side_counts,
                            this->num_global_side_df_counts);


  // Before we go any further we need to derive consistent node and
  // element numbering schemes for all local elems and nodes connected
  // to local elements.
  //
  // Must be called *after* the local_subdomain_counts map has been constructed
  // by the compute_num_global_elem_blocks() function!
  this->build_element_and_node_maps(pmesh);

  // Next step is to write "load balance" parameters.  Several things need to
  // be computed first though...

  // First we'll collect IDs of border nodes.
  this->compute_border_node_ids(pmesh);

  // Next we'll collect numbers of internal and border elements, and internal nodes.
  // Note: "A border node does not a border element make...", that is, just because one
  // of an element's nodes has been identified as a border node, the element is not
  // necessarily a border element.  It must have a side on the boundary between processors,
  // i.e. have a face neighbor with a different processor id...
  this->compute_internal_and_border_elems_and_internal_nodes(pmesh);

  // Finally we are ready to write the loadbal information to the file
  this->put_loadbal_param(this->num_internal_nodes,
                          this->num_border_nodes,
                          this->num_external_nodes,
                          this->num_internal_elems,
                          this->num_border_elems,
                          this->num_node_cmaps,
                          this->num_elem_cmaps);


  // Now we need to compute the "communication map" parameters.  These are basically
  // lists of nodes and elements which need to be communicated between different processors
  // when the mesh file is read back in.
  this->compute_communication_map_parameters();

  // Write communication map parameters to file.
  this->put_cmap_params(this->node_cmap_ids,
                        this->node_cmap_node_cnts,
                        this->elem_cmap_ids,
                        this->elem_cmap_elem_cnts);


  // Ready the node communication maps.  The node IDs which
  // are communicated are the ones currently stored in
  // proc_nodes_touched_intersections.
  this->compute_node_communication_maps();

  // Write the packed node communication vectors to file.
  this->put_node_cmap(this->node_cmap_node_ids,
                      this->node_cmap_proc_ids);


  // Ready the node maps.  These have nothing to do with communiction, they map
  // the nodes to internal, border, and external nodes in the file.
  this->compute_node_maps();

  // Call the Nemesis API to write the node maps to file.
  this->put_node_map(this->node_mapi,
                     this->node_mapb,
                     this->node_mape);



  // Ready the element communication maps.  This includes border
  // element IDs, sides which are on the border, and the processors to which
  // they are to be communicated...
  this->compute_elem_communication_maps();



  // Call the Nemesis API to write the packed element communication maps vectors to file
  this->put_elem_cmap(this->elem_cmap_elem_ids,
                      this->elem_cmap_side_ids,
                      this->elem_cmap_proc_ids);






  // Ready the Nemesis element maps (internal and border) for writing to file.
  this->compute_element_maps();

  // Call the Nemesis API to write the internal and border element IDs.
  this->put_elem_map(this->elem_mapi,
                     this->elem_mapb);


  // Now write Exodus-specific initialization information, some of which is
  // different when you are using Nemesis.
  this->write_exodus_initialization_info(pmesh, title_in);
} // end initialize()

void libMesh::ExodusII_IO_Helper::initialize_discontinuous	(	std::string	title,
		const MeshBase &	mesh
	)			[inherited]

Initializes the Exodus file

Definition at line 792 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::_use_mesh_dimension_instead_of_spatial_dimension, libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), libMesh::MeshBase::boundary_info, libMesh::ExodusII_IO_Helper::check_err(), end, libMesh::err, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_init(), libMesh::DofObject::id(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_elem(), libMesh::ExodusII_IO_Helper::num_dim, libMesh::ExodusII_IO_Helper::num_elem, libMesh::ExodusII_IO_Helper::num_elem_blk, libMesh::ExodusII_IO_Helper::num_node_sets, libMesh::ExodusII_IO_Helper::num_nodes, libMesh::ExodusII_IO_Helper::num_side_sets, libMesh::processor_id(), libMesh::MeshBase::spatial_dimension(), and libMesh::Elem::subdomain_id().

Referenced by libMesh::ExodusII_IO::write_nodal_data_discontinuous().

{
  if ((_run_only_on_proc0) && (libMesh::processor_id() != 0))
    return;

  if (_use_mesh_dimension_instead_of_spatial_dimension)
    num_dim = mesh.mesh_dimension();
  else
    num_dim = mesh.spatial_dimension();

  MeshBase::const_element_iterator       it  = mesh.active_elements_begin();
  const MeshBase::const_element_iterator end = mesh.active_elements_end();
  for ( ; it != end; ++it)
        num_nodes += (*it)->n_nodes();

  num_elem = mesh.n_elem();

  std::vector<boundary_id_type> unique_side_boundaries;
  std::vector<boundary_id_type> 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(it = mesh.active_elements_begin(); it != end; ++it)
    {
      const Elem * elem = *it;
      subdomain_id_type cur_subdomain = elem->subdomain_id();

      subdomain_map[cur_subdomain].push_back(elem->id());
    }
  num_elem_blk = subdomain_map.size();

  if (str_title.size() > MAX_LINE_LENGTH)
    {
      libMesh::err << "Warning, Exodus files cannot have titles longer than "
                   << MAX_LINE_LENGTH
                   << " characters.  Your title will be truncated."
                   << std::endl;
      str_title.resize(MAX_LINE_LENGTH);
    }

  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 libMesh::ExodusII_IO_Helper::initialize_element_variables	(	const MeshBase &	mesh,
		std::vector< std::string >	names
	)			[inherited]

Sets up the nodal variables

Definition at line 1304 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_elem_vars_initialized, libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::_verbose, libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_elem_var_tab(), ex_put_var_names(), ex_put_var_param(), libMesh::ExodusII_IO_Helper::num_elem_blk, libMesh::ExodusII_IO_Helper::num_elem_vars, libMesh::out, libMesh::processor_id(), libMesh::ExodusII_IO_Helper::strings, and libMesh::ExodusII_IO_Helper::vvc.

{
  if ((_run_only_on_proc0) && (libMesh::processor_id() != 0))
    return;

  num_elem_vars = names.size();

  if ( num_elem_vars == 0 )
    return;

  if (_elem_vars_initialized)
    return;
  _elem_vars_initialized = true;

  ex_err = exII::ex_put_var_param(ex_id, "e", num_elem_vars);
  check_err(ex_err, "Error setting number of element vars.");

  // Form the element variable truth table and send to Exodus.
  // This tells which variables are written to which blocks,
  // and can dramatically speed up writing element variables

  // We really should initialize all entries in the truth table to 0
  // and then loop over all subdomains, setting their entries to 1
  // if a given variable exists on that subdomain.  However,
  // we don't have that information, and the element variables
  // passed to us are padded with zeroes for the blocks where
  // they aren't defined.  To be consistent with that, fill
  // the truth table with ones.

  std::vector<int> truth_tab(num_elem_blk*num_elem_vars,1);
  ex_err = exII::ex_put_elem_var_tab(ex_id, num_elem_blk, num_elem_vars, &truth_tab[0]);
  check_err(ex_err, "Error writing element truth table.");

  // Use the vvc and strings objects to emulate the behavior of
  // a char** object.
  vvc.resize(num_elem_vars);
  strings.resize(num_elem_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_elem_vars; ++i)
    {
      // Note: the one additional character is to hold the trailing '\0'
      vvc[i].resize(names[i].size() + 1);
      //std::strcpy(&(vvc[i][0]), names[i].c_str());
      vvc[i][ names[i].copy(&vvc[i][0], vvc[i].size()-1) ] = '\0';
    }

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

  if (_verbose)
    {
      libMesh::out << "Writing variable name(s) to file: " << std::endl;
      for (int i=0; i < num_elem_vars; ++i)
        libMesh::out << "strings[" << i << "]=" << strings[i] << std::endl;
    }

  ex_err = exII::ex_put_var_names(ex_id,
                                  "e",
                                  num_elem_vars,
                                  &strings[0]//var_names
                                  );

  check_err(ex_err, "Error setting element variable names.");
}

void libMesh::ExodusII_IO_Helper::initialize_global_variables

(

const std::vector< std::string > &

names

)

[inherited]

Sets up the global variables

Definition at line 1419 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_global_vars_initialized, libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::_verbose, libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_var_names(), ex_put_var_param(), libMesh::ExodusII_IO_Helper::num_globals, libMesh::out, libMesh::processor_id(), libMesh::ExodusII_IO_Helper::strings, and libMesh::ExodusII_IO_Helper::vvc.

Referenced by libMesh::Nemesis_IO::write_global_data().

{
  if ((_run_only_on_proc0) && (libMesh::processor_id() != 0))
    return;

  if (_global_vars_initialized)
  {
    return;
  }
  _global_vars_initialized = true;

  num_globals = names.size();

  ex_err = exII::ex_put_var_param(ex_id, "g", num_globals);
  check_err(ex_err, "Error setting number of global vars.");

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

  // 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_globals; i++)
    {
      vvc[i].resize(names[i].size()+1);
      // std::strcpy(&(vvc[i][0]), names[i].c_str());
      vvc[i][ names[i].copy(&vvc[i][0], vvc[i].size()-1) ] = '\0';
    }

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

  if (_verbose)
    {
      libMesh::out << "Writing variable name(s) to file: " << std::endl;
      for (int i=0; i < num_globals; ++i)
        libMesh::out << "strings[" << i << "]=" << strings[i] << std::endl;
    }

  ex_err = exII::ex_put_var_names(ex_id,
                                  "g",
                                  num_globals,
                                  &strings[0]
                                  );

  check_err(ex_err, "Error setting global variable names.");
}

void libMesh::ExodusII_IO_Helper::initialize_nodal_variables

(

std::vector< std::string >

names

)

[inherited]

Sets up the nodal variables

Definition at line 1374 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::_verbose, libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_var_names(), ex_put_var_param(), libMesh::ExodusII_IO_Helper::num_nodal_vars, libMesh::out, libMesh::processor_id(), libMesh::ExodusII_IO_Helper::strings, and libMesh::ExodusII_IO_Helper::vvc.

Referenced by libMesh::Nemesis_IO::write_nodal_data(), and libMesh::ExodusII_IO::write_nodal_data_discontinuous().

{
  if ((_run_only_on_proc0) && (libMesh::processor_id() != 0))
    return;

  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());
      vvc[i][ names[i].copy(&vvc[i][0], vvc[i].size()-1) ] = '\0';
    }

  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)
    {
      libMesh::out << "Writing variable name(s) to file: " << std::endl;
      for (int i=0;i<num_nodal_vars;i++)
        libMesh::out << "strings[" << i << "]=" << strings[i] << std::endl;
    }

  ex_err = exII::ex_put_var_names(ex_id,
                                  "n",
                                  num_nodal_vars,
                                  strings.empty() ? NULL : &strings[0]//var_names
                                  );

  check_err(ex_err, "Error setting nodal variable names.");
}

int libMesh::ExodusII_IO_Helper::inquire	(	int	req_info,
		std::string	error_msg = ""
	)			[inherited]

Generic inquiry, returns the value

Definition at line 664 of file exodusII_io_helper.C.

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

Referenced by libMesh::ExodusII_IO_Helper::read_header().

{
  ex_err = exII::ex_inquire(ex_id,
                            req_info_in,
                            &ret_int,
                            &ret_float,
                            &ret_char);

  check_err(ex_err, error_msg);

  return ret_int;
}

void libMesh::ExodusII_IO_Helper::message	(	const std::string	msg,
		int	i
	)			[inherited]

Prints the message defined in msg, 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 248 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, and libMesh::out.

{
  if (_verbose) libMesh::out << msg << i << "." << std::endl;
}

void libMesh::ExodusII_IO_Helper::message

(

const std::string

msg

)

[inherited]

Prints the message defined in msg. Can be turned off if verbosity is set to 0.

Definition at line 241 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, and libMesh::out.

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

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

void libMesh::ExodusII_IO_Helper::open

(

const char *

filename

)

[inherited]

Opens an ExodusII mesh file named filename for reading.

Definition at line 255 of file exodusII_io_helper.C.

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

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

{
  ex_id = exII::ex_open(filename,
                        EX_READ,
                        &comp_ws,
                        &io_ws,
                        &ex_version);

  std::string err_msg = std::string("Error opening ExodusII mesh file: ") + std::string(filename);
  check_err(ex_id, err_msg);
  if (_verbose) libMesh::out << "File opened successfully." << std::endl;
}

void libMesh::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 293 of file exodusII_io_helper.C.

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

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

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

void libMesh::ExodusII_IO_Helper::print_nodes

(

std::ostream &

out = libMesh::out

)

[inherited]

Prints the nodal information, by default to libMesh::out.

Definition at line 344 of file exodusII_io_helper.C.

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

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

void libMesh::ExodusII_IO_Helper::print_nodeset_info

(

)

[inherited]

Prints information about all the nodesets.

void libMesh::ExodusII_IO_Helper::print_sideset_info

(

)

[inherited]

Prints information about all the sidesets.

Definition at line 639 of file exodusII_io_helper.C.

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

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

void libMesh::Nemesis_IO_Helper::put_cmap_params	(	std::vector< int > &	node_cmap_ids,
		std::vector< int > &	node_cmap_node_cnts,
		std::vector< int > &	elem_cmap_ids,
		std::vector< int > &	elem_cmap_elem_cnts
	)

Outputs initial information for communication maps. Note: the order of the arguments specified in the Nemsis User's Manual is *wrong*. The correct order is (ids, counts, ids, counts). Must be called after put_loadbal_param().

Definition at line 570 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, nemesis_err_flag, node_cmap_ids, and libMesh::processor_id().

Referenced by initialize().

{
  // We might not have cmaps on every processor in some corner
  // cases
  if(node_cmap_ids.size())
    {
      nemesis_err_flag =
        Nemesis::ne_put_cmap_params(ex_id,
                                    &node_cmap_ids_in[0],
                                    &node_cmap_node_cnts_in[0],
                                    &elem_cmap_ids_in[0],
                                    &elem_cmap_elem_cnts_in[0],
                                    libMesh::processor_id());
    }

  this->check_err(nemesis_err_flag, "Error writing cmap parameters!");
}

void libMesh::Nemesis_IO_Helper::put_eb_info_global	(	std::vector< int > &	global_elem_blk_ids,
		std::vector< int > &	global_elem_blk_cnts
	)

Writes global block information to the file .) global_elem_blk_ids - list of block IDs for all blocks present in the mesh .) global_elem_blk_cnts - number of elements in each block for the global mesh

Must be called after put_init_global().

Definition at line 490 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, and nemesis_err_flag.

Referenced by initialize().

{
  nemesis_err_flag =
    Nemesis::ne_put_eb_info_global(ex_id,
                                   &global_elem_blk_ids_in[0],
                                   &global_elem_blk_cnts_in[0]);

  this->check_err(nemesis_err_flag, "Error writing global element block information!");
}

void libMesh::Nemesis_IO_Helper::put_elem_cmap	(	std::vector< std::vector< int > > &	elem_cmap_elem_ids,
		std::vector< std::vector< int > > &	elem_cmap_side_ids,
		std::vector< std::vector< int > > &	elem_cmap_proc_ids
	)

Writes information about elemental communication map.

Note: this class contains vector<vectors>: elem_cmap_elem_ids elem_cmap_side_ids elem_cmap_proc_ids

Must be called after put_cmap_params().

Definition at line 653 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), elem_cmap_ids, libMesh::ExodusII_IO_Helper::ex_id, nemesis_err_flag, and libMesh::processor_id().

Referenced by initialize().

{
  for (unsigned int i=0; i<elem_cmap_ids.size(); ++i)
    {
      nemesis_err_flag =
        Nemesis::ne_put_elem_cmap(ex_id,
                                  this->elem_cmap_ids[i],
                                  &elem_cmap_elem_ids_in[i][0],
                                  &elem_cmap_side_ids_in[i][0],
                                  &elem_cmap_proc_ids_in[i][0],
                                  libMesh::processor_id());

      this->check_err(nemesis_err_flag, "Error writing elem communication map to file!");
    }
}

void libMesh::Nemesis_IO_Helper::put_elem_map	(	std::vector< int > &	elem_mapi,
		std::vector< int > &	elem_mapb
	)

Outputs IDs of internal and border elements.

Must be called after ne_put_loadbal_param().

Definition at line 674 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, nemesis_err_flag, and libMesh::processor_id().

Referenced by initialize().

{
  nemesis_err_flag =
    Nemesis::ne_put_elem_map(ex_id,
                             elem_mapi_in.empty() ? NULL : &elem_mapi_in[0],
                             elem_mapb_in.empty() ? NULL : &elem_mapb_in[0],
                             libMesh::processor_id());

  this->check_err(nemesis_err_flag, "Error writing Nemesis internal and border element maps to file!");
}

void libMesh::Nemesis_IO_Helper::put_init_global	(	dof_id_type	num_nodes_global,
		dof_id_type	num_elems_global,
		unsigned	num_elem_blks_global,
		unsigned	num_node_sets_global,
		unsigned	num_side_sets_global
	)

Writes global information including: .) global number of nodes .) global number of elems .) global number of element blocks .) global number of node sets .) global number of side sets

Definition at line 471 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, and nemesis_err_flag.

Referenced by initialize().

{
  nemesis_err_flag =
    Nemesis::ne_put_init_global(ex_id,
                                num_nodes_global_in,
                                num_elems_global_in,
                                num_elem_blks_global_in,
                                num_node_sets_global_in,
                                num_side_sets_global_in);

  this->check_err(nemesis_err_flag, "Error writing initial global data!");
}

void libMesh::Nemesis_IO_Helper::put_init_info	(	unsigned	num_proc,
		unsigned	num_proc_in_file,
		const char *	ftype
	)

Writing functions. Writes basic info about the partitioning to file .) num_proc - number of processors .) num_proc_in_file - number of processors in the current file - generally equal to 1 .) ftype = "s" for scalar load-balance file, "p" for parallel file

Definition at line 455 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, and nemesis_err_flag.

Referenced by initialize().

{
  nemesis_err_flag =
    Nemesis::ne_put_init_info(ex_id,
                              num_proc_in,
                              num_proc_in_file_in,
                              const_cast<char*>(ftype_in));

  this->check_err(nemesis_err_flag, "Error writing initial information!");
}

void libMesh::Nemesis_IO_Helper::put_loadbal_param	(	unsigned	num_internal_nodes,
		unsigned	num_border_nodes,
		unsigned	num_external_nodes,
		unsigned	num_internal_elems,
		unsigned	num_border_elems,
		unsigned	num_node_cmaps,
		unsigned	num_elem_cmaps
	)

Writes load balance parameters, some of which are described below: .) num_internal_nodes - nodes "wholly" owned by the current processor .) num_border_nodes - nodes local to a processor but residing in an element which also has nodes on other processors .) num_external_nodes - nodes that reside on other processors but whose element "partially" resides on the current processor -- we assert this should be zero on reading! .) num_border_elems - elements local to this processor but whose nodes reside on other processors as well. .) processor - ID of the processor for which information is to be written

Definition at line 544 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, nemesis_err_flag, and libMesh::processor_id().

Referenced by initialize().

{
  nemesis_err_flag =
    Nemesis::ne_put_loadbal_param(ex_id,
                                  num_internal_nodes_in,
                                  num_border_nodes_in,
                                  num_external_nodes_in,
                                  num_internal_elems_in,
                                  num_border_elems_in,
                                  num_node_cmaps_in,
                                  num_elem_cmaps_in,
                                  libMesh::processor_id());

  this->check_err(nemesis_err_flag, "Error writing loadbal parameters!");
}

void libMesh::Nemesis_IO_Helper::put_n_coord	(	unsigned	start_node_num,
		unsigned	num_nodes,
		std::vector< Real > &	x_coor,
		std::vector< Real > &	y_coor,
		std::vector< Real > &	z_coor
	)

Writes the specified number of coordinate values starting at the specified index.

Definition at line 691 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, and nemesis_err_flag.

{
  nemesis_err_flag =
    Nemesis::ne_put_n_coord(ex_id,
                            start_node_num,
                            num_nodes_in,
                            &x_coor[0],
                            &y_coor[0],
                            &z_coor[0]);

  this->check_err(nemesis_err_flag, "Error writing coords to file!");
}

void libMesh::Nemesis_IO_Helper::put_node_cmap	(	std::vector< std::vector< int > > &	node_cmap_node_ids,
		std::vector< std::vector< int > > &	node_cmap_proc_ids
	)

Outputs *all* of the nodal communication maps for this processor. Internally, this function loops over all communication maps and calls Nemesis::ne_put_node_cmap() for each one.

.) node_cmap_node_ids = Nodal IDs of the FEM nodes in this communication map .) node_cmap_proc_ids = processor IDs associated with each of the nodes in node_ids

In the Nemesis file, these all appeart to be written to the same chunks of data: n_comm_nids and n_comm_proc, but don't rely on these names...

Note: this class contains vector<vectors>: node_cmap_node_ids node_cmap_proc_ids which can be used when calling this function.

Must be called after put_cmap_params().

Definition at line 594 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, nemesis_err_flag, node_cmap_ids, libMesh::out, and libMesh::processor_id().

Referenced by initialize().

{

  // Print to screen what we are about to print to Nemesis file
  if (_verbose)
    {
      for (unsigned i=0; i<node_cmap_node_ids_in.size(); ++i)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] put_node_cmap() : nodes communicated to proc "
                       << this->node_cmap_ids[i]
                       << " = ";
          for (unsigned j=0; j<node_cmap_node_ids_in[i].size(); ++j)
            libMesh::out << node_cmap_node_ids_in[i][j] << " ";
          libMesh::out << std::endl;
        }

      for (unsigned i=0; i<node_cmap_node_ids_in.size(); ++i)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] put_node_cmap() : processor IDs = ";
          for (unsigned j=0; j<node_cmap_proc_ids_in[i].size(); ++j)
            libMesh::out << node_cmap_proc_ids_in[i][j] << " ";
          libMesh::out << std::endl;
        }
    }

  for (unsigned int i=0; i<node_cmap_node_ids_in.size(); ++i)
    {
      nemesis_err_flag =
        Nemesis::ne_put_node_cmap(ex_id,
                                  this->node_cmap_ids[i],
                                  &node_cmap_node_ids_in[i][0],
                                  &node_cmap_proc_ids_in[i][0],
                                  libMesh::processor_id());

      this->check_err(nemesis_err_flag, "Error writing node communication map to file!");
    }
}

void libMesh::Nemesis_IO_Helper::put_node_map	(	std::vector< int > &	node_mapi,
		std::vector< int > &	node_mapb,
		std::vector< int > &	node_mape
	)

Outputs IDs of internal, border, and external nodes. LibMesh asserts that the number of external nodes is zero in the Nemesis files it reads

Definition at line 636 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, nemesis_err_flag, and libMesh::processor_id().

Referenced by initialize().

{
  nemesis_err_flag =
    Nemesis::ne_put_node_map(ex_id,
                             node_mapi_in.empty() ? NULL : &node_mapi_in[0],
                             node_mapb_in.empty() ? NULL : &node_mapb_in[0],
                             node_mape_in.empty() ? NULL : &node_mape_in[0], // Don't take address of empty vector...
                             libMesh::processor_id());

  this->check_err(nemesis_err_flag, "Error writing Nemesis internal and border node maps to file!");
}

void libMesh::Nemesis_IO_Helper::put_ns_param_global	(	std::vector< int > &	global_nodeset_ids,
		std::vector< int > &	num_global_node_counts,
		std::vector< int > &	num_global_node_df_counts
	)

This function writes information about global node sets. .) global_nodeset_ids - vector of global node set IDs .) num_global_node_counts - vector of global node counts contained in each global node set .) num_global_df_count - vector of global distribution factors in each global node set

Must be called after put_init_global()

Definition at line 504 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, global_nodeset_ids, and nemesis_err_flag.

Referenced by initialize().

{
  // Only add nodesets if there are some
  if(global_nodeset_ids.size())
  {
    nemesis_err_flag =
      Nemesis::ne_put_ns_param_global(ex_id,
                                      &global_nodeset_ids_in[0],
                                      &num_global_node_counts_in[0],
                                      &num_global_node_df_counts_in[0]);
  }

  this->check_err(nemesis_err_flag, "Error writing global nodeset parameters!");
}

void libMesh::Nemesis_IO_Helper::put_ss_param_global	(	std::vector< int > &	global_sideset_ids,
		std::vector< int > &	num_global_side_counts,
		std::vector< int > &	num_global_side_df_counts
	)

This function writes information about global side sets. .) global_sideset_ids - vector of global side set IDs .) num_global_side_counts - vector of global side counts contained in each global side set .) num_global_df_count - vector of global distribution factors in each global side set

Must be called after put_init_global()

Definition at line 524 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_id, global_sideset_ids, and nemesis_err_flag.

Referenced by initialize().

{
  // Only add sidesets if there are some
  if(global_sideset_ids.size())
  {
    nemesis_err_flag =
      Nemesis::ne_put_ss_param_global(ex_id,
                                      &global_sideset_ids_in[0],
                                      &num_global_side_counts_in[0],
                                      &num_global_side_df_counts_in[0]);
  }

  this->check_err(nemesis_err_flag, "Error writing global sideset parameters!");
}

void libMesh::ExodusII_IO_Helper::read_block_info

(

)

[inherited]

Reads information for all of the blocks in the ExodusII mesh file.

Definition at line 352 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::block_ids, libMesh::ExodusII_IO_Helper::check_err(), EX_ELEM_BLOCK, libMesh::ExodusII_IO_Helper::ex_err, ex_get_elem_blk_ids(), ex_get_name(), libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::id_to_block_names, libMesh::ExodusII_IO_Helper::message(), and libMesh::ExodusII_IO_Helper::num_elem_blk.

Referenced by libMesh::Nemesis_IO::read(), and libMesh::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.");

  char name_buffer[MAX_STR_LENGTH+1];
  for (int i=0; i<num_elem_blk; ++i)
  {
    ex_err = exII::ex_get_name(ex_id, exII::EX_ELEM_BLOCK,
                               block_ids[i], name_buffer);
    check_err(ex_err, "Error getting block name.");
    id_to_block_names[block_ids[i]] = name_buffer;
  }
  message("All block mames retrieved successfully.");
}

void libMesh::ExodusII_IO_Helper::read_elem_in_block

(

int

block

)

[inherited]

Reads all of the element connectivity for block block in the ExodusII mesh file.

Definition at line 434 of file exodusII_io_helper.C.

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

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

{
  libmesh_assert_less (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)
    libMesh::out << "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 libMesh::ExodusII_IO_Helper::read_elem_num_map

(

)

[inherited]

Reads the optional node_num_map from the ExodusII mesh file.

Definition at line 474 of file exodusII_io_helper.C.

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

Referenced by libMesh::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)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] elem_num_map[i] = ";
      for (unsigned int i=0; i< static_cast<unsigned int>(std::min(10, num_elem-1)); ++i)
        libMesh::out << elem_num_map[i] << ", ";
      libMesh::out << "... " << elem_num_map.back() << std::endl;
    }
}

void libMesh::ExodusII_IO_Helper::read_header

(

)

[inherited]

Reads an ExodusII mesh file header.

Definition at line 270 of file exodusII_io_helper.C.

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

Referenced by libMesh::Nemesis_IO::read(), and libMesh::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 libMesh::ExodusII_IO_Helper::read_node_num_map

(

)

[inherited]

Reads the optional node_num_map from the ExodusII mesh file.

Definition at line 324 of file exodusII_io_helper.C.

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

Referenced by libMesh::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)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] node_num_map[i] = ";
      for (unsigned int i=0; i< static_cast<unsigned int>(std::min(10, num_nodes-1)); ++i)
        libMesh::out << node_num_map[i] << ", ";
      libMesh::out << "... " << node_num_map.back() << std::endl;
    }
}

void libMesh::ExodusII_IO_Helper::read_nodes

(

)

[inherited]

Reads the nodal data (x,y,z coordinates) from the ExodusII mesh file.

Definition at line 307 of file exodusII_io_helper.C.

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

Referenced by libMesh::Nemesis_IO::read(), and libMesh::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 libMesh::ExodusII_IO_Helper::read_nodeset

(

int

id

)

[inherited]

Reads information about nodeset id and inserts it into the global nodeset array at the position offset.

Definition at line 609 of file exodusII_io_helper.C.

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

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

{
  libmesh_assert_less (static_cast<unsigned int>(id), nodeset_ids.size());
  libmesh_assert_less (static_cast<unsigned int>(id), num_nodes_per_set.size());
  libmesh_assert_less (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]);

  // Don't call ex_get_node_set unless there are actually nodes there to get.
  // Exodus prints an annoying warning message in DEBUG mode otherwise...
  if (num_nodes_per_set[id] > 0)
    {
      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 libMesh::ExodusII_IO_Helper::read_nodeset_info

(

)

[inherited]

Reads information about all of the nodesets in the ExodusII mesh file.

Definition at line 538 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_err, ex_get_name(), ex_get_node_set_ids(), libMesh::ExodusII_IO_Helper::ex_id, EX_NODE_SET, libMesh::ExodusII_IO_Helper::id_to_ns_names, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::nodeset_ids, libMesh::ExodusII_IO_Helper::num_node_df_per_set, libMesh::ExodusII_IO_Helper::num_node_sets, and libMesh::ExodusII_IO_Helper::num_nodes_per_set.

Referenced by libMesh::Nemesis_IO::read(), and libMesh::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);
    }

  char name_buffer[MAX_STR_LENGTH+1];
  for (int i=0; i<num_node_sets; ++i)
  {
    ex_err = exII::ex_get_name(ex_id, exII::EX_NODE_SET,
                               nodeset_ids[i], name_buffer);
    check_err(ex_err, "Error getting node set name.");
    id_to_ns_names[nodeset_ids[i]] = name_buffer;
  }
  message("All node set mames retrieved successfully.");
}

void libMesh::ExodusII_IO_Helper::read_sideset	(	int	id,
		int	offset
	)			[inherited]

Reads information about sideset id and inserts it into the global sideset array at the position offset.

Definition at line 566 of file exodusII_io_helper.C.

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

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

{
  libmesh_assert_less (static_cast<unsigned int>(id), ss_ids.size());
  libmesh_assert_less (static_cast<unsigned int>(id), num_sides_per_set.size());
  libmesh_assert_less (static_cast<unsigned int>(id), num_df_per_set.size());
  libmesh_assert_less_equal (static_cast<unsigned int>(offset), elem_list.size());
  libmesh_assert_less_equal (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);


  // It's OK for offset==elem_list.size() as long as num_sides_per_set[id]==0
  // because in that case we don't actually read anything...
#ifdef DEBUG
  if (static_cast<unsigned int>(offset) == elem_list.size() ||
      static_cast<unsigned int>(offset) == side_list.size() )
    libmesh_assert_equal_to (num_sides_per_set[id], 0);
#endif


  // Don't call ex_get_side_set unless there are actually sides there to get.
  // Exodus prints an annoying warning in DEBUG mode otherwise...
  if (num_sides_per_set[id] > 0)
    {
      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 libMesh::ExodusII_IO_Helper::read_sideset_info

(

)

[inherited]

Reads information about all of the sidesets in the ExodusII mesh file.

Definition at line 496 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::elem_list, libMesh::ExodusII_IO_Helper::ex_err, ex_get_name(), ex_get_side_set_ids(), libMesh::ExodusII_IO_Helper::ex_id, EX_INQ_SS_ELEM_LEN, ex_inquire(), EX_SIDE_SET, libMesh::ExodusII_IO_Helper::id_list, libMesh::ExodusII_IO_Helper::id_to_ss_names, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::num_df_per_set, libMesh::ExodusII_IO_Helper::num_elem_all_sidesets, libMesh::ExodusII_IO_Helper::num_side_sets, libMesh::ExodusII_IO_Helper::num_sides_per_set, libMesh::ExodusII_IO_Helper::req_info, libMesh::ExodusII_IO_Helper::ret_char, libMesh::ExodusII_IO_Helper::ret_float, libMesh::ExodusII_IO_Helper::ret_int, libMesh::ExodusII_IO_Helper::side_list, and libMesh::ExodusII_IO_Helper::ss_ids.

Referenced by libMesh::Nemesis_IO::read(), and libMesh::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.");

      //libMesh::out << "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);
    }

  char name_buffer[MAX_STR_LENGTH+1];
  for (int i=0; i<num_side_sets; ++i)
  {
    ex_err = exII::ex_get_name(ex_id, exII::EX_SIDE_SET,
                               ss_ids[i], name_buffer);
    check_err(ex_err, "Error getting side set name.");
    id_to_ss_names[ss_ids[i]] = name_buffer;
  }
  message("All side set mames retrieved successfully.");
}

void libMesh::ExodusII_IO_Helper::use_mesh_dimension_instead_of_spatial_dimension

(

bool

val

)

[inherited]

Sets the underlying value of the boolean flag _use_mesh_dimension_instead_of_spatial_dimension. By default, the value of this flag is false.

See the ExodusII_IO class documentation for a detailed description of this flag.

Definition at line 1596 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_use_mesh_dimension_instead_of_spatial_dimension.

Referenced by libMesh::ExodusII_IO::use_mesh_dimension_instead_of_spatial_dimension().

{
  _use_mesh_dimension_instead_of_spatial_dimension = val;
}

void libMesh::ExodusII_IO_Helper::verbose

(

bool

set_verbosity

)

[inherited]

Get/set flag telling whether message printing is on or off.

Definition at line 223 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose.

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

{
  _verbose = set_verbosity;
}

void libMesh::ExodusII_IO_Helper::write_element_values	(	const MeshBase &	mesh,
		const std::vector< Number > &	values,
		int	timestep
	)			[inherited]

Writes the vector of values to the element variables.

Definition at line 1484 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::Elem::active(), libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), libMesh::ExodusII_IO_Helper::check_err(), data, end, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_elem_var(), ex_update(), libMesh::ExodusII_IO_Helper::get_block_id(), libMesh::DofObject::id(), libMesh::ExodusII_IO_Helper::num_elem, libMesh::processor_id(), and libMesh::Elem::subdomain_id().

{
  if ((_run_only_on_proc0) && (libMesh::processor_id() != 0))
    return;

  // Loop over the element blocks and write the data one block at a time
  std::map<unsigned int, std::vector<unsigned int>  > subdomain_map;

  const unsigned int num_vars = values.size() / num_elem;

  MeshBase::const_element_iterator mesh_it = mesh.active_elements_begin();
  const MeshBase::const_element_iterator end = mesh.active_elements_end();
  //loop through element and map between block and element vector
  for( ; mesh_it != end; ++mesh_it)
    {
      const Elem * elem = *mesh_it;

      //Only write out the active elements
      if(elem->active())
      {
        unsigned int cur_subdomain = elem->subdomain_id();

        subdomain_map[cur_subdomain].push_back(elem->id());
      }
    }

  for (unsigned int l=0; l < num_vars; ++l)
  {
    // The size of the subdomain map is the number of blocks.
    std::map<unsigned int, std::vector<unsigned int>  >::iterator it( subdomain_map.begin() );

    for(unsigned int j=0; it != subdomain_map.end(); ++it, ++j)
    {
      const std::vector<unsigned int> & elem_nums = (*it).second;
      const unsigned int num_elems_this_block = elem_nums.size();
      std::vector<Number> data( num_elems_this_block );
      for (unsigned int k=0; k < num_elems_this_block; ++k)
      {
        data[k] = values[l*num_elem+elem_nums[k]];
      }

      ex_err = exII::ex_put_elem_var(ex_id, timestep, l+1, get_block_id(j), num_elems_this_block, &data[0]);
      check_err(ex_err, "Error writing element values.");

    }
  }

  ex_err = exII::ex_update(ex_id);
  check_err(ex_err, "Error flushing buffers to file.");
}

void libMesh::Nemesis_IO_Helper::write_elements

(

const MeshBase &

mesh

)

[virtual]

This function is specialized to write the connectivity.

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 2322 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::ElementMaps::assign_conversion(), block_id_to_elem_connectivity, libMesh::ExodusII_IO_Helper::check_err(), libMesh::MeshBase::elem(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_elem_block(), ex_put_elem_conn(), ex_put_elem_num_map(), libMesh::ExodusII_IO_Helper::exodus_elem_num_to_libmesh, libMesh::ExodusII_IO_Helper::Conversion::exodus_elem_type(), global_elem_blk_ids, libMesh::Elem::n_nodes(), num_elem_blks_global, libMesh::ExodusII_IO_Helper::num_nodes_per_elem, subdomain_map, and libMesh::Elem::type().

Referenced by libMesh::Nemesis_IO::write(), and libMesh::Nemesis_IO::write_nodal_data().

{

  // Loop over all blocks, even if we don't have elements in each block.
  // If we don't have elements we need to write out a 0 for that block...
  for (unsigned int i=0; i<static_cast<unsigned>(this->num_elem_blks_global); ++i)
    {
      // Search for the current global block ID in the map
      std::map<int, std::vector<int> >::iterator it =
        this->block_id_to_elem_connectivity.find( this->global_elem_blk_ids[i] );

      // If not found, write a zero to file....
      if (it == this->block_id_to_elem_connectivity.end())
        {
          this->ex_err = exII::ex_put_elem_block(this->ex_id,
                                                 this->global_elem_blk_ids[i],
                                                 "Empty",
                                                 0, /* n. elements in this block */
                                                 0, /* n. nodes per element */
                                                 0);  /* number of attributes per element */

          this->check_err(this->ex_err, "Error writing element block from Nemesis.");
        }

      // Otherwise, write the actual block information and connectivity to file
      else
        {
          int block = (*it).first;
          std::vector<int> & this_block_connectivity = (*it).second;
          std::vector<unsigned int> & elements_in_this_block = subdomain_map[block];

          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(elements_in_this_block[0])->type());

          this->num_nodes_per_elem = mesh.elem(elements_in_this_block[0])->n_nodes();

          ex_err = exII::ex_put_elem_block(ex_id,
                                           block,
                                           conv.exodus_elem_type().c_str(),
                                           elements_in_this_block.size(),
                                           num_nodes_per_elem,
                                           0);
          check_err(ex_err, "Error writing element block from Nemesis.");

          ex_err = exII::ex_put_elem_conn(ex_id,
                                          block,
                                          &this_block_connectivity[0]);
          check_err(ex_err, "Error writing element connectivities from Nemesis.");
        }
    } // end loop over global block IDs

  // Only call this once, not in the loop above!
  ex_err = exII::ex_put_elem_num_map(ex_id,
    exodus_elem_num_to_libmesh.empty() ? NULL : &exodus_elem_num_to_libmesh[0]);
  check_err(ex_err, "Error writing element map");
}

void libMesh::ExodusII_IO_Helper::write_elements_discontinuous

(

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 1107 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::_verbose, libMesh::Elem::active(), libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), libMesh::ExodusII_IO_Helper::ElementMaps::assign_conversion(), libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::connect, libMesh::MeshBase::elem(), elem_id, end, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_elem_block(), ex_put_elem_conn(), ex_put_elem_num_map(), ex_update(), libMesh::ExodusII_IO_Helper::Conversion::exodus_elem_type(), libMesh::ExodusII_IO_Helper::Conversion::get_inverse_node_map(), libMesh::DofObject::id(), libMesh::ExodusII_IO_Helper::libmesh_elem_num_to_exodus, libMesh::Elem::n_nodes(), libMesh::ExodusII_IO_Helper::num_nodes_per_elem, libMesh::out, libMesh::processor_id(), libMesh::Elem::subdomain_id(), and libMesh::Elem::type().

Referenced by libMesh::ExodusII_IO::write_nodal_data_discontinuous().

{
  if ((_run_only_on_proc0) && (libMesh::processor_id() != 0))
    return;

  std::map<unsigned int, std::vector<unsigned int>  > subdomain_map;

  MeshBase::const_element_iterator mesh_it = mesh.active_elements_begin();
  const MeshBase::const_element_iterator end = mesh.active_elements_end();
  //loop through element and map between block and element vector
  for(; mesh_it != end; ++mesh_it)
    {
      const Elem * elem = *mesh_it;

      //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_out;

  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_out.push_back(elem_id);
          libmesh_elem_num_to_exodus[elem_id] = elem_num_map_out.size();

          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_inverse_node_map(j); // Inverse node map is for writing
              if (_verbose)
                {
                  libMesh::out << "Exodus node index: " << j
                                << "=LibMesh node index " << elem_node_index << std::endl;
                }
              connect[connect_index] = i*num_nodes_per_elem+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");

    // write out the element number map
    std::vector<unsigned int> elem_map(tmp_vec.size());
    std::transform(tmp_vec.begin(), tmp_vec.end(), elem_map.begin(),
                   std::bind2nd(std::plus<unsigned int>(), 1));  // Add one to each id for exodus!
    ex_err = exII::ex_put_elem_num_map(ex_id, (int *)&elem_map[0]);
    check_err(ex_err, "Error writing element map");
  }

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

  ex_err = exII::ex_update(ex_id);
  check_err(ex_err, "Error flushing buffers to file.");
}

void libMesh::Nemesis_IO_Helper::write_exodus_initialization_info	(	const MeshBase &	pmesh,
		const std::string &	title
	)			[private]

This function writes exodus-specific initialization information. This information is slightly different when you are working with Nemesis, as it depends on some global information being known.

Definition at line 913 of file nemesis_io_helper.C.

References libMesh::MeshBase::active_local_elements_begin(), libMesh::MeshBase::active_local_elements_end(), libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_init(), global_nodeset_ids, global_sideset_ids, libMesh::ExodusII_IO_Helper::num_dim, libMesh::ExodusII_IO_Helper::num_elem, libMesh::ExodusII_IO_Helper::num_elem_blk, num_elem_blks_global, libMesh::ExodusII_IO_Helper::num_node_sets, libMesh::ExodusII_IO_Helper::num_nodes, libMesh::ExodusII_IO_Helper::num_side_sets, and libMesh::MeshBase::spatial_dimension().

Referenced by initialize().

{
  // This follows the convention of Exodus: we always write out the mesh as LIBMESH_DIM-dimensional,
  // even if it is 2D...
  this->num_dim = pmesh.spatial_dimension();

  this->num_elem = static_cast<unsigned int>(std::distance (pmesh.active_local_elements_begin(),
                                                            pmesh.active_local_elements_end()));

  // Exodus will also use *global* number of side and node sets,
  // though it will not write out entries for all of them...
  this->num_side_sets =
    libmesh_cast_int<int>(this->global_sideset_ids.size());
  this->num_node_sets =
    libmesh_cast_int<int>(this->global_nodeset_ids.size());

  // We need to write the global number of blocks, even though this processor might not have
  // elements in some of them!
  this->num_elem_blk = this->num_elem_blks_global;

  ex_err = exII::ex_put_init(ex_id,
                             title_in.c_str(),
                             this->num_dim,
                             this->num_nodes,
                             this->num_elem,
                             this->num_elem_blk,
                             this->num_node_sets,
                             this->num_side_sets);

  check_err(ex_err, "Error initializing new Nemesis file.");
}

void libMesh::ExodusII_IO_Helper::write_global_values	(	const std::vector< Number > &	values,
		int	timestep
	)			[inherited]

Writes the vector of global variables.

Definition at line 1582 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_glob_vars(), ex_update(), libMesh::ExodusII_IO_Helper::num_globals, and libMesh::processor_id().

Referenced by libMesh::Nemesis_IO::write_global_data().

{
  if ((_run_only_on_proc0) && (libMesh::processor_id() != 0))
    return;

  ex_err = exII::ex_put_glob_vars(ex_id, timestep, num_globals, &values[0]);
  check_err(ex_err, "Error writing global values.");

  ex_err = exII::ex_update(ex_id);
  check_err(ex_err, "Error flushing buffers to file.");
}

void libMesh::ExodusII_IO_Helper::write_information_records

(

const std::vector< std::string > &

records

)

[inherited]

Writes the vector of information records.

Definition at line 1551 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::check_err(), libMesh::err, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_info(), ex_update(), and libMesh::processor_id().

Referenced by libMesh::Nemesis_IO::write_information_records().

{
  if ((_run_only_on_proc0) && (libMesh::processor_id() != 0))
    return;

  int num_records = records.size();
  std::vector<char*> info(num_records);

  // This is an abuse of the const char* returned by std::string, we trust that Exodus won't
  // modify these when it's writing them out...
  for (unsigned i=0; i<records.size(); ++i)
  {
    // Records cannot be longer than MAX_LINE_LENGTH, as defined in exodusII.h
    if (records[i].size() > MAX_LINE_LENGTH)
      {
        libMesh::err << "Error, cannot write records longer than " << MAX_LINE_LENGTH << " characters!" << std::endl;
        libmesh_error();
      }

    info[i] = const_cast<char*>(records[i].c_str());
  }

  ex_err = exII::ex_put_info(ex_id, num_records, &info[0]);
  check_err(ex_err, "Error writing global values.");

  ex_err = exII::ex_update(ex_id);
  check_err(ex_err, "Error flushing buffers to file.");
}

void libMesh::Nemesis_IO_Helper::write_nodal_coordinates

(

const MeshBase &

mesh

)

[virtual]

This function is specialized from ExodusII_IO_Helper to write only the nodal coordinates stored on the local piece of the Mesh.

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 2278 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_coord(), ex_put_node_num_map(), libMesh::ExodusII_IO_Helper::exodus_node_num_to_libmesh, libMesh::MeshBase::node_ptr(), libMesh::ExodusII_IO_Helper::x, libMesh::ExodusII_IO_Helper::y, and libMesh::ExodusII_IO_Helper::z.

Referenced by libMesh::Nemesis_IO::write(), and libMesh::Nemesis_IO::write_nodal_data().

{
  // Make sure that the reference passed in is really a ParallelMesh
  // const ParallelMesh& pmesh = libmesh_cast_ref<const ParallelMesh&>(mesh);

  unsigned local_num_nodes = this->exodus_node_num_to_libmesh.size();

  x.resize(local_num_nodes);
  y.resize(local_num_nodes);
  z.resize(local_num_nodes);

  // Just loop over our list outputing the nodes the way we built the map
  for (unsigned int i=0; i<local_num_nodes; ++i)
  {
    const Node & node = *mesh.node_ptr(this->exodus_node_num_to_libmesh[i]);
    x[i]=node(0);
    y[i]=node(1);
    z[i]=node(2);
  }

  if (local_num_nodes)
    {
      // Call Exodus API to write nodal coordinates...
      ex_err = exII::ex_put_coord(ex_id, &x[0], &y[0], &z[0]);
      check_err(ex_err, "Error writing node coordinates");

      // And write the nodal map we created for them
      ex_err = exII::ex_put_node_num_map(ex_id, &(this->exodus_node_num_to_libmesh[0]));
      check_err(ex_err, "Error writing node num map");
    }
  else // Does the Exodus API want us to write empty nodal coordinates?
    {
      ex_err = exII::ex_put_coord(ex_id, NULL, NULL, NULL);
      check_err(ex_err, "Error writing empty node coordinates");

      ex_err = exII::ex_put_node_num_map(ex_id, NULL);
      check_err(ex_err, "Error writing empty node num map");
    }
}

void libMesh::ExodusII_IO_Helper::write_nodal_coordinates_discontinuous

(

const MeshBase &

mesh

)

[inherited]

Writes the nodal coordinates contained in "mesh"

Definition at line 958 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), libMesh::ExodusII_IO_Helper::check_err(), end, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_coord(), libMesh::ExodusII_IO_Helper::num_nodes, libMesh::processor_id(), libMesh::ExodusII_IO_Helper::x, libMesh::ExodusII_IO_Helper::y, and libMesh::ExodusII_IO_Helper::z.

Referenced by libMesh::ExodusII_IO::write_nodal_data_discontinuous().

{
  if ((_run_only_on_proc0) && (libMesh::processor_id() != 0))
    return;

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

  MeshBase::const_element_iterator       it  = mesh.active_elements_begin();
  const MeshBase::const_element_iterator end = mesh.active_elements_end();

  unsigned int i = 0;
  for ( ; it != end; ++it)
        for (unsigned int n=0; n<(*it)->n_nodes(); n++)
    {
      x[i]=(*it)->point(n)(0);
#if LIBMESH_DIM > 1
      y[i]=(*it)->point(n)(1);
#else
      y[i]=0.;
#endif
#if LIBMESH_DIM > 2
      z[i]=(*it)->point(n)(2);
#else
      z[i]=0.;
#endif
      i++;
    }

  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 libMesh::Nemesis_IO_Helper::write_nodal_solution	(	const std::vector< Number > &	values,
		const std::vector< std::string >	names,
		int	timestep
	)

Takes a solution vector containing the solution for all variables and outputs it to the files

Definition at line 2388 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::exodus_node_num_to_libmesh, libMesh::ExodusII_IO_Helper::num_nodes, and libMesh::ExodusII_IO_Helper::write_nodal_values().

Referenced by libMesh::Nemesis_IO::write_nodal_data().

{
  int num_vars = names.size();
  //int num_values = values.size(); // Not used?

  for (int c=0; c<num_vars; c++)
  {
    std::vector<Number> cur_soln(num_nodes);

    //Copy out this variable's solution
    for(int i=0; i<num_nodes; i++)
      cur_soln[i] = values[this->exodus_node_num_to_libmesh[i]*num_vars + c];

    write_nodal_values(c+1,cur_soln,timestep);
  }
}

void libMesh::ExodusII_IO_Helper::write_nodal_values	(	int	var_id,
		const std::vector< Number > &	values,
		int	timestep
	)			[inherited]

Writes the vector of values to a nodal variable.

Definition at line 1537 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_nodal_var(), ex_update(), libMesh::ExodusII_IO_Helper::num_nodes, and libMesh::processor_id().

Referenced by libMesh::ExodusII_IO::write_nodal_data_discontinuous(), and write_nodal_solution().

{
  if ((_run_only_on_proc0) && (libMesh::processor_id() != 0))
    return;

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

  ex_err = exII::ex_update(ex_id);
  check_err(ex_err, "Error flushing buffers to file.");
}

void libMesh::Nemesis_IO_Helper::write_nodesets

(

const MeshBase &

mesh

)

[virtual]

Writes the nodesets for this processor.

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 1990 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::MeshBase::boundary_info, libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_node_set(), ex_put_node_set_param(), global_nodeset_ids, libMesh::ExodusII_IO_Helper::libmesh_node_num_to_exodus, libMesh::out, and libMesh::processor_id().

Referenced by libMesh::Nemesis_IO::write(), and libMesh::Nemesis_IO::write_nodal_data().

{
  // Write the nodesets.  In Nemesis, the idea is to "create space" for the global
  // set of boundary nodesets, but to only write node IDs which are local to the current
  // processor.  This is what is done in Nemesis files created by the "loadbal" script.

  // Store a map of vectors for boundary node IDs on this processor.
  // Use a vector of int here so it can be passed directly to Exodus.
  std::map<boundary_id_type, std::vector<int> > local_node_boundary_id_lists;
  typedef std::map<boundary_id_type, std::vector<int> >::iterator local_node_boundary_id_lists_iterator;

  // FIXME: We should build this list only one time!!  We already built it above, but we
  // did not have the libmesh to exodus node mapping at that time... for now we'll just
  // build it here again, hopefully it's small relative to the size of the entire mesh.
  std::vector<dof_id_type> boundary_node_list;
  std::vector<boundary_id_type> boundary_node_boundary_id_list;
  mesh.boundary_info->build_node_list(boundary_node_list, boundary_node_boundary_id_list);

  if (_verbose)
    {
      libMesh::out << "[" << libMesh::processor_id() << "] boundary_node_list.size()="
                   << boundary_node_list.size() << std::endl;
      libMesh::out << "[" << libMesh::processor_id() << "] (boundary_node_id, boundary_id) = ";
      for (unsigned i=0; i<boundary_node_list.size(); ++i)
        {
          libMesh::out << "(" << boundary_node_list[i] << ", " << boundary_node_boundary_id_list[i] << ") ";
        }
      libMesh::out << std::endl;
    }

  // For each node in the node list, add it to the vector of node IDs for that
  // set for the local processor.  This will be used later when writing Exodus
  // nodesets.
  for (unsigned i=0; i<boundary_node_list.size(); ++i)
    {
      // Don't try to grab a reference to the vector unless the current node is attached
      // to a local element.  Otherwise, another processor will be responsible for writing it in its nodeset.
      std::map<int, int>::iterator it = this->libmesh_node_num_to_exodus.find( boundary_node_list[i] );

      if ( it != this->libmesh_node_num_to_exodus.end() )
        {
          // Get reference to the vector where this node ID will be inserted.  If it
          // doesn't yet exist, this will create it.
          std::vector<int>& current_id_set = local_node_boundary_id_lists[ boundary_node_boundary_id_list[i] ];

          // Push back Exodus-mapped node ID for this set
          // TODO: reserve space in these vectors somehow.
          current_id_set.push_back( (*it).second );
        }
    }

  // See what we got
  if (_verbose)
    {
      for(std::map<boundary_id_type, std::vector<int> >::iterator it = local_node_boundary_id_lists.begin();
          it != local_node_boundary_id_lists.end();
          ++it)
        {
          libMesh::out << "[" << libMesh::processor_id() << "] ID: " << (*it).first << ", ";

          std::vector<int>& current_id_set = (*it).second;

          // Libmesh node ID (Exodus Node ID)
          for (unsigned j=0; j<current_id_set.size(); ++j)
            libMesh::out << current_id_set[j]
                         << ", ";

          libMesh::out << std::endl;
        }
    }

  // Loop over *global* nodeset IDs, call the Exodus API.  Note that some nodesets may be empty
  // for a given processor.
  for (unsigned i=0; i<this->global_nodeset_ids.size(); ++i)
    {
      if (_verbose)
        {
          libMesh::out << "[" << libMesh::processor_id()
                       << "] Writing out Exodus nodeset info for ID: " << global_nodeset_ids[i] << std::endl;
        }

      // Convert current global_nodeset_id into an exodus ID, which can't be zero...
      int exodus_id = global_nodeset_ids[i];

/*
      // Exodus can't handle zero nodeset IDs (?)  Use max short here since
      // when libmesh reads it back in, it will want to store it as a short...
      if (exodus_id==0)
        exodus_id = std::numeric_limits<short>::max();
*/

      // Try to find this boundary ID in the local list we created
      local_node_boundary_id_lists_iterator it =
        local_node_boundary_id_lists.find(this->global_nodeset_ids[i]);

      // No nodes found for this boundary ID on this processor
      if (it == local_node_boundary_id_lists.end())
        {
          if (_verbose)
            libMesh::out << "[" << libMesh::processor_id()
                         << "] No nodeset data for ID: " << global_nodeset_ids[i]
                         << " on this processor." << std::endl;

          // Call the Exodus interface to write the parameters of this node set
          this->ex_err = exII::ex_put_node_set_param(this->ex_id,
                                                     exodus_id,
                                                     0, /* No nodes for this ID */
                                                     0  /* No distribution factors */);
          this->check_err(this->ex_err, "Error writing nodeset parameters in Nemesis");

        }
      else // Boundary ID *was* found in list
        {
          // Get reference to the vector of node IDs
          std::vector<int>& current_nodeset_ids = (*it).second;

          // Call the Exodus interface to write the parameters of this node set
          this->ex_err = exII::ex_put_node_set_param(this->ex_id,
                                                     exodus_id,
                                                     current_nodeset_ids.size(),
                                                     0  /* No distribution factors */);

          this->check_err(this->ex_err, "Error writing nodeset parameters in Nemesis");

          // Call Exodus interface to write the actual node IDs for this boundary ID
          this->ex_err = exII::ex_put_node_set(this->ex_id,
                                               exodus_id,
                                               &current_nodeset_ids[0]);

          this->check_err(this->ex_err, "Error writing nodesets in Nemesis");

        }
    } // end loop over global nodeset IDs
}

void libMesh::Nemesis_IO_Helper::write_sidesets

(

const MeshBase &

mesh

)

[virtual]

Writes the sidesets for this processor.

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 2128 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_verbose, libMesh::Elem::active_family_tree_by_side(), libMesh::ExodusII_IO_Helper::ElementMaps::assign_conversion(), libMesh::MeshBase::boundary_info, libMesh::ExodusII_IO_Helper::check_err(), libMesh::MeshBase::elem(), libMesh::err, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_side_set(), ex_put_side_set_param(), libMesh::ExodusII_IO_Helper::Conversion::get_inverse_side_map(), global_sideset_ids, libMesh::ExodusII_IO_Helper::libmesh_elem_num_to_exodus, libMesh::out, libMesh::processor_id(), and libMesh::DofObject::processor_id().

Referenced by libMesh::Nemesis_IO::write(), and libMesh::Nemesis_IO::write_nodal_data().

{
  // Write the sidesets.  In Nemesis, the idea is to "create space" for the global
  // set of boundary sidesets, but to only write sideset IDs which are local to the current
  // processor.  This is what is done in Nemesis files created by the "loadbal" script.
  // See also: ExodusII_IO_Helper::write_sidesets()...


  // Store a map of vectors for boundary side IDs on this processor.
  // Use a vector of int here so it can be passed directly to Exodus.
  std::map<boundary_id_type, std::vector<int> > local_elem_boundary_id_lists;
  std::map<boundary_id_type, std::vector<int> > local_elem_boundary_id_side_lists;
  typedef std::map<boundary_id_type, std::vector<int> >::iterator local_elem_boundary_id_lists_iterator;

  ExodusII_IO_Helper::ElementMaps em;

  // FIXME: We already built this list once, we should reuse that information!
  std::vector< dof_id_type > bndry_elem_list;
  std::vector< unsigned short int > bndry_side_list;
  std::vector< boundary_id_type > bndry_id_list;

  mesh.boundary_info->build_side_list(bndry_elem_list, bndry_side_list, bndry_id_list);

  // Integer looping, skipping non-local elements
  for (unsigned i=0; i<bndry_elem_list.size(); ++i)
    {
      // Get pointer to current Elem
      const Elem* elem = mesh.elem(bndry_elem_list[i]);

      // If element is local, process it
      if (elem->processor_id() == libMesh::processor_id())
        {
          std::vector<const Elem*> family;
#ifdef LIBMESH_ENABLE_AMR
          // We need to build up active elements if AMR is enabled and add
          // them to the exodus sidesets instead of the potentially inactive "parent" elements
          // Technically we don't need to "reset" the tree since the vector was just created.
          elem->active_family_tree_by_side(family, bndry_side_list[i], /*reset tree=*/false);
#else
          // If AMR is not even enabled, just push back the element itself
          family.push_back( elem );
#endif

          // Loop over all the elements in the family tree, store their converted IDs
          // and side IDs to the map's vectors.  TODO: Somehow reserve enough space for these
          // push_back's...
          for(unsigned int j=0; j<family.size(); ++j)
            {
              const ExodusII_IO_Helper::Conversion conv = em.assign_conversion(mesh.elem(family[j]->id())->type());

              // Use the libmesh to exodus datastructure map to get the proper sideset IDs
              // The datastructure contains the "collapsed" contiguous ids.
              //
              // We know the parent element is local, but let's be absolutely sure that all the children have been
              // actually mapped to Exodus IDs before we blindly try to add them...
              std::map<int,int>::iterator it = this->libmesh_elem_num_to_exodus.find( family[j]->id() );
              if (it != this->libmesh_elem_num_to_exodus.end())
                {
                  local_elem_boundary_id_lists[ bndry_id_list[i] ].push_back( (*it).second );
                  local_elem_boundary_id_side_lists[ bndry_id_list[i] ].push_back(conv.get_inverse_side_map( bndry_side_list[i] ));
                }
              else
                {
                  libMesh::err << "Error, no Exodus mapping for Elem "
                               << family[j]->id()
                               << " on processor "
                               << libMesh::processor_id()
                               << std::endl;
                  libmesh_error();
                }
            }
        }
    }


  // Loop over *global* sideset IDs, call the Exodus API.  Note that some sidesets may be empty
  // for a given processor.
  for (unsigned i=0; i<this->global_sideset_ids.size(); ++i)
    {
      if (_verbose)
        {
          libMesh::out << "[" << libMesh::processor_id()
                       << "] Writing out Exodus sideset info for ID: " << global_sideset_ids[i] << std::endl;
        }

      // Convert current global_sideset_id into an exodus ID, which can't be zero...
      int exodus_id = global_sideset_ids[i];

/*
      // Exodus can't handle zero sideset IDs (?)  Use max short here since
      // when libmesh reads it back in, it will want to store it as a short...
      if (exodus_id==0)
        exodus_id = std::numeric_limits<short>::max();
*/

      // Try to find this boundary ID in the local list we created
      local_elem_boundary_id_lists_iterator it =
        local_elem_boundary_id_lists.find(this->global_sideset_ids[i]);

      // No sides found for this boundary ID on this processor
      if (it == local_elem_boundary_id_lists.end())
        {
          if (_verbose)
            libMesh::out << "[" << libMesh::processor_id()
                         << "] No sideset data for ID: " << global_sideset_ids[i]
                         << " on this processor." << std::endl;

          // Call the Exodus interface to write the parameters of this side set
          this->ex_err = exII::ex_put_side_set_param(this->ex_id,
                                                     exodus_id,
                                                     0, /* No sides for this ID */
                                                     0  /* No distribution factors */);
          this->check_err(this->ex_err, "Error writing sideset parameters in Nemesis");

        }
      else // Boundary ID *was* found in list
        {
          // Get iterator to sides vector as well
          local_elem_boundary_id_lists_iterator it_sides =
            local_elem_boundary_id_side_lists.find(this->global_sideset_ids[i]);

          libmesh_assert (it_sides != local_elem_boundary_id_side_lists.end());

          // Get reference to the vector of elem IDs
          std::vector<int>& current_sideset_elem_ids = (*it).second;

          // Get reference to the vector of side IDs
          std::vector<int>& current_sideset_side_ids = (*it_sides).second;

          // Call the Exodus interface to write the parameters of this side set
          this->ex_err = exII::ex_put_side_set_param(this->ex_id,
                                                     exodus_id,
                                                     current_sideset_elem_ids.size(),
                                                     0  /* No distribution factors */);

          this->check_err(this->ex_err, "Error writing sideset parameters in Nemesis");

          // Call Exodus interface to write the actual side IDs for this boundary ID
          this->ex_err = exII::ex_put_side_set(this->ex_id,
                                               exodus_id,
                                               &current_sideset_elem_ids[0],
                                               &current_sideset_side_ids[0]);

          this->check_err(this->ex_err, "Error writing sidesets in Nemesis");
        }
    } // end for loop over global sideset IDs
}

void libMesh::ExodusII_IO_Helper::write_timestep	(	int	timestep,
		Real	time
	)			[inherited]

Writes the time for the timestep

Definition at line 1470 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::check_err(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_time(), ex_update(), and libMesh::processor_id().

Referenced by libMesh::Nemesis_IO::write_timestep().

{
  if ((_run_only_on_proc0) && (libMesh::processor_id() != 0))
    return;

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

  ex_err = exII::ex_update(ex_id);
  check_err(ex_err, "Error flushing buffers to file.");
}

---

Member Data Documentation

bool libMesh::ExodusII_IO_Helper::_created [protected, inherited]

Definition at line 700 of file exodusII_io_helper.h.

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

bool libMesh::ExodusII_IO_Helper::_elem_vars_initialized [protected, inherited]

Definition at line 703 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize_element_variables().

bool libMesh::ExodusII_IO_Helper::_global_vars_initialized [protected, inherited]

Definition at line 704 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize_global_variables().

bool libMesh::ExodusII_IO_Helper::_run_only_on_proc0 [protected, inherited]

Definition at line 702 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::close(), libMesh::ExodusII_IO_Helper::create(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements_discontinuous(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), and libMesh::ExodusII_IO_Helper::write_timestep().

bool libMesh::ExodusII_IO_Helper::_use_mesh_dimension_instead_of_spatial_dimension [protected, inherited]

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

Definition at line 711 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), and libMesh::ExodusII_IO_Helper::use_mesh_dimension_instead_of_spatial_dimension().

bool libMesh::ExodusII_IO_Helper::_verbose [protected, inherited]

Definition at line 701 of file exodusII_io_helper.h.

Referenced by build_element_and_node_maps(), compute_border_node_ids(), compute_communication_map_parameters(), compute_internal_and_border_elems_and_internal_nodes(), compute_node_communication_maps(), compute_num_global_elem_blocks(), compute_num_global_nodesets(), compute_num_global_sidesets(), construct_nemesis_filename(), create(), libMesh::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(), libMesh::ExodusII_IO_Helper::get_nodal_var_names(), get_node_cmap(), get_node_map(), get_ns_param_global(), get_ss_param_global(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::open(), libMesh::ExodusII_IO_Helper::print_header(), put_node_cmap(), libMesh::ExodusII_IO_Helper::read_elem_in_block(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::ExodusII_IO_Helper::verbose(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements_discontinuous(), write_nodesets(), and write_sidesets().

std::map<int, std::vector<int> > libMesh::Nemesis_IO_Helper::block_id_to_elem_connectivity

This is the block connectivity, i.e. for each subdomain (block) there is an element connectivity list. This map associates the block ID to that vector.

Definition at line 391 of file nemesis_io_helper.h.

Referenced by build_element_and_node_maps(), and write_elements().

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

Definition at line 640 of file exodusII_io_helper.h.

Referenced by build_element_and_node_maps(), libMesh::ExodusII_IO_Helper::get_block_id(), libMesh::ExodusII_IO_Helper::get_block_name(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO_Helper::read_block_info(), libMesh::ExodusII_IO_Helper::read_elem_in_block(), and libMesh::ExodusII_IO_Helper::write_elements().

std::set<unsigned> libMesh::Nemesis_IO_Helper::border_elem_ids [private]

A set of border elem IDs for this processor.

Definition at line 568 of file nemesis_io_helper.h.

Referenced by compute_element_maps(), and compute_internal_and_border_elems_and_internal_nodes().

std::set<unsigned> libMesh::Nemesis_IO_Helper::border_node_ids [private]

The set which will eventually contain the IDs of "border nodes". These are nodes that lie on the boundary between one or more processors.

Definition at line 531 of file nemesis_io_helper.h.

Referenced by compute_border_node_ids(), compute_internal_and_border_elems_and_internal_nodes(), and compute_node_maps().

int libMesh::ExodusII_IO_Helper::comp_ws [inherited]

Definition at line 623 of file exodusII_io_helper.h.

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

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

Definition at line 641 of file exodusII_io_helper.h.

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

std::vector<int> libMesh::Nemesis_IO_Helper::elem_cmap_elem_cnts

Definition at line 493 of file nemesis_io_helper.h.

Referenced by compute_communication_map_parameters(), get_cmap_params(), get_elem_cmap(), and initialize().

std::vector<std::vector<int> > libMesh::Nemesis_IO_Helper::elem_cmap_elem_ids

3 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 513 of file nemesis_io_helper.h.

Referenced by compute_elem_communication_maps(), get_elem_cmap(), and initialize().

std::vector<int> libMesh::Nemesis_IO_Helper::elem_cmap_ids

Definition at line 492 of file nemesis_io_helper.h.

Referenced by compute_communication_map_parameters(), compute_elem_communication_maps(), get_cmap_params(), get_elem_cmap(), initialize(), and put_elem_cmap().

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

Definition at line 515 of file nemesis_io_helper.h.

Referenced by compute_elem_communication_maps(), get_elem_cmap(), and initialize().

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

Definition at line 514 of file nemesis_io_helper.h.

Referenced by compute_elem_communication_maps(), get_elem_cmap(), and initialize().

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

Definition at line 648 of file exodusII_io_helper.h.

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

std::vector<int> libMesh::Nemesis_IO_Helper::elem_mapb

Vector which stores border element IDs. Will have length num_border_elems. To be used with Nemesis::ne_get_elem_map().

Definition at line 458 of file nemesis_io_helper.h.

Referenced by compute_element_maps(), get_elem_map(), and initialize().

std::vector<int> libMesh::Nemesis_IO_Helper::elem_mapi

Vector which stores internal element IDs. Will have length num_internal_elems. To be used with Nemesis::ne_get_elem_map().

Definition at line 451 of file nemesis_io_helper.h.

Referenced by compute_element_maps(), get_elem_map(), and initialize().

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

Definition at line 653 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_elem_num_map().

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

Definition at line 662 of file exodusII_io_helper.h.

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

int libMesh::ExodusII_IO_Helper::ex_err [inherited]

Definition at line 626 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::close(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::ExodusII_IO_Helper::inquire(), libMesh::ExodusII_IO_Helper::read_block_info(), libMesh::ExodusII_IO_Helper::read_elem_in_block(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_header(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::ExodusII_IO_Helper::read_nodes(), libMesh::ExodusII_IO_Helper::read_nodeset(), libMesh::ExodusII_IO_Helper::read_nodeset_info(), libMesh::ExodusII_IO_Helper::read_sideset(), libMesh::ExodusII_IO_Helper::read_sideset_info(), libMesh::Nemesis_IO::write(), libMesh::ExodusII_IO_Helper::write_element_values(), write_elements(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements_discontinuous(), write_exodus_initialization_info(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::ExodusII_IO_Helper::write_information_records(), write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_timestep(), and ~Nemesis_IO_Helper().

int libMesh::ExodusII_IO_Helper::ex_id [inherited]

Definition at line 625 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::close(), create(), libMesh::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(), libMesh::ExodusII_IO_Helper::get_nodal_var_names(), libMesh::ExodusII_IO_Helper::get_nodal_var_values(), get_node_cmap(), get_node_map(), get_ns_param_global(), get_ss_param_global(), libMesh::ExodusII_IO_Helper::get_time_steps(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::ExodusII_IO_Helper::inquire(), libMesh::ExodusII_IO_Helper::open(), put_cmap_params(), put_eb_info_global(), put_elem_cmap(), put_elem_map(), put_init_global(), put_init_info(), put_loadbal_param(), put_n_coord(), put_node_cmap(), put_node_map(), put_ns_param_global(), put_ss_param_global(), libMesh::ExodusII_IO_Helper::read_block_info(), libMesh::ExodusII_IO_Helper::read_elem_in_block(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_header(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::ExodusII_IO_Helper::read_nodes(), libMesh::ExodusII_IO_Helper::read_nodeset(), libMesh::ExodusII_IO_Helper::read_nodeset_info(), libMesh::ExodusII_IO_Helper::read_sideset(), libMesh::ExodusII_IO_Helper::read_sideset_info(), libMesh::Nemesis_IO::write(), libMesh::ExodusII_IO_Helper::write_element_values(), write_elements(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements_discontinuous(), write_exodus_initialization_info(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::ExodusII_IO_Helper::write_information_records(), write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_timestep(), and ~Nemesis_IO_Helper().

float libMesh::ExodusII_IO_Helper::ex_version [inherited]

Definition at line 654 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::open().

std::vector<int> libMesh::ExodusII_IO_Helper::exodus_elem_num_to_libmesh [inherited]

Definition at line 667 of file exodusII_io_helper.h.

Referenced by build_element_and_node_maps(), and write_elements().

std::vector<int> libMesh::ExodusII_IO_Helper::exodus_node_num_to_libmesh [inherited]

Definition at line 675 of file exodusII_io_helper.h.

Referenced by build_element_and_node_maps(), write_nodal_coordinates(), and write_nodal_solution().

char libMesh::Nemesis_IO_Helper::ftype

The 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 343 of file nemesis_io_helper.h.

Referenced by get_init_info().

std::vector<int> libMesh::Nemesis_IO_Helper::global_elem_blk_cnts

Definition at line 375 of file nemesis_io_helper.h.

Referenced by compute_num_global_elem_blocks(), get_eb_info_global(), and initialize().

std::vector<int> libMesh::Nemesis_IO_Helper::global_elem_blk_ids

Read 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 374 of file nemesis_io_helper.h.

Referenced by compute_num_global_elem_blocks(), get_eb_info_global(), initialize(), and write_elements().

std::vector<int> libMesh::Nemesis_IO_Helper::global_nodeset_ids

Containers 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 364 of file nemesis_io_helper.h.

Referenced by compute_num_global_nodesets(), get_ns_param_global(), initialize(), put_ns_param_global(), write_exodus_initialization_info(), and write_nodesets().

std::vector<int> libMesh::Nemesis_IO_Helper::global_sideset_ids

Containers 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 352 of file nemesis_io_helper.h.

Referenced by compute_num_global_sidesets(), get_ss_param_global(), initialize(), put_ss_param_global(), libMesh::Nemesis_IO::read(), write_exodus_initialization_info(), and write_sidesets().

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

Definition at line 651 of file exodusII_io_helper.h.

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

std::map<int, std::string> libMesh::ExodusII_IO_Helper::id_to_block_names [inherited]

Maps of Ids to named entities

Definition at line 695 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_block_name(), and libMesh::ExodusII_IO_Helper::read_block_info().

std::map<int, std::string> libMesh::ExodusII_IO_Helper::id_to_ns_names [inherited]

Definition at line 697 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_node_set_name(), and libMesh::ExodusII_IO_Helper::read_nodeset_info().

std::map<int, std::string> libMesh::ExodusII_IO_Helper::id_to_ss_names [inherited]

Definition at line 696 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_side_set_name(), and libMesh::ExodusII_IO_Helper::read_sideset_info().

std::set<unsigned> libMesh::Nemesis_IO_Helper::internal_elem_ids [private]

A set of internal elem IDs for this processor.

Definition at line 563 of file nemesis_io_helper.h.

Referenced by compute_element_maps(), and compute_internal_and_border_elems_and_internal_nodes().

std::set<unsigned> libMesh::Nemesis_IO_Helper::internal_node_ids [private]

A set of internal node IDs for this processor.

Definition at line 558 of file nemesis_io_helper.h.

Referenced by compute_internal_and_border_elems_and_internal_nodes(), and compute_node_maps().

int libMesh::ExodusII_IO_Helper::io_ws [inherited]

Definition at line 624 of file exodusII_io_helper.h.

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

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

Definition at line 666 of file exodusII_io_helper.h.

Referenced by build_element_and_node_maps(), compute_elem_communication_maps(), compute_element_maps(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements_discontinuous(), write_sidesets(), and libMesh::ExodusII_IO_Helper::write_sidesets().

std::map<int, int> libMesh::ExodusII_IO_Helper::libmesh_node_num_to_exodus [inherited]

Map of all node numbers connected to local node numbers to their exodus numbering.

The exodus numbers are stored in here starting with 1

Definition at line 674 of file exodusII_io_helper.h.

Referenced by build_element_and_node_maps(), compute_node_communication_maps(), compute_node_maps(), and write_nodesets().

std::map<subdomain_id_type, unsigned> libMesh::Nemesis_IO_Helper::local_subdomain_counts [private]

This map keeps track of the number of elements in each subdomain (block) for *this* processor.

Definition at line 525 of file nemesis_io_helper.h.

Referenced by build_element_and_node_maps(), and compute_num_global_elem_blocks().

int libMesh::Nemesis_IO_Helper::nemesis_err_flag

Member data 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 313 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(), get_ss_param_global(), put_cmap_params(), put_eb_info_global(), put_elem_cmap(), put_elem_map(), put_init_global(), put_init_info(), put_loadbal_param(), put_n_coord(), put_node_cmap(), put_node_map(), put_ns_param_global(), and put_ss_param_global().

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

Definition at line 681 of file exodusII_io_helper.h.

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

std::vector<Real> libMesh::ExodusII_IO_Helper::nodal_var_values [inherited]

Definition at line 682 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_nodal_var_values().

std::vector<int> libMesh::Nemesis_IO_Helper::node_cmap_ids

Vectors 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 490 of file nemesis_io_helper.h.

Referenced by compute_communication_map_parameters(), compute_node_communication_maps(), get_cmap_params(), get_node_cmap(), initialize(), put_cmap_params(), put_node_cmap(), and libMesh::Nemesis_IO::read().

std::vector<int> libMesh::Nemesis_IO_Helper::node_cmap_node_cnts

Definition at line 491 of file nemesis_io_helper.h.

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

std::vector<std::vector<int> > libMesh::Nemesis_IO_Helper::node_cmap_node_ids

2 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 504 of file nemesis_io_helper.h.

Referenced by compute_node_communication_maps(), get_node_cmap(), initialize(), and libMesh::Nemesis_IO::read().

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

Definition at line 505 of file nemesis_io_helper.h.

Referenced by compute_node_communication_maps(), get_node_cmap(), initialize(), and libMesh::Nemesis_IO::read().

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

Definition at line 650 of file exodusII_io_helper.h.

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

std::vector<int> libMesh::Nemesis_IO_Helper::node_mapb

Vector which stores border node IDs. Will have length num_border_nodes. To be used with Nemesis::ne_get_node_map().

Definition at line 474 of file nemesis_io_helper.h.

Referenced by compute_node_maps(), get_node_map(), initialize(), and libMesh::Nemesis_IO::read().

std::vector<int> libMesh::Nemesis_IO_Helper::node_mape

Vector which stores external node IDs. Will have length num_external_nodes. To be used with Nemesis::ne_get_node_map().

Definition at line 481 of file nemesis_io_helper.h.

Referenced by compute_node_maps(), get_node_map(), initialize(), and libMesh::Nemesis_IO::read().

std::vector<int> libMesh::Nemesis_IO_Helper::node_mapi

Vector which stores internal node IDs. Will have length num_internal_nodes. To be used with Nemesis::ne_get_node_map().

Definition at line 467 of file nemesis_io_helper.h.

Referenced by compute_node_maps(), get_node_map(), initialize(), and libMesh::Nemesis_IO::read().

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

Definition at line 652 of file exodusII_io_helper.h.

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

std::set<int> libMesh::Nemesis_IO_Helper::nodes_attached_to_local_elems

libMesh numbered node ids attached to local elems.

Definition at line 380 of file nemesis_io_helper.h.

Referenced by build_element_and_node_maps(), and compute_internal_and_border_elems_and_internal_nodes().

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

Definition at line 643 of file exodusII_io_helper.h.

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

int libMesh::ExodusII_IO_Helper::num_attr [inherited]

Definition at line 636 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_elem_in_block().

int libMesh::Nemesis_IO_Helper::num_border_elems

The 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 428 of file nemesis_io_helper.h.

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

int libMesh::Nemesis_IO_Helper::num_border_nodes

The 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 408 of file nemesis_io_helper.h.

Referenced by compute_border_node_ids(), compute_internal_and_border_elems_and_internal_nodes(), get_loadbal_param(), get_node_map(), initialize(), and libMesh::Nemesis_IO::read().

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

Definition at line 646 of file exodusII_io_helper.h.

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

int libMesh::ExodusII_IO_Helper::num_dim [inherited]

Definition at line 627 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_num_dim(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::ExodusII_IO_Helper::read_header(), and write_exodus_initialization_info().

int libMesh::ExodusII_IO_Helper::num_elem [inherited]

Definition at line 630 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_num_elem(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_header(), libMesh::ExodusII_IO_Helper::write_element_values(), and write_exodus_initialization_info().

int libMesh::ExodusII_IO_Helper::num_elem_all_sidesets [inherited]

Definition at line 639 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::print_sideset_info(), libMesh::Nemesis_IO::read(), and libMesh::ExodusII_IO_Helper::read_sideset_info().

int libMesh::ExodusII_IO_Helper::num_elem_blk [inherited]

Definition at line 631 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_num_elem_blk(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO_Helper::read_block_info(), libMesh::ExodusII_IO_Helper::read_header(), libMesh::ExodusII_IO_Helper::write_elements(), and write_exodus_initialization_info().

int libMesh::Nemesis_IO_Helper::num_elem_blks_global

Definition at line 321 of file nemesis_io_helper.h.

Referenced by compute_num_global_elem_blocks(), get_eb_info_global(), get_init_global(), initialize(), write_elements(), and write_exodus_initialization_info().

int libMesh::Nemesis_IO_Helper::num_elem_cmaps

The 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 442 of file nemesis_io_helper.h.

Referenced by compute_communication_map_parameters(), compute_elem_communication_maps(), compute_internal_and_border_elems_and_internal_nodes(), get_cmap_params(), get_elem_cmap(), get_loadbal_param(), initialize(), and libMesh::Nemesis_IO::read().

int libMesh::ExodusII_IO_Helper::num_elem_this_blk [inherited]

Definition at line 634 of file exodusII_io_helper.h.

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

int libMesh::ExodusII_IO_Helper::num_elem_vars [inherited]

Definition at line 684 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize_element_variables().

int libMesh::Nemesis_IO_Helper::num_elems_global

Definition at line 320 of file nemesis_io_helper.h.

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

int libMesh::Nemesis_IO_Helper::num_external_nodes

The 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 415 of file nemesis_io_helper.h.

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

std::vector<int> libMesh::Nemesis_IO_Helper::num_global_node_counts

Definition at line 365 of file nemesis_io_helper.h.

Referenced by compute_num_global_nodesets(), get_ns_param_global(), and initialize().

std::vector<int> libMesh::Nemesis_IO_Helper::num_global_node_df_counts

Definition at line 366 of file nemesis_io_helper.h.

Referenced by get_ns_param_global(), and initialize().

std::vector<int> libMesh::Nemesis_IO_Helper::num_global_side_counts

Definition at line 353 of file nemesis_io_helper.h.

Referenced by compute_num_global_sidesets(), get_ss_param_global(), initialize(), and libMesh::Nemesis_IO::read().

std::vector<int> libMesh::Nemesis_IO_Helper::num_global_side_df_counts

Definition at line 354 of file nemesis_io_helper.h.

Referenced by get_ss_param_global(), and initialize().

int libMesh::ExodusII_IO_Helper::num_globals [inherited]

Definition at line 628 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_num_globals(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), and libMesh::ExodusII_IO_Helper::write_global_values().

int libMesh::Nemesis_IO_Helper::num_internal_elems

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

Definition at line 421 of file nemesis_io_helper.h.

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

int libMesh::Nemesis_IO_Helper::num_internal_nodes

To 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 401 of file nemesis_io_helper.h.

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

int libMesh::ExodusII_IO_Helper::num_nodal_vars [inherited]

Definition at line 680 of file exodusII_io_helper.h.

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

int libMesh::Nemesis_IO_Helper::num_node_cmaps

The 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 435 of file nemesis_io_helper.h.

Referenced by compute_border_node_ids(), compute_communication_map_parameters(), compute_node_communication_maps(), get_cmap_params(), get_loadbal_param(), get_node_cmap(), initialize(), and libMesh::Nemesis_IO::read().

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

Definition at line 647 of file exodusII_io_helper.h.

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

int libMesh::ExodusII_IO_Helper::num_node_sets [inherited]

Definition at line 632 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_num_node_sets(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO_Helper::read_header(), libMesh::ExodusII_IO_Helper::read_nodeset_info(), and write_exodus_initialization_info().

int libMesh::Nemesis_IO_Helper::num_node_sets_global

Definition at line 322 of file nemesis_io_helper.h.

Referenced by compute_num_global_nodesets(), get_init_global(), get_ns_param_global(), and initialize().

int libMesh::ExodusII_IO_Helper::num_nodes [inherited]

Definition at line 629 of file exodusII_io_helper.h.

Referenced by build_element_and_node_maps(), libMesh::ExodusII_IO_Helper::get_nodal_var_values(), libMesh::ExodusII_IO_Helper::get_num_nodes(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::ExodusII_IO_Helper::print_nodes(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO_Helper::read_header(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::ExodusII_IO_Helper::read_nodes(), write_exodus_initialization_info(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates_discontinuous(), write_nodal_solution(), and libMesh::ExodusII_IO_Helper::write_nodal_values().

int libMesh::Nemesis_IO_Helper::num_nodes_global

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

Definition at line 319 of file nemesis_io_helper.h.

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

int libMesh::ExodusII_IO_Helper::num_nodes_per_elem [inherited]

Definition at line 635 of file exodusII_io_helper.h.

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

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

Definition at line 645 of file exodusII_io_helper.h.

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

int libMesh::Nemesis_IO_Helper::num_proc

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

Definition at line 329 of file nemesis_io_helper.h.

Referenced by get_init_info().

int libMesh::Nemesis_IO_Helper::num_proc_in_file

The 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 336 of file nemesis_io_helper.h.

Referenced by get_init_info().

int libMesh::ExodusII_IO_Helper::num_side_sets [inherited]

Definition at line 633 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_num_side_sets(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO_Helper::read_header(), libMesh::ExodusII_IO_Helper::read_sideset_info(), and write_exodus_initialization_info().

int libMesh::Nemesis_IO_Helper::num_side_sets_global

Definition at line 323 of file nemesis_io_helper.h.

Referenced by compute_num_global_sidesets(), get_init_global(), get_ss_param_global(), and initialize().

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

Definition at line 644 of file exodusII_io_helper.h.

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

int libMesh::ExodusII_IO_Helper::num_time_steps [inherited]

Definition at line 678 of file exodusII_io_helper.h.

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

std::map<unsigned, std::set<std::pair<unsigned,unsigned> > > libMesh::Nemesis_IO_Helper::proc_border_elem_sets [private]

Map between processor ID and (element,side) pairs bordering that processor ID.

Definition at line 548 of file nemesis_io_helper.h.

Referenced by compute_communication_map_parameters(), compute_elem_communication_maps(), and compute_internal_and_border_elems_and_internal_nodes().

std::map<unsigned, std::set<unsigned> > libMesh::Nemesis_IO_Helper::proc_nodes_touched_intersections [private]

Another map to store sets of intersections with each other processor (other than ourself, of course). A node which appears in one of these vectors belongs to element owned by at least this processor and one other.

Definition at line 538 of file nemesis_io_helper.h.

Referenced by compute_border_node_ids(), compute_communication_map_parameters(), and compute_node_communication_maps().

int libMesh::ExodusII_IO_Helper::req_info [inherited]

Definition at line 637 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_sideset_info().

char libMesh::ExodusII_IO_Helper::ret_char [inherited]

Definition at line 659 of file exodusII_io_helper.h.

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

float libMesh::ExodusII_IO_Helper::ret_float [inherited]

Definition at line 655 of file exodusII_io_helper.h.

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

int libMesh::ExodusII_IO_Helper::ret_int [inherited]

Definition at line 638 of file exodusII_io_helper.h.

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

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

Definition at line 649 of file exodusII_io_helper.h.

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

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

Definition at line 642 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_side_set_id(), libMesh::ExodusII_IO_Helper::get_side_set_name(), libMesh::ExodusII_IO_Helper::read_sideset(), and libMesh::ExodusII_IO_Helper::read_sideset_info().

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

Definition at line 690 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_nodal_var_names(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), and libMesh::ExodusII_IO_Helper::initialize_nodal_variables().

std::map<subdomain_id_type, std::vector<unsigned int> > libMesh::Nemesis_IO_Helper::subdomain_map

Map of subdomains to element numbers.

Definition at line 385 of file nemesis_io_helper.h.

Referenced by build_element_and_node_maps(), and write_elements().

std::vector<Real> libMesh::ExodusII_IO_Helper::time_steps [inherited]

Definition at line 679 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_time_steps().

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

Definition at line 661 of file exodusII_io_helper.h.

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

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

Definition at line 689 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_nodal_var_names(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), and libMesh::ExodusII_IO_Helper::initialize_nodal_variables().

std::vector<Real> libMesh::ExodusII_IO_Helper::x [inherited]

Definition at line 656 of file exodusII_io_helper.h.

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

std::vector<Real> libMesh::ExodusII_IO_Helper::y [inherited]

Definition at line 657 of file exodusII_io_helper.h.

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

std::vector<Real> libMesh::ExodusII_IO_Helper::z [inherited]

Definition at line 658 of file exodusII_io_helper.h.

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

---

The documentation for this class was generated from the following files:

• nemesis_io_helper.h
• nemesis_io_helper.C