#include <exodusII_io_helper.h>

Inheritance diagram for libMesh::ExodusII_IO_Helper:

Classes
class	Conversion

class	ElementMaps

class	NamesData

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

Public Member Functions
	ExodusII_IO_Helper (const ParallelObject &parent, bool v=false, bool run_only_on_proc0=true, bool single_precision=false)

virtual	~ExodusII_IO_Helper ()

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)

virtual void	create (std::string filename)

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

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

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

virtual void	write_sidesets (const MeshBase &mesh)

virtual void	write_nodesets (const MeshBase &mesh)

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

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	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 Member Functions
void	read_var_names_impl (const char *var_type, int &count, std::vector< std::string > &result)

void	write_var_names_impl (const char *var_type, int &count, std::vector< std::string > &names)

Detailed Description

This is the ExodusII_IO_Helper class. This class hides the implementation details of interfacing with the Exodus binary format.

Author: John W. Peterson

Date: 2002

Definition at line 96 of file exodusII_io_helper.h.

Member Enumeration Documentation

◆ ExodusVarType

enum libMesh::ExodusII_IO_Helper::ExodusVarType

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

◆ ExodusII_IO_Helper()

libMesh::ExodusII_IO_Helper::ExodusII_IO_Helper	(	const ParallelObject &	parent,
		bool	v = `false`,
		bool	run_only_on_proc0 = `true`,
		bool	single_precision = `false`
	)

Constructor. Automatically initializes all the private members of the class. Also allows you to set the verbosity level to v=true (on) or v=false (off). The second argument, if true, tells the class to only perform its actions if running on processor zero. If you initialize this to false, the writing methods will run on all processors instead.

Definition at line 270 of file exodusII_io_helper.C.

References elem_type, and title.

                                                               :
   ParallelObject(parent),
   ex_id(0),
   ex_err(0),
   num_dim(0),
   num_global_vars(0),
   num_nodes(0),
   num_elem(0),
   num_elem_blk(0),
   num_node_sets(0),
   num_side_sets(0),
   num_elem_this_blk(0),
   num_nodes_per_elem(0),
   num_attr(0),
   num_elem_all_sidesets(0),
   num_time_steps(0),
   num_nodal_vars(0),
   num_elem_vars(0),
   verbose(v),
   opened_for_writing(false),
   opened_for_reading(false),
   _run_only_on_proc0(run_only_on_proc0),
   _elem_vars_initialized(false),
   _global_vars_initialized(false),
   _nodal_vars_initialized(false),
   _use_mesh_dimension_instead_of_spatial_dimension(false),
   _write_as_dimension(0),
   _single_precision(single_precision)
 {
   title.resize(MAX_LINE_LENGTH+1);
   elem_type.resize(MAX_STR_LENGTH);
 }

◆ ~ExodusII_IO_Helper()

libMesh::ExodusII_IO_Helper::~ExodusII_IO_Helper ( )

virtual

Destructor.

Definition at line 308 of file exodusII_io_helper.C.

309 {

310 }

Member Function Documentation

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

protected

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 read_var_names().

Referenced by initialize_element_variables(), libMesh::Nemesis_IO_Helper::initialize_element_variables(), initialize_global_variables(), and 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 ( )

Closes the ExodusII mesh file.

Definition at line 795 of file exodusII_io_helper.C.

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

Referenced by libMesh::Nemesis_IO_Helper::~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

◆ create()

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

virtual

Opens an ExodusII mesh file named filename for writing.

Reimplemented in libMesh::Nemesis_IO_Helper.

Definition at line 1079 of file exodusII_io_helper.C.

References _run_only_on_proc0, _single_precision, current_filename, ex_id, std::min(), opened_for_writing, libMesh::out, libMesh::ParallelObject::processor_id(), libMesh::Real, and verbose.

 {
   // If we're processor 0, always create the file.
   // If we running on all procs, e.g. as one of several Nemesis files, also
   // call create there.
   if ((this->processor_id() == 0) || (!_run_only_on_proc0))
     {
       int
         comp_ws = 0,
         io_ws = 0;
 
       if (_single_precision)
         {
           comp_ws = cast_int<int>(sizeof(float));
           io_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)));
           io_ws = cast_int<int>
             (std::min(sizeof(Real), sizeof(double)));
         }
 
       ex_id = exII::ex_create(filename.c_str(), EX_CLOBBER, &comp_ws, &io_ws);
 
       EX_CHECK_ERR(ex_id, "Error creating ExodusII mesh file.");
 
       if (verbose)
         libMesh::out << "File created successfully." << std::endl;
     }
 
   opened_for_writing = true;
   current_filename = filename;
 }

◆ get_block_id()

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

Get the block number for the given block index.

Definition at line 544 of file exodusII_io_helper.C.

References block_ids.

Referenced by 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 )

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 block_ids, and id_to_block_names.

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

◆ get_complex_names()

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

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

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

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

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

 {
   return elem_type.data();
 }

◆ get_node_set_id()

int libMesh::ExodusII_IO_Helper::get_node_set_id ( int index )

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

Definition at line 580 of file exodusII_io_helper.C.

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

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 id_to_ns_names, and nodeset_ids.

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

◆ get_side_set_id()

int libMesh::ExodusII_IO_Helper::get_side_set_id ( int index )

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

Definition at line 562 of file exodusII_io_helper.C.

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

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 id_to_ss_names, and ss_ids.

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

◆ initialize()

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

virtual

Initializes the Exodus file.

Reimplemented in libMesh::Nemesis_IO_Helper.

Definition at line 1119 of file exodusII_io_helper.C.

 {
   // n_active_elem() is a parallel_only function
   unsigned int n_active_elem = mesh.n_active_elem();
 
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   // If _write_as_dimension is nonzero, use it to set num_dim in the Exodus file.
   if (_write_as_dimension)
     num_dim = _write_as_dimension;
   else if (_use_mesh_dimension_instead_of_spatial_dimension)
     num_dim = mesh.mesh_dimension();
   else
     num_dim = mesh.spatial_dimension();
 
   num_elem = mesh.n_elem();
 
   if (!use_discontinuous)
     {
       // Don't rely on mesh.n_nodes() here.  If nodes have been
       // deleted recently, it will be incorrect.
       num_nodes = cast_int<int>(std::distance(mesh.nodes_begin(),
                                               mesh.nodes_end()));
     }
   else
     {
       for (const auto & elem : mesh.active_element_ptr_range())
         num_nodes += elem->n_nodes();
     }
 
   std::vector<boundary_id_type> unique_side_boundaries;
   std::vector<boundary_id_type> unique_node_boundaries;
 
   mesh.get_boundary_info().build_side_boundary_ids(unique_side_boundaries);
   {
     // Add shell face boundaries to the list of side boundaries, since ExodusII
     // treats these the same way.
     std::vector<boundary_id_type> shellface_boundaries;
     mesh.get_boundary_info().build_shellface_boundary_ids(shellface_boundaries);
     for (const auto & id : shellface_boundaries)
       unique_side_boundaries.push_back(id);
   }
   mesh.get_boundary_info().build_node_boundary_ids(unique_node_boundaries);
 
   num_side_sets = cast_int<int>(unique_side_boundaries.size());
   num_node_sets = cast_int<int>(unique_node_boundaries.size());
 
   //loop through element and map between block and element vector
   std::map<subdomain_id_type, std::vector<unsigned int>> subdomain_map;
 
   for (const auto & elem : mesh.active_element_ptr_range())
     {
       // We skip writing infinite elements to the Exodus file, so
       // don't put them in the subdomain_map. That way the number of
       // blocks should be correct.
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
       if (elem->infinite())
         continue;
 #endif
 
       subdomain_id_type cur_subdomain = elem->subdomain_id();
       subdomain_map[cur_subdomain].push_back(elem->id());
     }
   num_elem_blk = cast_int<int>(subdomain_map.size());
 
   if (str_title.size() > MAX_LINE_LENGTH)
     {
       libMesh::err << "Warning, Exodus files cannot have titles longer than "
                    << MAX_LINE_LENGTH
                    << " characters.  Your title will be truncated."
                    << std::endl;
       str_title.resize(MAX_LINE_LENGTH);
     }
 
   ex_err = exII::ex_put_init(ex_id,
                              str_title.c_str(),
                              num_dim,
                              num_nodes,
                              n_active_elem,
                              num_elem_blk,
                              num_node_sets,
                              num_side_sets);
 
   EX_CHECK_ERR(ex_err, "Error initializing new Exodus file.");
 }

◆ initialize_element_variables()

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

virtual

Sets up the nodal variables

Reimplemented in libMesh::Nemesis_IO_Helper.

Definition at line 1695 of file exodusII_io_helper.C.

