#include <nemesis_io_helper.h>

Inheritance diagram for libMesh::Nemesis_IO_Helper:

Public Types
enum	ExodusVarType { NODAL =0, ELEMENTAL =1, GLOBAL =2 }

Public Member Functions
	Nemesis_IO_Helper (const ParallelObject &parent, bool verbose=false, bool single_precision=false)

virtual	~Nemesis_IO_Helper ()

void	get_init_global ()

void	get_ss_param_global ()

void	get_ns_param_global ()

void	get_eb_info_global ()

void	get_init_info ()

void	get_loadbal_param ()

void	get_elem_map ()

void	get_node_map ()

void	get_cmap_params ()

void	get_node_cmap ()

void	get_elem_cmap ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual void	write_sidesets (const MeshBase &mesh) override

virtual void	write_nodesets (const MeshBase &mesh) override

virtual void	create (std::string filename) override

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

void	write_nodal_solution (const NumericVector< Number > &parallel_soln, const std::vector< std::string > &names, int timestep, const std::vector< std::string > &output_names)

void	write_nodal_solution (const std::vector< Number > &values, const std::vector< std::string > &names, int timestep)

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

void	write_element_values (const MeshBase &mesh, const NumericVector< Number > &parallel_soln, const std::vector< std::string > &names, int timestep, const std::vector< std::set< subdomain_id_type >> &vars_active_subdomains)

std::string	construct_nemesis_filename (const std::string &base_filename)

const char *	get_elem_type () const

void	open (const char *filename, bool read_only)

void	read_header ()

void	read_qa_records ()

void	print_header ()

void	read_nodes ()

void	read_node_num_map ()

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

void	read_block_info ()

int	get_block_id (int index)

std::string	get_block_name (int index)

int	get_side_set_id (int index)

std::string	get_side_set_name (int index)

int	get_node_set_id (int index)

std::string	get_node_set_name (int index)

void	read_elem_in_block (int block)

void	read_elem_num_map ()

void	read_sideset_info ()

void	read_nodeset_info ()

void	read_sideset (int id, int offset)

void	read_nodeset (int id)

void	close ()

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

void	read_time_steps ()

void	read_num_time_steps ()

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

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

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

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

void	write_timestep (int timestep, Real time)

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

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

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

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

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

void	use_mesh_dimension_instead_of_spatial_dimension (bool val)

void	write_as_dimension (unsigned dim)

void	set_coordinate_offset (Point p)

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

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

void	message (const std::string &msg)

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

void	read_var_names (ExodusVarType type)

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

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< dof_id_type > >	subdomain_map

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

int	num_internal_nodes

int	num_border_nodes

int	num_external_nodes

int	num_internal_elems

int	num_border_elems

int	num_node_cmaps

int	num_elem_cmaps

std::vector< int >	elem_mapi

std::vector< int >	elem_mapb

std::vector< int >	node_mapi

std::vector< int >	node_mapb

std::vector< int >	node_mape

std::vector< int >	node_cmap_ids

std::vector< int >	node_cmap_node_cnts

std::vector< int >	elem_cmap_ids

std::vector< int >	elem_cmap_elem_cnts

std::vector< std::vector< int > >	node_cmap_node_ids

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

std::vector< std::vector< int > >	elem_cmap_elem_ids

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

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

int	ex_id

int	ex_err

int	num_dim

int	num_global_vars

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	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

std::vector< Real >	x

std::vector< Real >	y

std::vector< Real >	z

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::string >	elem_var_names

std::vector< Real >	elem_var_values

std::vector< std::string >	global_var_names

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

bool	verbose

bool	opened_for_writing

bool	opened_for_reading

std::string	current_filename

Protected Member Functions
void	check_existing_vars (ExodusVarType type, std::vector< std::string > &names, std::vector< std::string > &names_from_file)

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

Protected Attributes
bool	_run_only_on_proc0

bool	_elem_vars_initialized

bool	_global_vars_initialized

bool	_nodal_vars_initialized

bool	_use_mesh_dimension_instead_of_spatial_dimension

unsigned	_write_as_dimension

Point	_coordinate_offset

bool	_single_precision

const Parallel::Communicator &	_communicator

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

Date: 2008

Definition at line 64 of file nemesis_io_helper.h.

Member Typedef Documentation

◆ proc_border_elem_sets_iterator

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

◆ proc_nodes_touched_iterator

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

Member Enumeration Documentation

◆ ExodusVarType

enum libMesh::ExodusII_IO_Helper::ExodusVarType

inherited

Wraps calls to exII::ex_get_var_names() and exII::ex_get_var_param(). The enumeration controls whether nodal, elemental, or global variable names are read and which class members are filled in. NODAL: num_nodal_vars nodal_var_names ELEMENTAL: num_elem_vars elem_var_names GLOBAL: num_global_vars global_var_names

Enumerator
NODAL
ELEMENTAL
GLOBAL

Definition at line 601 of file exodusII_io_helper.h.

601 {NODAL=0, ELEMENTAL=1, GLOBAL=2};

libMesh::ExodusII_IO_Helper::GLOBAL

Definition: exodusII_io_helper.h:601

libMesh::ExodusII_IO_Helper::ELEMENTAL

Definition: exodusII_io_helper.h:601

libMesh::ExodusII_IO_Helper::NODAL

Definition: exodusII_io_helper.h:601

Constructor & Destructor Documentation

◆ Nemesis_IO_Helper()

libMesh::Nemesis_IO_Helper::Nemesis_IO_Helper	(	const ParallelObject &	parent,
		bool	verbose = `false`,
		bool	single_precision = `false`
	)

explicit

Constructor.

Definition at line 45 of file nemesis_io_helper.C.

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

◆ ~Nemesis_IO_Helper()

libMesh::Nemesis_IO_Helper::~Nemesis_IO_Helper ( )

virtual

Destructor.

Definition at line 70 of file nemesis_io_helper.C.

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

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

Member Function Documentation

◆ build_element_and_node_maps()

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 1695 of file nemesis_io_helper.C.

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 (const auto & pr : local_subdomain_counts)
     {
       if (verbose)
         {
           libMesh::out << "[" << this->processor_id() << "] "
                        << "local_subdomain_counts [" << static_cast<unsigned>(pr.first) << "]= "
                        << pr.second
                        << std::endl;
         }
 
       // pr.first is the subdomain ID, pr.second is the number of elements it contains
       this->subdomain_map[pr.first].reserve(pr.second);
     }
 
 
   // First loop over the elements to figure out which elements are in which subdomain
   for (const auto & elem : pmesh.active_local_element_ptr_range())
     {
       // Grab the nodes while we're here.
       for (auto n : elem->node_index_range())
         this->nodes_attached_to_local_elems.insert( elem->node_id(n) );
 
       subdomain_id_type cur_subdomain = elem->subdomain_id();
 
       this->subdomain_map[cur_subdomain].push_back(elem->id());
     }
 
   // Set num_nodes which is used by exodusII_io_helper
   this->num_nodes =
     cast_int<int>(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 (const auto & id : nodes_attached_to_local_elems)
     {
       // 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(id);
 
       // 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[id] =
         cast_int<int>(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 (auto & pr : subdomain_map)
     {
       block_ids.push_back(pr.first);
 
       // Vector of element IDs for this subdomain
       std::vector<dof_id_type> & elem_ids_this_subdomain = pr.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_error_msg("Error, no element IDs found in subdomain " << pr.first);
 
       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_ref(elem_ids_this_subdomain[0]).type());
       this->num_nodes_per_elem =
         pmesh.elem_ref(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[pr.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 (auto i : index_range(elem_ids_this_subdomain))
         {
           auto 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] =
             cast_int<int>(this->exodus_elem_num_to_libmesh.size());
 
           const Elem & elem = pmesh.elem_ref(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(), nullptr)->n_nodes());
 
           for (auto j : IntRange<int>(0, this->num_nodes_per_elem))
             {
               const unsigned int connect_index   = (i*this->num_nodes_per_elem)+j;
               const unsigned int elem_node_index = conv.get_node_map(j);
 
               std::map<int, int>::iterator node_it = libmesh_node_num_to_exodus.find(elem.node_id(elem_node_index));
               if (node_it == libmesh_node_num_to_exodus.end())
                 libmesh_error_msg("Node number " << elem.node_id(elem_node_index) << " not found in libmesh_node_num_to_exodus map.");
 
               current_block_connectivity[connect_index] = node_it->second;
             }
         } // End loop over elems in this subdomain
     } // end loop over subdomain_map
 }

◆ check_existing_vars()

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

protectedinherited

When appending: during initialization, check that variable names in the file match those you attempt to initialize with.

Definition at line 1814 of file exodusII_io_helper.C.

References libMesh::err, libMesh::Quality::name(), libMesh::out, and libMesh::ExodusII_IO_Helper::read_var_names().

Referenced by libMesh::ExodusII_IO_Helper::initialize_element_variables(), initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), and libMesh::ExodusII_IO_Helper::initialize_nodal_variables().

 {
   // There may already be global variables in the file (for example,
   // if we're appending) and in that case, we
   // 1.) Cannot initialize them again.
   // 2.) Should check to be sure that the global variable names are the same.
 
   // Fills up names_from_file for us
   this->read_var_names(type);
 
   // Both the names of the global variables and their order must match
   if (names_from_file != names)
     {
       libMesh::err << "Error! The Exodus file already contains the variables:" << std::endl;
       for (const auto & name : names_from_file)
         libMesh::out << name << std::endl;
 
       libMesh::err << "And you asked to write:" << std::endl;
       for (const auto & name : names)
         libMesh::out << name << std::endl;
 
       libmesh_error_msg("Cannot overwrite existing variables in Exodus II file.");
     }
 }

