This is the ExodusII_IO_Helper class. More...

#include <exodusII_io_helper.h>

Inheritance diagram for libMesh::ExodusII_IO_Helper:

Classes
class	Conversion

struct	MappedInputVector
	This class facilitates reading in vectors from Exodus file that may be of a different floating point type than Real. More...

struct	MappedOutputVector
	This class facilitates inline conversion of an input data vector to a different precision level, depending on the underlying type of Real and whether or not the single_precision flag is set. More...

class	NamesData
	This class is useful for managing anything that requires a char ** input/output in ExodusII file. More...

Public Types
enum	ExodusVarType { NODAL =0, ELEMENTAL =1, GLOBAL =2, SIDESET =3 }
	Wraps calls to exII::ex_get_var_names() and exII::ex_get_var_param(). More...

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

	ExodusII_IO_Helper (const ExodusII_IO_Helper &)=default
	Special functions. More...

	ExodusII_IO_Helper (ExodusII_IO_Helper &&)=default

ExodusII_IO_Helper &	operator= (const ExodusII_IO_Helper &)=default

ExodusII_IO_Helper &	operator= (ExodusII_IO_Helper &&)=default

virtual	~ExodusII_IO_Helper ()

const char *	get_elem_type () const

void	open (const char *filename, bool read_only)
	Opens an `ExodusII` mesh file named `filename`. More...

void	read_header ()
	Reads an `ExodusII` mesh file header. More...

void	read_qa_records ()
	Reads the QA records from an ExodusII file. More...

void	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. More...

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

void	read_node_num_map ()
	Reads the optional `node_num_map` from the `ExodusII` mesh file. More...

void	print_nodes (std::ostream &out=libMesh::out)
	Prints the nodal information, by default to `libMesh::out`. More...

void	read_block_info ()
	Reads information for all of the blocks in the `ExodusII` mesh file. More...

int	get_block_id (int index)
	Get the block number for the given block index. More...

std::string	get_block_name (int index)
	Get the block name for the given block index if supplied in the mesh file. More...

int	get_side_set_id (int index)
	Get the side set id for the given side set index. More...

std::string	get_side_set_name (int index)
	Get the side set name for the given side set index if supplied in the mesh file. More...

int	get_node_set_id (int index)
	Get the node set id for the given node set index. More...

std::string	get_node_set_name (int index)
	Get the node set name for the given node set index if supplied in the mesh file. More...

void	read_elem_in_block (int block)
	Reads all of the element connectivity for block `block` in the `ExodusII` mesh file. More...

void	read_edge_blocks (MeshBase &mesh)
	Read in edge blocks, storing information in the BoundaryInfo object. More...

void	read_elem_num_map ()
	Reads the optional `node_num_map` from the `ExodusII` mesh file. More...

void	read_sideset_info ()
	Reads information about all of the sidesets in the `ExodusII` mesh file. More...

void	read_nodeset_info ()
	Reads information about all of the nodesets in the `ExodusII` mesh file. More...

void	read_sideset (int id, int offset)
	Reads information about sideset `id` and inserts it into the global sideset array at the position `offset`. More...

void	read_nodeset (int id)
	Reads information about nodeset `id` and inserts it into the global nodeset array at the position `offset`. More...

void	read_all_nodesets ()
	New API that reads all nodesets simultaneously. More...

void	close ()
	Closes the `ExodusII` mesh file. More...

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

void	read_time_steps ()
	Reads and stores the timesteps in the 'time_steps' array. More...

void	read_num_time_steps ()
	Reads the number of timesteps currently stored in the Exodus file and stores it in the num_time_steps variable. More...

void	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. More...

void	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. More...

virtual void	create (std::string filename)
	Opens an `ExodusII` mesh file named `filename` for writing. More...

virtual void	initialize (std::string title, const MeshBase &mesh, bool use_discontinuous=false)
	Initializes the Exodus file. More...

virtual void	write_nodal_coordinates (const MeshBase &mesh, bool use_discontinuous=false)
	Writes the nodal coordinates contained in "mesh". More...

virtual void	write_elements (const MeshBase &mesh, bool use_discontinuous=false)
	Writes the elements contained in "mesh". More...

virtual void	write_sidesets (const MeshBase &mesh)
	Writes the sidesets contained in "mesh". More...

virtual void	write_nodesets (const MeshBase &mesh)
	Writes the nodesets contained in "mesh". More...

virtual void	initialize_element_variables (std::vector< std::string > names, const std::vector< std::set< subdomain_id_type >> &vars_active_subdomains)
	Sets up the nodal variables. More...

void	initialize_nodal_variables (std::vector< std::string > names)
	Sets up the nodal variables. More...

void	initialize_global_variables (std::vector< std::string > names)
	Sets up the global variables. More...

void	write_timestep (int timestep, Real time)
	Writes the time for the timestep. More...

void	write_sideset_data (const MeshBase &mesh, int timestep, const std::vector< std::string > &var_names, const std::vector< std::set< boundary_id_type >> &side_ids, const std::vector< std::map< BoundaryInfo::BCTuple, Real >> &bc_vals)
	Write sideset data for the requested timestep. More...

void	read_sideset_data (const MeshBase &mesh, int timestep, std::vector< std::string > &var_names, std::vector< std::set< boundary_id_type >> &side_ids, std::vector< std::map< BoundaryInfo::BCTuple, Real >> &bc_vals)
	Read sideset variables, if any, into the provided data structures. More...

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)
	Writes the vector of values to the element variables. More...

void	write_element_values_element_major (const MeshBase &mesh, const std::vector< Real > &values, int timestep, const std::vector< std::set< subdomain_id_type >> &vars_active_subdomains, const std::vector< std::string > &derived_var_names, const std::map< subdomain_id_type, std::vector< std::string >> &subdomain_to_var_names)
	Same as the function above, but assume the input 'values' vector is in element-major order, i.e. More...

void	write_nodal_values (int var_id, const std::vector< Real > &values, int timestep)
	Writes the vector of values to a nodal variable. More...

void	write_information_records (const std::vector< std::string > &records)
	Writes the vector of information records. More...

void	write_global_values (const std::vector< Real > &values, int timestep)
	Writes the vector of global variables. More...

void	read_global_values (std::vector< Real > &values, int timestep)
	Reads the vector of global variables. More...

void	use_mesh_dimension_instead_of_spatial_dimension (bool val)
	Sets the underlying value of the boolean flag _use_mesh_dimension_instead_of_spatial_dimension. More...

void	write_as_dimension (unsigned dim)
	Sets the value of _write_as_dimension. More...

void	set_coordinate_offset (Point p)
	Allows you to set a vector that is added to the coordinates of all of the nodes. More...

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
	returns a "tripled" copy of `vars_active_subdomains`, which is necessary in the complex-valued case. More...

std::map< subdomain_id_type, std::vector< std::string > >	get_complex_subdomain_to_var_names (const std::map< subdomain_id_type, std::vector< std::string >> &subdomain_to_var_names) const
	Takes a map from subdomain id -> vector of active variable names as input and returns a corresponding map where the original variable names have been replaced by their complex counterparts. More...

void	message (const std::string &msg)
	Prints the message defined in `msg`. More...

void	message (const std::string &msg, int i)
	Prints the message defined in `msg`, and appends the number `i` to the end of the message. More...

void	read_var_names (ExodusVarType type)

const ExodusII_IO_Helper::Conversion &	get_conversion (const ElemType type) const

const ExodusII_IO_Helper::Conversion &	get_conversion (std::string type_str) const

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_sideset_vars

int	num_nodes

int	num_elem

int	num_elem_blk

int	num_edge

int	num_edge_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 >	edge_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 >	node_sets_node_index

std::vector< int >	node_sets_dist_index

std::vector< int >	node_sets_node_list

std::vector< Real >	node_sets_dist_fact

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::vector< std::string >	sideset_var_names

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

std::map< int, std::string >	id_to_edge_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)
	When appending: during initialization, check that variable names in the file match those you attempt to initialize with. More...

void	write_var_names (ExodusVarType type, const std::vector< std::string > &names)
	Wraps calls to exII::ex_put_var_names() and exII::ex_put_var_param(). More...

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)
	read_var_names() dispatches to this function. More...

void	write_var_names_impl (const char *var_type, int &count, const std::vector< std::string > &names)
	write_var_names() dispatches to this function. More...

void	init_element_equivalence_map ()

void	init_conversion_map ()

Private Attributes
std::map< std::string, ElemType >	element_equivalence_map
	Defines equivalence classes of Exodus element types that map to libmesh ElemTypes. More...

std::map< ElemType, ExodusII_IO_Helper::Conversion >	conversion_map
	Associates libMesh ElemTypes with node/face/edge/etc. More...

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 80 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 SIDESET: num_sideset_vars sideset_var_names

Enumerator
NODAL
ELEMENTAL
GLOBAL
SIDESET

Definition at line 692 of file exodusII_io_helper.h.

692 {NODAL=0, ELEMENTAL=1, GLOBAL=2, SIDESET=3};

Constructor & Destructor Documentation

◆ ExodusII_IO_Helper() [1/3]

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

                                                               :
   ParallelObject(parent),
   ex_id(0),
   ex_err(0),
   num_dim(0),
   num_global_vars(0),
   num_sideset_vars(0),
   num_nodes(0),
   num_elem(0),
   num_elem_blk(0),
   num_edge(0),
   num_edge_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);
   init_element_equivalence_map();
   init_conversion_map();
 }

References elem_type, init_conversion_map(), init_element_equivalence_map(), and title.

◆ ExodusII_IO_Helper() [2/3]

libMesh::ExodusII_IO_Helper::ExodusII_IO_Helper ( const ExodusII_IO_Helper & )

default

Special functions.

This class does not manage any dynamically allocated resources (file pointers, etc.) so it should be default copy/move constructable and assignable, but I don't know if any existing code actually uses these operations.

◆ ExodusII_IO_Helper() [3/3]

libMesh::ExodusII_IO_Helper::ExodusII_IO_Helper ( ExodusII_IO_Helper && )

default

◆ ~ExodusII_IO_Helper()

libMesh::ExodusII_IO_Helper::~ExodusII_IO_Helper ( )

virtualdefault

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

 {
   // 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 number of variables and their names (up to the first
   // MAX_STR_LENGTH characters) must match for the names we are
   // planning to write and the names already in the file.
   bool match =
     std::equal(names.begin(), names.end(),
                names_from_file.begin(),
                [](const std::string & a,
                   const std::string & b) -> bool
                {
                  return a.compare(/*pos=*/0, /*len=*/MAX_STR_LENGTH, b) == 0;
                });
  
   if (!match)
     {
       libMesh::err << "Error! The Exodus file already contains the variables:" << std::endl;
       for (const auto & name : names_from_file)
         libMesh::err << name << std::endl;
  
       libMesh::err << "And you asked to write:" << std::endl;
       for (const auto & name : names)
         libMesh::err << name << std::endl;
  
       libmesh_error_msg("Cannot overwrite existing variables in Exodus II file.");
     }
 }

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

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