References _elem_vars_initialized, _run_only_on_proc0, block_ids, check_existing_vars(), elem_var_names, ELEMENTAL, ex_err, ex_id, ex_put_elem_var_tab(), libMesh::index_range(), num_elem_blk, num_elem_vars, libMesh::ParallelObject::processor_id(), and write_var_names().

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   // 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);
 
   // Use the truth table to indicate which subdomain/variable pairs are
   // active according to vars_active_subdomains.
   std::vector<int> truth_tab(num_elem_blk*num_elem_vars, 0);
   for (auto var_num : index_range(vars_active_subdomains))
     {
       // If the list of active subdomains is empty, it is interpreted as being
       // active on *all* subdomains.
       std::set<subdomain_id_type> current_set;
       if (vars_active_subdomains[var_num].empty())
         for (auto block_id : block_ids)
           current_set.insert(cast_int<subdomain_id_type>(block_id));
       else
         current_set = vars_active_subdomains[var_num];
 
       // Find index into the truth table for each id in current_set.
       for (auto block_id : current_set)
         {
           auto it = std::find(block_ids.begin(), block_ids.end(), block_id);
           if (it == block_ids.end())
             libmesh_error_msg("ExodusII_IO_Helper: block id " << block_id << " not found in block_ids.");
 
           std::size_t block_index =
             std::distance(block_ids.begin(), it);
 
           std::size_t truth_tab_index = block_index*num_elem_vars + var_num;
           truth_tab[truth_tab_index] = 1;
         }
     }
 
   ex_err = exII::ex_put_elem_var_tab(ex_id,
                                      num_elem_blk,
                                      num_elem_vars,
                                      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 )

Sets up the global variables

Definition at line 1788 of file exodusII_io_helper.C.

References _global_vars_initialized, _run_only_on_proc0, check_existing_vars(), GLOBAL, global_var_names, num_global_vars, libMesh::ParallelObject::processor_id(), and 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 )

Sets up the nodal variables

Definition at line 1760 of file exodusII_io_helper.C.

References _nodal_vars_initialized, _run_only_on_proc0, check_existing_vars(), NODAL, nodal_var_names, num_nodal_vars, libMesh::ParallelObject::processor_id(), and 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 = `""`
	)

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

Definition at line 814 of file exodusII_io_helper.C.

References ex_err, ex_id, and ex_inquire().

Referenced by read_num_time_steps(), read_qa_records(), read_sideset_info(), and 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 )

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

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

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

◆ message() [2/2]

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

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

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 _single_precision, current_filename, ex_id, std::min(), opened_for_reading, opened_for_writing, libMesh::out, libMesh::Real, and 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 ( )

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 num_dim, num_elem, num_elem_blk, num_node_sets, num_nodes, num_side_sets, libMesh::out, title, and 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 )

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

Definition at line 509 of file exodusII_io_helper.C.

References num_nodes, x, y, and 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

◆ read_block_info()

void libMesh::ExodusII_IO_Helper::read_block_info ( )

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

Definition at line 517 of file exodusII_io_helper.C.

References block_ids, EX_ELEM_BLOCK, ex_err, ex_get_elem_blk_ids(), ex_get_name(), ex_id, id_to_block_names, message(), and 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 )

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 block_ids, connect, elem_type, ex_err, ex_get_elem_block(), ex_get_elem_conn(), ex_id, message(), num_attr, num_elem_this_blk, num_nodes_per_elem, libMesh::out, and 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 ( )

Reads the optional node_num_map from the ExodusII mesh file.

Definition at line 639 of file exodusII_io_helper.C.

References elem_num_map, ex_err, ex_get_elem_num_map(), ex_id, message(), std::min(), num_elem, libMesh::out, libMesh::ParallelObject::processor_id(), and 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
	)

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 block_ids, elem_num_map, elem_var_names, ELEMENTAL, libMesh::err, ex_err, ex_get_elem_block(), ex_get_elem_var(), ex_id, num_elem, num_elem_blk, num_elem_this_blk, and 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
	)

Reads the vector of global variables.

Definition at line 2031 of file exodusII_io_helper.C.

References _run_only_on_proc0, ex_err, ex_get_glob_vars(), ex_id, 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 ( )

Reads an ExodusII mesh file header.

Definition at line 375 of file exodusII_io_helper.C.

References ex_err, ex_get_init(), ex_get_var_param(), ex_id, message(), num_dim, num_elem, num_elem_blk, num_elem_vars, num_global_vars, num_nodal_vars, num_node_sets, num_nodes, num_side_sets, read_num_time_steps(), and title.

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

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, ex_err, ex_get_nodal_var(), ex_id, NODAL, nodal_var_names, nodal_var_values, num_nodes, and 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 ( )

Reads the optional node_num_map from the ExodusII mesh file.

Definition at line 489 of file exodusII_io_helper.C.

References ex_err, ex_get_node_num_map(), ex_id, message(), std::min(), node_num_map, num_nodes, libMesh::out, libMesh::ParallelObject::processor_id(), and 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 ( )

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

Definition at line 469 of file exodusII_io_helper.C.

References ex_err, ex_get_coord(), ex_id, message(), num_nodes, x, y, and 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 )

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 ex_err, ex_get_node_set(), ex_get_node_set_param(), ex_id, message(), node_list, nodeset_ids, num_node_df_per_set, and 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 ( )

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

Definition at line 694 of file exodusII_io_helper.C.

References ex_err, ex_get_name(), ex_get_node_set_ids(), ex_id, EX_NODE_SET, id_to_ns_names, message(), nodeset_ids, num_node_df_per_set, num_node_sets, and 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 ( )

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, inquire(), and num_time_steps.

Referenced by read_header(), and 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 ( )

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 ex_err, ex_get_qa(), ex_id, EX_INQ_QA, inquire(), libMesh::out, and 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
	)

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 elem_list, ex_err, ex_get_side_set(), ex_get_side_set_param(), ex_id, id_list, message(), num_df_per_set, num_sides_per_set, side_list, and 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 ( )

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

Definition at line 661 of file exodusII_io_helper.C.

References elem_list, ex_err, ex_get_name(), ex_get_side_set_ids(), ex_id, EX_INQ_SS_ELEM_LEN, EX_SIDE_SET, id_list, id_to_ss_names, inquire(), message(), num_df_per_set, num_elem_all_sidesets, num_side_sets, num_sides_per_set, side_list, and ss_ids.

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

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

Definition at line 833 of file exodusII_io_helper.C.

References ex_err, ex_get_all_times(), ex_id, num_time_steps, read_num_time_steps(), and 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 )

Definition at line 896 of file exodusII_io_helper.C.

References elem_var_names, ELEMENTAL, GLOBAL, global_var_names, NODAL, nodal_var_names, num_elem_vars, num_global_vars, num_nodal_vars, and read_var_names_impl().

Referenced by check_existing_vars(), read_elemental_var_values(), and read_nodal_var_values().

 {
   switch (type)
     {
     case NODAL:
       this->read_var_names_impl("n", num_nodal_vars, nodal_var_names);
       break;
     case ELEMENTAL:
       this->read_var_names_impl("e", num_elem_vars, elem_var_names);
       break;
     case GLOBAL:
       this->read_var_names_impl("g", num_global_vars, global_var_names);
       break;
     default:
       libmesh_error_msg("Unrecognized ExodusVarType " << type);
     }
 }

◆ read_var_names_impl()

void libMesh::ExodusII_IO_Helper::read_var_names_impl	(	const char *	var_type,
		int &	count,
		std::vector< std::string > &	result
	)

private

read_var_names() dispatches to this function.

Definition at line 916 of file exodusII_io_helper.C.

References ex_err, ex_get_var_names(), ex_get_var_param(), ex_id, libMesh::ExodusII_IO_Helper::NamesData::get_char_star(), libMesh::ExodusII_IO_Helper::NamesData::get_char_star_star(), libMesh::out, and verbose.

Referenced by read_var_names().

 {
   // First read and store the number of names we have
   ex_err = exII::ex_get_var_param(ex_id, var_type, &count);
   EX_CHECK_ERR(ex_err, "Error reading number of variables.");
 
   // Do nothing if no variables are detected
   if (count == 0)
     return;
 
   // Second read the actual names and convert them into a format we can use
   NamesData names_table(count, MAX_STR_LENGTH);
 
   ex_err = exII::ex_get_var_names(ex_id,
                                   var_type,
                                   count,
                                   names_table.get_char_star_star()
                                   );
   EX_CHECK_ERR(ex_err, "Error reading variable names!");
 
   if (verbose)
     {
       libMesh::out << "Read the variable(s) from the file:" << std::endl;
       for (int i=0; i<count; i++)
         libMesh::out << names_table.get_char_star(i) << std::endl;
     }
 
   // Allocate enough space for our variable name strings.
   result.resize(count);
 
   // Copy the char buffers into strings.
   for (int i=0; i<count; i++)
     result[i] = names_table.get_char_star(i); // calls string::op=(const char *)
 }