◆ close()

void libMesh::ExodusII_IO_Helper::close ( )

inherited

Closes the ExodusII mesh file.

Definition at line 795 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, ex_close(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::opened_for_reading, libMesh::ExodusII_IO_Helper::opened_for_writing, and libMesh::ParallelObject::processor_id().

Referenced by ~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 ((this->processor_id() == 0) || (!_run_only_on_proc0))
     {
       // Don't close the file if it was never opened, this raises an Exodus error
       if (opened_for_writing || opened_for_reading)
         {
           ex_err = exII::ex_close(ex_id);
           EX_CHECK_ERR(ex_err, "Error closing Exodus file.");
           message("Exodus file closed successfully.");
         }
     }
 }

◆ comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns: A reference to the Parallel::Communicator object used by this mesh.

Definition at line 89 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

90 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

◆ compute_border_node_ids()

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 1846 of file nemesis_io_helper.C.

References libMesh::MeshBase::active_element_ptr_range(), border_node_ids, libMesh::ParallelObject::n_processors(), num_border_nodes, num_node_cmaps, libMesh::out, proc_nodes_touched_intersections, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

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.
     for (const auto & elem : pmesh.active_element_ptr_range())
       {
         // 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 (auto node : elem->node_index_range())
           set_p.insert(elem->node_id(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 unless this processor has no nodes of its own.
     this->num_node_cmaps =
       cast_int<int>(proc_nodes_touched.size() -
                     proc_nodes_touched.count(this->processor_id()));
 
     // We can't be connecting to more processors than exist outside
     // ourselves
     libmesh_assert_less (static_cast<unsigned>(this->num_node_cmaps), this->n_processors());
 
     if (verbose)
       {
         libMesh::out << "[" << this->processor_id()
                      << "] proc_nodes_touched contains "
                      << proc_nodes_touched.size()
                      << " sets of nodes."
                      << std::endl;
 
         for (const auto & pr : proc_nodes_touched)
           libMesh::out << "[" << this->processor_id()
                        << "] proc_nodes_touched[" << pr.first << "] has "
                        << pr.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 (auto & pr : proc_nodes_touched)
       {
         // Don't compute intersections with ourself
         if (pr.first == this->processor_id())
           continue;
 
         // Otherwise, compute intersection with other processor and ourself
         std::set<unsigned> & my_set = proc_nodes_touched[this->processor_id()];
         std::set<unsigned> & other_set = pr.second;
         std::set<unsigned> & result_set = this->proc_nodes_touched_intersections[pr.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 (const auto & pr : proc_nodes_touched_intersections)
           libMesh::out << "[" << this->processor_id()
                        << "] this->proc_nodes_touched_intersections[" << pr.first << "] has "
                        << pr.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 (auto & pr : proc_nodes_touched_intersections)
       {
         std::set<unsigned> & other_set = pr.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);
       }
 
     libmesh_assert_less_equal
       (this->proc_nodes_touched_intersections.size(),
        std::size_t(this->num_node_cmaps));
 
     if (verbose)
       {
         libMesh::out << "[" << this->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 = cast_int<int>(this->border_node_ids.size());
 }

◆ compute_communication_map_parameters()

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 1171 of file nemesis_io_helper.C.

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

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
     proc_nodes_touched_iterator
       it = this->proc_nodes_touched_intersections.begin(),
       end = this->proc_nodes_touched_intersections.end();
 
     for (; it != end; ++it)
       {
         this->node_cmap_ids[cnt] = it->first; // The ID of the proc we communicate with
         this->node_cmap_node_cnts[cnt] = cast_int<int>(it->second.size()); // The number of nodes we communicate
         cnt++; // increment vector index!
       }
   }
 
   // Print the packed vectors we just filled
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] node_cmap_node_cnts = ";
       for (std::size_t i=0; i<node_cmap_node_cnts.size(); ++i)
         libMesh::out << node_cmap_node_cnts[i] << ", ";
       libMesh::out << std::endl;
 
       libMesh::out << "[" << this->processor_id() << "] node_cmap_ids = ";
       for (std::size_t 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
     proc_border_elem_sets_iterator
       it = this->proc_border_elem_sets.begin(),
       end = this->proc_border_elem_sets.end();
 
     for (; it != end; ++it)
       {
         this->elem_cmap_ids[cnt] = it->first; // The ID of the proc we communicate with
         this->elem_cmap_elem_cnts[cnt] = cast_int<int>(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 << "[" << this->processor_id() << "] elem_cmap_elem_cnts = ";
       for (std::size_t i=0; i<elem_cmap_elem_cnts.size(); ++i)
         libMesh::out << elem_cmap_elem_cnts[i] << ", ";
       libMesh::out << std::endl;
 
       libMesh::out << "[" << this->processor_id() << "] elem_cmap_ids = ";
       for (std::size_t i=0; i<elem_cmap_ids.size(); ++i)
         libMesh::out << elem_cmap_ids[i] << ", ";
       libMesh::out << std::endl;
     }
 }

◆ compute_elem_communication_maps()

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 1002 of file nemesis_io_helper.C.

References elem_cmap_elem_ids, elem_cmap_ids, elem_cmap_proc_ids, elem_cmap_side_ids, end, 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
     proc_border_elem_sets_iterator
       it = this->proc_border_elem_sets.begin(),
       end = this->proc_border_elem_sets.end();
 
     for (; it != 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 (std::size_t j=0; j<this->elem_cmap_elem_ids[cnt].size(); ++j, ++elem_set_iter)
           {
             std::map<int, int>::iterator elem_it = libmesh_elem_num_to_exodus.find((*elem_set_iter).first);
 
             if (elem_it == libmesh_elem_num_to_exodus.end())
               libmesh_error_msg("Elem number " << (*elem_set_iter).first << " not found in libmesh_elem_num_to_exodus map.");
 
             this->elem_cmap_elem_ids[cnt][j] = elem_it->second;
             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
           }
 
         // increment vector index to go to next processor
         cnt++;
       }
   } // end scope for packing
 }

◆ compute_element_maps()

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 967 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 (const auto & id : this->internal_elem_ids)
       {
         std::map<int, int>::iterator elem_it = libmesh_elem_num_to_exodus.find(id);
         if (elem_it == libmesh_elem_num_to_exodus.end())
           libmesh_error_msg("Elem number " << id << " not found in libmesh_elem_num_to_exodus map.");
         this->elem_mapi[cnt++] = elem_it->second;
       }
   }
 
   {
     unsigned cnt = 0;
     for (const auto & id : this->border_elem_ids)
       {
         std::map<int, int>::iterator elem_it = libmesh_elem_num_to_exodus.find(id);
         if (elem_it == libmesh_elem_num_to_exodus.end())
           libmesh_error_msg("Elem number " << id << " not found in libmesh_elem_num_to_exodus map.");
         this->elem_mapb[cnt++] = elem_it->second;
       }
   }
 }

◆ compute_internal_and_border_elems_and_internal_nodes()

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 1249 of file nemesis_io_helper.C.