◆ close()

void libMesh::ExodusII_IO_Helper::close ( )

Closes the ExodusII mesh file.

Definition at line 1228 of file exodusII_io_helper.C.

 {
   // 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.");
         }
     }
 }

References _run_only_on_proc0, 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().

◆ comm()

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

inlineinherited

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

Definition at line 94 of file parallel_object.h.

95 { return _communicator; }

References libMesh::ParallelObject::_communicator.

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

 {
   // 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)));
         }
  
       // By default we just open the Exodus file in "EX_CLOBBER" mode,
       // which, according to "ncdump -k", writes the file in "64-bit
       // offset" mode, which is a NETCDF3 file format.
       int mode = EX_CLOBBER;
  
       // If HDF5 is available, by default we will write Exodus files
       // in a more modern NETCDF4-compatible format. For this file
       // type, "ncdump -k" will report "netCDF-4".
 #ifdef LIBMESH_HAVE_HDF5
       mode |= EX_NETCDF4;
       mode |= EX_NOCLASSIC;
 #endif
  
       ex_id = exII::ex_create(filename.c_str(), mode, &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;
 }

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

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

 {
   libmesh_assert_less (index, block_ids.size());
  
   return block_ids[index];
 }

References block_ids.

Referenced by write_element_values(), and write_element_values_element_major().

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

 {
   libmesh_assert_less (index, block_ids.size());
  
   return id_to_block_names[block_ids[index]];
 }

References block_ids, and id_to_block_names.

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

 {
   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 (const auto & name : names)
     {
       complex_names.push_back("r_" + name);
       complex_names.push_back("i_" + name);
       complex_names.push_back("a_" + name);
     }
  
   return complex_names;
 }

References libMesh::Quality::name().

◆ get_complex_subdomain_to_var_names()

std::map< subdomain_id_type, std::vector< std::string > > libMesh::ExodusII_IO_Helper::get_complex_subdomain_to_var_names ( const std::map< subdomain_id_type, std::vector< std::string >> & subdomain_to_var_names ) const

Takes a map from subdomain id -> vector of active variable names as input and returns a corresponding map where the original variable names have been replaced by their complex counterparts.

Used by the ExodusII_IO::write_element_data_from_discontinuous_nodal_data() function.

Definition at line 3227 of file exodusII_io_helper.C.

 {
   // Eventual return value
   std::map<subdomain_id_type, std::vector<std::string>> ret;
  
   for (const auto & pr : subdomain_to_var_names)
     {
       // Initialize entry for current subdomain
       auto & vec = ret[pr.first];
  
       // Get list of non-complex variable names active on this subdomain.
       const auto & varnames = pr.second;
  
       // Allocate space for 3x the number of entries
       vec.reserve(3 * varnames.size());
  
       // For each varname in the input map, write three variable names
       // to the output formed by prepending "r_", "i_", and "a_",
       // respectively.
       for (const auto & varname : varnames)
         {
           vec.push_back("r_" + varname);
           vec.push_back("i_" + varname);
           vec.push_back("a_" + varname);
         }
     }
   return ret;
 }

◆ 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 3206 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_conversion() [1/2]

const ExodusII_IO_Helper::Conversion & libMesh::ExodusII_IO_Helper::get_conversion ( const ElemType type ) const

Definition at line 383 of file exodusII_io_helper.C.

 {
   return libmesh_map_find(conversion_map, type);
 }

References conversion_map.

Referenced by libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), get_conversion(), read_edge_blocks(), read_sideset_data(), libMesh::Nemesis_IO_Helper::write_elements(), write_elements(), write_sideset_data(), libMesh::Nemesis_IO_Helper::write_sidesets(), and write_sidesets().

◆ get_conversion() [2/2]

const ExodusII_IO_Helper::Conversion & libMesh::ExodusII_IO_Helper::get_conversion ( std::string type_str ) const

Definition at line 389 of file exodusII_io_helper.C.

 {
   // Do only upper-case comparisons
   std::transform(type_str.begin(), type_str.end(), type_str.begin(), ::toupper);
   return get_conversion (libmesh_map_find(element_equivalence_map, type_str));
 }

References element_equivalence_map, and get_conversion().

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

 {
   return elem_type.data();
 }

References elem_type.

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

 {
   libmesh_assert_less (index, nodeset_ids.size());
  
   return nodeset_ids[index];
 }

References nodeset_ids.

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

 {
   libmesh_assert_less (index, nodeset_ids.size());
  
   return id_to_ns_names[nodeset_ids[index]];
 }

References id_to_ns_names, and nodeset_ids.

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

 {
   libmesh_assert_less (index, ss_ids.size());
  
   return ss_ids[index];
 }

References ss_ids.

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

 {
   libmesh_assert_less (index, ss_ids.size());
  
   return id_to_ss_names[ss_ids[index]];
 }

References id_to_ss_names, and ss_ids.

◆ init_conversion_map()

void libMesh::ExodusII_IO_Helper::init_conversion_map ( )

private

Definition at line 146 of file exodusII_io_helper.C.

 {
   {
     auto & conv = conversion_map[NODEELEM];
     conv.libmesh_type = NODEELEM;
     conv.exodus_type = "SPHERE";
   }
   {
     auto & conv = conversion_map[EDGE2];
     conv.libmesh_type = EDGE2;
     conv.exodus_type = "EDGE2";
   }
   {
     auto & conv = conversion_map[EDGE3];
     conv.libmesh_type = EDGE3;
     conv.exodus_type = "EDGE3";
   }
   {
     auto & conv = conversion_map[QUAD4];
     conv.libmesh_type = QUAD4;
     conv.exodus_type = "QUAD4";
   }
   {
     auto & conv = conversion_map[QUADSHELL4];
     conv.inverse_side_map = &quadshell4_inverse_edge_map;
     conv.shellface_index_offset = 2;
     conv.libmesh_type = QUADSHELL4;
     conv.exodus_type = "SHELL4";
   }
   {
     auto & conv = conversion_map[QUAD8];
     conv.libmesh_type = QUAD8;
     conv.exodus_type = "QUAD8";
   }
   {
     auto & conv = conversion_map[QUADSHELL8];
     conv.inverse_side_map = &quadshell4_inverse_edge_map;
     conv.shellface_index_offset = 2;
     conv.libmesh_type = QUADSHELL8;
     conv.exodus_type = "SHELL8";
   }
   {
     auto & conv = conversion_map[QUAD9];
     conv.libmesh_type = QUAD9;
     conv.exodus_type = "QUAD9";
   }
   {
     auto & conv = conversion_map[TRI3];
     conv.libmesh_type = TRI3;
     conv.exodus_type = "TRI3";
   }
   {
     auto & conv = conversion_map[TRISHELL3];
     conv.inverse_side_map = &trishell3_inverse_edge_map;
     conv.shellface_index_offset = 2;
     conv.libmesh_type = TRISHELL3;
     conv.exodus_type = "TRISHELL3";
   }
   {
     auto & conv = conversion_map[TRI3SUBDIVISION];
     conv.libmesh_type = TRI3SUBDIVISION;
     conv.exodus_type = "TRI3";
   }
   {
     auto & conv = conversion_map[TRI6];
     conv.libmesh_type = TRI6;
     conv.exodus_type = "TRI6";
   }
   {
     auto & conv = conversion_map[HEX8];
     conv.side_map = &hex_face_map;
     conv.inverse_side_map = &hex_inverse_face_map;
     conv.libmesh_type = HEX8;
     conv.exodus_type = "HEX8";
   }
   {
     auto & conv = conversion_map[HEX20];
     conv.side_map = &hex_face_map;
     conv.inverse_side_map = &hex_inverse_face_map;
     conv.libmesh_type = HEX20;
     conv.exodus_type = "HEX20";
   }
   {
     auto & conv = conversion_map[HEX27];
     conv.node_map = &hex27_node_map;
     conv.inverse_node_map = &hex27_inverse_node_map;
     conv.side_map = &hex_face_map;
     conv.inverse_side_map = &hex_inverse_face_map;
     conv.libmesh_type = HEX27;
     conv.exodus_type = "HEX27";
   }
   {
     auto & conv = conversion_map[TET4];
     conv.side_map = &tet_face_map;
     conv.inverse_side_map = &tet_inverse_face_map;
     conv.libmesh_type = TET4;
     conv.exodus_type = "TETRA4";
   }
   {
     auto & conv = conversion_map[TET10];
     conv.side_map = &tet_face_map;
     conv.inverse_side_map = &tet_inverse_face_map;
     conv.libmesh_type = TET10;
     conv.exodus_type = "TETRA10";
   }
   {
     auto & conv = conversion_map[PRISM6];
     conv.side_map = &prism_face_map;
     conv.inverse_side_map = &prism_inverse_face_map;
     conv.libmesh_type = PRISM6;
     conv.exodus_type = "WEDGE";
   }
   {
     auto & conv = conversion_map[PRISM15];
     conv.side_map = &prism_face_map;
     conv.inverse_side_map = &prism_inverse_face_map;
     conv.libmesh_type = PRISM15;
     conv.exodus_type = "WEDGE15";
   }
   {
     auto & conv = conversion_map[PRISM18];
     conv.side_map = &prism_face_map;
     conv.inverse_side_map = &prism_inverse_face_map;
     conv.libmesh_type = PRISM18;
     conv.exodus_type = "WEDGE18";
   }
   {
     auto & conv = conversion_map[PYRAMID5];
     conv.libmesh_type = PYRAMID5;
     conv.exodus_type = "PYRAMID5";
   }
   {
     auto & conv = conversion_map[PYRAMID13];
     conv.libmesh_type = PYRAMID13;
     conv.exodus_type = "PYRAMID13";
   }
   {
     auto & conv = conversion_map[PYRAMID14];
     conv.libmesh_type = PYRAMID14;
     conv.exodus_type = "PYRAMID14";
   }
 }

References conversion_map, libMesh::EDGE2, libMesh::EDGE3, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI3SUBDIVISION, libMesh::TRI6, and libMesh::TRISHELL3.

Referenced by ExodusII_IO_Helper().

◆ init_element_equivalence_map()

void libMesh::ExodusII_IO_Helper::init_element_equivalence_map ( )