◆ set_coordinate_offset()

void libMesh::ExodusII_IO_Helper::set_coordinate_offset ( Point p )

Allows you to set a vector that is added to the coordinates of all of the nodes. Effectively, this "moves" the mesh to a particular position

Definition at line 2058 of file exodusII_io_helper.C.

References _coordinate_offset.

 {
   _coordinate_offset = p;
 }

◆ use_mesh_dimension_instead_of_spatial_dimension()

void libMesh::ExodusII_IO_Helper::use_mesh_dimension_instead_of_spatial_dimension ( bool val )

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

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

Definition at line 2044 of file exodusII_io_helper.C.

References _use_mesh_dimension_instead_of_spatial_dimension.

 {
   _use_mesh_dimension_instead_of_spatial_dimension = val;
 }

◆ write_as_dimension()

void libMesh::ExodusII_IO_Helper::write_as_dimension ( unsigned dim )

Sets the value of _write_as_dimension.

This directly controls the num_dim which is written to the Exodus file. If non-zero, this value supersedes all other dimensions, including: 1.) MeshBase::spatial_dimension() 2.) MeshBase::mesh_dimension() 3.) Any value passed to use_mesh_dimension_instead_of_spatial_dimension() This is useful/necessary for working around a bug in Paraview which prevents the "Plot Over Line" filter from working on 1D meshes.

Definition at line 2051 of file exodusII_io_helper.C.

References _write_as_dimension.

 {
   _write_as_dimension = dim;
 }

◆ write_element_values()

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

Writes the vector of values to the element variables.

Definition at line 1865 of file exodusII_io_helper.C.

References _run_only_on_proc0, _single_precision, libMesh::MeshBase::active_element_ptr_range(), data, ex_err, ex_get_var_param(), ex_id, ex_put_elem_var(), ex_update(), get_block_id(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshTools::n_elem(), num_elem_vars, and libMesh::ParallelObject::processor_id().

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   // Loop over the element blocks and write the data one block at a time
   std::map<subdomain_id_type, std::vector<unsigned int>> subdomain_map;
 
   // Ask the file how many element vars it has, store it in the num_elem_vars variable.
   ex_err = exII::ex_get_var_param(ex_id, "e", &num_elem_vars);
   EX_CHECK_ERR(ex_err, "Error reading number of elemental variables.");
 
   // loop through element and map between block and element vector
   for (const auto & elem : mesh.active_element_ptr_range())
     subdomain_map[elem->subdomain_id()].push_back(elem->id());
 
   // Use mesh.n_elem() to access into the values vector rather than
   // the number of elements the Exodus writer thinks the mesh has,
   // which may not include inactive elements.
   dof_id_type n_elem = mesh.n_elem();
 
   // For each variable, create a 'data' array which holds all the elemental variable
   // values *for a given block* on this processor, then write that data vector to file
   // before moving onto the next block.
   libmesh_assert_equal_to(vars_active_subdomains.size(), static_cast<unsigned>(num_elem_vars));
   for (unsigned int i=0; i<static_cast<unsigned>(num_elem_vars); ++i)
     {
       // The size of the subdomain map is the number of blocks.
       std::map<subdomain_id_type, std::vector<unsigned int>>::iterator it = subdomain_map.begin();
 
       const std::set<subdomain_id_type> & active_subdomains = vars_active_subdomains[i];
       for (unsigned int j=0; it!=subdomain_map.end(); ++it, ++j)
         {
           // Skip any variable/subdomain pairs that are inactive.
           // Note that if active_subdomains is empty, it is interpreted
           // as being active on *all* subdomains.
           if (!active_subdomains.empty())
             if (active_subdomains.find(it->first) == active_subdomains.end())
               {
                 continue;
               }
 
           const std::vector<unsigned int> & elem_nums = (*it).second;
           const unsigned int num_elems_this_block =
             cast_int<unsigned int>(elem_nums.size());
           std::vector<Real> data(num_elems_this_block);
 
           for (unsigned int k=0; k<num_elems_this_block; ++k)
             data[k] = values[i*n_elem + elem_nums[k]];
 
           if (_single_precision)
             {
               std::vector<float> cast_data(data.begin(), data.end());
 
               ex_err = exII::ex_put_elem_var(ex_id,
                                              timestep,
                                              i+1,
                                              this->get_block_id(j),
                                              num_elems_this_block,
                                              cast_data.data());
             }
           else
             {
               ex_err = exII::ex_put_elem_var(ex_id,
                                              timestep,
                                              i+1,
                                              this->get_block_id(j),
                                              num_elems_this_block,
                                              data.data());
             }
           EX_CHECK_ERR(ex_err, "Error writing element values.");
         }
     }
 
   ex_err = exII::ex_update(ex_id);
   EX_CHECK_ERR(ex_err, "Error flushing buffers to file.");
 }

◆ write_elements()

void libMesh::ExodusII_IO_Helper::write_elements	(	const MeshBase &	mesh,
		bool	use_discontinuous = `false`
	)

virtual

Writes the elements contained in "mesh". FIXME: This only works for Meshes having a single type of element!

Reimplemented in libMesh::Nemesis_IO_Helper.

Definition at line 1324 of file exodusII_io_helper.C.