References libMesh::MeshBase::active_local_element_ptr_range(), libMesh::ExodusII_IO_Helper::ElementMaps::assign_conversion(), border_elem_ids, border_node_ids, libMesh::ExodusII_IO_Helper::Conversion::get_inverse_side_map(), internal_elem_ids, internal_node_ids, 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::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

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;
 
   for (const auto & elem : pmesh.active_local_element_ptr_range())
     {
       // 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 (auto node : elem->node_index_range())
         this->nodes_attached_to_local_elems.insert(elem->node_id(node));
 
       // Loop over element's neighbors, see if it has a neighbor which is off-processor
       for (auto n : elem->side_index_range())
         {
           if (elem->neighbor_ptr(n) != nullptr)
             {
               unsigned neighbor_proc_id = elem->neighbor_ptr(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 != this->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 << "[" << this->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 << "[" << this->processor_id() << "] neighboring_processor_ids = ";
       for (const auto & id : neighboring_processor_ids)
         libMesh::out << id << " ";
       libMesh::out << std::endl;
     }
 
   // The size of the neighboring_processor_ids set should be the number of element communication maps
   this->num_elem_cmaps =
     cast_int<int>(neighboring_processor_ids.size());
 
   if (verbose)
     libMesh::out << "[" << this->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 (const auto & pr : proc_border_elem_sets)
         {
           libMesh::out << "[" << this->processor_id() << "] "
                        << "Proc "
                        << pr.first << " communicates "
                        << pr.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 =
     cast_int<int>(this->internal_elem_ids.size());
   this->num_border_elems   =
     cast_int<int>(this->border_elem_ids.size());
   this->num_internal_nodes =
     cast_int<int>(this->internal_node_ids.size());
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] num_internal_nodes=" << this->num_internal_nodes << std::endl;
       libMesh::out << "[" << this->processor_id() << "] num_border_nodes=" << this->num_border_nodes << std::endl;
       libMesh::out << "[" << this->processor_id() << "] num_border_elems=" << this->num_border_elems << std::endl;
       libMesh::out << "[" << this->processor_id() << "] num_internal_elems=" << this->num_internal_elems << std::endl;
     }
 }

◆ compute_node_communication_maps()

void libMesh::Nemesis_IO_Helper::compute_node_communication_maps ( )

private

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

Definition at line 1096 of file nemesis_io_helper.C.

References end, libMesh::ExodusII_IO_Helper::libmesh_node_num_to_exodus, node_cmap_ids, node_cmap_node_ids, node_cmap_proc_ids, node_set, num_node_cmaps, libMesh::out, proc_nodes_touched_intersections, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

Referenced by initialize().

 {
   // Make sure there's no left-over information
   this->node_cmap_node_ids.clear();
   this->node_cmap_proc_ids.clear();
 
   libmesh_assert_less_equal
     (this->proc_nodes_touched_intersections.size(),
      std::size_t(this->num_node_cmaps));
 
   // 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
     proc_nodes_touched_iterator
       it = this->proc_nodes_touched_intersections.begin(),
       end = this->proc_nodes_touched_intersections.end();
 
     for (; it != 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;
 
         // 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 (std::size_t j=0; j<this->node_cmap_node_ids[cnt].size(); ++j, ++node_set_iter)
           {
             std::map<int, int>::iterator node_it = libmesh_node_num_to_exodus.find(*node_set_iter);
             if (node_it == libmesh_node_num_to_exodus.end())
               libmesh_error_msg("Node number " << *node_set_iter << " not found in libmesh_node_num_to_exodus map.");
 
             this->node_cmap_node_ids[cnt][j] = node_it->second;
             this->node_cmap_proc_ids[cnt][j] = it->first;
           }
 
         // increment vector index to go to next processor
         cnt++;
       }
   } // end scope for packing
 
   // Print out the vectors we just packed
   if (verbose)
     {
       for (std::size_t i=0; i<this->node_cmap_node_ids.size(); ++i)
         {
           libMesh::out << "[" << this->processor_id() << "] nodes communicated to proc "
                        << this->node_cmap_ids[i]
                        << " = ";
           for (std::size_t 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 (std::size_t i=0; i<this->node_cmap_node_ids.size(); ++i)
         {
           libMesh::out << "[" << this->processor_id() << "] processor ID node communicated to = ";
           for (std::size_t j=0; j<this->node_cmap_proc_ids[i].size(); ++j)
             libMesh::out << this->node_cmap_proc_ids[i][j] << " ";
           libMesh::out << std::endl;
         }
     }
 }

◆ compute_node_maps()

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 1057 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
   {
     unsigned cnt = 0;
     for (const auto & id : this->internal_node_ids)
       {
         std::map<int, int>::iterator node_it = libmesh_node_num_to_exodus.find(id);
         if (node_it == libmesh_node_num_to_exodus.end())
           libmesh_error_msg("Node number " << id << " not found in libmesh_node_num_to_exodus map.");
         this->node_mapi[cnt++] = node_it->second;
       }
   }
 
   {
     unsigned cnt=0;
     for (const auto & id : this->border_node_ids)
       {
         std::map<int, int>::iterator node_it = libmesh_node_num_to_exodus.find(id);
         if (node_it == libmesh_node_num_to_exodus.end())
           libmesh_error_msg("Node number " << id << " not found in libmesh_node_num_to_exodus map.");
         this->node_mapb[cnt++] = node_it->second;
       }
   }
 }

◆ compute_num_global_elem_blocks()

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 1595 of file nemesis_io_helper.C.

References libMesh::MeshBase::active_local_element_ptr_range(), libMesh::Parallel::Communicator::allgather(), libMesh::ParallelObject::comm(), global_elem_blk_cnts, global_elem_blk_ids, local_subdomain_counts, num_elem_blks_global, libMesh::out, libMesh::ParallelObject::processor_id(), libMesh::Parallel::Communicator::sum(), and libMesh::ExodusII_IO_Helper::verbose.

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;
 
   for (const auto & elem : pmesh.active_local_element_ptr_range())
     {
       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 this->comm().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
     this->comm().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 =
     cast_int<int>(global_subdomain_ids.size());
 
   // Print the number of elements found locally in each subdomain
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] ";
       for (const auto & pr : global_subdomain_counts)
         {
           libMesh::out << "ID: "
                        << static_cast<unsigned>(pr.first)
                        << ", Count: " << pr.second << ", ";
         }
       libMesh::out << std::endl;
     }
 
   // 6.) this->comm().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;
   // Find the entry in the local map, note: if not found, will be created with 0 default value, which is OK...
   for (const auto & id : global_subdomain_ids)
     this->global_elem_blk_cnts[cnt++] = global_subdomain_counts[id];
 
   // Sum up subdomain counts from all processors
   this->comm().sum(this->global_elem_blk_cnts);
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] global_elem_blk_cnts = ";
       for (std::size_t 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 << "[" << this->processor_id() << "] global_elem_blk_ids = ";
       for (std::size_t 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().
 }

◆ compute_num_global_nodesets()

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 1484 of file nemesis_io_helper.C.

References libMesh::BoundaryInfo::build_node_list(), libMesh::ParallelObject::comm(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::get_node_boundary_ids(), global_nodeset_ids, libMesh::MeshBase::node_ptr(), num_global_node_counts, num_node_sets_global, libMesh::out, libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Parallel::Communicator::set_union(), libMesh::Parallel::Communicator::sum(), swap(), and libMesh::ExodusII_IO_Helper::verbose.

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.get_boundary_info().get_node_boundary_ids().begin(),
      pmesh.get_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
   this->comm().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 =
     cast_int<int>(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 << "[" << this->processor_id() << "] global_nodeset_ids = ";
       for (std::size_t i=0; i<global_nodeset_ids.size(); ++i)
         libMesh::out << global_nodeset_ids[i] << ", ";
       libMesh::out << std::endl;
 
       libMesh::out << "[" << this->processor_id() << "] local_node_boundary_ids = ";
       for (const auto & id : local_node_boundary_ids)
         libMesh::out << id << ", ";
       libMesh::out << std::endl;
     }
 
   // 7.) We also need to know the number of nodes which is in each of the nodesets, globally.
 
   // Build list of (node-id, bc-id) tuples.
   typedef std::tuple<dof_id_type, boundary_id_type> Tuple;
   std::vector<Tuple> bc_tuples = pmesh.get_boundary_info().build_node_list();
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] boundary_node_list.size()="
                    << bc_tuples.size() << std::endl;
       libMesh::out << "[" << this->processor_id() << "] (boundary_node_id, boundary_id) = ";
       for (const auto & t : bc_tuples)
         libMesh::out << "(" << std::get<0>(t) << ", " << std::get<1>(t) << ") ";
       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<Tuple>::iterator
     it = bc_tuples.begin(),
     new_end = bc_tuples.end();
 
   while (it != new_end)
     {
       if (pmesh.node_ptr(std::get<0>(*it))->processor_id() != this->processor_id())
         {
           // Back up the new end iterators to prepare for swap
           --new_end;
 
           // Swap places, the non-local node will now be "past-the-end"
           std::swap(*it, *new_end);
         }
       else // node is local, go to next
         ++it;
     }
 
   // Erase from "new" end to old end.
   bc_tuples.erase(new_end, bc_tuples.end());
 
   // Now we can do the local count for each ID...
   for (std::size_t i=0; i<global_nodeset_ids.size(); ++i)
     {
       int id = this->global_nodeset_ids[i];
       this->num_global_node_counts[i] =
         cast_int<int>(std::count_if(bc_tuples.begin(),
                                     bc_tuples.end(),
                                     [id](const Tuple & t)->bool { return std::get<1>(t) == id; }));
     }
 
   // And finally we can sum them up
   this->comm().sum(this->num_global_node_counts);
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] num_global_node_counts = ";
       for (std::size_t i=0; i<num_global_node_counts.size(); ++i)
         libMesh::out << num_global_node_counts[i] << ", ";
       libMesh::out << std::endl;
     }
 }

◆ compute_num_global_sidesets()

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 1391 of file nemesis_io_helper.C.