private

Definition at line 293 of file exodusII_io_helper.C.

 {
   // We use an ExodusII SPHERE element to represent a NodeElem
   element_equivalence_map["SPHERE"] = NODEELEM;
  
   // EDGE2 equivalences
   element_equivalence_map["EDGE"]   = EDGE2;
   element_equivalence_map["EDGE2"]  = EDGE2;
   element_equivalence_map["TRUSS"]  = EDGE2;
   element_equivalence_map["BEAM"]   = EDGE2;
   element_equivalence_map["BAR"]    = EDGE2;
   element_equivalence_map["TRUSS2"] = EDGE2;
   element_equivalence_map["BEAM2"]  = EDGE2;
   element_equivalence_map["BAR2"]   = EDGE2;
  
   // EDGE3 equivalences
   element_equivalence_map["EDGE3"]  = EDGE3;
   element_equivalence_map["TRUSS3"] = EDGE3;
   element_equivalence_map["BEAM3"]  = EDGE3;
   element_equivalence_map["BAR3"]   = EDGE3;
  
   // QUAD4 equivalences
   element_equivalence_map["QUAD"]   = QUAD4;
   element_equivalence_map["QUAD4"]  = QUAD4;
  
   // QUADSHELL4 equivalences
   element_equivalence_map["SHELL"]  = QUADSHELL4;
   element_equivalence_map["SHELL4"] = QUADSHELL4;
  
   // QUAD8 equivalences
   element_equivalence_map["QUAD8"]  = QUAD8;
  
   // QUADSHELL8 equivalences
   element_equivalence_map["SHELL8"] = QUADSHELL8;
  
   // QUAD9 equivalences
   element_equivalence_map["QUAD9"]  = QUAD9;
   // element_equivalence_map["SHELL9"] = QUAD9;
  
   // TRI3 equivalences
   element_equivalence_map["TRI"]       = TRI3;
   element_equivalence_map["TRI3"]      = TRI3;
   element_equivalence_map["TRIANGLE"]  = TRI3;
  
   // TRISHELL3 equivalences
   element_equivalence_map["TRISHELL"]  = TRISHELL3;
   element_equivalence_map["TRISHELL3"] = TRISHELL3;
  
   // TRI6 equivalences
   element_equivalence_map["TRI6"]      = TRI6;
   // element_equivalence_map["TRISHELL6"] = TRI6;
  
   // HEX8 equivalences
   element_equivalence_map["HEX"]  = HEX8;
   element_equivalence_map["HEX8"] = HEX8;
  
   // HEX20 equivalences
   element_equivalence_map["HEX20"] = HEX20;
  
   // HEX27 equivalences
   element_equivalence_map["HEX27"] = HEX27;
  
   // TET4 equivalences
   element_equivalence_map["TETRA"]  = TET4;
   element_equivalence_map["TETRA4"] = TET4;
  
   // TET10 equivalences
   element_equivalence_map["TETRA10"] = TET10;
  
   // PRISM6 equivalences
   element_equivalence_map["WEDGE"] = PRISM6;
  
   // PRISM15 equivalences
   element_equivalence_map["WEDGE15"] = PRISM15;
  
   // PRISM18 equivalences
   element_equivalence_map["WEDGE18"] = PRISM18;
  
   // PYRAMID5 equivalences
   element_equivalence_map["PYRAMID"]  = PYRAMID5;
   element_equivalence_map["PYRAMID5"] = PYRAMID5;
  
   // PYRAMID13 equivalences
   element_equivalence_map["PYRAMID13"] = PYRAMID13;
  
   // PYRAMID14 equivalences
   element_equivalence_map["PYRAMID14"] = PYRAMID14;
 }

References libMesh::EDGE2, libMesh::EDGE3, element_equivalence_map, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and libMesh::TRISHELL3.

Referenced by ExodusII_IO_Helper().

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

 {
   // The majority of this function only executes on processor 0, so any functions
   // which are collective, like n_active_elem() or n_edge_conds() must be called
   // before the processors' execution paths diverge.
   unsigned int n_active_elem = mesh.n_active_elem();
   const BoundaryInfo & bi = mesh.get_boundary_info();
   num_edge = bi.n_edge_conds();
  
   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;
  
   bi.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;
     bi.build_shellface_boundary_ids(shellface_boundaries);
     for (const auto & id : shellface_boundaries)
       unique_side_boundaries.push_back(id);
   }
   bi.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);
     }
  
   // Edge BCs are handled a bit differently than sidesets and nodesets.
   // They are written as separate "edge blocks", and then edge variables
   // can be defined on those blocks. That is, they are not written as
   // edge sets, since edge sets must refer to edges stored elsewhere.
   // We write a separate edge block for each unique boundary id that
   // we have.
   num_edge_blk = bi.get_edge_boundary_ids().size();
  
   // Build an ex_init_params() structure that is to be passed to the
   // newer ex_put_init_ext() API. The new API will eventually allow us
   // to store edge and face data in the Exodus file.
   //
   // Notes:
   // * We use C++11 zero initialization syntax to make sure that all
   //   members of the struct (including ones we aren't using) are
   //   given sensible values.
   // * For the "title" field, we manually do a null-terminated string
   //   copy since std::string does not null-terminate but it does
   //   return the number of characters successfully copied.
   exII::ex_init_params params = {};
   params.title[str_title.copy(params.title, MAX_LINE_LENGTH)] = '\0';
   params.num_dim = num_dim;
   params.num_nodes = num_nodes;
   params.num_elem = n_active_elem;
   params.num_elem_blk = num_elem_blk;
   params.num_node_sets = num_node_sets;
   params.num_side_sets = num_side_sets;
   params.num_edge_blk = num_edge_blk;
   params.num_edge = num_edge;
  
   ex_err = exII::ex_put_init_ext(ex_id, &params);
   EX_CHECK_ERR(ex_err, "Error initializing new Exodus file.");
 }

References _run_only_on_proc0, _use_mesh_dimension_instead_of_spatial_dimension, _write_as_dimension, libMesh::BoundaryInfo::build_node_boundary_ids(), libMesh::BoundaryInfo::build_shellface_boundary_ids(), libMesh::BoundaryInfo::build_side_boundary_ids(), distance(), libMesh::err, ex_err, ex_id, libMesh::BoundaryInfo::get_edge_boundary_ids(), mesh, libMesh::MeshBase::mesh_dimension(), libMesh::BoundaryInfo::n_edge_conds(), num_dim, num_edge, num_edge_blk, num_elem, num_elem_blk, num_node_sets, num_nodes, num_side_sets, and libMesh::ParallelObject::processor_id().

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

 {
   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;
  
   // 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;
     }
  
   // Quick return if we have already called this function
   if (_elem_vars_initialized)
     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.");
 }

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

◆ initialize_global_variables()

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

Sets up the global variables.

Definition at line 2496 of file exodusII_io_helper.C.

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

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

◆ initialize_nodal_variables()

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

Sets up the nodal variables.

Definition at line 2468 of file exodusII_io_helper.C.

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

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

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

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

References ex_err, and ex_id.

Referenced by read_all_nodesets(), read_num_time_steps(), read_qa_records(), read_sideset_info(), and write_information_records().

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

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

References libMesh::out, and verbose.

Referenced by close(), read_block_info(), read_edge_blocks(), 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().

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

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

References libMesh::out, and verbose.

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 100 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

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

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

References _single_precision, current_filename, ex_id, opened_for_reading, opened_for_writing, libMesh::out, libMesh::Real, and verbose.

◆ operator=() [1/2]

ExodusII_IO_Helper& libMesh::ExodusII_IO_Helper::operator= ( const ExodusII_IO_Helper & )

default

◆ operator=() [2/2]

ExodusII_IO_Helper& libMesh::ExodusII_IO_Helper::operator= ( ExodusII_IO_Helper && )

default

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

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

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

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

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

References num_nodes, x, y, and z.

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 106 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

◆ read_all_nodesets()

void libMesh::ExodusII_IO_Helper::read_all_nodesets ( )

New API that reads all nodesets simultaneously.

This may be slightly faster than reading them one at a time. Calls ex_get_concat_node_sets() under the hood.

Definition at line 1164 of file exodusII_io_helper.C.

 {
   // Figure out how many nodesets there are in the file so we can
   // properly resize storage as necessary.
   num_node_sets =
     this->inquire
     (exII::EX_INQ_NODE_SETS,
      "Error retrieving number of node sets");
  
   // Figure out how many nodes there are in all the nodesets.
   int total_nodes_in_all_sets =
     this->inquire
     (exII::EX_INQ_NS_NODE_LEN,
      "Error retrieving number of nodes in all node sets.");
  
   // Figure out how many distribution factors there are in all the nodesets.
   int total_df_in_all_sets =
     this->inquire
     (exII::EX_INQ_NS_DF_LEN,
      "Error retrieving number of distribution factors in all node sets.");
  
   // If there are no nodesets, there's nothing to read in.
   if (num_node_sets == 0)
     return;
  
   // Allocate space to read all the nodeset data.
   // Use existing class members where possible to avoid shadowing
   nodeset_ids.clear();          nodeset_ids.resize(num_node_sets);
   num_nodes_per_set.clear();    num_nodes_per_set.resize(num_node_sets);
   num_node_df_per_set.clear();  num_node_df_per_set.resize(num_node_sets);
   node_sets_node_index.clear(); node_sets_node_index.resize(num_node_sets);
   node_sets_dist_index.clear(); node_sets_dist_index.resize(num_node_sets);
   node_sets_node_list.clear();  node_sets_node_list.resize(total_nodes_in_all_sets);
   node_sets_dist_fact.clear();  node_sets_dist_fact.resize(total_df_in_all_sets);
  
   ex_err = exII::ex_get_concat_node_sets
     (ex_id,
      nodeset_ids.data(),
      num_nodes_per_set.data(),
      num_node_df_per_set.data(),
      node_sets_node_index.data(),
      node_sets_dist_index.data(),
      node_sets_node_list.data(),
      total_df_in_all_sets ?
      MappedInputVector(node_sets_dist_fact, _single_precision).data() : nullptr);
  
   EX_CHECK_ERR(ex_err, "Error reading concatenated nodesets");
  
   // Read the nodeset names from file!
   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;
     }
 }