References _run_only_on_proc0, libMesh::MeshBase::active_element_ptr_range(), libMesh::ExodusII_IO_Helper::ElementMaps::assign_conversion(), block_ids, connect, elem_num_map, libMesh::MeshBase::elem_ref(), libMesh::Utility::enum_to_string(), EX_ELEM_BLOCK, ex_err, ex_id, ex_put_concat_elem_block(), ex_put_elem_conn(), ex_put_elem_num_map(), ex_put_names(), libMesh::ExodusII_IO_Helper::Conversion::exodus_elem_type(), libMesh::ExodusII_IO_Helper::Conversion::get_canonical_type(), libMesh::ExodusII_IO_Helper::NamesData::get_char_star_star(), libMesh::ExodusII_IO_Helper::Conversion::get_inverse_node_map(), libMesh::index_range(), libmesh_elem_num_to_exodus, libmesh_node_num_to_exodus, mesh, libMesh::MeshBase::n_active_elem(), libMesh::Elem::n_nodes(), libMesh::Elem::node_id(), num_elem_blk, num_nodes_per_elem, libMesh::out, libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO_Helper::NamesData::push_back_entry(), libMesh::MeshBase::subdomain_name(), libMesh::Elem::type(), and verbose.

 {
   // n_active_elem() is a parallel_only function
   unsigned int n_active_elem = mesh.n_active_elem();
 
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   // Map from block ID to a vector of element IDs in that block.  Element
   // IDs are now of type dof_id_type, subdomain IDs are of type subdomain_id_type.
   typedef std::map<subdomain_id_type, std::vector<dof_id_type>> subdomain_map_type;
   subdomain_map_type subdomain_map;
 
   // Loop through element and map between block and element vector.
   for (const auto & elem : mesh.active_element_ptr_range())
     {
       // We skip writing infinite elements to the Exodus file, so
       // don't put them in the subdomain_map. That way the number of
       // blocks should be correct.
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
       if (elem->infinite())
         continue;
 #endif
 
       subdomain_map[ elem->subdomain_id() ].push_back(elem->id());
     }
 
   // element map vector
   num_elem_blk = cast_int<int>(subdomain_map.size());
   block_ids.resize(num_elem_blk);
   elem_num_map.resize(n_active_elem);
   std::vector<int>::iterator curr_elem_map_end = elem_num_map.begin();
 
   std::vector<int> elem_blk_id;
   std::vector<int> num_elem_this_blk_vec;
   std::vector<int> num_nodes_per_elem_vec;
   std::vector<int> num_attr_vec;
   NamesData elem_type_table(num_elem_blk, MAX_STR_LENGTH);
 
   // Note: It appears that there is a bug in exodusII::ex_put_name where
   // the index returned from the ex_id_lkup is erroneously used.  For now
   // the work around is to use the alternative function ex_put_names, but
   // this function requires a char ** data structure.
   NamesData names_table(num_elem_blk, MAX_STR_LENGTH);
 
   // counter indexes into the block_ids vector
   unsigned int counter = 0;
   for (auto & pr : subdomain_map)
     {
       block_ids[counter] = pr.first;
       names_table.push_back_entry(mesh.subdomain_name(pr.first));
 
       // Get a reference to a vector of element IDs for this subdomain.
       subdomain_map_type::mapped_type & tmp_vec = pr.second;
 
       // 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!
       ExodusII_IO_Helper::ElementMaps em;
       const ExodusII_IO_Helper::Conversion conv =
         em.assign_conversion(mesh.elem_ref(tmp_vec[0]).type());
       num_nodes_per_elem = mesh.elem_ref(tmp_vec[0]).n_nodes();
 
       elem_blk_id.push_back(pr.first);
       elem_type_table.push_back_entry(conv.exodus_elem_type().c_str());
       num_elem_this_blk_vec.push_back(cast_int<int>(tmp_vec.size()));
       num_nodes_per_elem_vec.push_back(num_nodes_per_elem);
       num_attr_vec.push_back(0); // we don't currently use elem block attributes.
       ++counter;
     }
 
   // The "define_maps" parameter should be 0 if node_number_map and
   // elem_number_map will not be written later, and nonzero otherwise.
   ex_err = exII::ex_put_concat_elem_block(ex_id,
                                           elem_blk_id.data(),
                                           elem_type_table.get_char_star_star(),
                                           num_elem_this_blk_vec.data(),
                                           num_nodes_per_elem_vec.data(),
                                           num_attr_vec.data(),
                                           /*define_maps=*/0);
   EX_CHECK_ERR(ex_err, "Error writing element blocks.");
 
   // This counter is used to fill up the libmesh_elem_num_to_exodus map in the loop below.
   unsigned libmesh_elem_num_to_exodus_counter = 0;
 
   // In the case of discontinuous plotting we initialize a map from (element,node) pairs
   // to the corresponding discontinuous node index. This ordering must match the ordering
   // used in write_nodal_coordinates.
   std::map< std::pair<dof_id_type,unsigned int>, dof_id_type > discontinuous_node_indices;
   if (use_discontinuous)
   {
     dof_id_type node_counter = 1; // Exodus numbering is 1-based
     for (const auto & elem : mesh.active_element_ptr_range())
       for (unsigned int n=0; n<elem->n_nodes(); n++)
         {
           std::pair<dof_id_type,unsigned int> id_pair;
           id_pair.first = elem->id();
           id_pair.second = n;
           discontinuous_node_indices[id_pair] = node_counter;
           node_counter++;
         }
   }
 
   for (auto & pr : subdomain_map)
     {
       // Get a reference to a vector of element IDs for this subdomain.
       subdomain_map_type::mapped_type & tmp_vec = pr.second;
 
       //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!
       ExodusII_IO_Helper::ElementMaps em;
       const ExodusII_IO_Helper::Conversion conv =
         em.assign_conversion(mesh.elem_ref(tmp_vec[0]).type());
       num_nodes_per_elem = mesh.elem_ref(tmp_vec[0]).n_nodes();
 
       connect.resize(tmp_vec.size()*num_nodes_per_elem);
 
       for (auto i : index_range(tmp_vec))
         {
           unsigned int elem_id = tmp_vec[i];
           libmesh_elem_num_to_exodus[elem_id] = ++libmesh_elem_num_to_exodus_counter; // 1-based indexing for Exodus
 
           const Elem & elem = mesh.elem_ref(elem_id);
 
           // We *might* be able to get away with writing mixed element
           // types which happen to have the same number of nodes, but
           // do we actually *want* to get away with that?
           // .) No visualization software would be able to handle it.
           // .) There'd be no way for us to read it back in reliably.
           // .) Even elements with the same number of nodes may have different connectivities (?)
 
           // This needs to be more than an assert so we don't fail
           // with a mysterious segfault while trying to write mixed
           // element meshes in optimized mode.
           if (elem.type() != conv.get_canonical_type())
             libmesh_error_msg("Error: Exodus requires all elements with a given subdomain ID to be the same type.\n" \
                               << "Can't write both "                  \
                               << Utility::enum_to_string(elem.type()) \
                               << " and "                              \
                               << Utility::enum_to_string(conv.get_canonical_type()) \
                               << " in the same block!");
 
 
           for (unsigned int j=0; j<static_cast<unsigned int>(num_nodes_per_elem); ++j)
             {
               unsigned int connect_index   = cast_int<unsigned int>((i*num_nodes_per_elem)+j);
               unsigned elem_node_index = conv.get_inverse_node_map(j); // inverse node map is for writing.
               if (verbose)
                 {
                   libMesh::out << "Exodus node index " << j
                                << " = LibMesh node index " << elem_node_index << std::endl;
                 }
 
               if (!use_discontinuous)
                 {
                   // The global id for the current node in libmesh.
                   dof_id_type libmesh_node_id = elem.node_id(elem_node_index);
 
                   // Find the zero-based libmesh id in the map, this
                   // should be faster than doing linear searches on
                   // the node_num_map.
                   std::map<int, int>::iterator pos =
                     libmesh_node_num_to_exodus.find(cast_int<int>(libmesh_node_id));
 
                   // Make sure it was found.
                   if (pos == libmesh_node_num_to_exodus.end())
                     libmesh_error_msg("libmesh node id " << libmesh_node_id << " not found in node_num_map.");
 
                   // Write the Exodus global node id associated with
                   // this libmesh node number to the connectivity
                   // array.
                   connect[connect_index] = pos->second;
                 }
               else
                 {
                   std::pair<dof_id_type,unsigned int> id_pair;
                   id_pair.first = elem_id;
                   id_pair.second = elem_node_index;
                   auto node_it = discontinuous_node_indices.find(id_pair);
 
                   libmesh_assert(node_it != discontinuous_node_indices.end());
 
                   connect[connect_index] = node_it->second;
                 }
             }
         }
 
       ex_err = exII::ex_put_elem_conn(ex_id, pr.first, connect.data());
       EX_CHECK_ERR(ex_err, "Error writing element connectivities");
 
       // This transform command stores its result in a range that begins at the third argument,
       // so this command is adding values to the elem_num_map vector starting from curr_elem_map_end.
       curr_elem_map_end = std::transform(tmp_vec.begin(),
                                          tmp_vec.end(),
                                          curr_elem_map_end,
                                          std::bind2nd(std::plus<subdomain_map_type::mapped_type::value_type>(), 1));  // Adds one to each id to make a 1-based exodus file!
 
       // But if we don't want to add one, we just want to put the values
       // of tmp_vec into elem_map in the right location, we can use
       // std::copy().
       // curr_elem_map_end = std::copy(tmp_vec.begin(), tmp_vec.end(), curr_elem_map_end);
     }
 
   // write out the element number map that we created
   ex_err = exII::ex_put_elem_num_map(ex_id, elem_num_map.data());
   EX_CHECK_ERR(ex_err, "Error writing element map");
 
   // Write out the block names
   if (num_elem_blk > 0)
     {
       ex_err = exII::ex_put_names(ex_id, exII::EX_ELEM_BLOCK, names_table.get_char_star_star());
       EX_CHECK_ERR(ex_err, "Error writing element names");
     }
 
 }

◆ write_global_values()

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

Writes the vector of global variables.

Definition at line 2009 of file exodusII_io_helper.C.

References _run_only_on_proc0, _single_precision, ex_err, ex_id, ex_put_glob_vars(), ex_update(), num_global_vars, and libMesh::ParallelObject::processor_id().

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   if (_single_precision)
     {
       std::vector<float> cast_values(values.begin(), values.end());
       ex_err = exII::ex_put_glob_vars(ex_id, timestep, num_global_vars, cast_values.data());
     }
   else
     {
       ex_err = exII::ex_put_glob_vars(ex_id, timestep, num_global_vars, values.data());
     }
   EX_CHECK_ERR(ex_err, "Error writing global values.");
 
   ex_err = exII::ex_update(ex_id);
   EX_CHECK_ERR(ex_err, "Error flushing buffers to file.");
 }

◆ write_information_records()

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

Writes the vector of information records.

Definition at line 1970 of file exodusII_io_helper.C.

References _run_only_on_proc0, libMesh::err, ex_err, ex_id, EX_INQ_INFO, ex_put_info(), ex_update(), libMesh::ExodusII_IO_Helper::NamesData::get_char_star_star(), inquire(), libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::NamesData::push_back_entry().

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   // There may already be information records in the file (for
   // example, if we're appending) and in that case, according to the
   // Exodus documentation, writing more information records is not
   // supported.
   int num_info = inquire(exII::EX_INQ_INFO, "Error retrieving the number of information records from file!");
   if (num_info > 0)
     {
       libMesh::err << "Warning! The Exodus file already contains information records.\n"
                    << "Exodus does not support writing additional records in this situation."
                    << std::endl;
       return;
     }
 
   int num_records = cast_int<int>(records.size());
 
   if (num_records > 0)
     {
       NamesData info(num_records, MAX_LINE_LENGTH);
 
       // If an entry is longer than MAX_LINE_LENGTH characters it's not an error, we just
       // write the first MAX_LINE_LENGTH characters to the file.
       for (const auto & record : records)
         info.push_back_entry(record);
 
       ex_err = exII::ex_put_info(ex_id, num_records, info.get_char_star_star());
       EX_CHECK_ERR(ex_err, "Error writing global values.");
 
       ex_err = exII::ex_update(ex_id);
       EX_CHECK_ERR(ex_err, "Error flushing buffers to file.");
     }
 }