References libMesh::BoundaryInfo::build_side_list(), libMesh::ParallelObject::comm(), libMesh::MeshBase::elem_ref(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::get_side_boundary_ids(), global_sideset_ids, num_global_side_counts, num_side_sets_global, libMesh::out, libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Parallel::Communicator::set_union(), libMesh::Parallel::Communicator::sum(), swap(), and libMesh::ExodusII_IO_Helper::verbose.

Referenced by initialize().

 {
   // 1.) Get reference to the set of side boundary IDs
   std::set<boundary_id_type> global_side_boundary_ids
     (pmesh.get_boundary_info().get_side_boundary_ids().begin(),
      pmesh.get_boundary_info().get_side_boundary_ids().end());
 
   // 2.) Gather boundary side IDs from other processors
   this->comm().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 =
     cast_int<int>(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 << "[" << this->processor_id() << "] global_sideset_ids = ";
       for (std::size_t 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.
   // Build a list of (elem, side, bc) tuples.
   typedef std::tuple<dof_id_type, unsigned short int, boundary_id_type> Tuple;
   std::vector<Tuple> bc_triples = pmesh.get_boundary_info().build_side_list();
 
   // Iterators to the beginning and end of the current range.
   std::vector<Tuple>::iterator
     it = bc_triples.begin(),
     new_end = bc_triples.end();
 
   while (it != new_end)
     {
       if (pmesh.elem_ref(std::get<0>(*it)).processor_id() != this->processor_id())
         {
           // Back up the new end iterators to prepare for swap
           --new_end;
 
           // Swap places, the non-local elem will now be "past-the-end"
           std::swap (*it, *new_end);
         }
       else // elem is local, go to next
         ++it;
     }
 
   // Erase from "new" end to old.
   bc_triples.erase(new_end, bc_triples.end());
 
   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 (std::size_t i=0; i<global_sideset_ids.size(); ++i)
     {
       int id = global_sideset_ids[i];
       this->num_global_side_counts[i] =
         cast_int<int>(std::count_if(bc_triples.begin(),
                                     bc_triples.end(),
                                     [id](const Tuple & t)->bool { return std::get<2>(t) == id; }));
     }
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] num_global_side_counts = ";
       for (std::size_t 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
   this->comm().sum(this->num_global_side_counts);
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] num_global_side_counts = ";
       for (std::size_t i=0; i<this->num_global_side_counts.size(); ++i)
         libMesh::out << this->num_global_side_counts[i] << ", ";
       libMesh::out << std::endl;
     }
 }

◆ construct_nemesis_filename()

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 2648 of file nemesis_io_helper.C.

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

 {
   // 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 << (this->n_processors());
   unsigned int field_width = cast_int<unsigned int>(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
            << '.' << this->n_processors()
            << '.' << std::setfill('0') << std::setw(field_width) << this->processor_id();
 
   // Return the resulting string
   return file_oss.str();
 }

◆ create()

void libMesh::Nemesis_IO_Helper::create ( std::string filename )

overridevirtual

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 727 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_single_precision, libMesh::ExodusII_IO_Helper::ex_id, std::min(), libMesh::ExodusII_IO_Helper::opened_for_writing, libMesh::out, libMesh::Real, and libMesh::ExodusII_IO_Helper::verbose.

 {
   // Fall back on double precision when necessary since ExodusII
   // doesn't seem to support long double
   int
     comp_ws = 0,
     io_ws = 0;
 
   if (_single_precision)
     {
       comp_ws = sizeof(float);
       io_ws = sizeof(float);
     }
   else
     {
       comp_ws = cast_int<int>(std::min(sizeof(Real), sizeof(double)));
       io_ws = cast_int<int>(std::min(sizeof(Real), sizeof(double)));
     }
 
   this->ex_id = exII::ex_create(filename.c_str(), EX_CLOBBER, &comp_ws, &io_ws);
 
   EX_CHECK_ERR(ex_id, "Error creating Nemesis mesh file.");
 
   if (verbose)
     libMesh::out << "File created successfully." << std::endl;
 
   this->opened_for_writing = true;
 }

◆ get_block_id()

int libMesh::ExodusII_IO_Helper::get_block_id ( int index )

inherited

Get the block number for the given block index.

Definition at line 544 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::block_ids.

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

 {
   libmesh_assert_less (static_cast<unsigned int>(index), block_ids.size());
 
   return block_ids[index];
 }

◆ get_block_name()

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

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

 {
   libmesh_assert_less (static_cast<unsigned int>(index), block_ids.size());
 
   return id_to_block_names[block_ids[index]];
 }

◆ get_cmap_params()

void libMesh::Nemesis_IO_Helper::get_cmap_params ( )

Definition at line 322 of file nemesis_io_helper.C.

References 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, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   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()       ? nullptr : node_cmap_ids.data(),
                                 node_cmap_node_cnts.empty() ? nullptr : node_cmap_node_cnts.data(),
                                 elem_cmap_ids.empty()       ? nullptr : elem_cmap_ids.data(),
                                 elem_cmap_elem_cnts.empty() ? nullptr : elem_cmap_elem_cnts.data(),
                                 this->processor_id());
   EX_CHECK_ERR(nemesis_err_flag, "Error reading cmap parameters!");
 
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] ";
       for (std::size_t i=0; i<node_cmap_ids.size(); ++i)
         libMesh::out << "node_cmap_ids["<<i<<"]=" << node_cmap_ids[i] << " ";
       libMesh::out << std::endl;
 
       libMesh::out << "[" << this->processor_id() << "] ";
       for (std::size_t 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 << "[" << this->processor_id() << "] ";
       for (std::size_t i=0; i<elem_cmap_ids.size(); ++i)
         libMesh::out << "elem_cmap_ids["<<i<<"]=" << elem_cmap_ids[i] << " ";
       libMesh::out << std::endl;
 
       libMesh::out << "[" << this->processor_id() << "] ";
       for (std::size_t 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;
     }
 }

◆ get_complex_names()

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

inherited

Returns: A vector with three copies of each element in the provided name vector, starting with r_, i_ and a_ respectively.

Definition at line 2064 of file exodusII_io_helper.C.

 {
   std::vector<std::string>::const_iterator names_it = names.begin();
   std::vector<std::string>::const_iterator names_end = names.end();
 
   std::vector<std::string> complex_names;
 
   // This will loop over all names and create new "complex" names
   // (i.e. names that start with r_, i_ or a_
   for (; names_it != names_end; ++names_it)
     {
       std::stringstream name_real, name_imag, name_abs;
       name_real << "r_" << *names_it;
       name_imag << "i_" << *names_it;
       name_abs << "a_" << *names_it;
 
       complex_names.push_back(name_real.str());
       complex_names.push_back(name_imag.str());
       complex_names.push_back(name_abs.str());
     }
 
   return complex_names;
 }

◆ get_complex_vars_active_subdomains()

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

inherited

returns a "tripled" copy of vars_active_subdomains, which is necessary in the complex-valued case.

Definition at line 2090 of file exodusII_io_helper.C.

 {
   std::vector<std::set<subdomain_id_type>> complex_vars_active_subdomains;
 
   for (auto & s : vars_active_subdomains)
     {
       // Push back the same data three times to match the tripling of the variables
       // for the real, imag, and modulus for the complex-valued solution.
       complex_vars_active_subdomains.push_back(s);
       complex_vars_active_subdomains.push_back(s);
       complex_vars_active_subdomains.push_back(s);
     }
 
   return complex_vars_active_subdomains;
 }

◆ get_eb_info_global()

void libMesh::Nemesis_IO_Helper::get_eb_info_global ( )

Definition at line 176 of file nemesis_io_helper.C.

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

 {
   global_elem_blk_ids.resize(num_elem_blks_global);
   global_elem_blk_cnts.resize(num_elem_blks_global);
 
   if (num_elem_blks_global > 0)
     {
       nemesis_err_flag =
         Nemesis::ne_get_eb_info_global(ex_id,
                                        global_elem_blk_ids.data(),
                                        global_elem_blk_cnts.data());
       EX_CHECK_ERR(nemesis_err_flag, "Error reading global element block info!");
     }
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] " << "Global Element Block IDs and Counts:" << std::endl;
       for (std::size_t bn=0; bn<global_elem_blk_ids.size(); ++bn)
         {
           libMesh::out << "  [" << this->processor_id() << "] "
                        << "global_elem_blk_ids["<<bn<<"]=" << global_elem_blk_ids[bn]
                        << ", global_elem_blk_cnts["<<bn<<"]=" << global_elem_blk_cnts[bn]
                        << std::endl;
         }
     }
 }

◆ get_elem_cmap()

void libMesh::Nemesis_IO_Helper::get_elem_cmap ( )

Definition at line 407 of file nemesis_io_helper.C.

References data, 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, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   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 (std::size_t 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]);
 
       if (elem_cmap_elem_cnts[i] > 0)
         {
           nemesis_err_flag =
             Nemesis::ne_get_elem_cmap(ex_id,
                                       elem_cmap_ids[i],
                                       elem_cmap_elem_ids[i].data(),
                                       elem_cmap_side_ids[i].data(),
                                       elem_cmap_proc_ids[i].data(),
                                       this->processor_id());
           EX_CHECK_ERR(nemesis_err_flag, "Error reading elem cmap elem, side, and processor ids!");
         }
 
       if (verbose)
         {
           libMesh::out << "[" << this->processor_id() << "] elem_cmap_elem_ids["<<i<<"]=";
           for (std::size_t 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 << "[" << this->processor_id() << "] elem_cmap_side_ids["<<i<<"]=";
           for (std::size_t 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 << "[" << this->processor_id() << "] elem_cmap_proc_ids["<<i<<"]=";
           for (std::size_t j=0; j<elem_cmap_proc_ids[i].size(); ++j)
             libMesh::out << elem_cmap_proc_ids[i][j] << " ";
           libMesh::out << std::endl;
         }
     }
 }

◆ get_elem_map()

void libMesh::Nemesis_IO_Helper::get_elem_map ( )

Definition at line 254 of file nemesis_io_helper.C.

References elem_mapb, elem_mapi, libMesh::ExodusII_IO_Helper::ex_id, std::min(), nemesis_err_flag, num_border_elems, num_internal_elems, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   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() ? nullptr : elem_mapi.data(),
                              elem_mapb.empty() ? nullptr : elem_mapb.data(),
                              this->processor_id()
                              );
   EX_CHECK_ERR(nemesis_err_flag, "Error reading element maps!");
 
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] elem_mapi[i] = ";
       for (auto i : IntRange<int>(0, num_internal_elems-1))
         libMesh::out << elem_mapi[i] << ", ";
       libMesh::out << "... " << elem_mapi.back() << std::endl;
 
       libMesh::out << "[" << this->processor_id() << "] elem_mapb[i] = ";
       for (auto i : IntRange<int>(0, std::min(10, num_border_elems-1)))
         libMesh::out << elem_mapb[i] << ", ";
       libMesh::out << "... " << elem_mapb.back() << std::endl;
     }
 }