References _single_precision, libMesh::ExodusII_IO_Helper::MappedInputVector::data(), ex_err, ex_id, id_to_ns_names, inquire(), node_sets_dist_fact, node_sets_dist_index, node_sets_node_index, node_sets_node_list, nodeset_ids, num_node_df_per_set, num_node_sets, and num_nodes_per_set.

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

 {
   if (num_elem_blk)
     {
       // Read all element block IDs.
       block_ids.resize(num_elem_blk);
       ex_err = exII::ex_get_ids(ex_id,
                                 exII::EX_ELEM_BLOCK,
                                 block_ids.data());
  
       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.");
     }
  
   if (num_edge_blk)
     {
       // Read all edge block IDs.
       edge_block_ids.resize(num_edge_blk);
       ex_err = exII::ex_get_ids(ex_id,
                                 exII::EX_EDGE_BLOCK,
                                 edge_block_ids.data());
  
       EX_CHECK_ERR(ex_err, "Error getting edge block IDs.");
       message("All edge block IDs retrieved successfully.");
  
       // Read in edge block names
       char name_buffer[MAX_STR_LENGTH+1];
       for (int i=0; i<num_edge_blk; ++i)
         {
           ex_err = exII::ex_get_name(ex_id, exII::EX_EDGE_BLOCK,
                                      edge_block_ids[i], name_buffer);
           EX_CHECK_ERR(ex_err, "Error getting block name.");
           id_to_edge_block_names[edge_block_ids[i]] = name_buffer;
         }
       message("All edge block names retrieved successfully.");
     }
 }

References block_ids, edge_block_ids, ex_err, ex_id, id_to_block_names, id_to_edge_block_names, message(), num_edge_blk, and num_elem_blk.

◆ read_edge_blocks()

void libMesh::ExodusII_IO_Helper::read_edge_blocks ( MeshBase & mesh )

Read in edge blocks, storing information in the BoundaryInfo object.

Definition at line 852 of file exodusII_io_helper.C.

 {
   // Check for quick return if there are no edge blocks.
   if (num_edge_blk == 0)
     return;
  
   // Build data structure that we can quickly search for edges
   // and then add required BoundaryInfo information. This is a
   // map from edge->key() to a list of (elem_id, edge_id) pairs
   // for the Edge in question. Since edge->key() is edge orientation
   // invariant, this map does not distinguish different orientations
   // of the same Edge.
   typedef std::pair<dof_id_type, unsigned int> ElemEdgePair;
   std::unordered_map<dof_id_type, std::vector<ElemEdgePair>> edge_map;
   for (const auto & elem : mesh.element_ptr_range())
     for (auto e : elem->edge_index_range())
       {
         // TODO: Make various Elem::compute_key() functions
         // unprotected, this would allow us to avoid calling
         // build_edge_ptr() repeatedly in case that turns out to be
         // a bottleneck.
         std::unique_ptr<Elem> edge = elem->build_edge_ptr(e);
         dof_id_type edge_key = edge->key();
  
         // Creates vector if not already there
         auto & vec = edge_map[edge_key];
         vec.push_back(std::make_pair(elem->id(), e));
       }
  
   // Get reference to the mesh's BoundaryInfo object, as we will be
   // adding edges to this below.
   BoundaryInfo & bi = mesh.get_boundary_info();
  
   for (const auto & edge_block_id : edge_block_ids)
     {
       // exII::ex_get_block() output parameters.  Unlike the other
       // "extended" APIs, exII::ex_get_block() does not use a
       // parameter struct.
       int num_edge_this_blk = 0;
       int num_nodes_per_edge = 0;
       int num_edges_per_edge = 0;
       int num_faces_per_edge = 0;
       int num_attr_per_edge = 0;
       ex_err = exII::ex_get_block(ex_id,
                                   exII::EX_EDGE_BLOCK,
                                   edge_block_id,
                                   elem_type.data(),
                                   &num_edge_this_blk,
                                   &num_nodes_per_edge,
                                   &num_edges_per_edge, // 0 or -1 for edge blocks
                                   &num_faces_per_edge, // 0 or -1 for edge blocks
                                   &num_attr_per_edge);
  
       EX_CHECK_ERR(ex_err, "Error getting edge block info.");
       message("Info retrieved successfully for block: ", edge_block_id);
  
       // Read in the connectivity of the edges 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_edge * num_edge_this_blk);
  
       if (!connect.empty())
         {
           ex_err = exII::ex_get_conn(ex_id,
                                      exII::EX_EDGE_BLOCK,
                                      edge_block_id,
                                      connect.data(), // node_conn
                                      nullptr,        // elem_edge_conn (unused)
                                      nullptr);       // elem_face_conn (unused)
  
           EX_CHECK_ERR(ex_err, "Error reading block connectivity.");
           message("Connectivity retrieved successfully for block: ", edge_block_id);
  
           // All edge types have an identity mapping from the corresponding
           // Exodus type, so we don't need to bother with mapping ids, but
           // we do need to know what kind of elements to build.
           const auto & conv = get_conversion(std::string(elem_type.data()));
  
           // Loop over indices in connectivity array, build edge elements,
           // look them up in the edge_map.
           for (unsigned int i=0, sz=connect.size(); i<sz; i+=num_nodes_per_edge)
             {
               auto edge = Elem::build(conv.libmesh_elem_type());
               for (int n=0; n<num_nodes_per_edge; ++n)
                 {
                   int exodus_node_id = connect[i+n];
                   int exodus_node_id_zero_based = exodus_node_id - 1;
                   int libmesh_node_id = node_num_map[exodus_node_id_zero_based] - 1;
  
                   edge->set_node(n) = mesh.node_ptr(libmesh_node_id);
                 }
  
               // Compute key for the edge Elem we just built.
               dof_id_type edge_key = edge->key();
  
               // If this key is not found in the edge_map, which is
               // supposed to include every edge in the Mesh, then we
               // need to throw an error.
               auto & elem_edge_pair_vec =
                 libmesh_map_find(edge_map, edge_key);
  
               for (const auto & elem_edge_pair : elem_edge_pair_vec)
                 {
                   // We only want to match edges which have the same
                   // orientation (node ordering) to the one in the
                   // Exodus file, otherwise we ignore this elem_edge_pair.
                   //
                   // Note: this also handles the situation where two
                   // edges have the same key (hash collision) as then
                   // this check avoids a false positive.
  
                   // Build edge indicated by elem_edge_pair
                   auto candidate_edge =
                     mesh.elem_ptr(elem_edge_pair.first)->
                     build_edge_ptr(elem_edge_pair.second);
  
                   // Determine whether this candidate edge is a "real" match,
                   // i.e. also has the same orientation.
                   bool is_match = true;
                   for (int n=0; n<num_nodes_per_edge; ++n)
                     if (candidate_edge->node_id(n) != edge->node_id(n))
                       {
                         is_match = false;
                         break;
                       }
  
                   if (is_match)
                     {
                       // Add this (elem, edge, id) combo to the BoundaryInfo object.
                       bi.add_edge(elem_edge_pair.first,
                                   elem_edge_pair.second,
                                   edge_block_id);
                     }
                 } // end loop over elem_edge_pairs
             } // end loop over connectivity array
  
           // Set edgeset name in the BoundaryInfo object.
           bi.edgeset_name(edge_block_id) = id_to_edge_block_names[edge_block_id];
         } // end if !connect.empty()
     } // end for edge_block_id : edge_block_ids
 }

References libMesh::BoundaryInfo::add_edge(), libMesh::Elem::build(), connect, edge_block_ids, libMesh::BoundaryInfo::edgeset_name(), elem_type, ex_err, ex_id, get_conversion(), id_to_edge_block_names, mesh, message(), node_num_map, and num_edge_blk.

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

 {
   libmesh_assert_less (block, block_ids.size());
  
   // Unlike the other "extended" APIs, this one does not use a parameter struct.
   int num_edges_per_elem = 0;
   int num_faces_per_elem = 0;
   ex_err = exII::ex_get_block(ex_id,
                               exII::EX_ELEM_BLOCK,
                               block_ids[block],
                               elem_type.data(),
                               &num_elem_this_blk,
                               &num_nodes_per_elem,
                               &num_edges_per_elem, // 0 or -1 if no "extended" block info
                               &num_faces_per_elem, // 0 or -1 if no "extended" block info
                               &num_attr);
  
   EX_CHECK_ERR(ex_err, "Error getting block info.");
   message("Info retrieved successfully for block: ", block);
  
   // Warn that we don't currently support reading blocks with extended info.
   // Note: the docs say -1 will be returned for this but I found that it was
   // actually 0, so not sure which it will be in general.
   if (!(num_edges_per_elem == 0) && !(num_edges_per_elem == -1))
     libmesh_warning("Exodus files with extended edge connectivity not currently supported.");
   if (!(num_faces_per_elem == 0) && !(num_faces_per_elem == -1))
     libmesh_warning("Exodus files with extended face connectivity not currently supported.");
  
   if (verbose)
     libMesh::out << "Read a block of " << num_elem_this_blk
                  << " " << elem_type.data() << "(s)"
                  << " having " << num_nodes_per_elem
                  << " nodes per element." << std::endl;
  
   // 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_conn(ex_id,
                                  exII::EX_ELEM_BLOCK,
                                  block_ids[block],
                                  connect.data(), // node_conn
                                  nullptr,        // elem_edge_conn (unused)
                                  nullptr);       // elem_face_conn (unused)
  
       EX_CHECK_ERR(ex_err, "Error reading block connectivity.");
       message("Connectivity retrieved successfully for block: ", block);
     }
 }

References block_ids, connect, elem_type, ex_err, ex_id, message(), num_attr, num_elem_this_blk, num_nodes_per_elem, libMesh::out, and verbose.

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

 {
   elem_num_map.resize(num_elem);
  
   // Note: we cannot use the exII::ex_get_num_map() here because it
   // (apparently) does not behave like ex_get_elem_num_map() when
   // there is no elem number map in the file: it throws an error
   // instead of returning a default identity array (1,2,3,...).
   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;
     }
 }

References elem_num_map, ex_err, ex_id, message(), num_elem, libMesh::out, libMesh::ParallelObject::processor_id(), and verbose.

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

 {
   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 elem_var_name in elemental_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;
  
   // Element variable truth table
   std::vector<int> var_table(block_ids.size() * elem_var_names.size());
   exII::ex_get_var_tab(ex_id, "e", block_ids.size(), elem_var_names.size(), var_table.data());
  
   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.");
  
       // If the current variable isn't active on this subdomain, advance
       // the index by the number of elements on this block and go to the
       // next loop iteration.
       if (!var_table[elem_var_names.size()*i + var_index])
         {
           ex_el_num += num_elem_this_blk;
           continue;
         }
  
       std::vector<Real> block_elem_var_values(num_elem_this_blk);
  
       ex_err = exII::ex_get_elem_var
         (ex_id,
          time_step,
          var_index+1,
          block_ids[i],
          num_elem_this_blk,
          MappedInputVector(block_elem_var_values, _single_precision).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++;
         }
     }
 }