◆ write_nodal_coordinates()

void libMesh::ExodusII_IO_Helper::write_nodal_coordinates	(	const MeshBase &	mesh,
		bool	use_discontinuous = `false`
	)

virtual

Writes the nodal coordinates contained in "mesh"

Reimplemented in libMesh::Nemesis_IO_Helper.

Definition at line 1208 of file exodusII_io_helper.C.

References _coordinate_offset, _run_only_on_proc0, _single_precision, libMesh::MeshBase::active_element_ptr_range(), ex_err, ex_id, ex_put_coord(), ex_put_node_num_map(), libMesh::DofObject::id(), libmesh_node_num_to_exodus, mesh, node_num_map, libMesh::MeshBase::node_ptr_range(), num_nodes, libMesh::ParallelObject::processor_id(), x, y, and z.

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   // Clear existing data from any previous calls.
   x.clear();
   y.clear();
   z.clear();
   node_num_map.clear();
 
   // Reserve space in the nodal coordinate vectors.  num_nodes is
   // exact, this just allows us to do away with one potentially
   // error-inducing loop index.
   x.reserve(num_nodes);
   y.reserve(num_nodes);
   z.reserve(num_nodes);
 
   // And in the node_num_map - since the nodes aren't organized in
   // blocks, libmesh will always write out the identity map
   // here... unless there has been some refinement and coarsening, or
   // node deletion without a corresponding call to contract(). You
   // need to write this any time there could be 'holes' in the node
   // numbering, so we write it every time.
   node_num_map.reserve(num_nodes);
 
   // Clear out any previously-mapped node IDs.
   libmesh_node_num_to_exodus.clear();
 
   if (!use_discontinuous)
     {
       for (const auto & node_ptr : mesh.node_ptr_range())
         {
           const Node & node = *node_ptr;
 
           x.push_back(node(0) + _coordinate_offset(0));
 
 #if LIBMESH_DIM > 1
           y.push_back(node(1) + _coordinate_offset(1));
 #else
           y.push_back(0.);
 #endif
 #if LIBMESH_DIM > 2
           z.push_back(node(2) + _coordinate_offset(2));
 #else
           z.push_back(0.);
 #endif
 
           // Fill in node_num_map entry with the proper (1-based) node id
           node_num_map.push_back(node.id() + 1);
 
           // Also map the zero-based libmesh node id to the 1-based
           // Exodus ID it will be assigned (this is equivalent to the
           // current size of the x vector).
           libmesh_node_num_to_exodus[ cast_int<int>(node.id()) ] = cast_int<int>(x.size());
         }
     }
   else
     {
       for (const auto & elem : mesh.active_element_ptr_range())
         for (unsigned int n=0; n<elem->n_nodes(); n++)
           {
             x.push_back(elem->point(n)(0));
 #if LIBMESH_DIM > 1
             y.push_back(elem->point(n)(1));
 #else
             y.push_back(0.);
 #endif
 #if LIBMESH_DIM > 2
             z.push_back(elem->point(n)(2));
 #else
             z.push_back(0.);
 #endif
 
             // Let's skip the node_num_map in the discontinuous
             // case, since we're effectively duplicating nodes for
             // the sake of discontinuous visualization, so it isn't
             // clear how to deal with node_num_map here. This means
             // that writing discontinuous meshes won't work with
             // element numberings that have "holes".
           }
     }
 
   if (_single_precision)
     {
       std::vector<float>
         x_single(x.begin(), x.end()),
         y_single(y.begin(), y.end()),
         z_single(z.begin(), z.end());
 
       ex_err = exII::ex_put_coord(ex_id,
                                   x_single.empty() ? nullptr : x_single.data(),
                                   y_single.empty() ? nullptr : y_single.data(),
                                   z_single.empty() ? nullptr : z_single.data());
     }
   else
     {
       ex_err = exII::ex_put_coord(ex_id,
                                   x.empty() ? nullptr : x.data(),
                                   y.empty() ? nullptr : y.data(),
                                   z.empty() ? nullptr : z.data());
     }
 
 
   EX_CHECK_ERR(ex_err, "Error writing coordinates to Exodus file.");
 
   if (!use_discontinuous)
     {
       // Also write the (1-based) node_num_map to the file.
       ex_err = exII::ex_put_node_num_map(ex_id, node_num_map.data());
       EX_CHECK_ERR(ex_err, "Error writing node_num_map");
     }
 }

◆ write_nodal_values()

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

Writes the vector of values to a nodal variable.

Definition at line 1948 of file exodusII_io_helper.C.

References _run_only_on_proc0, _single_precision, ex_err, ex_id, ex_put_nodal_var(), ex_update(), num_nodes, and libMesh::ParallelObject::processor_id().

Referenced by libMesh::Nemesis_IO_Helper::write_nodal_solution().

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   if (_single_precision)
     {
       std::vector<float> cast_values(values.begin(), values.end());
       ex_err = exII::ex_put_nodal_var(ex_id, timestep, var_id, num_nodes, cast_values.data());
     }
   else
     {
       ex_err = exII::ex_put_nodal_var(ex_id, timestep, var_id, num_nodes, values.data());
     }
   EX_CHECK_ERR(ex_err, "Error writing nodal values.");
 
   ex_err = exII::ex_update(ex_id);
   EX_CHECK_ERR(ex_err, "Error flushing buffers to file.");
 }

◆ write_nodesets()

void libMesh::ExodusII_IO_Helper::write_nodesets ( const MeshBase & mesh )

virtual

Writes the nodesets contained in "mesh"

Reimplemented in libMesh::Nemesis_IO_Helper.

Definition at line 1653 of file exodusII_io_helper.C.

References _run_only_on_proc0, libMesh::BoundaryInfo::build_node_boundary_ids(), libMesh::BoundaryInfo::build_node_list(), data, ex_err, ex_id, EX_NODE_SET, ex_put_names(), ex_put_node_set(), ex_put_node_set_param(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::get_nodeset_name(), mesh, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::NamesData::push_back_entry().

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   // Maps from nodeset id to the nodes
   std::map<boundary_id_type, std::vector<int>> node;
 
   // Accumulate the vectors to pass into ex_put_node_set
   // build_node_list() builds a list of (node-id, bc-id) tuples.
   for (const auto & t : mesh.get_boundary_info().build_node_list())
     node[std::get<1>(t)].push_back(std::get<0>(t) + 1);
 
   std::vector<boundary_id_type> node_boundary_ids;
   mesh.get_boundary_info().build_node_boundary_ids(node_boundary_ids);
 
   // Write out the nodeset names, but only if there is something to write
   if (node_boundary_ids.size() > 0)
     {
       NamesData names_table(node_boundary_ids.size(), MAX_STR_LENGTH);
 
       for (const auto & nodeset_id : node_boundary_ids)
         {
           int actual_id = nodeset_id;
 
           names_table.push_back_entry(mesh.get_boundary_info().get_nodeset_name(nodeset_id));
 
           ex_err = exII::ex_put_node_set_param(ex_id, actual_id, node[nodeset_id].size(), 0);
           EX_CHECK_ERR(ex_err, "Error writing nodeset parameters");
 
           ex_err = exII::ex_put_node_set(ex_id, actual_id, node[nodeset_id].data());
           EX_CHECK_ERR(ex_err, "Error writing nodesets");
         }
 
       // Write out the nodeset names
       ex_err = exII::ex_put_names(ex_id, exII::EX_NODE_SET, names_table.get_char_star_star());
       EX_CHECK_ERR(ex_err, "Error writing nodeset names");
     }
 }

◆ write_sidesets()

void libMesh::ExodusII_IO_Helper::write_sidesets ( const MeshBase & mesh )

virtual

Writes the sidesets contained in "mesh"

We need to build up active elements if AMR is enabled and add them to the exodus sidesets instead of the potentially inactive "parent" elements

Reimplemented in libMesh::Nemesis_IO_Helper.

Definition at line 1544 of file exodusII_io_helper.C.