◆ get_elem_type()

const char * libMesh::ExodusII_IO_Helper::get_elem_type ( ) const

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

References libMesh::ExodusII_IO_Helper::elem_type.

 {
   return elem_type.data();
 }

◆ get_init_global()

void libMesh::Nemesis_IO_Helper::get_init_global ( )

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 85 of file nemesis_io_helper.C.

References 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, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   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);
   EX_CHECK_ERR(nemesis_err_flag, "Error reading initial global data!");
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] " << "num_nodes_global=" << num_nodes_global << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "num_elems_global=" << num_elems_global << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "num_elem_blks_global=" << num_elem_blks_global << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "num_node_sets_global=" << num_node_sets_global << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "num_side_sets_global=" << num_side_sets_global << std::endl;
     }
 }

◆ get_init_info()

void libMesh::Nemesis_IO_Helper::get_init_info ( )

Definition at line 205 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::ex_id, ftype, nemesis_err_flag, num_proc, num_proc_in_file, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   nemesis_err_flag =
     Nemesis::ne_get_init_info(ex_id,
                               &num_proc,
                               &num_proc_in_file,
                               &ftype);
   EX_CHECK_ERR(nemesis_err_flag, "Error reading initial info!");
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] " << "num_proc=" << num_proc << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "num_proc_in_file=" << num_proc_in_file << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "ftype=" << ftype << std::endl;
     }
 }

◆ get_loadbal_param()

void libMesh::Nemesis_IO_Helper::get_loadbal_param ( )

Definition at line 224 of file nemesis_io_helper.C.

References 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, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   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,
                                   this->processor_id() // The ID of the processor for which info is to be read
                                   );
   EX_CHECK_ERR(nemesis_err_flag, "Error reading load balance parameters!");
 
 
   if (verbose)
     {
       libMesh::out << "[" << this->processor_id() << "] " << "num_internal_nodes=" << num_internal_nodes << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "num_border_nodes=" << num_border_nodes << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "num_external_nodes=" << num_external_nodes << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "num_internal_elems=" << num_internal_elems << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "num_border_elems=" << num_border_elems << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "num_node_cmaps=" << num_node_cmaps << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "num_elem_cmaps=" << num_elem_cmaps << std::endl;
     }
 }

◆ get_node_cmap()

void libMesh::Nemesis_IO_Helper::get_node_cmap ( )

Definition at line 365 of file nemesis_io_helper.C.

References data, 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, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   node_cmap_node_ids.resize(num_node_cmaps);
   node_cmap_proc_ids.resize(num_node_cmaps);
 
   for (std::size_t 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]);
 
       // Don't call ne_get_node_cmap() if there is nothing there to
       // get, Nemesis throws an error in this case.
       if (node_cmap_node_cnts[i] > 0)
         {
           nemesis_err_flag =
             Nemesis::ne_get_node_cmap(ex_id,
                                       node_cmap_ids[i],
                                       node_cmap_node_ids[i].data(),
                                       node_cmap_proc_ids[i].data(),
                                       this->processor_id());
           EX_CHECK_ERR(nemesis_err_flag, "Error reading node cmap node and processor ids!");
         }
 
       if (verbose)
         {
           libMesh::out << "[" << this->processor_id() << "] node_cmap_node_ids["<<i<<"]=";
           for (std::size_t 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 << "[" << this->processor_id() << "] node_cmap_proc_ids["<<i<<"]=";
           for (std::size_t j=0; j<node_cmap_proc_ids[i].size(); ++j)
             libMesh::out << node_cmap_proc_ids[i][j] << " ";
           libMesh::out << std::endl;
         }
     }
 }

◆ get_node_map()

void libMesh::Nemesis_IO_Helper::get_node_map ( )

Definition at line 285 of file nemesis_io_helper.C.

References 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, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   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() ? nullptr : node_mapi.data(),
                              node_mapb.empty() ? nullptr : node_mapb.data(),
                              node_mape.empty() ? nullptr : node_mape.data(),
                              this->processor_id()
                              );
   EX_CHECK_ERR(nemesis_err_flag, "Error reading node maps!");
 
   if (verbose)
     {
       // Remark: The Exodus/Nemesis node numbering is always (?) 1-based!  This means the first interior node id will
       // always be == 1.
       libMesh::out << "[" << this->processor_id() << "] " << "first interior node id=" << node_mapi[0] << std::endl;
       libMesh::out << "[" << this->processor_id() << "] " << "last interior node id=" << node_mapi.back() << std::endl;
 
       libMesh::out << "[" << this->processor_id() << "] " << "first boundary node id=" << node_mapb[0] << std::endl;
       libMesh::out << "[" << this->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 << "[" << this->processor_id() << "] " << "first external node id=" << node_mape[0] << std::endl;
           libMesh::out << "[" << this->processor_id() << "] " << "last external node id=" << node_mape.back() << std::endl;
         }
     }
 }

◆ get_node_set_id()

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 580 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];
 }

◆ get_node_set_name()

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

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

 {
   libmesh_assert_less (static_cast<unsigned int>(index), nodeset_ids.size());
 
   return id_to_ns_names[nodeset_ids[index]];
 }

◆ get_ns_param_global()

void libMesh::Nemesis_IO_Helper::get_ns_param_global ( )

Definition at line 144 of file nemesis_io_helper.C.

References 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, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   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.data(),
                                         num_global_node_counts.data(),
                                         num_global_node_df_counts.data());
       EX_CHECK_ERR(nemesis_err_flag, "Error reading global nodeset parameters!");
 
       if (verbose)
         {
           libMesh::out << "[" << this->processor_id() << "] " << "Global Nodeset IDs, Node Counts, and DF counts:" << std::endl;
           for (std::size_t bn=0; bn<global_nodeset_ids.size(); ++bn)
             {
               libMesh::out << "  [" << this->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;
             }
         }
     }
 }

◆ get_side_set_id()

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

References libMesh::ExodusII_IO_Helper::ss_ids.

 {
   libmesh_assert_less (static_cast<unsigned int>(index), ss_ids.size());
 
   return ss_ids[index];
 }

◆ get_side_set_name()

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

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

 {
   libmesh_assert_less (static_cast<unsigned int>(index), ss_ids.size());
 
   return id_to_ss_names[ss_ids[index]];
 }

◆ get_ss_param_global()

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 108 of file nemesis_io_helper.C.

References 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, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   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.data(),
                                         num_global_side_counts.data(),
                                         num_global_side_df_counts.data());
       EX_CHECK_ERR(nemesis_err_flag, "Error reading global sideset parameters!");
 
       if (verbose)
         {
           libMesh::out << "[" << this->processor_id() << "] " << "Global Sideset IDs, Side Counts, and DF counts:" << std::endl;
           for (std::size_t bn=0; bn<global_sideset_ids.size(); ++bn)
             {
               libMesh::out << "  [" << this->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;
             }
         }
     }
 }

◆ initialize()

void libMesh::Nemesis_IO_Helper::initialize	(	std::string	title,
		const MeshBase &	mesh,
		bool	use_discontinuous = `false`
	)