References _single_precision, block_ids, data, elem_num_map, elem_var_names, ELEMENTAL, libMesh::err, ex_err, ex_id, num_elem_blk, num_elem_this_blk, and read_var_names().

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

 {
   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,
      MappedInputVector(values, _single_precision).data());
  
   EX_CHECK_ERR(ex_err, "Error reading global values.");
 }

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

◆ read_header()

void libMesh::ExodusII_IO_Helper::read_header ( )

Reads an ExodusII mesh file header.

Definition at line 532 of file exodusII_io_helper.C.

 {
   // Read init params using newer API that reads into a struct.  For
   // backwards compatibility, assign local member values from struct
   // afterwards. Note: using the new API allows us to automatically
   // read edge and face block/set information if it's present in the
   // file.
   exII::ex_init_params params = {};
   ex_err = exII::ex_get_init_ext(ex_id, &params);
   EX_CHECK_ERR(ex_err, "Error retrieving header info.");
  
   // "title" has MAX_LINE_LENGTH+1 characters, but the last one is reserved
   // for null termination so we only copy MAX_LINE_LENGTH chars.
   title.assign(params.title, params.title + MAX_LINE_LENGTH);
   num_dim = params.num_dim;
   num_nodes = params.num_nodes;
   num_elem = params.num_elem;
   num_elem_blk = params.num_elem_blk;
   num_node_sets = params.num_node_sets;
   num_side_sets = params.num_side_sets;
   num_edge_blk = params.num_edge_blk;
   num_edge = params.num_edge;
  
   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.");
  
   ex_err = exII::ex_get_var_param(ex_id, "s", &num_sideset_vars);
   EX_CHECK_ERR(ex_err, "Error reading number of sideset variables.");
  
   message("Exodus header info retrieved successfully.");
 }

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

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

 {
   // 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);
  
   std::vector<Real> unmapped_nodal_var_values(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,
      MappedInputVector(unmapped_nodal_var_values, _single_precision).data());
   EX_CHECK_ERR(ex_err, "Error reading nodal variable values!");
  
   for (unsigned i=0; i<static_cast<unsigned>(num_nodes); i++)
     {
       // Use the node_num_map to obtain the ID of this node in the Exodus file,
       // and remember to subtract 1 since libmesh is zero-based and Exodus is 1-based.
       unsigned mapped_node_id = this->node_num_map[i] - 1;
  
       // Store the nodal value in the map.
       nodal_var_values[mapped_node_id] = unmapped_nodal_var_values[i];
     }
 }

References _single_precision, data, libMesh::err, ex_err, ex_id, NODAL, nodal_var_names, nodal_var_values, node_num_map, num_nodes, and read_var_names().

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

 {
   node_num_map.resize(num_nodes);
  
   // Note: we cannot use the exII::ex_get_num_map() here because it
   // (apparently) does not behave like ex_get_node_num_map() when
   // there is no node number map in the file: it throws an error
   // instead of returning a default identity array (1,2,3,...).
   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;
     }
 }

References ex_err, ex_id, message(), node_num_map, num_nodes, libMesh::out, libMesh::ParallelObject::processor_id(), and verbose.

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

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

References _single_precision, data, ex_err, ex_id, message(), num_nodes, x, y, and z.

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

 {
   libmesh_assert_less (id, nodeset_ids.size());
   libmesh_assert_less (id, num_nodes_per_set.size());
   libmesh_assert_less (id, num_node_df_per_set.size());
  
   ex_err = exII::ex_get_set_param(ex_id,
                                   exII::EX_NODE_SET,
                                   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_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_set(ex_id,
                                 exII::EX_NODE_SET,
                                 nodeset_ids[id],
                                 node_list.data(),
                                 nullptr); // set_extra_list, ignored for node sets
  
       EX_CHECK_ERR(ex_err, "Error retrieving nodeset data.");
       message("Data retrieved successfully for nodeset: ", id);
     }
 }

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

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

 {
   nodeset_ids.resize(num_node_sets);
   if (num_node_sets > 0)
     {
       ex_err = exII::ex_get_ids(ex_id,
                                 exII::EX_NODE_SET,
                                 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.");
 }

References ex_err, ex_id, id_to_ns_names, message(), nodeset_ids, num_node_df_per_set, num_node_sets, and num_nodes_per_set.

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

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

References inquire(), and num_time_steps.

Referenced by read_header(), and read_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 575 of file exodusII_io_helper.C.

 {
   // 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;
     }
 }

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

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

 {
   libmesh_assert_less (id, ss_ids.size());
   libmesh_assert_less (id, num_sides_per_set.size());
   libmesh_assert_less (id, num_df_per_set.size());
   libmesh_assert_less_equal (offset, elem_list.size());
   libmesh_assert_less_equal (offset, side_list.size());
  
   ex_err = exII::ex_get_set_param(ex_id,
                                   exII::EX_SIDE_SET,
                                   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_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_set(ex_id,
                                 exII::EX_SIDE_SET,
                                 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];
     }
 }

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

Referenced by write_sideset_data().

◆ read_sideset_data()

void libMesh::ExodusII_IO_Helper::read_sideset_data	(	const MeshBase &	mesh,
		int	timestep,
		std::vector< std::string > &	var_names,
		std::vector< std::set< boundary_id_type >> &	side_ids,
		std::vector< std::map< BoundaryInfo::BCTuple, Real >> &	bc_vals
	)

Read sideset variables, if any, into the provided data structures.

Definition at line 2736 of file exodusII_io_helper.C.

 {
   // This reads the sideset variable names into the local
   // sideset_var_names data structure.
   this->read_var_names(SIDESET);
  
   if (num_sideset_vars)
     {
       // Read the sideset data truth table
       std::vector<int> sset_var_tab(num_side_sets * num_sideset_vars);
       ex_err = exII::ex_get_sset_var_tab
         (ex_id,
          num_side_sets,
          num_sideset_vars,
          sset_var_tab.data());
       EX_CHECK_ERR(ex_err, "Error reading sideset variable truth table.");
  
       // Set up/allocate space in incoming data structures.
       var_names = sideset_var_names;
       side_ids.resize(num_sideset_vars);
       bc_vals.resize(num_sideset_vars);
  
       // Read the sideset data.
       //
       // Note: we assume that read_sideset() has already been called
       // for each sideset, so the required values in elem_list and
       // side_list are already present.
       //
       // TODO: As a future optimization, we could read only the values
       // requested by the user by looking at the input parameter
       // var_names and checking whether it already has entries in
       // it. We could do the same thing with the input side_ids
       // container and only read values for requested sidesets.
       int offset=0;
       for (int ss=0; ss<num_side_sets; ++ss)
         {
           offset += (ss > 0 ? num_sides_per_set[ss-1] : 0);
           for (int var=0; var<num_sideset_vars; ++var)
             {
               int is_present = sset_var_tab[num_sideset_vars*ss + var];
  
               if (is_present)
                 {
                   // Record the fact that this variable is defined on this sideset.
                   side_ids[var].insert(ss_ids[ss]);
  
                   // Note: the assumption here is that a previous call
                   // to this->read_sideset_info() has already set the
                   // values of num_sides_per_set, so we just use those values here.
                   std::vector<Real> sset_var_vals(num_sides_per_set[ss]);
                   ex_err = exII::ex_get_sset_var
                     (ex_id,
                      timestep,
                      var + 1, // 1-based sideset variable index!
                      ss_ids[ss],
                      num_sides_per_set[ss],
                      MappedInputVector(sset_var_vals, _single_precision).data());
                   EX_CHECK_ERR(ex_err, "Error reading sideset variable.");
  
                   // Debugging:
                   // libMesh::out << "Variable " << sideset_var_names[var]
                   //              << " is defined on side set " << ss_ids[ss]
                   //              << " and has values: " << std::endl;
                   // for (int i=0; i<num_sides_per_set[ss]; ++i)
                   //   libMesh::out << sset_var_vals[i] << " ";
                   // libMesh::out << std::endl;
  
                   for (int i=0; i<num_sides_per_set[ss]; ++i)
                     {
                       dof_id_type exodus_elem_id = elem_list[i + offset];
                       unsigned int exodus_side_id = side_list[i + offset];
  
                       // FIXME: We should use exodus_elem_num_to_libmesh for this,
                       // but it apparently is never set up, so just
                       // subtract 1 from the Exodus elem id.
                       dof_id_type converted_elem_id = exodus_elem_id - 1;
  
                       // Map Exodus side id to libmesh side id.
                       // Map from Exodus side ids to libmesh side ids.
                       const auto & conv = get_conversion(mesh.elem_ptr(converted_elem_id)->type());
  
                       // Map from Exodus side id to libmesh side id.
                       // Note: the mapping is defined on 0-based indices, so subtract
                       // 1 before doing the mapping.
                       unsigned int converted_side_id = conv.get_side_map(exodus_side_id - 1);
  
                       // Debugging:
                       // libMesh::out << "exodus_elem_id = " << exodus_elem_id
                       //              << "\n"
                       //              << "converted_elem_id = " << converted_elem_id
                       //              << "\n\n"
                       //              << "exodus_side_id = " << exodus_side_id
                       //              << "\n"
                       //              << "converted_side_id = " << converted_side_id
                       //              << std::endl;
  
                       // Make a BCTuple key from the converted information.
                       BoundaryInfo::BCTuple key = std::make_tuple
                         (converted_elem_id,
                          converted_side_id,
                          ss_ids[ss]);
  
                       // Store (elem, side, b_id) tuples in bc_vals[var]
                       bc_vals[var].insert(std::make_pair(key, sset_var_vals[i]));
                     } // end for (i)
                 } // end if (present)
             } // end for (var)
         } // end for (ss)
     } // end if (num_sideset_vars)
 }

References _single_precision, data, elem_list, ex_err, ex_id, get_conversion(), libMesh::ExodusII_IO_Helper::Conversion::get_side_map(), mesh, num_side_sets, num_sides_per_set, num_sideset_vars, read_var_names(), side_list, SIDESET, sideset_var_names, and ss_ids.

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

 {
   ss_ids.resize(num_side_sets);
   if (num_side_sets > 0)
     {
       ex_err = exII::ex_get_ids(ex_id,
                                 exII::EX_SIDE_SET,
                                 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.");
 }

References elem_list, ex_err, ex_id, 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.

Referenced by write_sideset_data().

◆ read_time_steps()

void libMesh::ExodusII_IO_Helper::read_time_steps ( )

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

Definition at line 1266 of file exodusII_io_helper.C.

 {
   // 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,
          MappedInputVector(time_steps, _single_precision).data());
       EX_CHECK_ERR(ex_err, "Error reading timesteps!");
     }
 }

References _single_precision, data, ex_err, ex_id, num_time_steps, read_num_time_steps(), and time_steps.

◆ read_var_names()

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

Definition at line 1344 of file exodusII_io_helper.C.

 {
   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;
     case SIDESET:
       this->read_var_names_impl("s", num_sideset_vars, sideset_var_names);
       break;
     default:
       libmesh_error_msg("Unrecognized ExodusVarType " << type);
     }
 }

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

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

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

 {
   // 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 *)
 }