References _run_only_on_proc0, libMesh::Elem::active_family_tree_by_side(), libMesh::ExodusII_IO_Helper::ElementMaps::assign_conversion(), libMesh::BoundaryInfo::build_shellface_boundary_ids(), libMesh::BoundaryInfo::build_shellface_list(), libMesh::BoundaryInfo::build_side_boundary_ids(), libMesh::BoundaryInfo::build_side_list(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::elem_ref(), ex_err, ex_id, ex_put_names(), ex_put_sets(), EX_SIDE_SET, libMesh::MeshBase::get_boundary_info(), libMesh::ExodusII_IO_Helper::Conversion::get_inverse_shellface_map(), libMesh::ExodusII_IO_Helper::Conversion::get_inverse_side_map(), libMesh::BoundaryInfo::get_sideset_name(), libMesh::index_range(), libmesh_elem_num_to_exodus, mesh, libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO_Helper::NamesData::push_back_entry(), and side.

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   ExodusII_IO_Helper::ElementMaps em;
 
   // Maps from sideset id to the element and sides
   std::map<int, std::vector<int>> elem;
   std::map<int, std::vector<int>> side;
   std::vector<boundary_id_type> side_boundary_ids;
 
   {
     // Accumulate the vectors to pass into ex_put_side_set
     // build_side_list() returns a vector of (elem, side, bc) tuples.
     for (const auto & t : mesh.get_boundary_info().build_side_list())
       {
         std::vector<const Elem *> family;
 #ifdef LIBMESH_ENABLE_AMR
 
         mesh.elem_ref(std::get<0>(t)).active_family_tree_by_side(family, std::get<1>(t), false);
 #else
         family.push_back(mesh.elem_ptr(std::get<0>(t)));
 #endif
 
         for (const auto & f : family)
           {
             const ExodusII_IO_Helper::Conversion conv =
               em.assign_conversion(mesh.elem_ptr(f->id())->type());
 
             // Use the libmesh to exodus data structure map to get the proper sideset IDs
             // The data structure contains the "collapsed" contiguous ids
             elem[std::get<2>(t)].push_back(libmesh_elem_num_to_exodus[f->id()]);
             side[std::get<2>(t)].push_back(conv.get_inverse_side_map(std::get<1>(t)));
           }
       }
 
     mesh.get_boundary_info().build_side_boundary_ids(side_boundary_ids);
   }
 
   {
     // add data for shell faces, if needed
 
     // Accumulate the vectors to pass into ex_put_side_set
     for (const auto & t : mesh.get_boundary_info().build_shellface_list())
       {
         std::vector<const Elem *> family;
 #ifdef LIBMESH_ENABLE_AMR
 
         mesh.elem_ref(std::get<0>(t)).active_family_tree_by_side(family, std::get<1>(t), false);
 #else
         family.push_back(mesh.elem_ptr(std::get<0>(t)));
 #endif
 
         for (const auto & f : family)
           {
             const ExodusII_IO_Helper::Conversion conv =
               em.assign_conversion(mesh.elem_ptr(f->id())->type());
 
             // Use the libmesh to exodus data structure map to get the proper sideset IDs
             // The data structure contains the "collapsed" contiguous ids
             elem[std::get<2>(t)].push_back(libmesh_elem_num_to_exodus[f->id()]);
             side[std::get<2>(t)].push_back(conv.get_inverse_shellface_map(std::get<1>(t)));
           }
       }
 
     std::vector<boundary_id_type> shellface_boundary_ids;
     mesh.get_boundary_info().build_shellface_boundary_ids(shellface_boundary_ids);
     for (const auto & id : shellface_boundary_ids)
       side_boundary_ids.push_back(id);
   }
 
   // Write out the sideset names, but only if there is something to write
   if (side_boundary_ids.size() > 0)
     {
       NamesData names_table(side_boundary_ids.size(), MAX_STR_LENGTH);
 
       std::vector<exII::ex_set> sets(side_boundary_ids.size());
 
       for (auto i : index_range(side_boundary_ids))
         {
           boundary_id_type ss_id = side_boundary_ids[i];
           names_table.push_back_entry(mesh.get_boundary_info().get_sideset_name(ss_id));
 
           sets[i].id = ss_id;
           sets[i].type = exII::EX_SIDE_SET;
           sets[i].num_entry = elem[ss_id].size();
           sets[i].num_distribution_factor = 0;
           sets[i].entry_list = elem[ss_id].data();
           sets[i].extra_list = side[ss_id].data();
           sets[i].distribution_factor_list = nullptr;
         }
 
       ex_err = exII::ex_put_sets(ex_id, side_boundary_ids.size(), sets.data());
       EX_CHECK_ERR(ex_err, "Error writing sidesets");
 
       ex_err = exII::ex_put_names(ex_id, exII::EX_SIDE_SET, names_table.get_char_star_star());
       EX_CHECK_ERR(ex_err, "Error writing sideset names");
     }
 }

◆ write_timestep()

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

Writes the time for the timestep

Definition at line 1843 of file exodusII_io_helper.C.

References _run_only_on_proc0, _single_precision, ex_err, ex_id, ex_put_time(), ex_update(), and libMesh::ParallelObject::processor_id().

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
 
   if (_single_precision)
     {
       float cast_time = float(time);
       ex_err = exII::ex_put_time(ex_id, timestep, &cast_time);
     }
   else
     {
       ex_err = exII::ex_put_time(ex_id, timestep, &time);
     }
   EX_CHECK_ERR(ex_err, "Error writing timestep.");
 
   ex_err = exII::ex_update(ex_id);
   EX_CHECK_ERR(ex_err, "Error flushing buffers to file.");
 }

◆ write_var_names()

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

protected

Wraps calls to exII::ex_put_var_names() and exII::ex_put_var_param(). The enumeration controls whether nodal, elemental, or global variable names are read and which class members are filled in.

Definition at line 956 of file exodusII_io_helper.C.

References ELEMENTAL, GLOBAL, NODAL, num_elem_vars, num_global_vars, num_nodal_vars, and write_var_names_impl().

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

 {
   switch (type)
     {
     case NODAL:
       this->write_var_names_impl("n", num_nodal_vars, names);
       break;
     case ELEMENTAL:
       this->write_var_names_impl("e", num_elem_vars, names);
       break;
     case GLOBAL:
       this->write_var_names_impl("g", num_global_vars, names);
       break;
     default:
       libmesh_error_msg("Unrecognized ExodusVarType " << type);
     }
 }

◆ write_var_names_impl()

void libMesh::ExodusII_IO_Helper::write_var_names_impl	(	const char *	var_type,
		int &	count,
		std::vector< std::string > &	names
	)

private

write_var_names() dispatches to this function.

Definition at line 976 of file exodusII_io_helper.C.

References ex_err, ex_id, ex_put_var_names(), ex_put_var_param(), libMesh::ExodusII_IO_Helper::NamesData::get_char_star(), libMesh::ExodusII_IO_Helper::NamesData::get_char_star_star(), libMesh::out, libMesh::ExodusII_IO_Helper::NamesData::push_back_entry(), and verbose.

Referenced by write_var_names().

 {
   // Update the count variable so that it's available to other parts of the class.
   count = cast_int<int>(names.size());
 
   // Write that number of variables to the file.
   ex_err = exII::ex_put_var_param(ex_id, var_type, count);
   EX_CHECK_ERR(ex_err, "Error setting number of vars.");
 
   if (count > 0)
     {
       NamesData names_table(count, MAX_STR_LENGTH);
 
       // Store the input names in the format required by Exodus.
       for (int i=0; i != count; ++i)
         names_table.push_back_entry(names[i]);
 
       if (verbose)
         {
           libMesh::out << "Writing variable name(s) to file: " << std::endl;
           for (int i=0; i != count; ++i)
             libMesh::out << names_table.get_char_star(i) << std::endl;
         }
 
       ex_err = exII::ex_put_var_names(ex_id,
                                       var_type,
                                       count,
                                       names_table.get_char_star_star()
                                       );
 
       EX_CHECK_ERR(ex_err, "Error writing variable names.");
     }
 }

Member Data Documentation

◆ _communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 107 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

◆ _coordinate_offset

Point libMesh::ExodusII_IO_Helper::_coordinate_offset

protected

Definition at line 640 of file exodusII_io_helper.h.

Referenced by set_coordinate_offset(), and write_nodal_coordinates().

◆ _elem_vars_initialized

bool libMesh::ExodusII_IO_Helper::_elem_vars_initialized

protected

Definition at line 622 of file exodusII_io_helper.h.

Referenced by initialize_element_variables(), and libMesh::Nemesis_IO_Helper::initialize_element_variables().

◆ _global_vars_initialized

bool libMesh::ExodusII_IO_Helper::_global_vars_initialized

protected

Definition at line 625 of file exodusII_io_helper.h.