overridevirtual

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 763 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, mesh, libMesh::ParallelObject::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().

 {
   // Make sure that the reference passed in is really a DistributedMesh
   // const DistributedMesh & pmesh = cast_ref<const DistributedMesh &>(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(this->n_processors(), 1, "p");
 
 
   // Gather global "initial" information for Nemesis.  This consists of
   // three parts labeled 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();
 
   // Do we have communication maps to write?  Note that
   // ne_put_cmap_params expects us to have either *both* node and elem
   // cmaps or *neither*
   if (!this->node_cmap_ids.empty() &&
       !this->node_cmap_node_cnts.empty() &&
       !this->elem_cmap_ids.empty() &&
       !this->elem_cmap_elem_cnts.empty())
     {
       // 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 communication, 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()

◆ initialize_element_variables()

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

overridevirtual

Override the Exodus Helper's implementation of this function so that it works correctly in parallel.

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 2531 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::_elem_vars_initialized, libMesh::ExodusII_IO_Helper::check_existing_vars(), libMesh::ExodusII_IO_Helper::elem_var_names, libMesh::ExodusII_IO_Helper::ELEMENTAL, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, ex_put_elem_var_tab(), global_elem_blk_ids, libMesh::ExodusII_IO_Helper::num_elem_vars, and libMesh::ExodusII_IO_Helper::write_var_names().

 {
   // Quick return if there are no element variables to write
   if (names.size() == 0)
     return;
 
   // Quick return if we have already called this function
   if (_elem_vars_initialized)
     return;
 
   // Be sure that variables in the file match what we are asking for
   if (num_elem_vars > 0)
     {
       this->check_existing_vars(ELEMENTAL, names, this->elem_var_names);
       return;
     }
 
   // Set the flag so we can skip this stuff on subsequent calls to
   // initialize_element_variables()
   _elem_vars_initialized = true;
 
   this->write_var_names(ELEMENTAL, names);
 
   // Create a truth table from global_elem_blk_ids and the information
   // in vars_active_subdomains. Create a truth table of
   // size global_elem_blk_ids.size() * names.size().
   std::vector<int> truth_tab(global_elem_blk_ids.size() * names.size());
   for (unsigned int blk=0; blk<global_elem_blk_ids.size(); ++blk)
     for (unsigned int var=0; var<names.size(); ++var)
       if (vars_active_subdomains[var].empty() ||
           vars_active_subdomains[var].count
             (cast_int<subdomain_id_type>(global_elem_blk_ids[blk])))
         truth_tab[names.size()*blk + var] = 1;
 
   // Write truth table to file.
   if (truth_tab.size())
     {
       ex_err = exII::ex_put_elem_var_tab(ex_id,
                                          cast_int<int>(global_elem_blk_ids.size()),
                                          cast_int<int>(names.size()),
                                          truth_tab.data());
       EX_CHECK_ERR(ex_err, "Error writing element truth table.");
     }
 }

◆ initialize_global_variables()

void libMesh::ExodusII_IO_Helper::initialize_global_variables ( std::vector< std::string > names )

inherited

Sets up the global variables

Definition at line 1788 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::check_existing_vars(), libMesh::ExodusII_IO_Helper::GLOBAL, libMesh::ExodusII_IO_Helper::global_var_names, libMesh::ExodusII_IO_Helper::num_global_vars, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::write_var_names().

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   // Quick return if there are no global variables to write
   if (names.size() == 0)
     return;
 
   if (_global_vars_initialized)
     return;
 
   // Be sure that variables in the file match what we are asking for
   if (num_global_vars > 0)
     {
       this->check_existing_vars(GLOBAL, names, this->global_var_names);
       return;
     }
 
   _global_vars_initialized = true;
 
   this->write_var_names(GLOBAL, names);
 }

◆ initialize_nodal_variables()

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

inherited

Sets up the nodal variables

Definition at line 1760 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_nodal_vars_initialized, libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::check_existing_vars(), libMesh::ExodusII_IO_Helper::NODAL, libMesh::ExodusII_IO_Helper::nodal_var_names, libMesh::ExodusII_IO_Helper::num_nodal_vars, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::write_var_names().

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   // Quick return if there are no nodal variables to write
   if (names.size() == 0)
     return;
 
   // Quick return if we have already called this function
   if (_nodal_vars_initialized)
     return;
 
   // Be sure that variables in the file match what we are asking for
   if (num_nodal_vars > 0)
     {
       this->check_existing_vars(NODAL, names, this->nodal_var_names);
       return;
     }
 
   // Set the flag so we can skip the rest of this function on subsequent calls.
   _nodal_vars_initialized = true;
 
   this->write_var_names(NODAL, names);
 }

◆ inquire()

int libMesh::ExodusII_IO_Helper::inquire	(	int	req_info,
		std::string	error_msg = `""`
	)

inherited

Returns: The value obtained from a generic exII::ex_inquire() call.

Definition at line 814 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, and ex_inquire().

Referenced by libMesh::ExodusII_IO_Helper::read_num_time_steps(), libMesh::ExodusII_IO_Helper::read_qa_records(), libMesh::ExodusII_IO_Helper::read_sideset_info(), and libMesh::ExodusII_IO_Helper::write_information_records().

 {
   int ret_int = 0;
   char ret_char = 0;
   float ret_float = 0.;
 
   ex_err = exII::ex_inquire(ex_id,
                             req_info_in,
                             &ret_int,
                             &ret_float,
                             &ret_char);
 
   EX_CHECK_ERR(ex_err, error_msg);
 
   return ret_int;
 }

◆ message() [1/2]

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

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

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

◆ message() [2/2]

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

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

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

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 95 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::size().

96 { return cast_int<processor_id_type>(_communicator.size()); }

libMesh::Parallel::Communicator::size

processor_id_type size() const

Definition: communicator.h:175

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

◆ open()

void libMesh::ExodusII_IO_Helper::open	(	const char *	filename,
		bool	read_only
	)

inherited

Opens an ExodusII mesh file named filename. If read_only==true, the file will be opened with the EX_READ flag, otherwise it will be opened with the EX_WRITE flag.

Definition at line 335 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_single_precision, libMesh::ExodusII_IO_Helper::current_filename, libMesh::ExodusII_IO_Helper::ex_id, std::min(), libMesh::ExodusII_IO_Helper::opened_for_reading, libMesh::ExodusII_IO_Helper::opened_for_writing, libMesh::out, libMesh::Real, and libMesh::ExodusII_IO_Helper::verbose.

 {
   // Version of Exodus you are using
   float ex_version = 0.;
 
   int comp_ws = 0;
 
   if (_single_precision)
     comp_ws = cast_int<int>(sizeof(float));
 
   // Fall back on double precision when necessary since ExodusII
   // doesn't seem to support long double
   else
     comp_ws = cast_int<int>(std::min(sizeof(Real), sizeof(double)));
 
   // Word size in bytes of the floating point data as they are stored
   // in the ExodusII file.  "If this argument is 0, the word size of the
   // floating point data already stored in the file is returned"
   int io_ws = 0;
 
   ex_id = exII::ex_open(filename,
                         read_only ? EX_READ : EX_WRITE,
                         &comp_ws,
                         &io_ws,
                         &ex_version);
 
   std::string err_msg = std::string("Error opening ExodusII mesh file: ") + std::string(filename);
   EX_CHECK_ERR(ex_id, err_msg);
   if (verbose) libMesh::out << "File opened successfully." << std::endl;
 
   if (read_only)
     opened_for_reading = true;
   else
     opened_for_writing = true;
 
   current_filename = std::string(filename);
 }

◆ print_header()

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

References 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, libMesh::ExodusII_IO_Helper::title, and libMesh::ExodusII_IO_Helper::verbose.

 {
   if (verbose)
     libMesh::out << "Title: \t" << title.data() << 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;
 }

◆ print_nodes()

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 509 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;
 }

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 101 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

102 { return cast_int<processor_id_type>(_communicator.rank()); }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

Definition: communicator.h:173

◆ put_cmap_params()

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 Nemesis User's Manual is wrong. The correct order is (ids, counts, ids, counts). Must be called after put_loadbal_param().

Definition at line 573 of file nemesis_io_helper.C.

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

Referenced by initialize().

 {
   libmesh_assert(!node_cmap_ids_in.empty());
   libmesh_assert(!node_cmap_node_cnts_in.empty());
   libmesh_assert(!elem_cmap_ids_in.empty());
   libmesh_assert(!elem_cmap_elem_cnts_in.empty());
 
   nemesis_err_flag =
     Nemesis::ne_put_cmap_params(ex_id,
                                 node_cmap_ids_in.data(),
                                 node_cmap_node_cnts_in.data(),
                                 elem_cmap_ids_in.data(),
                                 elem_cmap_elem_cnts_in.data(),
                                 this->processor_id());
 
   EX_CHECK_ERR(nemesis_err_flag, "Error writing cmap parameters!");
 }

◆ put_eb_info_global()

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 493 of file nemesis_io_helper.C.

References 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.data(),
                                    global_elem_blk_cnts_in.data());
 
   EX_CHECK_ERR(nemesis_err_flag, "Error writing global element block information!");
 }

◆ put_elem_cmap()

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 elem_cmap_elem_ids, elem_cmap_side_ids, abd elem_cmap_proc_ids which can be used when calling this function.

Must be called after put_cmap_params().

Definition at line 659 of file nemesis_io_helper.C.

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

Referenced by initialize().

 {
   for (std::size_t 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].data(),
                                   elem_cmap_side_ids_in[i].data(),
                                   elem_cmap_proc_ids_in[i].data(),
                                   this->processor_id());
 
       EX_CHECK_ERR(nemesis_err_flag, "Error writing elem communication map to file!");
     }
 }

◆ put_elem_map()

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 680 of file nemesis_io_helper.C.

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

Referenced by initialize().

 {
   nemesis_err_flag =
     Nemesis::ne_put_elem_map(ex_id,
                              elem_mapi_in.empty() ? nullptr : elem_mapi_in.data(),
                              elem_mapb_in.empty() ? nullptr : elem_mapb_in.data(),
                              this->processor_id());
 
   EX_CHECK_ERR(nemesis_err_flag, "Error writing Nemesis internal and border element maps to file!");
 }

◆ put_init_global()

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 474 of file nemesis_io_helper.C.

References 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);
 
   EX_CHECK_ERR(nemesis_err_flag, "Error writing initial global data!");
 }

◆ put_init_info()

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 458 of file nemesis_io_helper.C.

References 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));
 
   EX_CHECK_ERR(nemesis_err_flag, "Error writing initial information!");
 }

◆ put_loadbal_param()

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 547 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::ex_id, nemesis_err_flag, and libMesh::ParallelObject::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,
                                   this->processor_id());
 
   EX_CHECK_ERR(nemesis_err_flag, "Error writing loadbal parameters!");
 }

◆ put_n_coord()

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 697 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::ex_id, and nemesis_err_flag.

 {
   if (num_nodes_in)
     {
       nemesis_err_flag =
         Nemesis::ne_put_n_coord(ex_id,
                                 start_node_num,
                                 num_nodes_in,
                                 x_coor.empty() ? nullptr : x_coor.data(),
                                 y_coor.empty() ? nullptr : y_coor.data(),
                                 z_coor.empty() ? nullptr : z_coor.data());
 
       EX_CHECK_ERR(nemesis_err_flag, "Error writing coords to file!");
     }
 }