References ex_err, 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().

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

 {
   _coordinate_offset = p;
 }

References _coordinate_offset.

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

 {
   _use_mesh_dimension_instead_of_spatial_dimension = val;
 }

References _use_mesh_dimension_instead_of_spatial_dimension.

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

 {
   _write_as_dimension = dim;
 }

References _write_as_dimension, and 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.

The 'values' vector is assumed to be in the order: {(u1, u2, u3, ..., uN), (v1, v2, v3, ..., vN), (w1, w2, w3, ..., wN)} where N is the number of elements.

This ordering is produced by calls to ES::build_elemental_solution_vector(). ES::build_discontinuous_solution_vector(), on the other hand, produces an element-major ordering. See the function below for that case.

Definition at line 2854 of file exodusII_io_helper.C.

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
  
   // 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.");
  
   // We will eventually loop over the element blocks (subdomains) and
   // write the data one block at a time. Build a data structure that
   // maps each subdomain to a list of element ids it contains.
   std::map<subdomain_id_type, std::vector<unsigned int>> subdomain_map;
   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();
  
   // Sanity check: we must have an entry in vars_active_subdomains for
   // each variable that we are potentially writing out.
   libmesh_assert_equal_to
     (vars_active_subdomains.size(),
      static_cast<unsigned>(num_elem_vars));
  
   // 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.
   for (unsigned int var_id=0; var_id<static_cast<unsigned>(num_elem_vars); ++var_id)
     {
       // The size of the subdomain map is the number of blocks.
       auto it = subdomain_map.begin();
  
       // Reference to the set of active subdomains for the current variable.
       const auto & active_subdomains
         = vars_active_subdomains[var_id];
  
       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() || active_subdomains.count(it->first)))
             continue;
  
           // Get reference to list of elem ids which are in the
           // current subdomain and count, allocate storage to hold
           // data that will be written to file.
           const auto & 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);
  
           // variable-major ordering is:
           // (u1, u2, u3, ..., uN), (v1, v2, v3, ..., vN), ...
           // where N is the number of elements.
           for (unsigned int k=0; k<num_elems_this_block; ++k)
             data[k] = values[var_id*n_elem + elem_nums[k]];
  
           ex_err = exII::ex_put_elem_var
             (ex_id,
              timestep,
              var_id+1,
              this->get_block_id(j),
              num_elems_this_block,
              MappedOutputVector(data, _single_precision).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.");
 }

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

◆ write_element_values_element_major()

void libMesh::ExodusII_IO_Helper::write_element_values_element_major	(	const MeshBase &	mesh,
		const std::vector< Real > &	values,
		int	timestep,
		const std::vector< std::set< subdomain_id_type >> &	vars_active_subdomains,
		const std::vector< std::string > &	derived_var_names,
		const std::map< subdomain_id_type, std::vector< std::string >> &	subdomain_to_var_names
	)

Same as the function above, but assume the input 'values' vector is in element-major order, i.e.

{(u1,v1,w1), (u2,v2,w2), ... (uN,vN,wN)} This function is called by ExodusII_IO::write_element_data_from_discontinuous_nodal_data() because ES::build_discontinuous_solution_vector() builds the solution vector in this order.

Note: If some variables are subdomain-restricted, then the tuples will be of different lengths for each element, i.e. {(u1,v1,w1), (u2,v2), ... (uN,vN,wN)} if variable w is not active on element 2.

Definition at line 2937 of file exodusII_io_helper.C.

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
  
   // 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.");
  
   // We will eventually loop over the element blocks (subdomains) and
   // write the data one block (subdomain) at a time. Build a data
   // structure that keeps track of how many elements are in each
   // subdomain. This will allow us to reserve space in the data vector
   // we are going to write.
   std::map<subdomain_id_type, unsigned int> subdomain_to_n_elem;
   for (const auto & elem : mesh.active_element_ptr_range())
     subdomain_to_n_elem[elem->subdomain_id()] += 1;
  
   // Sanity check: we must have an entry in vars_active_subdomains for
   // each variable that we are potentially writing out.
   libmesh_assert_equal_to
     (vars_active_subdomains.size(),
      static_cast<unsigned>(num_elem_vars));
  
   // The size of the subdomain map is the number of blocks.
   auto subdomain_to_n_elem_iter = subdomain_to_n_elem.begin();
  
   // Store range of active Elem pointers. We are going to loop over
   // the elements n_vars * n_subdomains times, so let's make sure
   // the predicated iterators aren't slowing us down too much.
   ConstElemRange elem_range
     (mesh.active_elements_begin(),
      mesh.active_elements_end());
  
   for (unsigned int sbd_idx=0;
        subdomain_to_n_elem_iter != subdomain_to_n_elem.end();
        ++subdomain_to_n_elem_iter, ++sbd_idx)
     for (unsigned int var_id=0; var_id<static_cast<unsigned>(num_elem_vars); ++var_id)
       {
         // Reference to the set of active subdomains for the current variable.
         const auto & active_subdomains
           = vars_active_subdomains[var_id];
  
         // If the vars_active_subdomains container passed to this function
         // has an empty entry, it means the variable really is not active on
         // _any_ subdomains, not that it is active on _all_ subdomains. This
         // is just due to the way that we build the vars_active_subdomains
         // container.
         if (!active_subdomains.count(subdomain_to_n_elem_iter->first))
           continue;
  
         // Vector to hold values that will be written to Exodus file.
         std::vector<Real> data;
         data.reserve(subdomain_to_n_elem_iter->second);
  
         unsigned int values_offset = 0;
         for (auto & elem : elem_range)
           {
             // We'll use the Elem's subdomain id in several places below.
             subdomain_id_type sbd_id = elem->subdomain_id();
  
             // Get reference to the list of variable names defining
             // the indexing for the current Elem's subdomain.
             auto subdomain_to_var_names_iter =
               subdomain_to_var_names.find(sbd_id);
  
             // It's possible, but unusual, for there to be an Elem
             // from a subdomain that has no active variables from the
             // set of variables we are currently writing. If that
             // happens, we can just go to the next Elem because we
             // don't need to advance the offset into the values
             // vector, etc.
             if (subdomain_to_var_names_iter == subdomain_to_var_names.end())
               continue;
  
             const auto & var_names_this_sbd
               = subdomain_to_var_names_iter->second;
  
             // Only extract values if Elem is in the current subdomain.
             if (sbd_id == subdomain_to_n_elem_iter->first)
               {
                 // Location of current var_id in the list of all variables on this
                 // subdomain. FIXME: linear search but it's over a typically relatively
                 // short vector of active variable names on this subdomain. We could do
                 // a nested std::map<string,index> instead of a std::vector where the
                 // location of the string is implicitly the index..
                 auto pos =
                   std::find(var_names_this_sbd.begin(),
                             var_names_this_sbd.end(),
                             derived_var_names[var_id]);
  
                 if (pos == var_names_this_sbd.end())
                   libmesh_error_msg("Derived name " << derived_var_names[var_id] << " not found!");
  
                 // Find the current variable's location in the list of all variable
                 // names on the current Elem's subdomain.
                 auto true_index =
                   std::distance(var_names_this_sbd.begin(), pos);
  
                 data.push_back(values[values_offset + true_index]);
               }
  
             // The "true" offset is how much we have to advance the index for each Elem
             // in this subdomain.
             auto true_offset = var_names_this_sbd.size();
  
             // Increment to the next Elem's values
             values_offset += true_offset;
           } // for elem
  
         // Now write 'data' to Exodus file, in single precision if requested.
         if (!data.empty())
           {
             ex_err = exII::ex_put_elem_var
               (ex_id, timestep, var_id+1, this->get_block_id(sbd_idx), data.size(),
                MappedOutputVector(data, _single_precision).data());
  
             EX_CHECK_ERR(ex_err, "Error writing element values.");
           }
       } // for each var_id
  
   ex_err = exII::ex_update(ex_id);
   EX_CHECK_ERR(ex_err, "Error flushing buffers to file.");
 }

References _run_only_on_proc0, _single_precision, data, libMesh::ExodusII_IO_Helper::MappedOutputVector::data(), distance(), ex_err, ex_id, get_block_id(), mesh, num_elem_vars, and libMesh::ParallelObject::processor_id().