Referenced by initialize_global_variables().

◆ _nodal_vars_initialized

bool libMesh::ExodusII_IO_Helper::_nodal_vars_initialized

protected

Definition at line 628 of file exodusII_io_helper.h.

Referenced by initialize_nodal_variables().

◆ _run_only_on_proc0

bool libMesh::ExodusII_IO_Helper::_run_only_on_proc0

protected

Definition at line 619 of file exodusII_io_helper.h.

Referenced by close(), create(), initialize(), initialize_element_variables(), initialize_global_variables(), initialize_nodal_variables(), read_global_values(), write_element_values(), write_elements(), write_global_values(), write_information_records(), write_nodal_coordinates(), write_nodal_values(), write_nodesets(), write_sidesets(), and write_timestep().

◆ _single_precision

bool libMesh::ExodusII_IO_Helper::_single_precision

protected

Definition at line 643 of file exodusII_io_helper.h.

Referenced by create(), libMesh::Nemesis_IO_Helper::create(), open(), write_element_values(), write_global_values(), libMesh::Nemesis_IO_Helper::write_nodal_coordinates(), write_nodal_coordinates(), write_nodal_values(), and write_timestep().

◆ _use_mesh_dimension_instead_of_spatial_dimension

bool libMesh::ExodusII_IO_Helper::_use_mesh_dimension_instead_of_spatial_dimension

protected

Definition at line 633 of file exodusII_io_helper.h.

Referenced by initialize(), and use_mesh_dimension_instead_of_spatial_dimension().

◆ _write_as_dimension

unsigned libMesh::ExodusII_IO_Helper::_write_as_dimension

protected

Definition at line 637 of file exodusII_io_helper.h.

Referenced by initialize(), and write_as_dimension().

◆ block_ids

std::vector<int> libMesh::ExodusII_IO_Helper::block_ids

Definition at line 474 of file exodusII_io_helper.h.

Referenced by libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), get_block_id(), get_block_name(), initialize_element_variables(), read_block_info(), read_elem_in_block(), read_elemental_var_values(), and write_elements().

◆ connect

std::vector<int> libMesh::ExodusII_IO_Helper::connect

Definition at line 477 of file exodusII_io_helper.h.

Referenced by read_elem_in_block(), and write_elements().

◆ current_filename

std::string libMesh::ExodusII_IO_Helper::current_filename

Definition at line 591 of file exodusII_io_helper.h.

Referenced by create(), and open().

◆ elem_list

std::vector<int> libMesh::ExodusII_IO_Helper::elem_list

Definition at line 498 of file exodusII_io_helper.h.

Referenced by read_sideset(), and read_sideset_info().

◆ elem_num_map

std::vector<int> libMesh::ExodusII_IO_Helper::elem_num_map

Definition at line 513 of file exodusII_io_helper.h.

Referenced by read_elem_num_map(), read_elemental_var_values(), and write_elements().

◆ elem_type

std::vector<char> libMesh::ExodusII_IO_Helper::elem_type

Definition at line 528 of file exodusII_io_helper.h.

Referenced by ExodusII_IO_Helper(), get_elem_type(), and read_elem_in_block().

◆ elem_var_names

std::vector<std::string> libMesh::ExodusII_IO_Helper::elem_var_names

Definition at line 559 of file exodusII_io_helper.h.

Referenced by initialize_element_variables(), libMesh::Nemesis_IO_Helper::initialize_element_variables(), read_elemental_var_values(), and read_var_names().

◆ elem_var_values

std::vector<Real> libMesh::ExodusII_IO_Helper::elem_var_values

Definition at line 562 of file exodusII_io_helper.h.

◆ ex_err

int libMesh::ExodusII_IO_Helper::ex_err

Definition at line 438 of file exodusII_io_helper.h.

Referenced by close(), initialize(), initialize_element_variables(), libMesh::Nemesis_IO_Helper::initialize_element_variables(), inquire(), read_block_info(), read_elem_in_block(), read_elem_num_map(), read_elemental_var_values(), read_global_values(), read_header(), read_nodal_var_values(), read_node_num_map(), read_nodes(), read_nodeset(), read_nodeset_info(), read_qa_records(), read_sideset(), read_sideset_info(), read_time_steps(), read_var_names_impl(), write_element_values(), libMesh::Nemesis_IO_Helper::write_element_values(), libMesh::Nemesis_IO_Helper::write_elements(), write_elements(), libMesh::Nemesis_IO_Helper::write_exodus_initialization_info(), write_global_values(), write_information_records(), libMesh::Nemesis_IO_Helper::write_nodal_coordinates(), write_nodal_coordinates(), write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), write_nodesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), write_sidesets(), write_timestep(), write_var_names_impl(), and libMesh::Nemesis_IO_Helper::~Nemesis_IO_Helper().

◆ ex_id

int libMesh::ExodusII_IO_Helper::ex_id

Definition at line 435 of file exodusII_io_helper.h.

◆ exodus_elem_num_to_libmesh

std::vector<int> libMesh::ExodusII_IO_Helper::exodus_elem_num_to_libmesh

Definition at line 533 of file exodusII_io_helper.h.

Referenced by libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), and libMesh::Nemesis_IO_Helper::write_elements().

◆ exodus_node_num_to_libmesh

std::vector<int> libMesh::ExodusII_IO_Helper::exodus_node_num_to_libmesh

Definition at line 538 of file exodusII_io_helper.h.

Referenced by libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Nemesis_IO_Helper::write_nodal_coordinates(), and libMesh::Nemesis_IO_Helper::write_nodal_solution().

◆ global_var_names

std::vector<std::string> libMesh::ExodusII_IO_Helper::global_var_names

Definition at line 565 of file exodusII_io_helper.h.

Referenced by initialize_global_variables(), and read_var_names().

◆ id_list

std::vector<int> libMesh::ExodusII_IO_Helper::id_list

Definition at line 507 of file exodusII_io_helper.h.

Referenced by read_sideset(), and read_sideset_info().

◆ id_to_block_names

std::map<int, std::string> libMesh::ExodusII_IO_Helper::id_to_block_names

Definition at line 568 of file exodusII_io_helper.h.

Referenced by get_block_name(), and read_block_info().

◆ id_to_ns_names

std::map<int, std::string> libMesh::ExodusII_IO_Helper::id_to_ns_names

Definition at line 570 of file exodusII_io_helper.h.

Referenced by get_node_set_name(), and read_nodeset_info().

◆ id_to_ss_names

std::map<int, std::string> libMesh::ExodusII_IO_Helper::id_to_ss_names

Definition at line 569 of file exodusII_io_helper.h.

Referenced by get_side_set_name(), and read_sideset_info().

◆ libmesh_elem_num_to_exodus

std::map<int, int> libMesh::ExodusII_IO_Helper::libmesh_elem_num_to_exodus

Definition at line 532 of file exodusII_io_helper.h.

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

◆ libmesh_node_num_to_exodus

std::map<int, int> libMesh::ExodusII_IO_Helper::libmesh_node_num_to_exodus

Definition at line 537 of file exodusII_io_helper.h.

Referenced by libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_node_maps(), write_elements(), write_nodal_coordinates(), and libMesh::Nemesis_IO_Helper::write_nodesets().

◆ nodal_var_names

std::vector<std::string> libMesh::ExodusII_IO_Helper::nodal_var_names

Definition at line 550 of file exodusII_io_helper.h.

Referenced by initialize_nodal_variables(), read_nodal_var_values(), and read_var_names().

◆ nodal_var_values

std::vector<Real> libMesh::ExodusII_IO_Helper::nodal_var_values

Definition at line 553 of file exodusII_io_helper.h.

Referenced by read_nodal_var_values().

◆ node_list

std::vector<int> libMesh::ExodusII_IO_Helper::node_list

Definition at line 504 of file exodusII_io_helper.h.

Referenced by read_nodeset().

◆ node_num_map

std::vector<int> libMesh::ExodusII_IO_Helper::node_num_map

Definition at line 510 of file exodusII_io_helper.h.

Referenced by read_node_num_map(), and write_nodal_coordinates().

◆ nodeset_ids

std::vector<int> libMesh::ExodusII_IO_Helper::nodeset_ids

Definition at line 483 of file exodusII_io_helper.h.

Referenced by get_node_set_id(), get_node_set_name(), read_nodeset(), and read_nodeset_info().

◆ num_attr

int libMesh::ExodusII_IO_Helper::num_attr

Definition at line 468 of file exodusII_io_helper.h.

Referenced by read_elem_in_block().

◆ num_df_per_set

std::vector<int> libMesh::ExodusII_IO_Helper::num_df_per_set

Definition at line 492 of file exodusII_io_helper.h.