◆ put_node_cmap()

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 appear 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 node_cmap_node_ids and node_cmap_proc_ids which can be used when calling this function.

Must be called after put_cmap_params().

Definition at line 597 of file nemesis_io_helper.C.

References libMesh::ExodusII_IO_Helper::ex_id, nemesis_err_flag, node_cmap_ids, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

Referenced by initialize().

 {
 
   // Print to screen what we are about to print to Nemesis file
   if (verbose)
     {
       for (std::size_t i=0; i<node_cmap_node_ids_in.size(); ++i)
         {
           libMesh::out << "[" << this->processor_id() << "] put_node_cmap() : nodes communicated to proc "
                        << this->node_cmap_ids[i]
                        << " = ";
           for (std::size_t 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 (std::size_t i=0; i<node_cmap_node_ids_in.size(); ++i)
         {
           libMesh::out << "[" << this->processor_id() << "] put_node_cmap() : processor IDs = ";
           for (std::size_t 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 (std::size_t i=0; i<node_cmap_node_ids_in.size(); ++i)
     {
       int * node_ids_ptr = node_cmap_node_ids_in[i].empty() ?
         nullptr : node_cmap_node_ids_in[i].data();
       int * proc_ids_ptr = node_cmap_proc_ids_in[i].empty() ?
         nullptr : node_cmap_proc_ids_in[i].data();
 
       nemesis_err_flag =
         Nemesis::ne_put_node_cmap(ex_id, this->node_cmap_ids[i],
                                   node_ids_ptr, proc_ids_ptr,
                                   this->processor_id());
 
       EX_CHECK_ERR(nemesis_err_flag, "Error writing node communication map to file!");
     }
 }

◆ put_node_map()

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 642 of file nemesis_io_helper.C.

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

Referenced by initialize().

 {
   nemesis_err_flag =
     Nemesis::ne_put_node_map(ex_id,
                              node_mapi_in.empty() ? nullptr : node_mapi_in.data(),
                              node_mapb_in.empty() ? nullptr : node_mapb_in.data(),
                              node_mape_in.empty() ? nullptr : node_mape_in.data(),
                              this->processor_id());
 
   EX_CHECK_ERR(nemesis_err_flag, "Error writing Nemesis internal and border node maps to file!");
 }

◆ put_ns_param_global()

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 507 of file nemesis_io_helper.C.

References 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.data(),
                                         num_global_node_counts_in.data(),
                                         num_global_node_df_counts_in.data());
     }
 
   EX_CHECK_ERR(nemesis_err_flag, "Error writing global nodeset parameters!");
 }

◆ put_ss_param_global()

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 527 of file nemesis_io_helper.C.

References 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.data(),
                                         num_global_side_counts_in.data(),
                                         num_global_side_df_counts_in.data());
     }
 
   EX_CHECK_ERR(nemesis_err_flag, "Error writing global sideset parameters!");
 }

◆ read_block_info()

void libMesh::ExodusII_IO_Helper::read_block_info ( )

inherited

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

Definition at line 517 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::block_ids, 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.

 {
   block_ids.resize(num_elem_blk);
   // Get all element block IDs.
   ex_err = exII::ex_get_elem_blk_ids(ex_id,
                                      block_ids.empty() ? nullptr : block_ids.data());
   // Usually, there is only one
   // block since there is only
   // one type of element.
   // However, there could be more.
 
   EX_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);
       EX_CHECK_ERR(ex_err, "Error getting block name.");
       id_to_block_names[block_ids[i]] = name_buffer;
     }
   message("All block names retrieved successfully.");
 }

◆ read_elem_in_block()

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

References libMesh::ExodusII_IO_Helper::block_ids, 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, libMesh::out, and libMesh::ExodusII_IO_Helper::verbose.

 {
   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.data(),
                                    &num_elem_this_blk,
                                    &num_nodes_per_elem,
                                    &num_attr);
   if (verbose)
     libMesh::out << "Reading a block of " << num_elem_this_blk
                  << " " << elem_type.data() << "(s)"
                  << " having " << num_nodes_per_elem
                  << " nodes per element." << std::endl;
 
   EX_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.data());
 
       EX_CHECK_ERR(ex_err, "Error reading block connectivity.");
       message("Connectivity retrieved successfully for block: ", block);
     }
 }

◆ read_elem_num_map()

void libMesh::ExodusII_IO_Helper::read_elem_num_map ( )

inherited

Reads the optional node_num_map from the ExodusII mesh file.

Definition at line 639 of file exodusII_io_helper.C.

References 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, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   elem_num_map.resize(num_elem);
 
   ex_err = exII::ex_get_elem_num_map (ex_id,
                                       elem_num_map.empty() ? nullptr : elem_num_map.data());
 
   EX_CHECK_ERR(ex_err, "Error retrieving element number map.");
   message("Element numbering map retrieved successfully.");
 
 
   if (verbose)
     {
       libMesh::out << "[" << this->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;
     }
 }

◆ read_elemental_var_values()

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

inherited

Reads elemental values for the variable 'elemental_var_name' at the specified timestep into the 'elem_var_value_map' which is passed in.

Definition at line 1012 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::block_ids, libMesh::ExodusII_IO_Helper::elem_num_map, libMesh::ExodusII_IO_Helper::elem_var_names, libMesh::ExodusII_IO_Helper::ELEMENTAL, libMesh::err, libMesh::ExodusII_IO_Helper::ex_err, ex_get_elem_block(), ex_get_elem_var(), libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::num_elem, libMesh::ExodusII_IO_Helper::num_elem_blk, libMesh::ExodusII_IO_Helper::num_elem_this_blk, and libMesh::ExodusII_IO_Helper::read_var_names().

 {
   this->read_var_names(ELEMENTAL);
 
   // 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 != elem_var_names.size(); ++var_index)
     if (elem_var_names[var_index] == elemental_var_name)
       {
         found = true;
         break;
       }
 
   if (!found)
     {
       libMesh::err << "Available variables: " << std::endl;
       for (const auto & var_name : elem_var_names)
         libMesh::err << var_name << std::endl;
 
       libmesh_error_msg("Unable to locate variable named: " << elemental_var_name);
     }
 
   // Sequential index which we can use to look up the element ID in the elem_num_map.
   unsigned ex_el_num = 0;
 
   for (unsigned i=0; i<static_cast<unsigned>(num_elem_blk); i++)
     {
       ex_err = exII::ex_get_elem_block(ex_id,
                                        block_ids[i],
                                        nullptr,
                                        &num_elem_this_blk,
                                        nullptr,
                                        nullptr);
       EX_CHECK_ERR(ex_err, "Error getting number of elements in block.");
 
       std::vector<Real> block_elem_var_values(num_elem);
       ex_err = exII::ex_get_elem_var(ex_id,
                                      time_step,
                                      var_index+1,
                                      block_ids[i],
                                      num_elem_this_blk,
                                      block_elem_var_values.data());
       EX_CHECK_ERR(ex_err, "Error getting elemental values.");
 
       for (unsigned j=0; j<static_cast<unsigned>(num_elem_this_blk); j++)
         {
           // Use the elem_num_map to obtain the ID of this element in the Exodus file,
           // and remember to subtract 1 since libmesh is zero-based and Exodus is 1-based.
           unsigned mapped_elem_id = this->elem_num_map[ex_el_num] - 1;
 
           // Store the elemental value in the map.
           elem_var_value_map[mapped_elem_id] = block_elem_var_values[j];
 
           // Go to the next sequential element ID.
           ex_el_num++;
         }
     }
 }

◆ read_global_values()

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

inherited

Reads the vector of global variables.

Definition at line 2031 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::ex_err, ex_get_glob_vars(), libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::num_global_vars, and libMesh::ParallelObject::processor_id().

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   values.clear();
   values.resize(num_global_vars);
   ex_err = exII::ex_get_glob_vars(ex_id, timestep, num_global_vars, values.data());
   EX_CHECK_ERR(ex_err, "Error reading global values.");
 }

◆ read_header()

void libMesh::ExodusII_IO_Helper::read_header ( )

inherited

Reads an ExodusII mesh file header.

Definition at line 375 of file exodusII_io_helper.C.

 {
   ex_err = exII::ex_get_init(ex_id,
                              title.data(),
                              &num_dim,
                              &num_nodes,
                              &num_elem,
                              &num_elem_blk,
                              &num_node_sets,
                              &num_side_sets);
 
   EX_CHECK_ERR(ex_err, "Error retrieving header info.");
 
   this->read_num_time_steps();
 
   ex_err = exII::ex_get_var_param(ex_id, "n", &num_nodal_vars);
   EX_CHECK_ERR(ex_err, "Error reading number of nodal variables.");
 
   ex_err = exII::ex_get_var_param(ex_id, "e", &num_elem_vars);
   EX_CHECK_ERR(ex_err, "Error reading number of elemental variables.");
 
   ex_err = exII::ex_get_var_param(ex_id, "g", &num_global_vars);
   EX_CHECK_ERR(ex_err, "Error reading number of global variables.");
 
   message("Exodus header info retrieved successfully.");
 }

◆ read_nodal_var_values()

void libMesh::ExodusII_IO_Helper::read_nodal_var_values	(	std::string	nodal_var_name,
		int	time_step
	)

inherited

Reads the nodal values for the variable 'nodal_var_name' at the specified time into the 'nodal_var_values' array.