◆ 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 1827 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;
  
   // 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_edges_per_elem_vec;
   std::vector<int> num_faces_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!
       const auto & conv = get_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.
       num_edges_per_elem_vec.push_back(0); // We don't currently store any edge blocks
       num_faces_per_elem_vec.push_back(0); // We don't currently store any face blocks
       ++counter;
     }
  
   // 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.
   //
   // Note: This map takes the place of the libmesh_node_num_to_exodus map in
   // the discontinuous case.
   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 (auto n : elem->node_index_range())
         {
           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++;
         }
   }
  
   // Reference to the BoundaryInfo object for convenience.
   const BoundaryInfo & bi = mesh.get_boundary_info();
  
   // Build list of (elem, edge, id) triples
   std::vector<BoundaryInfo::BCTuple> edge_tuples = bi.build_edge_list();
  
   // Build the connectivity array for each edge block. The connectivity array
   // is a vector<int> with "num_edges * num_nodes_per_edge" entries. We write
   // the Exodus node numbers to the connectivity arrays so that they can
   // be used directly in the calls to exII::ex_put_conn() below. We also keep
   // track of the ElemType and the number of nodes for each boundary_id. All
   // edges with a given boundary_id must be of the same type.
   std::map<boundary_id_type, std::vector<int>> edge_id_to_conn;
   std::map<boundary_id_type, std::pair<ElemType, unsigned int>> edge_id_to_elem_type;
  
   for (const auto & t : edge_tuples)
     {
       dof_id_type elem_id = std::get<0>(t);
       unsigned int edge_id = std::get<1>(t);
       boundary_id_type b_id = std::get<2>(t);
  
       // Build the edge in question
       std::unique_ptr<const Elem> edge =
         mesh.elem_ptr(elem_id)->build_edge_ptr(edge_id);
  
       // Error checking: make sure that all edges in this block are
       // the same geometric type.
       auto check_it = edge_id_to_elem_type.find(b_id);
  
       if (check_it == edge_id_to_elem_type.end())
         {
           // Keep track of the ElemType and number of nodes in this boundary id.
           edge_id_to_elem_type[b_id] = std::make_pair(edge->type(), edge->n_nodes());
         }
       else
         {
           // Make sure the existing data is consistent
           auto & val_pair = check_it->second;
           if (val_pair.first != edge->type() || val_pair.second != edge->n_nodes())
             libmesh_error_msg("All edges in a block must have same geometric type.");
         }
  
       // Get reference to the connectivity array for this block
       auto & conn = edge_id_to_conn[b_id];
  
       // For each node on the edge, look up the exodus node id and
       // store it in the conn array. Note: all edge types have
       // identity node mappings so we don't bother with Conversion
       // objects here.
       for (auto n : edge->node_index_range())
         {
           dof_id_type libmesh_node_id = edge->node_ptr(n)->id();
  
           // We look up Exodus node numbers differently if we are
           // writing a discontinuous Exodus file.
           int exodus_node_id = -1;
  
           if (!use_discontinuous)
             exodus_node_id = libmesh_map_find
               (libmesh_node_num_to_exodus, cast_int<int>(libmesh_node_id));
           else
             {
               // Find the node on the "parent" element containing this edge
               // which matches libmesh_node_id. Then use that id to look up
               // the exodus_node_id in the discontinuous_node_indices map.
               //
               // TODO: This should also be given by e.g.:
               // Hex8::edge_nodes_map[edge_id][n]. Note: we have something
               // like this for sides, Elem::which_node_am_i(), but nothing
               // equivalent for edges.
               const Elem * parent = mesh.elem_ptr(elem_id);
               for (auto pn : parent->node_index_range())
                 if (parent->node_ptr(pn)->id() == libmesh_node_id)
                   {
                     exodus_node_id = libmesh_map_find
                       (discontinuous_node_indices,
                        std::make_pair(elem_id, pn));
                     break;
                   }
             }
  
           if (exodus_node_id == -1)
             libmesh_error_msg("Unable to map edge's libMesh node id to its Exodus node id.");
  
           conn.push_back(exodus_node_id);
         }
     }
  
   // Make sure we have the same number of edge ids that we thought we would.
   libmesh_assert(static_cast<int>(edge_id_to_conn.size()) == num_edge_blk);
  
   // Build data structures describing edge blocks. This information must be
   // be passed to exII::ex_put_concat_all_blocks() at the same time as the
   // information about elem blocks.
   std::vector<int> edge_blk_id;
   NamesData edge_type_table(num_edge_blk, MAX_STR_LENGTH);
   std::vector<int> num_edge_this_blk_vec;
   std::vector<int> num_nodes_per_edge_vec;
   std::vector<int> num_attr_edge_vec;
  
   // We also build a data structure of edge block names which can
   // later be passed to exII::ex_put_names().
   NamesData edge_block_names_table(num_edge_blk, MAX_STR_LENGTH);
  
   // Note: We are going to use the edge **boundary** ids as **block** ids.
   for (const auto & pr : edge_id_to_conn)
     {
       // Store the edge block id in the array to be passed to Exodus.
       boundary_id_type id = pr.first;
       edge_blk_id.push_back(id);
  
       // Set Exodus element type and number of nodes for this edge block.
       const auto & elem_type_node_count = edge_id_to_elem_type[id];
       const auto & conv = get_conversion(elem_type_node_count.first);
       edge_type_table.push_back_entry(conv.exodus_type.c_str());
       num_nodes_per_edge_vec.push_back(elem_type_node_count.second);
  
       // The number of edges is the number of entries in the connectivity
       // array divided by the number of nodes per edge.
       num_edge_this_blk_vec.push_back(pr.second.size() / elem_type_node_count.second);
  
       // We don't store any attributes currently
       num_attr_edge_vec.push_back(0);
  
       // Store the name of this edge block
       edge_block_names_table.push_back_entry(bi.get_edgeset_name(id));
     }
  
   // Zero-initialize and then fill in an exII::ex_block_params struct
   // with the data we have collected. This new API replaces the old
   // exII::ex_put_concat_elem_block() API, and will eventually allow
   // us to also allocate space for edge/face blocks if desired.
   //
   // TODO: It seems like we should be able to take advantage of the
   // optimization where you set define_maps==1, but when I tried this
   // I got the error: "failed to find node map size". I think the
   // problem is that we need to first specify a nonzero number of
   // node/elem maps during the call to ex_put_init_ext() in order for
   // this to work correctly.
   exII::ex_block_params params = {};
  
   // Set pointers for information about elem blocks.
   params.elem_blk_id = elem_blk_id.data();
   params.elem_type = elem_type_table.get_char_star_star();
   params.num_elem_this_blk = num_elem_this_blk_vec.data();
   params.num_nodes_per_elem = num_nodes_per_elem_vec.data();
   params.num_edges_per_elem = num_edges_per_elem_vec.data();
   params.num_faces_per_elem = num_faces_per_elem_vec.data();
   params.num_attr_elem = num_attr_vec.data();
   params.define_maps = 0;
  
   // Set pointers to edge block information only if we actually have some.
   if (num_edge_blk)
     {
       params.edge_blk_id = edge_blk_id.data();
       params.edge_type = edge_type_table.get_char_star_star();
       params.num_edge_this_blk = num_edge_this_blk_vec.data();
       params.num_nodes_per_edge = num_nodes_per_edge_vec.data();
       params.num_attr_edge = num_attr_edge_vec.data();
     }
  
   ex_err = exII::ex_put_concat_all_blocks(ex_id, &params);
   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;
  
   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!
       const auto & conv = get_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.libmesh_elem_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.libmesh_elem_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 (!use_discontinuous)
                 {
                   // The global id for the current node in libmesh.
                   dof_id_type libmesh_node_id = elem.node_id(elem_node_index);
  
                   // Write the Exodus global node id associated with
                   // this libmesh node number to the connectivity
                   // array, or throw an error if it's not found.
                   connect[connect_index] =
                     libmesh_map_find(libmesh_node_num_to_exodus,
                                      cast_int<int>(libmesh_node_id));
                 }
               else
                 {
                   // Look up the (elem_id, elem_node_index) pair in the map.
                   connect[connect_index] =
                     libmesh_map_find(discontinuous_node_indices,
                                      std::make_pair(elem_id, elem_node_index));
                 }
             }
         }
  
       ex_err = exII::ex_put_conn
         (ex_id,
          exII::EX_ELEM_BLOCK,
          pr.first,
          connect.data(), // node_conn
          nullptr,        // elem_edge_conn (unused)
          nullptr);       // elem_face_conn (unused)
       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.  Here we add 1 to each id to make a
       // 1-based exodus file.
       curr_elem_map_end = std::transform
         (tmp_vec.begin(),
          tmp_vec.end(),
          curr_elem_map_end,
          [](dof_id_type id){return id+1;});
     }
  
   // 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 block names");
     }
  
   // Write out edge blocks if we have any
   for (const auto & pr : edge_id_to_conn)
     {
       ex_err = exII::ex_put_conn
         (ex_id,
          exII::EX_EDGE_BLOCK,
          pr.first,
          pr.second.data(), // node_conn
          nullptr,          // elem_edge_conn (unused)
          nullptr);         // elem_face_conn (unused)
       EX_CHECK_ERR(ex_err, "Error writing element connectivities");
     }
  
   // Write out the edge block names, if any.
   if (num_edge_blk > 0)
     {
       ex_err = exII::ex_put_names
         (ex_id,
          exII::EX_EDGE_BLOCK,
          edge_block_names_table.get_char_star_star());
       EX_CHECK_ERR(ex_err, "Error writing edge block names");
     }
 }

References _run_only_on_proc0, block_ids, libMesh::BoundaryInfo::build_edge_list(), connect, elem_num_map, libMesh::Utility::enum_to_string(), ex_err, ex_id, libMesh::ExodusII_IO_Helper::NamesData::get_char_star_star(), get_conversion(), libMesh::BoundaryInfo::get_edgeset_name(), libMesh::DofObject::id(), libMesh::index_range(), libMesh::libmesh_assert(), libmesh_elem_num_to_exodus, libmesh_node_num_to_exodus, mesh, libMesh::Elem::node_id(), libMesh::Elem::node_index_range(), libMesh::Elem::node_ptr(), num_edge_blk, num_elem_blk, num_nodes_per_elem, libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO_Helper::NamesData::push_back_entry(), and libMesh::Elem::type().

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

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
  
   if (!values.empty())
     {
       ex_err = exII::ex_put_glob_vars
         (ex_id, timestep, num_global_vars,
          MappedOutputVector(values, _single_precision).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.");
     }
 }

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

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

 {
   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.");
     }
 }

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

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

 {
   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 (const Node & node : elem->node_ref_range())
           {
             x.push_back(node(0));
 #if LIBMESH_DIM > 1
             y.push_back(node(1));
 #else
             y.push_back(0.);
 #endif
 #if LIBMESH_DIM > 2
             z.push_back(node(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".
           }
     }
  
   ex_err = exII::ex_put_coord
     (ex_id,
      x.empty() ? nullptr : MappedOutputVector(x, _single_precision).data(),
      y.empty() ? nullptr : MappedOutputVector(y, _single_precision).data(),
      z.empty() ? nullptr : MappedOutputVector(z, _single_precision).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");
     }
 }

References _coordinate_offset, _run_only_on_proc0, _single_precision, libMesh::ExodusII_IO_Helper::MappedOutputVector::data(), ex_err, ex_id, libMesh::DofObject::id(), libmesh_node_num_to_exodus, mesh, node_num_map, num_nodes, libMesh::ParallelObject::processor_id(), x, y, and z.

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

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
  
   if (!values.empty())
     {
       ex_err = exII::ex_put_nodal_var
         (ex_id, timestep, var_id, num_nodes,
          MappedOutputVector(values, _single_precision).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.");
     }
 }

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

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

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

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
  
   // build_node_list() builds a sorted list of (node-id, bc-id) tuples
   // that is sorted by node-id, but we actually want it to be sorted
   // by bc-id, i.e. the second argument of the tuple.
   typedef std::tuple<dof_id_type, boundary_id_type> tuple_t;
   std::vector<tuple_t> bc_tuples =
     mesh.get_boundary_info().build_node_list();
  
   // We use std::stable_sort so that the entries within a single
   // nodeset remain in whatever order they were previously in.
   std::stable_sort(bc_tuples.begin(), bc_tuples.end(),
                    [](const tuple_t & t1,
                       const tuple_t & t2)
                    { return std::get<1>(t1) < std::get<1>(t2); });
  
   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 &&
       bc_tuples.size() > 0)
     {
       NamesData names_table(node_boundary_ids.size(), MAX_STR_LENGTH);
  
       // Vectors to be filled and passed to exII::ex_put_concat_sets()
       // Use existing class members and avoid variable shadowing.
       nodeset_ids.clear();
       num_nodes_per_set.clear();
       num_node_df_per_set.clear();
       node_sets_node_index.clear();
       node_sets_node_list.clear();
  
       // Pre-allocate space
       nodeset_ids.reserve(node_boundary_ids.size());
       num_nodes_per_set.reserve(node_boundary_ids.size());
       num_node_df_per_set.resize(node_boundary_ids.size()); // all zeros
       node_sets_node_index.reserve(node_boundary_ids.size());
       node_sets_node_list.reserve(bc_tuples.size());
  
       // Assign entries to node_sets_node_list, keeping track of counts as we go.
       std::map<boundary_id_type, unsigned int> nodeset_counts;
       for (const auto & t : bc_tuples)
         {
           const dof_id_type & node_id = std::get<0>(t) + 1; // Note: we use 1-based node ids in Exodus!
           const boundary_id_type & nodeset_id = std::get<1>(t);
           node_sets_node_list.push_back(node_id);
           nodeset_counts[nodeset_id] += 1;
         }
  
       // Fill in other indexing vectors needed by Exodus
       unsigned int running_sum = 0;
       for (const auto & pr : nodeset_counts)
         {
           nodeset_ids.push_back(pr.first);
           num_nodes_per_set.push_back(pr.second);
           node_sets_node_index.push_back(running_sum);
           names_table.push_back_entry(mesh.get_boundary_info().get_nodeset_name(pr.first));
           running_sum += pr.second;
         }
  
       // Fill in an exII::ex_set_specs object which can then be passed to
       // the ex_put_concat_sets() function.
       exII::ex_set_specs set_data = {};
       set_data.sets_ids = nodeset_ids.data();
       set_data.num_entries_per_set = num_nodes_per_set.data();
       set_data.num_dist_per_set = num_node_df_per_set.data(); // zeros
       set_data.sets_entry_index = node_sets_node_index.data();
       set_data.sets_dist_index = node_sets_node_index.data(); // dummy value
       set_data.sets_entry_list = node_sets_node_list.data();
  
       // Write all nodesets together.
       ex_err = exII::ex_put_concat_sets(ex_id, exII::EX_NODE_SET, &set_data);
       EX_CHECK_ERR(ex_err, "Error writing concatenated 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");
     }
 }