Referenced by read_sideset(), and read_sideset_info().

◆ num_dim

int libMesh::ExodusII_IO_Helper::num_dim

Definition at line 441 of file exodusII_io_helper.h.

Referenced by initialize(), print_header(), read_header(), and libMesh::Nemesis_IO_Helper::write_exodus_initialization_info().

◆ num_elem

int libMesh::ExodusII_IO_Helper::num_elem

Definition at line 450 of file exodusII_io_helper.h.

Referenced by initialize(), print_header(), read_elem_num_map(), read_elemental_var_values(), read_header(), and libMesh::Nemesis_IO_Helper::write_exodus_initialization_info().

◆ num_elem_all_sidesets

int libMesh::ExodusII_IO_Helper::num_elem_all_sidesets

Definition at line 471 of file exodusII_io_helper.h.

Referenced by read_sideset_info().

◆ num_elem_blk

int libMesh::ExodusII_IO_Helper::num_elem_blk

Definition at line 453 of file exodusII_io_helper.h.

Referenced by initialize(), initialize_element_variables(), print_header(), read_block_info(), read_elemental_var_values(), read_header(), write_elements(), and libMesh::Nemesis_IO_Helper::write_exodus_initialization_info().

◆ num_elem_this_blk

int libMesh::ExodusII_IO_Helper::num_elem_this_blk

Definition at line 462 of file exodusII_io_helper.h.

Referenced by read_elem_in_block(), and read_elemental_var_values().

◆ num_elem_vars

int libMesh::ExodusII_IO_Helper::num_elem_vars

Definition at line 556 of file exodusII_io_helper.h.

Referenced by initialize_element_variables(), libMesh::Nemesis_IO_Helper::initialize_element_variables(), read_header(), read_var_names(), write_element_values(), and write_var_names().

◆ num_global_vars

int libMesh::ExodusII_IO_Helper::num_global_vars

Definition at line 444 of file exodusII_io_helper.h.

Referenced by initialize_global_variables(), read_global_values(), read_header(), read_var_names(), write_global_values(), and write_var_names().

◆ num_nodal_vars

int libMesh::ExodusII_IO_Helper::num_nodal_vars

Definition at line 547 of file exodusII_io_helper.h.

Referenced by initialize_nodal_variables(), read_header(), read_var_names(), and write_var_names().

◆ num_node_df_per_set

std::vector<int> libMesh::ExodusII_IO_Helper::num_node_df_per_set

Definition at line 495 of file exodusII_io_helper.h.

Referenced by read_nodeset(), and read_nodeset_info().

◆ num_node_sets

int libMesh::ExodusII_IO_Helper::num_node_sets

Definition at line 456 of file exodusII_io_helper.h.

Referenced by initialize(), print_header(), read_header(), read_nodeset_info(), and libMesh::Nemesis_IO_Helper::write_exodus_initialization_info().

◆ num_nodes

int libMesh::ExodusII_IO_Helper::num_nodes

Definition at line 447 of file exodusII_io_helper.h.

Referenced by libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), initialize(), print_header(), print_nodes(), read_header(), read_nodal_var_values(), read_node_num_map(), read_nodes(), libMesh::Nemesis_IO_Helper::write_exodus_initialization_info(), write_nodal_coordinates(), libMesh::Nemesis_IO_Helper::write_nodal_solution(), and write_nodal_values().

◆ num_nodes_per_elem

int libMesh::ExodusII_IO_Helper::num_nodes_per_elem

Definition at line 465 of file exodusII_io_helper.h.

Referenced by libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), read_elem_in_block(), libMesh::Nemesis_IO_Helper::write_elements(), and write_elements().

◆ num_nodes_per_set

std::vector<int> libMesh::ExodusII_IO_Helper::num_nodes_per_set

Definition at line 489 of file exodusII_io_helper.h.

Referenced by read_nodeset(), and read_nodeset_info().

◆ num_side_sets

int libMesh::ExodusII_IO_Helper::num_side_sets

Definition at line 459 of file exodusII_io_helper.h.

Referenced by initialize(), print_header(), read_header(), read_sideset_info(), and libMesh::Nemesis_IO_Helper::write_exodus_initialization_info().

◆ num_sides_per_set

std::vector<int> libMesh::ExodusII_IO_Helper::num_sides_per_set

Definition at line 486 of file exodusII_io_helper.h.

Referenced by read_sideset(), and read_sideset_info().

◆ num_time_steps

int libMesh::ExodusII_IO_Helper::num_time_steps

Definition at line 541 of file exodusII_io_helper.h.

Referenced by read_num_time_steps(), and read_time_steps().

◆ opened_for_reading

bool libMesh::ExodusII_IO_Helper::opened_for_reading

Definition at line 581 of file exodusII_io_helper.h.

Referenced by close(), and open().

◆ opened_for_writing

bool libMesh::ExodusII_IO_Helper::opened_for_writing

Definition at line 577 of file exodusII_io_helper.h.

Referenced by close(), create(), libMesh::Nemesis_IO_Helper::create(), open(), and libMesh::Nemesis_IO_Helper::~Nemesis_IO_Helper().

◆ side_list

std::vector<int> libMesh::ExodusII_IO_Helper::side_list

Definition at line 501 of file exodusII_io_helper.h.

Referenced by read_sideset(), and read_sideset_info().

◆ ss_ids

std::vector<int> libMesh::ExodusII_IO_Helper::ss_ids

Definition at line 480 of file exodusII_io_helper.h.

Referenced by get_side_set_id(), get_side_set_name(), read_sideset(), and read_sideset_info().

◆ time_steps

std::vector<Real> libMesh::ExodusII_IO_Helper::time_steps

Definition at line 544 of file exodusII_io_helper.h.

Referenced by read_time_steps().

◆ title

std::vector<char> libMesh::ExodusII_IO_Helper::title

Definition at line 525 of file exodusII_io_helper.h.

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

◆ verbose

bool libMesh::ExodusII_IO_Helper::verbose

Definition at line 573 of file exodusII_io_helper.h.

◆ x

std::vector<Real> libMesh::ExodusII_IO_Helper::x

Definition at line 516 of file exodusII_io_helper.h.

Referenced by print_nodes(), read_nodes(), libMesh::Nemesis_IO_Helper::write_nodal_coordinates(), and write_nodal_coordinates().

◆ y

std::vector<Real> libMesh::ExodusII_IO_Helper::y

Definition at line 519 of file exodusII_io_helper.h.

Referenced by print_nodes(), read_nodes(), libMesh::Nemesis_IO_Helper::write_nodal_coordinates(), and write_nodal_coordinates().

◆ z

std::vector<Real> libMesh::ExodusII_IO_Helper::z

Definition at line 522 of file exodusII_io_helper.h.

Referenced by print_nodes(), read_nodes(), libMesh::Nemesis_IO_Helper::write_nodal_coordinates(), and write_nodal_coordinates().

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Member Enumeration Documentation

◆ ExodusVarType

Constructor & Destructor Documentation

◆ ExodusII_IO_Helper()

◆ ~ExodusII_IO_Helper()

Member Function Documentation

◆ check_existing_vars()

◆ close()

◆ comm()

◆ create()

◆ get_block_id()

◆ get_block_name()

◆ get_complex_names()

◆ get_complex_vars_active_subdomains()

◆ get_elem_type()

◆ get_node_set_id()

◆ get_node_set_name()

◆ get_side_set_id()

◆ get_side_set_name()

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

◆ read_block_info()

◆ read_elem_in_block()

◆ read_elem_num_map()

◆ read_elemental_var_values()

◆ read_global_values()

◆ read_header()

◆ read_nodal_var_values()

◆ read_node_num_map()

◆ read_nodes()

◆ read_nodeset()

◆ read_nodeset_info()

◆ read_num_time_steps()

◆ read_qa_records()

◆ read_sideset()

◆ read_sideset_info()

◆ read_time_steps()

◆ read_var_names()

◆ read_var_names_impl()

◆ set_coordinate_offset()

◆ use_mesh_dimension_instead_of_spatial_dimension()

◆ write_as_dimension()

◆ write_element_values()

◆ write_elements()

◆ write_global_values()

◆ write_information_records()

◆ write_nodal_coordinates()

◆ write_nodal_values()

◆ write_nodesets()

◆ write_sidesets()

◆ write_timestep()

◆ write_var_names()

◆ write_var_names_impl()

Member Data Documentation

◆ _communicator

◆ _coordinate_offset

◆ _elem_vars_initialized

◆ _global_vars_initialized

◆ _nodal_vars_initialized

◆ _run_only_on_proc0

◆ _single_precision

◆ _use_mesh_dimension_instead_of_spatial_dimension