Definition at line 856 of file exodusII_io_helper.C.

References libMesh::err, libMesh::ExodusII_IO_Helper::ex_err, ex_get_nodal_var(), libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::NODAL, libMesh::ExodusII_IO_Helper::nodal_var_names, libMesh::ExodusII_IO_Helper::nodal_var_values, libMesh::ExodusII_IO_Helper::num_nodes, and libMesh::ExodusII_IO_Helper::read_var_names().

 {
   // Read the nodal variable names from file, so we can see if we have the one we're looking for
   this->read_var_names(NODAL);
 
   // 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 << "Available variables: " << std::endl;
       for (const auto & var_name : nodal_var_names)
         libMesh::err << var_name << std::endl;
 
       libmesh_error_msg("Unable to locate variable named: " << nodal_var_name);
     }
 
   // Allocate enough space to store the nodal variable values
   nodal_var_values.resize(num_nodes);
 
   // Call the Exodus API to read the nodal variable values
   ex_err = exII::ex_get_nodal_var(ex_id,
                                   time_step,
                                   var_index+1,
                                   num_nodes,
                                   nodal_var_values.data());
   EX_CHECK_ERR(ex_err, "Error reading nodal variable values!");
 }

◆ read_node_num_map()

void libMesh::ExodusII_IO_Helper::read_node_num_map ( )

inherited

Reads the optional node_num_map from the ExodusII mesh file.

Definition at line 489 of file exodusII_io_helper.C.

References 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, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

 {
   node_num_map.resize(num_nodes);
 
   ex_err = exII::ex_get_node_num_map (ex_id,
                                       node_num_map.empty() ? nullptr : node_num_map.data());
 
   EX_CHECK_ERR(ex_err, "Error retrieving nodal number map.");
   message("Nodal numbering map retrieved successfully.");
 
   if (verbose)
     {
       libMesh::out << "[" << this->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;
     }
 }

◆ read_nodes()

void libMesh::ExodusII_IO_Helper::read_nodes ( )

inherited

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

Definition at line 469 of file exodusII_io_helper.C.

References 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.

 {
   x.resize(num_nodes);
   y.resize(num_nodes);
   z.resize(num_nodes);
 
   if (num_nodes)
     {
       ex_err = exII::ex_get_coord(ex_id,
                                   static_cast<void *>(x.data()),
                                   static_cast<void *>(y.data()),
                                   static_cast<void *>(z.data()));
 
       EX_CHECK_ERR(ex_err, "Error retrieving nodal data.");
       message("Nodal data retrieved successfully.");
     }
 }

◆ read_nodeset()

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

References 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.

 {
   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]);
   EX_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.data());
 
       EX_CHECK_ERR(ex_err, "Error retrieving nodeset data.");
       message("Data retrieved successfully for nodeset: ", id);
     }
 }

◆ read_nodeset_info()

void libMesh::ExodusII_IO_Helper::read_nodeset_info ( )

inherited

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

Definition at line 694 of file exodusII_io_helper.C.

References 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.

 {
   nodeset_ids.resize(num_node_sets);
   if (num_node_sets > 0)
     {
       ex_err = exII::ex_get_node_set_ids(ex_id,
                                          nodeset_ids.data());
       EX_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);
       EX_CHECK_ERR(ex_err, "Error getting node set name.");
       id_to_ns_names[nodeset_ids[i]] = name_buffer;
     }
   message("All node set names retrieved successfully.");
 }

◆ read_num_time_steps()

void libMesh::ExodusII_IO_Helper::read_num_time_steps ( )

inherited

Reads the number of timesteps currently stored in the Exodus file and stores it in the num_time_steps variable.

Definition at line 848 of file exodusII_io_helper.C.

References EX_INQ_TIME, libMesh::ExodusII_IO_Helper::inquire(), and libMesh::ExodusII_IO_Helper::num_time_steps.

Referenced by libMesh::ExodusII_IO_Helper::read_header(), and libMesh::ExodusII_IO_Helper::read_time_steps().

 {
   num_time_steps =
     this->inquire(exII::EX_INQ_TIME, "Error retrieving number of time steps");
 }

◆ read_qa_records()

void libMesh::ExodusII_IO_Helper::read_qa_records ( )

inherited

Reads the QA records from an ExodusII file. We can use this to detect when e.g. CUBIT 14+ was used to generate a Mesh file, and work around certain known bugs in that version.

Definition at line 405 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::ex_err, ex_get_qa(), libMesh::ExodusII_IO_Helper::ex_id, EX_INQ_QA, libMesh::ExodusII_IO_Helper::inquire(), libMesh::out, and libMesh::ExodusII_IO_Helper::verbose.

 {
   // The QA records are four MAX_STR_LENGTH-byte character strings.
   int num_qa_rec =
     this->inquire(exII::EX_INQ_QA, "Error retrieving number of QA records");
 
   if (verbose)
     libMesh::out << "Found "
                  << num_qa_rec
                  << " QA record(s) in the Exodus file."
                  << std::endl;
 
   if (num_qa_rec > 0)
     {
       // How to dynamically allocate an array of fixed-size char * arrays in C++.
       // http://stackoverflow.com/questions/8529359/creating-a-dynamic-sized-array-of-fixed-sized-int-arrays-in-c
       typedef char * inner_array_t[4];
       inner_array_t * qa_record = new inner_array_t[num_qa_rec];
 
       for (int i=0; i<num_qa_rec; i++)
         for (int j=0; j<4; j++)
           qa_record[i][j] = new char[MAX_STR_LENGTH+1];
 
       ex_err = exII::ex_get_qa (ex_id, qa_record);
       EX_CHECK_ERR(ex_err, "Error reading the QA records.");
 
       // Print the QA records
       if (verbose)
         {
           for (int i=0; i<num_qa_rec; i++)
             {
               libMesh::out << "QA Record: " << i << std::endl;
               for (int j=0; j<4; j++)
                 libMesh::out << qa_record[i][j] << std::endl;
             }
         }
 
 
       // Clean up dynamically-allocated memory
       for (int i=0; i<num_qa_rec; i++)
         for (int j=0; j<4; j++)
           delete [] qa_record[i][j];
 
       delete [] qa_record;
     }
 }

◆ read_sideset()

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

References 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.

 {
   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]);
   EX_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]);
       EX_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];
     }
 }

◆ read_sideset_info()

void libMesh::ExodusII_IO_Helper::read_sideset_info ( )

inherited

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

Definition at line 661 of file exodusII_io_helper.C.

 {
   ss_ids.resize(num_side_sets);
   if (num_side_sets > 0)
     {
       ex_err = exII::ex_get_side_set_ids(ex_id,
                                          ss_ids.data());
       EX_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
       num_elem_all_sidesets = inquire(exII::EX_INQ_SS_ELEM_LEN, "Error retrieving length of the concatenated side sets element list!");
 
       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);
       EX_CHECK_ERR(ex_err, "Error getting side set name.");
       id_to_ss_names[ss_ids[i]] = name_buffer;
     }
   message("All side set names retrieved successfully.");
 }

◆ read_time_steps()

void libMesh::ExodusII_IO_Helper::read_time_steps ( )

inherited

Reads and stores the timesteps in the 'time_steps' array.

Definition at line 833 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::ex_err, ex_get_all_times(), libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::num_time_steps, libMesh::ExodusII_IO_Helper::read_num_time_steps(), and libMesh::ExodusII_IO_Helper::time_steps.

 {
   // Make sure we have an up-to-date count of the number of time steps in the file.
   this->read_num_time_steps();
 
   if (num_time_steps > 0)
     {
       time_steps.resize(num_time_steps);
       ex_err = exII::ex_get_all_times(ex_id, time_steps.data());
       EX_CHECK_ERR(ex_err, "Error reading timesteps!");
     }
 }

◆ read_var_names()

void libMesh::ExodusII_IO_Helper::read_var_names ( ExodusVarType type )

inherited

Definition at line 896 of file exodusII_io_helper.C.

References

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ proc_border_elem_sets_iterator

◆ proc_nodes_touched_iterator

Member Enumeration Documentation

◆ ExodusVarType

Constructor & Destructor Documentation

◆ Nemesis_IO_Helper()

◆ ~Nemesis_IO_Helper()

Member Function Documentation

◆ build_element_and_node_maps()

◆ check_existing_vars()

◆ close()

◆ comm()

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

◆ construct_nemesis_filename()

◆ create()

◆ get_block_id()

◆ get_block_name()

◆ get_cmap_params()

◆ get_complex_names()

◆ get_complex_vars_active_subdomains()

◆ get_eb_info_global()

◆ get_elem_cmap()

◆ get_elem_map()

◆ get_elem_type()

◆ get_init_global()

◆ get_init_info()

◆ get_loadbal_param()

◆ get_node_cmap()

◆ get_node_map()

◆ get_node_set_id()

◆ get_node_set_name()

◆ get_ns_param_global()

◆ get_side_set_id()

◆ get_side_set_name()

◆ get_ss_param_global()

◆ initialize()

◆ initialize_element_variables()

◆ initialize_global_variables()

◆ initialize_nodal_variables()

◆ inquire()

◆ message() [1/2]

◆ message() [2/2]

◆ n_processors()

◆ open()

◆ print_header()

◆ print_nodes()

◆ processor_id()

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

◆ read_block_info()

◆ read_elem_in_block()