References _run_only_on_proc0, ex_err, ex_id, mesh, node_sets_node_index, node_sets_node_list, nodeset_ids, num_node_df_per_set, num_nodes_per_set, and libMesh::ParallelObject::processor_id().

◆ write_sideset_data()

void libMesh::ExodusII_IO_Helper::write_sideset_data	(	const MeshBase &	mesh,
		int	timestep,
		const std::vector< std::string > &	var_names,
		const std::vector< std::set< boundary_id_type >> &	side_ids,
		const std::vector< std::map< BoundaryInfo::BCTuple, Real >> &	bc_vals
	)

Write sideset data for the requested timestep.

Definition at line 2587 of file exodusII_io_helper.C.

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
  
   // Write the sideset variable names to file. This function should
   // only be called once for SIDESET variables, repeated calls to
   // write_var_names overwrites/changes the order of names that were
   // there previously, and will mess up any data that has already been
   // written.
   this->write_var_names(SIDESET, var_names);
  
   // I hope that we are allowed to call read_sideset_info() even
   // though we are in the middle of writing? It seems to work provided
   // that you have already written the mesh itself... read_sideset_info()
   // fills in the following data members:
   // .) num_side_sets
   // .) ss_ids
   this->read_sideset_info();
  
   // Debugging:
   // libMesh::out << "File has " << num_side_sets << " side sets." << std::endl;
  
   // Write "truth" table for sideset variables.  The function
   // exII::ex_put_var_param() must be called before
   // exII::ex_put_sset_var_tab(). For us, this happens during the call
   // to ExodusII_IO_Helper::write_var_names(). sset_var_tab is a logically
   // (num_side_sets x num_sset_var) integer array of 0s and 1s
   // indicating which sidesets a given sideset variable is defined on.
   std::vector<int> sset_var_tab(num_side_sets * var_names.size());
  
   // We now call read_sideset() once per sideset and write any sideset
   // variable values which are defined there.
   int offset=0;
   for (int ss=0; ss<num_side_sets; ++ss)
     {
       // We don't know num_sides_per_set for each set until we call
       // read_sideset(). The values for each sideset are stored (using
       // the offsets) into the 'elem_list' and 'side_list' arrays of
       // this class.
       offset += (ss > 0 ? num_sides_per_set[ss-1] : 0);
       this->read_sideset(ss, offset);
  
       // Debugging:
       // libMesh::out << "Sideset " << ss_ids[ss]
       //              << " has " << num_sides_per_set[ss]
       //              << " entries."
       //              << std::endl;
  
       // For each variable in var_names, write the values for the
       // current sideset, if any.
       for (auto var : index_range(var_names))
         {
           // If this var has no values on this sideset, go to the next one.
           if (!side_ids[var].count(ss_ids[ss]))
             continue;
  
           // Otherwise, fill in this entry of the sideset truth table.
           sset_var_tab[ss*var_names.size() + var] = 1;
  
           // Data vector that will eventually be passed to exII::ex_put_sset_var().
           std::vector<Real> sset_var_vals(num_sides_per_set[ss]);
  
           // Get reference to the BCTuple -> Real map for this variable.
           const auto & data_map = bc_vals[var];
  
           // Loop over elem_list, side_list entries in current sideset.
           for (int i=0; i<num_sides_per_set[ss]; ++i)
             {
               // Get elem_id and side_id from the respective lists that
               // are filled in by calling read_sideset().
               //
               // Note: these are Exodus-specific ids, so we have to convert them
               // to libmesh ids, as that is what will be in the bc_tuples.
               //
               // TODO: we should probably consult the exodus_elem_num_to_libmesh
               // mapping in order to figure out which libmesh element id 'elem_id'
               // actually corresponds to here, instead of just assuming it will be
               // off by one. Unfortunately that data structure does not seem to
               // be used at the moment. If we assume that write_sideset_data() is
               // always called following write(), then this should be a fairly safe
               // assumption...
               dof_id_type elem_id = elem_list[i + offset] - 1;
               unsigned int side_id = side_list[i + offset] - 1;
  
               // Sanity check: make sure that the "off by one"
               // assumption we used above to set 'elem_id' is valid.
               if (libmesh_map_find(libmesh_elem_num_to_exodus, cast_int<int>(elem_id))
                   != elem_list[i + offset])
                 libmesh_error_msg("Error mapping Exodus elem id to libmesh elem id.");
  
               // Map from Exodus side ids to libmesh side ids.
               const auto & conv = get_conversion(mesh.elem_ptr(elem_id)->type());
  
               // Map from Exodus side ids to libmesh side ids.
               unsigned int converted_side_id = conv.get_side_map(side_id);
  
               // Debugging:
               // libMesh::out << "side_id=" << side_id
               //              << ", converted_side_id=" << converted_side_id
               //              << std::endl;
  
               // Construct a key so we can quickly see whether there is any
               // data for this variable in the map.
               BoundaryInfo::BCTuple key = std::make_tuple
                 (elem_id,
                  converted_side_id,
                  ss_ids[ss]);
  
               // Find the data for this (elem,side,id) tuple. Throw an
               // error if not found. Then store value in vector which
               // will be passed to Exodus.
               sset_var_vals[i] = libmesh_map_find(data_map, key);
             } // end for (i)
  
           // As far as I can tell, there is no "concat" version of writing
           // sideset data, you have to call ex_put_sset_var() once per (variable,
           // sideset) pair.
           if (sset_var_vals.size() > 0)
             {
               ex_err = exII::ex_put_sset_var
                 (ex_id,
                  timestep,
                  var + 1, // 1-based variable index of current variable
                  ss_ids[ss],
                  num_sides_per_set[ss],
                  MappedOutputVector(sset_var_vals, _single_precision).data());
               EX_CHECK_ERR(ex_err, "Error writing sideset vars.");
             }
         } // end for (var)
     } // end for (ss)
  
   // Finally, write the sideset truth table.
   ex_err =
     exII::ex_put_sset_var_tab(ex_id,
                               num_side_sets,
                               cast_int<int>(var_names.size()),
                               sset_var_tab.data());
   EX_CHECK_ERR(ex_err, "Error writing sideset var truth table.");
 }

References _run_only_on_proc0, _single_precision, data, elem_list, ex_err, ex_id, get_conversion(), libMesh::ExodusII_IO_Helper::Conversion::get_side_map(), libMesh::index_range(), libmesh_elem_num_to_exodus, mesh, num_side_sets, num_sides_per_set, libMesh::ParallelObject::processor_id(), read_sideset(), read_sideset_info(), side_list, SIDESET, ss_ids, and write_var_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 2212 of file exodusII_io_helper.C.

 {
   if ((_run_only_on_proc0) && (this->processor_id() != 0))
     return;
  
   // 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 auto & conv = get_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 auto & conv = get_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");
     }
 }

References _run_only_on_proc0, ex_err, ex_id, get_conversion(), libMesh::index_range(), libmesh_elem_num_to_exodus, mesh, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::NamesData::push_back_entry().

◆ write_timestep()

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

Writes the time for the timestep.

Definition at line 2562 of file exodusII_io_helper.C.

 {
   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
     {
       double cast_time = double(time);
       ex_err = exII::ex_put_time(ex_id, timestep, &cast_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.");
 }

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

◆ write_var_names()

void libMesh::ExodusII_IO_Helper::write_var_names	(	ExodusVarType	type,
		const 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 1408 of file exodusII_io_helper.C.

 {
   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;
     case SIDESET:
       {
         // Note: calling this function *sets* num_sideset_vars to the
         // number of entries in the 'names' vector, num_sideset_vars
         // does not already need to be set before calling this.
         this->write_var_names_impl("s", num_sideset_vars, names);
         break;
       }
     default:
       libmesh_error_msg("Unrecognized ExodusVarType " << type);
     }
 }

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

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

◆ write_var_names_impl()

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

private

write_var_names() dispatches to this function.

Definition at line 1438 of file exodusII_io_helper.C.

 {
   // 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.");
     }
 }