This is the Nemesis_IO_Helper class. More...

#include <nemesis_io_helper.h>

Inheritance diagram for libMesh::Nemesis_IO_Helper:

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

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

virtual	~Nemesis_IO_Helper ()
	Destructor.

void	write_complex_magnitude (bool val)
	Set the flag indicating whether the complex modulus should be written when complex numbers are enabled.

void	read_nodeset (int id)
	Reading functions.

void	get_init_global ()
	Fills: num_nodes_global, num_elems_global, num_elem_blks_global, num_node_sets_global, num_side_sets_global Call after: read_and_store_header_info() Call before: Any other get_* function from this class.

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

void	get_ns_param_global ()

void	get_eb_info_global ()

void	get_init_info ()

void	get_loadbal_param ()

void	get_elem_map ()

void	get_node_map ()

void	get_cmap_params ()

void	get_node_cmap ()

void	get_elem_cmap ()

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

void	put_init_global (dof_id_type num_nodes_global, dof_id_type num_elems_global, unsigned num_elem_blks_global, unsigned num_node_sets_global, unsigned num_side_sets_global)
	Writes global information including: .) global number of nodes .) global number of elems .) global number of element blocks .) global number of node sets .) global number of side sets.

void	put_eb_info_global (std::vector< int > &global_elem_blk_ids, std::vector< int > &global_elem_blk_cnts)
	Writes global block information to the file .) global_elem_blk_ids - list of block IDs for all blocks present in the mesh .) global_elem_blk_cnts - number of elements in each block for the global mesh.

void	put_ns_param_global (std::vector< int > &global_nodeset_ids, std::vector< int > &num_global_node_counts, std::vector< int > &num_global_node_df_counts)
	This function writes information about global node sets.

void	put_ss_param_global (std::vector< int > &global_sideset_ids, std::vector< int > &num_global_side_counts, std::vector< int > &num_global_side_df_counts)
	This function writes information about global side sets.

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

void	put_cmap_params (std::vector< int > &node_cmap_ids, std::vector< int > &node_cmap_node_cnts, std::vector< int > &elem_cmap_ids, std::vector< int > &elem_cmap_elem_cnts)
	Outputs initial information for communication maps.

void	put_node_cmap (std::vector< std::vector< int > > &node_cmap_node_ids, std::vector< std::vector< int > > &node_cmap_proc_ids)
	Outputs all of the nodal communication maps for this processor.

void	put_node_map (std::vector< int > &node_mapi, std::vector< int > &node_mapb, std::vector< int > &node_mape)
	Outputs IDs of internal, border, and external nodes.

void	put_elem_cmap (std::vector< std::vector< int > > &elem_cmap_elem_ids, std::vector< std::vector< int > > &elem_cmap_side_ids, std::vector< std::vector< int > > &elem_cmap_proc_ids)
	Writes information about elemental communication map.

void	put_elem_map (std::vector< int > &elem_mapi, std::vector< int > &elem_mapb)
	Outputs IDs of internal and border elements.

virtual void	write_nodal_coordinates (const MeshBase &mesh, bool use_discontinuous=false) override
	This function is specialized from ExodusII_IO_Helper to write only the nodal coordinates stored on the local piece of the Mesh.

virtual void	write_elements (const MeshBase &mesh, bool use_discontinuous=false) override
	This function is specialized to write the connectivity.

virtual void	write_sidesets (const MeshBase &mesh) override
	Writes the sidesets for this processor.

virtual void	write_nodesets (const MeshBase &mesh) override
	Writes the nodesets for this processor.

virtual void	initialize (std::string title, const MeshBase &mesh, bool use_discontinuous=false) override
	Specialization of the initialize function from ExodusII_IO_Helper that also writes global initial data to file.

void	compute_num_global_elem_blocks (const MeshBase &pmesh)
	This function uses global communication routines to determine the number of element blocks across the entire mesh.

void	build_element_and_node_maps (const MeshBase &pmesh)
	This function builds the libmesh -> exodus and exodus -> libmesh node and element maps.

void	write_nodal_solution (const NumericVector< Number > &parallel_soln, const std::vector< std::string > &names, int timestep, const std::vector< std::string > &output_names)
	Takes a parallel solution vector containing the node-major solution vector for all variables and outputs it to the files.

void	write_nodal_solution (const EquationSystems &es, const std::vector< std::pair< unsigned int, unsigned int > > &var_nums, int timestep, const std::vector< std::string > &output_names)
	Outputs EquationSystems current_local_solution nodal values.

void	write_nodal_solution (const std::vector< Number > &values, const std::vector< std::string > &names, int timestep)
	Takes a solution vector containing the solution for all variables and outputs it to the files.

virtual void	initialize_element_variables (std::vector< std::string > names, const std::vector< std::set< subdomain_id_type > > &vars_active_subdomains) override
	Override the Exodus Helper's implementation of this function so that it works correctly in parallel.

void	write_element_values (const MeshBase &mesh, const EquationSystems &es, const std::vector< std::pair< unsigned int, unsigned int > > &var_nums, int timestep, const std::vector< std::set< subdomain_id_type > > &vars_active_subdomains)
	Writes the vector of elemental variable values, one variable and one subdomain at a time.

std::string	construct_nemesis_filename (std::string_view base_filename)
	Given base_filename, foo.e, constructs the Nemesis filename foo.e.X.Y, where X=n.

const char *	get_elem_type () const

void	set_add_sides (bool add_sides)
	Sets whether or not to write extra "side" elements.

bool	get_add_sides ()

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

ExodusHeaderInfo	read_header () const
	Reads an `ExodusII` mesh file header, leaving this object's internal data structures unchanged.

void	read_and_store_header_info ()
	Reads an `ExodusII` mesh file header, and stores required information on this object.

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

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.

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

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

void	read_bex_cv_blocks ()
	Reads the optional `bex_cv_blocks` from the `ExodusII` mesh file.

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

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

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

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

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

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.

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

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.

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

void	read_face_blocks ()
	Reads NSIDED face blocks used by NFACED element blocks.

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

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

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

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

void	read_elemset_info ()
	Reads information about all of the elemsets in the `ExodusII` mesh file.

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

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

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

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

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

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.

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.

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.

dof_id_type	get_libmesh_node_id (int exodus_node_id)
	Helper function that takes a (1-based) Exodus node/elem id and determines the corresponding libMesh Node/Elem id.

dof_id_type	get_libmesh_elem_id (int exodus_elem_id)

void	conditionally_set_node_unique_id (MeshBase &mesh, Node *node, int zero_based_node_num_map_index)
	Helper function that conditionally sets the unique_id of the passed-in Node/Elem.

void	conditionally_set_elem_unique_id (MeshBase &mesh, Elem *elem, int zero_based_elem_num_map_index)

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

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

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

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

void	write_elemsets (const MeshBase &mesh)
	Write elemsets stored on the Mesh to the exo file.

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.

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.

void	get_sideset_data_indices (const MeshBase &mesh, std::map< BoundaryInfo::BCTuple, unsigned int > &bc_array_indices)
	Similar to read_sideset_data(), but instead of creating one std::map per sideset per variable, creates a single map of (elem, side, boundary_id) tuples, and stores the exo file array indexing for any/all sideset variables on that sideset (they are all the same).

void	write_nodeset_data (int timestep, const std::vector< std::string > &var_names, const std::vector< std::set< boundary_id_type > > &node_boundary_ids, const std::vector< std::map< BoundaryInfo::NodeBCTuple, Real > > &bc_vals)
	Write nodeset data for the requested timestep.

void	read_nodeset_data (int timestep, std::vector< std::string > &var_names, std::vector< std::set< boundary_id_type > > &node_boundary_ids, std::vector< std::map< BoundaryInfo::NodeBCTuple, Real > > &bc_vals)
	Read nodeset variables, if any, into the provided data structures.

void	get_nodeset_data_indices (std::map< BoundaryInfo::NodeBCTuple, unsigned int > &bc_array_indices)
	Similar to read_nodeset_data(), but instead of creating one std::map per nodeset per variable, creates a single map of (node_id, boundary_id) tuples, and stores the exo file array indexing for any/all nodeset variables on that nodeset (they are all the same).

void	write_elemset_data (int timestep, const std::vector< std::string > &var_names, const std::vector< std::set< elemset_id_type > > &elemset_ids_in, const std::vector< std::map< std::pair< dof_id_type, elemset_id_type >, Real > > &elemset_vals)
	Write elemset data for the requested timestep.

void	read_elemset_data (int timestep, std::vector< std::string > &var_names, std::vector< std::set< elemset_id_type > > &elemset_ids_in, std::vector< std::map< std::pair< dof_id_type, elemset_id_type >, Real > > &elemset_vals)
	Read elemset variables, if any, into the provided data structures.

void	get_elemset_data_indices (std::map< std::pair< dof_id_type, elemset_id_type >, unsigned int > &elemset_array_indices)
	Similar to read_elemset_data(), but instead of creating one std::map per elemset per variable, creates a single map of (elem_id, elemset_id) tuples, and stores the exo file array indexing for any/all elemset variables on that elemset (they are all the same).

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.

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.

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

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

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

void	update ()
	Uses ex_update() to flush buffers to file.

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

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.

void	set_hdf5_writing (bool write_hdf5)
	Set to true (the default) to write files in an HDF5-based file format (when HDF5 is available), or to false to write files in the old NetCDF3-based format.

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

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

void	set_max_name_length (unsigned int max_length)
	Set how many characters to use in names when opening a file for writing.

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

std::vector< std::set< subdomain_id_type > >	get_complex_vars_active_subdomains (const std::vector< std::set< subdomain_id_type > > &vars_active_subdomains, bool write_complex_abs) const
	returns a "tripled" copy of `vars_active_subdomains`, which is necessary in the complex-valued case.

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, bool write_complex_abs) 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.

void	message (std::string_view msg)
	Prints the message defined in `msg`.

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

int	end_elem_id () const

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

dof_id_type	node_id_to_vec_id (dof_id_type n) const

dof_id_type	added_node_offset_on (processor_id_type p) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static int	get_exodus_version ()

Public Attributes
int	nemesis_err_flag
	Member data.

int	num_nodes_global
	Global initial information.

int	num_elems_global

int	num_elem_blks_global

int	num_node_sets_global

int	num_side_sets_global

int	num_proc
	The number of processors for which the NEMESIS I file was created.

int	num_proc_in_file
	The number of processors for which the NEMESIS I file stores information.

char	ftype
	The type of file to be written.

std::vector< int >	node_list

std::vector< int >	global_sideset_ids
	Containers for reading global sideset (boundary conditions) information.

std::vector< int >	num_global_side_counts

std::vector< int >	num_global_side_df_counts

std::vector< int >	global_nodeset_ids
	Containers for reading global nodeset information.

std::vector< int >	num_global_node_counts

std::vector< int >	num_global_node_df_counts

std::vector< int >	global_elem_blk_ids
	Read the global element block IDs and counts.

std::vector< int >	global_elem_blk_cnts

std::set< int >	nodes_attached_to_local_elems
	libMesh numbered node ids attached to local elems.

std::map< subdomain_id_type, std::vector< dof_id_type > >	subdomain_map
	Map of subdomains to element numbers.

std::map< int, std::vector< int > >	block_id_to_elem_connectivity
	This is the block connectivity, i.e.

int	num_internal_nodes
	To be used with the Nemesis::ne_get_loadbal_param() routine.

int	num_border_nodes
	The number of FEM nodes local to a processor but residing in an element which also has FEM nodes on other processors.

int	num_external_nodes
	The number of FEM nodes that reside on another processor but whose element partially resides on the current processor.

int	num_internal_elems
	The number of internal FEM elements.

int	num_border_elems
	The number of border FEM elements.

int	num_node_cmaps
	The number of nodal communication maps for this processor.

int	num_elem_cmaps
	The number of elemental communication maps for this processor.

std::vector< int >	elem_mapi
	Vector which stores internal element IDs.

std::vector< int >	elem_mapb
	Vector which stores border element IDs.

std::vector< int >	node_mapi
	Vector which stores internal node IDs.

std::vector< int >	node_mapb
	Vector which stores border node IDs.

std::vector< int >	node_mape
	Vector which stores external node IDs.

std::vector< int >	node_cmap_ids
	Vectors for storing the communication map parameters.

std::vector< int >	node_cmap_node_cnts

std::vector< int >	elem_cmap_ids

std::vector< int >	elem_cmap_elem_cnts

std::vector< std::vector< int > >	node_cmap_node_ids
	2 vectors of vectors for storing the node communication IDs for this processor.

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

std::vector< std::vector< int > >	elem_cmap_elem_ids
	3 vectors of vectors for storing element communication IDs for this processor.

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

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

bool	write_complex_abs
	By default, when complex numbers are enabled, for each variable we write out three values: the real part, "r_u" the imaginary part, "i_u", and the complex modulus, a_u := sqrt(r_ur_u + i_ui_u), which is also the value returned by std::abs(std::complex).

int	ex_id

int	ex_err

ExodusHeaderInfo	header_info

std::vector< char > &	title

int &	num_dim

int &	num_nodes

int &	num_elem

int &	num_elem_blk

int &	num_edge

int &	num_edge_blk

int &	num_face

int &	num_face_blk

int &	num_node_sets

int &	num_side_sets

int &	num_elem_sets

int	num_global_vars

int	num_sideset_vars

int	num_nodeset_vars

int	num_elemset_vars

int	num_elem_this_blk

int	num_nodes_per_elem

int	num_attr

int	num_elem_all_sidesets

int	num_elem_all_elemsets

std::vector< int >	block_ids

std::vector< int >	edge_block_ids

std::vector< int >	connect

std::vector< int >	elem_node_counts

std::vector< int >	elem_face_counts

std::vector< std::vector< int > >	c0polyhedron_face_connect

std::vector< int >	ss_ids

std::vector< int >	nodeset_ids

std::vector< int >	elemset_ids

std::vector< int >	num_sides_per_set

std::vector< int >	num_nodes_per_set

std::vector< int >	num_elems_per_set

std::vector< int >	num_df_per_set

std::vector< int >	num_node_df_per_set

std::vector< int >	num_elem_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 >	id_list

std::vector< int >	elemset_list

std::vector< int >	elemset_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< Real >	w

unsigned int	bex_num_elem_cvs

std::vector< std::vector< long unsigned int > >	bex_cv_conn

std::vector< std::vector< std::vector< Real > > >	bex_dense_constraint_vecs

std::vector< char >	elem_type

std::map< dof_id_type, dof_id_type >	libmesh_elem_num_to_exodus

std::vector< int >	exodus_elem_num_to_libmesh

std::map< dof_id_type, dof_id_type >	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::map< dof_id_type, 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::vector< std::string >	nodeset_var_names

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

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

bool	verbose

bool	set_unique_ids_from_maps

bool	opened_for_writing

bool	opened_for_reading

std::string	current_filename

Protected Member Functions
virtual void	read_var_names_impl (const char *var_type, int &count, std::vector< std::string > &result) override
	read_var_names() dispatches to this function.

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.

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

Protected Attributes
bool	_run_only_on_proc0

bool	_opened_by_create

bool	_elem_vars_initialized

bool	_global_vars_initialized

bool	_nodal_vars_initialized

bool	_use_mesh_dimension_instead_of_spatial_dimension

bool	_write_hdf5

unsigned int	_max_name_length

int	_end_elem_id

unsigned	_write_as_dimension

Point	_coordinate_offset

bool	_single_precision

std::vector< dof_id_type >	_added_side_node_offsets
	If we're adding "fake" sides to visualize SIDE_DISCONTINUOUS variables, _added_side_node_offsets[p] gives us the total solution vector offset to use on processor p+1 from the nodes on those previous ranks' sides.

std::vector< dof_id_type >	_true_node_offsets
	If we're adding "fake" sides to visualize SIDE_DISCONTINUOUS variables, we also need to know how many real nodes from previous ranks are taking up space in a solution vector.

const Parallel::Communicator &	_communicator

Private Types
typedef std::map< unsigned, std::set< unsigned > >::iterator	proc_nodes_touched_iterator
	Typedef for an iterator into the data structure above.

typedef std::map< unsigned, std::set< std::pair< unsigned, unsigned > > >::iterator	proc_border_elem_sets_iterator
	Typedef for an iterator into the data structure above.

Private Member Functions
void	compute_num_global_nodesets (const MeshBase &pmesh)
	This function uses global communication routines to determine the number of nodesets across the entire mesh.

void	compute_num_global_sidesets (const MeshBase &pmesh)
	This function uses global communication routines to determine the number of sidesets across the entire mesh.

void	compute_border_node_ids (const MeshBase &pmesh)
	This function constructs the set of border node IDs present on the current mesh.

void	compute_internal_and_border_elems_and_internal_nodes (const MeshBase &pmesh)
	This function constructs the set of border and internal element IDs and internal node IDs present on the current mesh.

void	compute_communication_map_parameters ()
	This function determines the communication map parameters which will eventually be written to file.

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

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

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

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

void	write_exodus_initialization_info (const MeshBase &pmesh, const std::string &title)
	This function writes exodus-specific initialization information.

dof_id_type	get_libmesh_id (int exodus_id, const std::vector< int > &num_map)
	Internal implementation for the two sets of functions above.

void	set_dof_object_unique_id (MeshBase &mesh, DofObject *dof_object, int exodus_mapped_id)

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

void	init_element_equivalence_map ()

void	init_conversion_map ()

Private Attributes
std::map< subdomain_id_type, unsigned >	local_subdomain_counts
	This map keeps track of the number of elements in each subdomain (block) for this processor.

std::set< unsigned >	border_node_ids
	The set which will eventually contain the IDs of "border nodes".

std::map< unsigned, std::set< unsigned > >	proc_nodes_touched_intersections
	Another map to store sets of intersections with each other processor (other than ourself, of course).

std::map< unsigned, std::set< std::pair< unsigned, unsigned > > >	proc_border_elem_sets
	Map between processor ID and (element,side) pairs bordering that processor ID.

std::set< unsigned >	internal_node_ids
	A set of internal node IDs for this processor.

std::set< unsigned >	internal_elem_ids
	A set of internal elem IDs for this processor.

std::set< unsigned >	border_elem_ids
	A set of border elem IDs for this processor.

bool	_add_sides = false
	Set to true iff we want to write separate "side" elements too.

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

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

Detailed Description

This is the Nemesis_IO_Helper class.

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

Author: John W. Peterson; Roy Stogner

Date: 2008; 2020

Definition at line 52 of file nemesis_io_helper.h.

Member Typedef Documentation

◆ proc_border_elem_sets_iterator

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

private

Typedef for an iterator into the data structure above.

Definition at line 626 of file nemesis_io_helper.h.

◆ proc_nodes_touched_iterator

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

private

Typedef for an iterator into the data structure above.

Definition at line 616 of file nemesis_io_helper.h.

Member Enumeration Documentation

◆ ExodusVarType

enum libMesh::ExodusII_IO_Helper::ExodusVarType

inherited

Wraps calls to exII::ex_get_var_names() and exII::ex_get_var_param().

The enumeration controls whether nodal, elemental, global, etc. 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 NODESET: num_nodeset_vars nodeset_var_names

Enumerator
NODAL
ELEMENTAL
GLOBAL
SIDESET
NODESET
ELEMSET

Definition at line 951 of file exodusII_io_helper.h.

951{NODAL=0, ELEMENTAL=1, GLOBAL=2, SIDESET=3, NODESET=4, ELEMSET=5};

libMesh::ExodusII_IO_Helper::GLOBAL

@ GLOBAL

Definition exodusII_io_helper.h:951

libMesh::ExodusII_IO_Helper::NODAL

@ NODAL

Definition exodusII_io_helper.h:951

libMesh::ExodusII_IO_Helper::SIDESET

@ SIDESET

Definition exodusII_io_helper.h:951

libMesh::ExodusII_IO_Helper::NODESET

@ NODESET

Definition exodusII_io_helper.h:951

libMesh::ExodusII_IO_Helper::ELEMENTAL

@ ELEMENTAL

Definition exodusII_io_helper.h:951

libMesh::ExodusII_IO_Helper::ELEMSET

@ ELEMSET

Definition exodusII_io_helper.h:951

Constructor & Destructor Documentation

◆ Nemesis_IO_Helper()

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

explicit

Constructor.

Definition at line 77 of file nemesis_io_helper.C.

                                                                             :
  ExodusII_IO_Helper(parent, verbose_in, /*run_only_on_proc0=*/false, /*single_precision=*/single_precision),
  nemesis_err_flag(0),
  num_nodes_global(0),
  num_elems_global(0),
  num_elem_blks_global(0),
  num_node_sets_global(0),
  num_side_sets_global(0),
  num_proc(0),
  num_proc_in_file(0),
  ftype('\0'),
  num_internal_nodes(0),
  num_border_nodes(0),
  num_external_nodes(0),
  num_internal_elems(0),
  num_border_elems(0),
  num_node_cmaps(0),
  num_elem_cmaps(0),
  write_complex_abs(true)
{
  // Warn about using untested code!
  libmesh_experimental();
}

◆ ~Nemesis_IO_Helper()

libMesh::Nemesis_IO_Helper::~Nemesis_IO_Helper ( )

virtual

Destructor.

Definition at line 103 of file nemesis_io_helper.C.

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

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

Member Function Documentation

◆ added_node_offset_on()

dof_id_type libMesh::ExodusII_IO_Helper::added_node_offset_on ( processor_id_type p ) const

inlineinherited

Definition at line 985 of file exodusII_io_helper.h.

  {
    libmesh_assert (p < _true_node_offsets.size());
    const dof_id_type added_node_offsets =
      (_added_side_node_offsets.empty() || !p) ? 0 :
      _added_side_node_offsets[p-1];
    return _true_node_offsets[p] + added_node_offsets;
  }

References libMesh::ExodusII_IO_Helper::_added_side_node_offsets, libMesh::ExodusII_IO_Helper::_true_node_offsets, and libMesh::libmesh_assert().

◆ build_element_and_node_maps()

void libMesh::Nemesis_IO_Helper::build_element_and_node_maps ( const MeshBase & pmesh )

This function builds the libmesh -> exodus and exodus -> libmesh node and element maps.

These maps allow us to have a consistent numbering scheme within an Exodus file, given an existing globally consistent numbering scheme from LibMesh.

Definition at line 1649 of file nemesis_io_helper.C.

{
  // If we don't have any local subdomains, it had better be because
  // we don't have any local elements
#ifdef DEBUG
  if (local_subdomain_counts.empty())
    {
      libmesh_assert(pmesh.active_local_elements_begin() ==
                     pmesh.active_local_elements_end());
      libmesh_assert(this->nodes_attached_to_local_elems.empty());
    }
#endif
 
  // Elements have to be numbered contiguously based on what block
  // number they are in.  Therefore we have to do a bit of work to get
  // the block (ie subdomain) numbers first and store them off as
  // block_ids.
 
  // Make sure there is no leftover information in the subdomain_map, and reserve
  // enough space to store the elements we need.
  this->subdomain_map.clear();
  for (const auto & [sbd_id, cnt] : local_subdomain_counts)
    {
      if (verbose)
        {
          libMesh::out << "[" << this->processor_id() << "] "
                       << "local_subdomain_counts [" << static_cast<unsigned>(sbd_id) << "]= "
                       << cnt
                       << std::endl;
        }
 
      this->subdomain_map[sbd_id].reserve(cnt);
    }
 
 
  // First loop over the elements to figure out which elements are in which subdomain
  for (const auto & elem : pmesh.active_local_element_ptr_range())
    {
      // Grab the nodes while we're here.
      for (auto n : elem->node_index_range())
        this->nodes_attached_to_local_elems.insert( elem->node_id(n) );
 
      subdomain_id_type cur_subdomain = elem->subdomain_id();
 
      this->subdomain_map[cur_subdomain].push_back(elem->id());
    }
 
  // Set num_nodes which is used by exodusII_io_helper
  this->num_nodes =
    cast_int<int>(this->nodes_attached_to_local_elems.size());
 
  // Now come up with a 1-based numbering for these nodes
  this->exodus_node_num_to_libmesh.clear(); // Make sure it's empty
  this->exodus_node_num_to_libmesh.reserve(this->nodes_attached_to_local_elems.size());
 
  // Also make sure there's no leftover information in the map which goes the
  // other direction.
  this->libmesh_node_num_to_exodus.clear();
 
  // Set the map for nodes
  for (const auto & id : nodes_attached_to_local_elems)
    {
      // I.e. given exodus_node_id,
      // exodus_node_num_to_libmesh[ exodus_node_id ] returns the
      // libmesh ID for that node, plus one.
      // Here we index libMesh IDs with an offset of 1 because they're
      // the literal numbers that get written to the exodus file, but
      // we index Exodus IDs with an offset of 0 because we read that
      // exodus data into a C++ vector.  Confused yet?
      this->exodus_node_num_to_libmesh.push_back(id+1);
 
      // Likewise, given libmesh_node_id,
      // libmesh_node_num_to_exodus[ libmesh_node_id] returns the
      // *Exodus* ID for that node.  Unlike the
      // exodus_node_num_to_libmesh vector above, this one is a
      // std::map.  We're never handing a data buffer from it over to
      // another API so we don't need to do any weird offsets with it.
      this->libmesh_node_num_to_exodus[id] =
        this->exodus_node_num_to_libmesh.size(); // should never be zero...
    }
 
  // Now we're going to loop over the subdomain map and build a few things right
  // now that we'll use later.
 
  // First make sure our data structures don't have any leftover data...
  this->exodus_elem_num_to_libmesh.clear();
  this->block_ids.clear();
  this->libmesh_elem_num_to_exodus.clear();
 
  // Now loop over each subdomain and get a unique numbering for the elements
  for (auto & [block_id, elem_ids_this_subdomain] : subdomain_map)
    {
      block_ids.push_back(block_id);
 
      // The code below assumes this subdomain block is not empty, make sure that's the case!
      libmesh_error_msg_if(elem_ids_this_subdomain.size() == 0,
                           "Error, no element IDs found in subdomain " << block_id);
 
      // 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
        (pmesh.elem_ref(elem_ids_this_subdomain[0]).type());
      this->num_nodes_per_elem =
        pmesh.elem_ref(elem_ids_this_subdomain[0]).n_nodes();
 
      // Get a reference to the connectivity vector for this subdomain.  This vector
      // is most likely empty, we are going to fill it up now.
      std::vector<int> & current_block_connectivity = this->block_id_to_elem_connectivity[block_id];
 
      // Just in case it's not already empty...
      current_block_connectivity.clear();
      current_block_connectivity.resize(elem_ids_this_subdomain.size() * this->num_nodes_per_elem);
 
      for (auto i : index_range(elem_ids_this_subdomain))
        {
          auto elem_id = elem_ids_this_subdomain[i];
 
          // Set the number map for elements
          // exodus_elem_num_to_libmesh[ exodus_node_id ] returns the
          // libmesh ID for that element, plus one.
          // Like with nodes above, we index libMesh IDs with an
          // offset of 1 because they're the literal numbers that get
          // written to the exodus file, but we index Exodus IDs with
          // an offset of 0 because we read that exodus data into a
          // C++ vector.
          this->exodus_elem_num_to_libmesh.push_back(elem_id+1);
 
          // Likewise, given libmesh elem_id,
          // libmesh_elem_num_to_exodus[ elem_id ] returns the
          // *Exodus* ID for that node.  Unlike the
          // exodus_elem_num_to_libmesh vector above, this one is a
          // std::map.  We're never handing a data buffer from it over to
          // another API so we don't need to do any weird offsets with it.
          this->libmesh_elem_num_to_exodus[elem_id] =
            this->exodus_elem_num_to_libmesh.size();
 
          const Elem & elem = pmesh.elem_ref(elem_id);
 
          // Exodus/Nemesis want every block to have the same element type
          // libmesh_assert_equal_to (elem->type(), conv.libmesh_elem_type());
 
          // But we can get away with writing e.g. HEX8 and INFHEX8 in
          // the same block...
          libmesh_assert_equal_to (elem.n_nodes(), Elem::build(conv.libmesh_elem_type(), nullptr)->n_nodes());
 
          for (auto j : make_range(this->num_nodes_per_elem))
            {
              const unsigned int connect_index   = (i*this->num_nodes_per_elem)+j;
              const unsigned int elem_node_index = conv.get_inverse_node_map(j); // inverse node map is used for writing
 
              current_block_connectivity[connect_index] =
                libmesh_map_find(libmesh_node_num_to_exodus,
                                 elem.node_id(elem_node_index));
            }
        } // End loop over elems in this subdomain
    } // end loop over subdomain_map
}

Referenced by initialize().

◆ check_existing_vars()

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

protectedinherited

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

Definition at line 4022 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(),
               [this](const std::string & a,
                      const std::string & b) -> bool
               {
                 return a.compare(/*pos=*/0, /*len=*/_max_name_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 b, libMesh::err, and libMesh::ExodusII_IO_Helper::read_var_names().

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

◆ close()

void libMesh::ExodusII_IO_Helper::close ( )

noexceptinherited

Closes the ExodusII mesh file.

This function is called from the ExodusII_IO destructor, so it should not throw an exception.

Definition at line 2040 of file exodusII_io_helper.C.

{
  // Call ex_close on every processor that did ex_open or ex_create;
  // newer Exodus versions error if we try to reopen a file that
  // hasn't been officially closed.  Don't close the file if we didn't
  // open it; this also raises an Exodus error.
 
  // We currently do read-only ex_open on every proc (to do read
  // operations on every proc), but we do ex_open and ex_create for
  // writes on every proc only with Nemesis files.
  if (!(_opened_by_create || opened_for_writing) ||
      (this->processor_id() == 0) ||
      (!_run_only_on_proc0))
    {
      if (opened_for_writing || opened_for_reading)
        {
          ex_err = exII::ex_close(ex_id);
          // close() is called from the destructor, so it may be called e.g.
          // during stack unwinding while processing an exception. In that case
          // we don't want to throw another exception or immediately terminate
          // the code, since that would prevent any possible recovery from the
          // exception in question. So we just log the error closing the file
          // and continue.
          if (ex_err < 0)
            message("Error closing Exodus file.");
          else
            message("Exodus file closed successfully.");
        }
    }
 
  // Now that the file is closed, it's no longer opened for
  // reading or writing.
  opened_for_writing = false;
  opened_for_reading = false;
  _opened_by_create = false;
}

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

Referenced by ~Nemesis_IO_Helper().

◆ comm()

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

inlineinherited

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

Definition at line 97 of file parallel_object.h.

98 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition parallel_object.h:120

References libMesh::ParallelObject::_communicator.

◆ compute_border_node_ids()

void libMesh::Nemesis_IO_Helper::compute_border_node_ids ( const MeshBase & pmesh )

private

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

These are nodes which live on the "border" between elements which live on different processors.

Definition at line 1812 of file nemesis_io_helper.C.

{
  // The set which will eventually contain the IDs of "border nodes".  These are nodes
  // that lie on the boundary between one or more processors.
  //std::set<unsigned> border_node_ids;
 
  // map from processor ID to set of nodes which elements from this processor "touch",
  // that is,
  // proc_nodes_touched[p] = (set all node IDs found in elements owned by processor p)
  std::map<unsigned, std::set<unsigned>> proc_nodes_touched;
 
 
  // We are going to create a lot of intermediate data structures here, so make sure
  // as many as possible all cleaned up by creating scope!
  {
    // Loop over active (not just active local) elements, make sets of node IDs for each
    // processor which has an element that "touches" a node.
    for (const auto & elem : pmesh.active_element_ptr_range())
      {
        // Get reference to the set for this processor.  If it does not exist
        // it will be created.
        std::set<unsigned> & set_p = proc_nodes_touched[ elem->processor_id() ];
 
        // Insert all nodes touched by this element into the set
        for (auto node : elem->node_index_range())
          set_p.insert(elem->node_id(node));
      }
 
    if (verbose)
      {
        libMesh::out << "[" << this->processor_id()
                     << "] proc_nodes_touched contains "
                     << proc_nodes_touched.size()
                     << " sets of nodes."
                     << std::endl;
 
        for (const auto & [proc_id, set] : proc_nodes_touched)
          libMesh::out << "[" << this->processor_id()
                       << "] proc_nodes_touched[" << proc_id << "] has "
                       << set.size()
                       << " entries."
                       << std::endl;
      }
 
 
    // Loop over all the sets we just created and compute intersections with the
    // this processor's set.  Obviously, don't intersect with ourself.
    this->proc_nodes_touched_intersections.clear();
    for (auto & [proc_id, other_set] : proc_nodes_touched)
      {
        // Don't compute intersections with ourself
        if (proc_id == this->processor_id())
          continue;
 
        std::set<unsigned int> this_intersection;
 
        // Otherwise, compute intersection with other processor and ourself
        std::set<unsigned> & my_set = proc_nodes_touched[this->processor_id()];
 
        std::set_intersection(my_set.begin(), my_set.end(),
                              other_set.begin(), other_set.end(),
                              std::inserter(this_intersection, this_intersection.end()));
 
        if (!this_intersection.empty())
          this->proc_nodes_touched_intersections.emplace
            (proc_id, std::move(this_intersection));
      }
 
    if (verbose)
      {
        for (const auto & [proc_id, set] : proc_nodes_touched_intersections)
          libMesh::out << "[" << this->processor_id()
                       << "] this->proc_nodes_touched_intersections[" << proc_id << "] has "
                       << set.size()
                       << " entries."
                       << std::endl;
      }
 
    // The number of node communication maps is the number of other processors
    // with which we share nodes.
    this->num_node_cmaps =
      cast_int<int>(proc_nodes_touched_intersections.size());
 
    // We can't be connecting to more processors than exist outside
    // ourselves
    libmesh_assert_less (this->num_node_cmaps, this->n_processors());
 
    // Compute the set_union of all the preceding intersections.  This will be the set of
    // border node IDs for this processor.
    for (auto & pr : proc_nodes_touched_intersections)
      {
        std::set<unsigned> & other_set = pr.second;
        std::set<unsigned> intermediate_result; // Don't think we can insert into one of the sets we're unioning...
 
        std::set_union(this->border_node_ids.begin(), this->border_node_ids.end(),
                       other_set.begin(), other_set.end(),
                       std::inserter(intermediate_result, intermediate_result.end()));
 
        // Swap our intermediate result into the final set
        this->border_node_ids.swap(intermediate_result);
      }
 
    libmesh_assert_less_equal
      (this->proc_nodes_touched_intersections.size(),
       std::size_t(this->num_node_cmaps));
 
    if (verbose)
      {
        libMesh::out << "[" << this->processor_id()
                     << "] border_node_ids.size()=" << this->border_node_ids.size()
                     << std::endl;
      }
  } // end scope for border node ID creation
 
  // Store the number of border node IDs to be written to Nemesis file
  this->num_border_nodes = cast_int<int>(this->border_node_ids.size());
}

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

Referenced by initialize().

◆ compute_communication_map_parameters()

void libMesh::Nemesis_IO_Helper::compute_communication_map_parameters ( )

private

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

Definition at line 1129 of file nemesis_io_helper.C.

{
  // For the nodes, these are the number of entries in the sets in proc_nodes_touched_intersections
  // map computed above.  Note: this map does not contain self-intersections so we can loop over it
  // directly.
  this->node_cmap_node_cnts.clear(); // Make sure we don't have any leftover information...
  this->node_cmap_ids.clear();       // Make sure we don't have any leftover information...
  this->node_cmap_node_cnts.resize(this->num_node_cmaps);
  this->node_cmap_ids.resize(this->num_node_cmaps);
 
  {
    unsigned cnt=0; // Index into the vector
    proc_nodes_touched_iterator
      it = this->proc_nodes_touched_intersections.begin(),
      end = this->proc_nodes_touched_intersections.end();
 
    for (; it != end; ++it)
      {
        this->node_cmap_ids[cnt] = it->first; // The ID of the proc we communicate with
        this->node_cmap_node_cnts[cnt] = cast_int<int>(it->second.size()); // The number of nodes we communicate
        cnt++; // increment vector index!
      }
  }
 
  // Print the packed vectors we just filled
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] node_cmap_node_cnts = ";
      for (const auto & node_cnt : node_cmap_node_cnts)
        libMesh::out << node_cnt << ", ";
      libMesh::out << std::endl;
 
      libMesh::out << "[" << this->processor_id() << "] node_cmap_ids = ";
      for (const auto & node_id : node_cmap_ids)
        libMesh::out << node_id << ", ";
      libMesh::out << std::endl;
    }
 
  // For the elements, we have not yet computed all this information..
  this->elem_cmap_elem_cnts.clear(); // Make sure we don't have any leftover information...
  this->elem_cmap_ids.clear();       // Make sure we don't have any leftover information...
  this->elem_cmap_elem_cnts.resize(this->num_elem_cmaps);
  this->elem_cmap_ids.resize(this->num_elem_cmaps);
 
  // Pack the elem_cmap_ids and elem_cmap_elem_cnts vectors
  {
    unsigned cnt=0; // Index into the vectors we're filling
    proc_border_elem_sets_iterator
      it = this->proc_border_elem_sets.begin(),
      end = this->proc_border_elem_sets.end();
 
    for (; it != end; ++it)
      {
        this->elem_cmap_ids[cnt] = it->first; // The ID of the proc we communicate with
        this->elem_cmap_elem_cnts[cnt] = cast_int<int>(it->second.size()); // The number of elems we communicate to/from that proc
        cnt++; // increment vector index!
      }
  }
 
  // Print the packed vectors we just filled
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] elem_cmap_elem_cnts = ";
      for (const auto & elem_cnt : elem_cmap_elem_cnts)
        libMesh::out << elem_cnt << ", ";
      libMesh::out << std::endl;
 
      libMesh::out << "[" << this->processor_id() << "] elem_cmap_ids = ";
      for (const auto & elem_id : elem_cmap_ids)
        libMesh::out << elem_id << ", ";
      libMesh::out << std::endl;
    }
}

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

Referenced by initialize().

◆ compute_elem_communication_maps()

void libMesh::Nemesis_IO_Helper::compute_elem_communication_maps ( )

private

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

Definition at line 977 of file nemesis_io_helper.C.

{
  // Make sure there is no leftover information
  this->elem_cmap_elem_ids.clear();
  this->elem_cmap_side_ids.clear();
  this->elem_cmap_proc_ids.clear();
 
  // Allocate enough space for all our element maps
  this->elem_cmap_elem_ids.resize(this->num_elem_cmaps);
  this->elem_cmap_side_ids.resize(this->num_elem_cmaps);
  this->elem_cmap_proc_ids.resize(this->num_elem_cmaps);
  {
    unsigned cnt=0; // Index into vectors
    proc_border_elem_sets_iterator
      it = this->proc_border_elem_sets.begin(),
      end = this->proc_border_elem_sets.end();
 
    for (; it != end; ++it)
      {
        // Make sure the current elem_cmap_id matches the index in our map of node intersections
        libmesh_assert_equal_to (static_cast<unsigned>(this->elem_cmap_ids[cnt]), it->first);
 
        // Get reference to the set of IDs to be packed into the vector
        std::set<std::pair<unsigned,unsigned>> & elem_set = it->second;
 
        // Resize the vectors to receive their payload
        this->elem_cmap_elem_ids[cnt].resize(elem_set.size());
        this->elem_cmap_side_ids[cnt].resize(elem_set.size());
        this->elem_cmap_proc_ids[cnt].resize(elem_set.size());
 
        std::set<std::pair<unsigned,unsigned>>::iterator elem_set_iter = elem_set.begin();
 
        // Pack the vectors with elem IDs, side IDs, and processor IDs.
        for (std::size_t j=0, eceis=this->elem_cmap_elem_ids[cnt].size(); j<eceis; ++j, ++elem_set_iter)
          {
            this->elem_cmap_elem_ids[cnt][j] =
              libmesh_map_find(libmesh_elem_num_to_exodus, elem_set_iter->first);
            this->elem_cmap_side_ids[cnt][j] = elem_set_iter->second;     // Side ID, this has already been converted above
            this->elem_cmap_proc_ids[cnt][j] = it->first; // All have the same processor ID
          }
 
        // increment vector index to go to next processor
        cnt++;
      }
  } // end scope for packing
}

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

Referenced by initialize().

◆ compute_element_maps()

void libMesh::Nemesis_IO_Helper::compute_element_maps ( )

private

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

Definition at line 952 of file nemesis_io_helper.C.

{
  // Make sure we don't have any leftover info
  this->elem_mapi.clear();
  this->elem_mapb.clear();
 
  // Copy set contents into vectors
  this->elem_mapi.resize(this->internal_elem_ids.size());
  this->elem_mapb.resize(this->border_elem_ids.size());
 
  {
    unsigned cnt = 0;
    for (const auto & id : this->internal_elem_ids)
      this->elem_mapi[cnt++] = libmesh_map_find(libmesh_elem_num_to_exodus, id);
  }
 
  {
    unsigned cnt = 0;
    for (const auto & id : this->border_elem_ids)
      this->elem_mapb[cnt++] = libmesh_map_find(libmesh_elem_num_to_exodus, id);
  }
}

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

Referenced by initialize().

◆ compute_internal_and_border_elems_and_internal_nodes()

void libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes ( const MeshBase & pmesh )

private

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

Definition at line 1207 of file nemesis_io_helper.C.

{
  // Set of all local, active element IDs.  After we have identified border element
  // IDs, the set_difference between this set and the border_elem_ids set will give us
  // the set of internal_elem_ids.
  std::set<unsigned> all_elem_ids;
 
  // A set of processor IDs which elements on this processor have as
  // neighbors.  The size of this set will determine the number of
  // element communication maps in Exodus.
  std::set<unsigned> neighboring_processor_ids;
 
  for (const auto & elem : pmesh.active_local_element_ptr_range())
    {
      // Add this Elem's ID to all_elem_ids, later we will take the difference
      // between this set and the set of border_elem_ids, to get the set of
      // internal_elem_ids.
      all_elem_ids.insert(elem->id());
 
      // Will be set to true if element is determined to be a border element
      bool is_border_elem = false;
 
      // Construct a conversion object for this Element.  This will help us map
      // Libmesh numberings into Nemesis numberings for sides.
      const auto & conv = get_conversion(elem->type());
 
      // Add all this element's node IDs to the set of all node IDs.
      // The set of internal_node_ids will be the set difference between
      // the set of all nodes and the set of border nodes.
      //
      // In addition, if any node of a local node is listed in the
      // border nodes list, then this element goes into the proc_border_elem_sets.
      // Note that there is not a 1:1 correspondence between
      // border_elem_ids and the entries which go into proc_border_elem_sets.
      // The latter is for communication purposes, ie determining which elements
      // should be shared between processors.
      for (auto node : elem->node_index_range())
        this->nodes_attached_to_local_elems.insert(elem->node_id(node));
 
      // Loop over element's neighbors, see if it has a neighbor which is off-processor
      for (auto n : elem->side_index_range())
        {
          if (elem->neighbor_ptr(n) != nullptr)
            {
              unsigned neighbor_proc_id = elem->neighbor_ptr(n)->processor_id();
 
              // If my neighbor has a different processor ID, I must be a border element.
              // Also track the neighboring processor ID if it is are different from our processor ID
              if (neighbor_proc_id != this->processor_id())
                {
                  is_border_elem = true;
                  neighboring_processor_ids.insert(neighbor_proc_id);
 
                  // Convert libmesh side(n) of this element into a side ID for Nemesis
                  unsigned nemesis_side_id = conv.get_inverse_side_map(n);
 
                  if (verbose)
                    libMesh::out << "[" << this->processor_id() << "] LibMesh side "
                                 << n
                                 << " mapped to (1-based) Exodus side "
                                 << nemesis_side_id
                                 << std::endl;
 
                  // Add this element's ID and the ID of the side which is on the boundary
                  // to the set of border elements for this processor.
                  // Note: if the set does not already exist, this creates it.
                  this->proc_border_elem_sets[ neighbor_proc_id ].emplace(elem->id(), nemesis_side_id);
                }
            }
        } // end for loop over neighbors
 
      // If we're on a border element, add it to the set
      if (is_border_elem)
        this->border_elem_ids.insert( elem->id() );
 
    } // end for loop over active local elements
 
  // Take the set_difference between all elements and border elements to get internal
  // element IDs
  std::set_difference(all_elem_ids.begin(), all_elem_ids.end(),
                      this->border_elem_ids.begin(), this->border_elem_ids.end(),
                      std::inserter(this->internal_elem_ids, this->internal_elem_ids.end()));
 
  // Take the set_difference between all nodes and border nodes to get internal nodes
  std::set_difference(this->nodes_attached_to_local_elems.begin(), this->nodes_attached_to_local_elems.end(),
                      this->border_node_ids.begin(), this->border_node_ids.end(),
                      std::inserter(this->internal_node_ids, this->internal_node_ids.end()));
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] neighboring_processor_ids = ";
      for (const auto & id : neighboring_processor_ids)
        libMesh::out << id << " ";
      libMesh::out << std::endl;
    }
 
  // The size of the neighboring_processor_ids set should be the number of element communication maps
  this->num_elem_cmaps =
    cast_int<int>(neighboring_processor_ids.size());
 
  if (verbose)
    libMesh::out << "[" << this->processor_id() << "] "
                 << "Number of neighboring processor IDs="
                 << this->num_elem_cmaps
                 << std::endl;
 
  if (verbose)
    {
      // Print out counts of border elements for each processor
      for (const auto & [proc_id, set] : proc_border_elem_sets)
        {
          libMesh::out << "[" << this->processor_id() << "] "
                       << "Proc "
                       << proc_id << " communicates "
                       << set.size() << " elements." << std::endl;
        }
    }
 
  // Store the number of internal and border elements, and the number of internal nodes,
  // to be written to the Nemesis file.
  this->num_internal_elems =
    cast_int<int>(this->internal_elem_ids.size());
  this->num_border_elems   =
    cast_int<int>(this->border_elem_ids.size());
  this->num_internal_nodes =
    cast_int<int>(this->internal_node_ids.size());
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] num_internal_nodes=" << this->num_internal_nodes << std::endl;
      libMesh::out << "[" << this->processor_id() << "] num_border_nodes=" << this->num_border_nodes << std::endl;
      libMesh::out << "[" << this->processor_id() << "] num_border_elems=" << this->num_border_elems << std::endl;
      libMesh::out << "[" << this->processor_id() << "] num_internal_elems=" << this->num_internal_elems << std::endl;
    }
}

References border_elem_ids, libMesh::ExodusII_IO_Helper::get_conversion(), internal_elem_ids, internal_node_ids, nodes_attached_to_local_elems, num_border_elems, num_border_nodes, num_elem_cmaps, num_internal_elems, num_internal_nodes, libMesh::out, proc_border_elem_sets, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

Referenced by initialize().

◆ compute_node_communication_maps()

void libMesh::Nemesis_IO_Helper::compute_node_communication_maps ( )

private

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

Definition at line 1057 of file nemesis_io_helper.C.

{
  // Make sure there's no left-over information
  this->node_cmap_node_ids.clear();
  this->node_cmap_proc_ids.clear();
 
  libmesh_assert_less_equal
    (this->proc_nodes_touched_intersections.size(),
     std::size_t(this->num_node_cmaps));
 
  // Allocate enough space for all our node maps
  this->node_cmap_node_ids.resize(this->num_node_cmaps);
  this->node_cmap_proc_ids.resize(this->num_node_cmaps);
  {
    unsigned cnt=0; // Index into vectors
    proc_nodes_touched_iterator
      it = this->proc_nodes_touched_intersections.begin(),
      end = this->proc_nodes_touched_intersections.end();
 
    for (; it != end; ++it)
      {
        // Make sure the current node_cmap_id matches the index in our map of node intersections
        libmesh_assert_equal_to (static_cast<unsigned>(this->node_cmap_ids[cnt]), it->first);
 
        // Get reference to the set of IDs to be packed into the vector.
        std::set<unsigned> & node_set = it->second;
 
        // Resize the vectors to receive their payload
        this->node_cmap_node_ids[cnt].resize(node_set.size());
        this->node_cmap_proc_ids[cnt].resize(node_set.size());
 
        std::set<unsigned>::iterator node_set_iter = node_set.begin();
 
        // Pack the vectors with node IDs and processor IDs.
        for (std::size_t j=0, nceis=this->node_cmap_node_ids[cnt].size(); j<nceis; ++j, ++node_set_iter)
          {
            this->node_cmap_node_ids[cnt][j] =
              libmesh_map_find(libmesh_node_num_to_exodus, *node_set_iter);
            this->node_cmap_proc_ids[cnt][j] = it->first;
          }
 
        // increment vector index to go to next processor
        cnt++;
      }
  } // end scope for packing
 
  // Print out the vectors we just packed
  if (verbose)
    {
      for (auto i : index_range(this->node_cmap_node_ids))
        {
          libMesh::out << "[" << this->processor_id() << "] nodes communicated to proc "
                       << this->node_cmap_ids[i]
                       << " = ";
          for (const auto & node_id : this->node_cmap_node_ids[i])
            libMesh::out << node_id << " ";
          libMesh::out << std::endl;
        }
 
      for (const auto & id_vec : this->node_cmap_node_ids)
        {
          libMesh::out << "[" << this->processor_id() << "] processor ID node communicated to = ";
          for (const auto & proc_id : id_vec)
            libMesh::out << proc_id << " ";
          libMesh::out << std::endl;
        }
    }
}

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

Referenced by initialize().

◆ compute_node_maps()

void libMesh::Nemesis_IO_Helper::compute_node_maps ( )

private

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

Definition at line 1028 of file nemesis_io_helper.C.

{
  // Make sure we don't have any leftover information
  this->node_mapi.clear();
  this->node_mapb.clear();
  this->node_mape.clear();
 
  // Make sure there's enough space to hold all our node IDs
  this->node_mapi.resize(this->internal_node_ids.size());
  this->node_mapb.resize(this->border_node_ids.size());
 
  // Copy set contents into vectors
  {
    unsigned cnt = 0;
    for (const auto & id : this->internal_node_ids)
      this->node_mapi[cnt++] = libmesh_map_find(libmesh_node_num_to_exodus, id);
  }
 
  {
    unsigned cnt=0;
    for (const auto & id : this->border_node_ids)
      this->node_mapb[cnt++] = libmesh_map_find(libmesh_node_num_to_exodus, id);
  }
}

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

Referenced by initialize().

◆ compute_num_global_elem_blocks()

void libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks ( const MeshBase & pmesh )

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

Definition at line 1549 of file nemesis_io_helper.C.

{
  // 1.) Loop over active local elements, build up set of subdomain IDs.
  std::set<subdomain_id_type> global_subdomain_ids;
 
  // This map keeps track of the number of elements in each subdomain over all processors
  std::map<subdomain_id_type, unsigned> global_subdomain_counts;
 
  for (const auto & elem : pmesh.active_local_element_ptr_range())
    {
      subdomain_id_type cur_subdomain = elem->subdomain_id();
 
      /*
      // We can't have a zero subdomain ID in Exodus (for some reason?)
      // so map zero subdomains to a max value...
      if (cur_subdomain == 0)
      cur_subdomain = std::numeric_limits<subdomain_id_type>::max();
      */
 
      global_subdomain_ids.insert(cur_subdomain);
 
      // Increment the count of elements in this subdomain
      global_subdomain_counts[cur_subdomain]++;
    }
 
  // We're next going to this->comm().sum the subdomain counts, so save the local counts
  this->local_subdomain_counts = global_subdomain_counts;
 
  {
    // 2.) Copy local subdomain IDs into a vector for communication
    std::vector<subdomain_id_type> global_subdomain_ids_vector(global_subdomain_ids.begin(),
                                                               global_subdomain_ids.end());
 
    // 3.) Gather them into an enlarged vector
    this->comm().allgather(global_subdomain_ids_vector);
 
    // 4.) Insert any new IDs into the set (any duplicates will be dropped)
    global_subdomain_ids.insert(global_subdomain_ids_vector.begin(),
                                global_subdomain_ids_vector.end());
  }
 
  // 5.) Now global_subdomain_ids actually contains a global list of all subdomain IDs
  this->num_elem_blks_global =
    cast_int<int>(global_subdomain_ids.size());
 
  // Print the number of elements found locally in each subdomain
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] ";
      for (const auto & [subdomain_id, cnt] : global_subdomain_counts)
        {
          libMesh::out << "ID: "
                       << static_cast<unsigned>(subdomain_id)
                       << ", Count: " << cnt << ", ";
        }
      libMesh::out << std::endl;
    }
 
  // 6.) this->comm().sum up the number of elements in each block.  We know the global
  // subdomain IDs, so pack them into a vector one by one.  Use a vector of int since
  // that is what Nemesis wants
  this->global_elem_blk_cnts.resize(global_subdomain_ids.size());
 
  unsigned cnt=0;
  // Find the entry in the local map, note: if not found, will be created with 0 default value, which is OK...
  for (const auto & id : global_subdomain_ids)
    this->global_elem_blk_cnts[cnt++] = global_subdomain_counts[id];
 
  // Sum up subdomain counts from all processors
  this->comm().sum(this->global_elem_blk_cnts);
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] global_elem_blk_cnts = ";
      for (const auto & bc : this->global_elem_blk_cnts)
        libMesh::out << bc << ", ";
      libMesh::out << std::endl;
    }
 
  // 7.) Create a vector<int> from the global_subdomain_ids set, for passing to Nemesis
  this->global_elem_blk_ids.clear();
  this->global_elem_blk_ids.insert(this->global_elem_blk_ids.end(), // pos
                                   global_subdomain_ids.begin(),
                                   global_subdomain_ids.end());
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] global_elem_blk_ids = ";
      for (const auto & id : this->global_elem_blk_ids)
        libMesh::out << id << ", ";
      libMesh::out << std::endl;
    }
 
 
  // 8.) We will call put_eb_info_global later, it must be called after this->put_init_global().
}

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

Referenced by initialize().

◆ compute_num_global_nodesets()

void libMesh::Nemesis_IO_Helper::compute_num_global_nodesets ( const MeshBase & pmesh )

private

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

Definition at line 1438 of file nemesis_io_helper.C.

{
  std::set<boundary_id_type> local_node_boundary_ids;
 
  // 1.) Get reference to the set of node boundary IDs *for this processor*
  std::set<boundary_id_type> global_node_boundary_ids
    (pmesh.get_boundary_info().get_node_boundary_ids().begin(),
     pmesh.get_boundary_info().get_node_boundary_ids().end());
 
  // Save a copy of the local_node_boundary_ids...
  local_node_boundary_ids = global_node_boundary_ids;
 
  // 2.) Gather boundary node IDs from other processors
  this->comm().set_union(global_node_boundary_ids);
 
  // 3.) Now global_node_boundary_ids actually contains a global list of all node boundary IDs
  this->num_node_sets_global =
    cast_int<int>(global_node_boundary_ids.size());
 
  // 4.) Create a vector<int> from the global_node_boundary_ids set
  this->global_nodeset_ids.clear();
  this->global_nodeset_ids.insert(this->global_nodeset_ids.end(),
                                  global_node_boundary_ids.begin(),
                                  global_node_boundary_ids.end());
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] global_nodeset_ids = ";
      for (const auto & id : global_nodeset_ids)
        libMesh::out << id << ", ";
      libMesh::out << std::endl;
 
      libMesh::out << "[" << this->processor_id() << "] local_node_boundary_ids = ";
      for (const auto & id : local_node_boundary_ids)
        libMesh::out << id << ", ";
      libMesh::out << std::endl;
    }
 
  // 7.) We also need to know the number of nodes which is in each of the nodesets, globally.
 
  // Build list of (node-id, bc-id) tuples.
  typedef std::tuple<dof_id_type, boundary_id_type> Tuple;
  std::vector<Tuple> bc_tuples = pmesh.get_boundary_info().build_node_list();
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] boundary_node_list.size()="
                   << bc_tuples.size() << std::endl;
      libMesh::out << "[" << this->processor_id() << "] (boundary_node_id, boundary_id) = ";
      for (const auto & t : bc_tuples)
        libMesh::out << "(" << std::get<0>(t) << ", " << std::get<1>(t) << ") ";
      libMesh::out << std::endl;
    }
 
  // Now get the global information.  In this case, we only want to count boundary
  // information for nodes *owned* by this processor, so there are no duplicates.
 
  // Make sure we don't have any left over information
  this->num_global_node_counts.clear();
  this->num_global_node_counts.resize(this->global_nodeset_ids.size());
 
  // Unfortunately, we can't just count up all occurrences of a given id,
  // that would give us duplicate entries when we do the parallel summation.
  // So instead, only count entries for nodes owned by this processor.
  // Start by getting rid of all non-local node entries from the vectors.
  std::vector<Tuple>::iterator
    it = bc_tuples.begin(),
    new_end = bc_tuples.end();
 
  while (it != new_end)
    {
      if (pmesh.node_ptr(std::get<0>(*it))->processor_id() != this->processor_id())
        {
          // Back up the new end iterators to prepare for swap
          --new_end;
 
          // Swap places, the non-local node will now be "past-the-end"
          std::swap(*it, *new_end);
        }
      else // node is local, go to next
        ++it;
    }
 
  // Erase from "new" end to old end.
  bc_tuples.erase(new_end, bc_tuples.end());
 
  // Now we can do the local count for each ID...
  for (auto i : index_range(global_nodeset_ids))
    {
      int id = this->global_nodeset_ids[i];
      this->num_global_node_counts[i] =
        cast_int<int>(std::count_if(bc_tuples.begin(),
                                    bc_tuples.end(),
                                    [id](const Tuple & t)->bool { return std::get<1>(t) == id; }));
    }
 
  // And finally we can sum them up
  this->comm().sum(this->num_global_node_counts);
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] num_global_node_counts = ";
      for (const auto & cnt : num_global_node_counts)
        libMesh::out << cnt << ", ";
      libMesh::out << std::endl;
    }
}

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

Referenced by initialize().

◆ compute_num_global_sidesets()

void libMesh::Nemesis_IO_Helper::compute_num_global_sidesets ( const MeshBase & pmesh )

private

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

Definition at line 1345 of file nemesis_io_helper.C.

{
  // 1.) Get reference to the set of side boundary IDs
  std::set<boundary_id_type> global_side_boundary_ids
    (pmesh.get_boundary_info().get_side_boundary_ids().begin(),
     pmesh.get_boundary_info().get_side_boundary_ids().end());
 
  // 2.) Gather boundary side IDs from other processors
  this->comm().set_union(global_side_boundary_ids);
 
  // 3.) Now global_side_boundary_ids actually contains a global list of all side boundary IDs
  this->num_side_sets_global =
    cast_int<int>(global_side_boundary_ids.size());
 
  // 4.) Pack these sidesets into a vector so they can be written by Nemesis
  this->global_sideset_ids.clear(); // Make sure there is no leftover information
  this->global_sideset_ids.insert(this->global_sideset_ids.end(),
                                  global_side_boundary_ids.begin(),
                                  global_side_boundary_ids.end());
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] global_sideset_ids = ";
      for (const auto & id : this->global_sideset_ids)
        libMesh::out << id << ", ";
      libMesh::out << std::endl;
    }
 
  // We also need global counts of sides in each of the sidesets.
  // Build a list of (elem, side, bc) tuples.
  typedef std::tuple<dof_id_type, unsigned short int, boundary_id_type> Tuple;
  std::vector<Tuple> bc_triples = pmesh.get_boundary_info().build_side_list();
 
  // Iterators to the beginning and end of the current range.
  std::vector<Tuple>::iterator
    it = bc_triples.begin(),
    new_end = bc_triples.end();
 
  while (it != new_end)
    {
      if (pmesh.elem_ref(std::get<0>(*it)).processor_id() != this->processor_id())
        {
          // Back up the new end iterators to prepare for swap
          --new_end;
 
          // Swap places, the non-local elem will now be "past-the-end"
          std::swap (*it, *new_end);
        }
      else // elem is local, go to next
        ++it;
    }
 
  // Erase from "new" end to old.
  bc_triples.erase(new_end, bc_triples.end());
 
  this->num_global_side_counts.clear(); // Make sure we don't have any leftover information
  this->num_global_side_counts.resize(this->global_sideset_ids.size());
 
  // Get the count for each global sideset ID
  for (auto i : index_range(global_sideset_ids))
    {
      int id = global_sideset_ids[i];
      this->num_global_side_counts[i] =
        cast_int<int>(std::count_if(bc_triples.begin(),
                                    bc_triples.end(),
                                    [id](const Tuple & t)->bool { return std::get<2>(t) == id; }));
    }
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] num_global_side_counts = ";
      for (const auto & cnt : this->num_global_side_counts)
        libMesh::out << cnt << ", ";
      libMesh::out << std::endl;
    }
 
  // Finally sum up the result
  this->comm().sum(this->num_global_side_counts);
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] num_global_side_counts = ";
      for (const auto & cnt : this->num_global_side_counts)
        libMesh::out << cnt << ", ";
      libMesh::out << std::endl;
    }
}

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

Referenced by initialize().

◆ conditionally_set_elem_unique_id()

void libMesh::ExodusII_IO_Helper::conditionally_set_elem_unique_id	(	MeshBase &	mesh,
		Elem *	elem,
		int	zero_based_elem_num_map_index
	)

inherited

Definition at line 2469 of file exodusII_io_helper.C.

{
  this->set_dof_object_unique_id(mesh, elem, libmesh_vector_at(this->elem_num_map, zero_based_elem_num_map_index));
}

References libMesh::ExodusII_IO_Helper::elem_num_map, and libMesh::ExodusII_IO_Helper::set_dof_object_unique_id().

◆ conditionally_set_node_unique_id()

void libMesh::ExodusII_IO_Helper::conditionally_set_node_unique_id	(	MeshBase &	mesh,
		Node *	node,
		int	zero_based_node_num_map_index
	)

inherited

Helper function that conditionally sets the unique_id of the passed-in Node/Elem.

Calling this function does nothing if _set_unique_ids_from_maps == false, otherwise it sets the unique_id based on the entries of the {node,elem_num_map}. The input index is assumed to be a zero-based index into the {node,elem}_num_map array.

Definition at line 2462 of file exodusII_io_helper.C.

{
  this->set_dof_object_unique_id(mesh, node, libmesh_vector_at(this->node_num_map, zero_based_node_num_map_index));
}

References libMesh::ExodusII_IO_Helper::node_num_map, and libMesh::ExodusII_IO_Helper::set_dof_object_unique_id().

◆ construct_nemesis_filename()

std::string libMesh::Nemesis_IO_Helper::construct_nemesis_filename ( std::string_view base_filename )

Given base_filename, foo.e, constructs the Nemesis filename foo.e.X.Y, where X=n.

CPUs and Y=processor ID

Definition at line 2791 of file nemesis_io_helper.C.

{
  // Build a filename for this processor.  This code is cut-n-pasted from the read function
  // and should probably be put into a separate function...
  std::ostringstream file_oss;
 
  // We have to be a little careful here: Nemesis left pads its file
  // numbers based on the number of processors, so for example on 10
  // processors, we'd have:
  // mesh.e.10.00
  // mesh.e.10.01
  // mesh.e.10.02
  // ...
  // mesh.e.10.09
 
  // And on 100 you'd have:
  // mesh.e.100.000
  // mesh.e.100.001
  // ...
  // mesh.e.128.099
 
  // Find the length of the highest processor ID
  file_oss << (this->n_processors());
  unsigned int field_width = cast_int<unsigned int>(file_oss.str().size());
 
  if (verbose)
    libMesh::out << "field_width=" << field_width << std::endl;
 
  file_oss.str(""); // reset the string stream
  file_oss << base_filename
           << '.' << this->n_processors()
           << '.' << std::setfill('0') << std::setw(field_width) << this->processor_id();
 
  // Return the resulting string
  return file_oss.str();
}

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

◆ create()

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

virtualinherited

Opens an ExodusII mesh file named filename for writing.

Definition at line 2513 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
      if (this->_write_hdf5)
        {
          mode |= EX_NETCDF4;
          mode |= EX_NOCLASSIC;
        }
#endif
 
      {
        FPEDisabler disable_fpes;
        ex_id = exII::ex_create(filename.c_str(), mode, &comp_ws, &io_ws);
      }
 
      EX_CHECK_ERR(ex_id, "Error creating ExodusII/Nemesis mesh file.");
 
      // We don't have access to the names we might be writing until we
      // write them, so we can't set a guaranteed max name length here.
      // But it looks like the most ExodusII can support is 80, so we'll
      // just waste 48 bytes here and there.
      ex_err = exII::ex_set_max_name_length(ex_id, _max_name_length);
      EX_CHECK_ERR(ex_err, "Error setting max ExodusII name length.");
 
      if (verbose)
        libMesh::out << "File created successfully." << std::endl;
    }
 
  opened_for_writing = true;
  _opened_by_create = true;
  current_filename = filename;
}

◆ end_elem_id()

int libMesh::ExodusII_IO_Helper::end_elem_id ( ) const

inlineinherited

Definition at line 1374 of file exodusII_io_helper.h.

{
  libmesh_assert_equal_to(std::size_t(num_elem), elem_num_map.size());
  return _end_elem_id;
}

References libMesh::ExodusII_IO_Helper::_end_elem_id, libMesh::ExodusII_IO_Helper::elem_num_map, and libMesh::ExodusII_IO_Helper::num_elem.

◆ get_add_sides()

bool libMesh::ExodusII_IO_Helper::get_add_sides ( )

inlineinherited

Definition at line 1368 of file exodusII_io_helper.h.

{
  return _add_sides;
}

References libMesh::ExodusII_IO_Helper::_add_sides.

◆ get_block_id()

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

inherited

Get the block number for the given block index.

Definition at line 1149 of file exodusII_io_helper.C.

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

References libMesh::ExodusII_IO_Helper::block_ids.

Referenced by libMesh::ExodusII_IO_Helper::write_element_values(), and libMesh::ExodusII_IO_Helper::write_element_values_element_major().

◆ get_block_name()

std::string libMesh::ExodusII_IO_Helper::get_block_name ( int index )

inherited

Get the block name for the given block index if supplied in the mesh file.

Otherwise an empty string is returned.

Definition at line 1158 of file exodusII_io_helper.C.

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

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

◆ get_cmap_params()

void libMesh::Nemesis_IO_Helper::get_cmap_params ( )

Definition at line 388 of file nemesis_io_helper.C.

{
  node_cmap_ids.resize(num_node_cmaps);
  node_cmap_node_cnts.resize(num_node_cmaps);
  elem_cmap_ids.resize(num_elem_cmaps);
  elem_cmap_elem_cnts.resize(num_elem_cmaps);
 
  nemesis_err_flag =
    Nemesis::ne_get_cmap_params(ex_id,
                                node_cmap_ids.empty()       ? nullptr : node_cmap_ids.data(),
                                node_cmap_node_cnts.empty() ? nullptr : node_cmap_node_cnts.data(),
                                elem_cmap_ids.empty()       ? nullptr : elem_cmap_ids.data(),
                                elem_cmap_elem_cnts.empty() ? nullptr : elem_cmap_elem_cnts.data(),
                                this->processor_id());
  EX_CHECK_ERR(nemesis_err_flag, "Error reading cmap parameters!");
 
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] ";
      for (auto i : index_range(node_cmap_ids))
        libMesh::out << "node_cmap_ids[" << i << "]=" << node_cmap_ids[i] << " ";
      libMesh::out << std::endl;
 
      libMesh::out << "[" << this->processor_id() << "] ";
      for (auto i : index_range(node_cmap_node_cnts))
        libMesh::out << "node_cmap_node_cnts[" << i << "]=" << node_cmap_node_cnts[i] << " ";
      libMesh::out << std::endl;
 
      libMesh::out << "[" << this->processor_id() << "] ";
      for (auto i : index_range(elem_cmap_ids))
        libMesh::out << "elem_cmap_ids[" << i << "]=" << elem_cmap_ids[i] << " ";
      libMesh::out << std::endl;
 
      libMesh::out << "[" << this->processor_id() << "] ";
      for (auto i : index_range(elem_cmap_elem_cnts))
        libMesh::out << "elem_cmap_elem_cnts[" << i << "]=" << elem_cmap_elem_cnts[i] << " ";
      libMesh::out << std::endl;
    }
}

References elem_cmap_elem_cnts, elem_cmap_ids, libMesh::ExodusII_IO_Helper::ex_id, libMesh::index_range(), nemesis_err_flag, node_cmap_ids, node_cmap_node_cnts, num_elem_cmaps, num_node_cmaps, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

◆ get_complex_names()

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

inherited

Returns: A vector with three copies of each element in the provided name vector, starting with r_, i_ and a_ respectively. If the "write_complex_abs" parameter is true (default), the complex modulus is written, otherwise only the real and imaginary parts are written.

Definition at line 5379 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);
      if (write_complex_abs)
        complex_names.push_back("a_" + name);
    }
 
  return complex_names;
}

◆ 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,
		bool	write_complex_abs
	)		const

inherited

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

{
  // Eventual return value
  std::map<subdomain_id_type, std::vector<std::string>> ret;
 
  unsigned int num_complex_outputs = write_complex_abs ? 3 : 2;
 
  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 the complex-valued entries
      vec.reserve(num_complex_outputs * 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);
          if (write_complex_abs)
            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,
		bool	write_complex_abs
	)		const

inherited

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

Definition at line 5400 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 enough times for the real, imag, (and
      // possibly modulus) for the complex-valued solution.
      complex_vars_active_subdomains.push_back(s);
      complex_vars_active_subdomains.push_back(s);
      if (write_complex_abs)
        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

inherited

Definition at line 572 of file exodusII_io_helper.C.

{
  auto & maps_for_dim = libmesh_map_find(conversion_map, this->num_dim);
  return libmesh_map_find(maps_for_dim, type);
}

References libMesh::ExodusII_IO_Helper::conversion_map, and libMesh::ExodusII_IO_Helper::num_dim.

◆ get_conversion() [2/2]

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

inherited

Definition at line 579 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 libMesh::ExodusII_IO_Helper::element_equivalence_map, and libMesh::ExodusII_IO_Helper::get_conversion().

◆ get_eb_info_global()

void libMesh::Nemesis_IO_Helper::get_eb_info_global ( )

Definition at line 242 of file nemesis_io_helper.C.

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

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

◆ get_elem_cmap()

void libMesh::Nemesis_IO_Helper::get_elem_cmap ( )

Definition at line 473 of file nemesis_io_helper.C.

{
  elem_cmap_elem_ids.resize(num_elem_cmaps);
  elem_cmap_side_ids.resize(num_elem_cmaps);
  elem_cmap_proc_ids.resize(num_elem_cmaps);
 
  for (auto i : index_range(elem_cmap_elem_ids))
    {
      elem_cmap_elem_ids[i].resize(elem_cmap_elem_cnts[i]);
      elem_cmap_side_ids[i].resize(elem_cmap_elem_cnts[i]);
      elem_cmap_proc_ids[i].resize(elem_cmap_elem_cnts[i]);
 
      if (elem_cmap_elem_cnts[i] > 0)
        {
          nemesis_err_flag =
            Nemesis::ne_get_elem_cmap(ex_id,
                                      elem_cmap_ids[i],
                                      elem_cmap_elem_ids[i].data(),
                                      elem_cmap_side_ids[i].data(),
                                      elem_cmap_proc_ids[i].data(),
                                      this->processor_id());
          EX_CHECK_ERR(nemesis_err_flag, "Error reading elem cmap elem, side, and processor ids!");
        }
 
      if (verbose)
        {
          libMesh::out << "[" << this->processor_id() << "] elem_cmap_elem_ids[" << i << "]=";
          for (const auto & dof : elem_cmap_elem_ids[i])
            libMesh::out << dof << " ";
          libMesh::out << std::endl;
 
          // These must be the (local) side IDs (in the ExodusII face numbering scheme)
          // of the sides shared across processors.
          libMesh::out << "[" << this->processor_id() << "] elem_cmap_side_ids[" << i << "]=";
          for (const auto & dof : elem_cmap_side_ids[i])
            libMesh::out << dof << " ";
          libMesh::out << std::endl;
 
          // This is basically a vector, all entries of which are = elem_cmap_ids[i]
          // Not sure if it's always guaranteed to be that or what...
          libMesh::out << "[" << this->processor_id() << "] elem_cmap_proc_ids[" << i << "]=";
          for (const auto & dof : elem_cmap_proc_ids[i])
            libMesh::out << dof << " ";
          libMesh::out << std::endl;
        }
    }
}

References elem_cmap_elem_cnts, elem_cmap_elem_ids, elem_cmap_ids, elem_cmap_proc_ids, elem_cmap_side_ids, libMesh::ExodusII_IO_Helper::ex_id, libMesh::index_range(), nemesis_err_flag, num_elem_cmaps, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

◆ get_elem_map()

void libMesh::Nemesis_IO_Helper::get_elem_map ( )

Definition at line 320 of file nemesis_io_helper.C.

{
  elem_mapi.resize(num_internal_elems);
  elem_mapb.resize(num_border_elems);
 
  nemesis_err_flag =
    Nemesis::ne_get_elem_map(ex_id,
                             elem_mapi.empty() ? nullptr : elem_mapi.data(),
                             elem_mapb.empty() ? nullptr : elem_mapb.data(),
                             this->processor_id()
                             );
  EX_CHECK_ERR(nemesis_err_flag, "Error reading element maps!");
 
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] elem_mapi[i] = ";
      for (auto i : make_range(num_internal_elems-1))
        libMesh::out << elem_mapi[i] << ", ";
      libMesh::out << "... " << elem_mapi.back() << std::endl;
 
      libMesh::out << "[" << this->processor_id() << "] elem_mapb[i] = ";
      for (auto i : make_range(std::min(10, num_border_elems-1)))
        libMesh::out << elem_mapb[i] << ", ";
      libMesh::out << "... " << elem_mapb.back() << std::endl;
    }
}

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

◆ get_elem_type()

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

inherited

Returns: The current element type.

Note: The default behavior is for this value to be in all capital letters, e.g. HEX27.

Definition at line 586 of file exodusII_io_helper.C.

{
  return elem_type.data();
}

References libMesh::ExodusII_IO_Helper::elem_type.

◆ get_elemset_data_indices()

void libMesh::ExodusII_IO_Helper::get_elemset_data_indices ( std::map< std::pair< dof_id_type, elemset_id_type >, unsigned int > & elemset_array_indices )

inherited

Similar to read_elemset_data(), but instead of creating one std::map per elemset per variable, creates a single map of (elem_id, elemset_id) tuples, and stores the exo file array indexing for any/all elemset variables on that elemset (they are all the same).

Definition at line 4810 of file exodusII_io_helper.C.

{
  // Clear existing data, we are going to build these data structures from scratch
  elemset_array_indices.clear();
 
  // Read the elemset data.
  //
  // Note: we assume that the functions
  // 1.) this->read_elemset_info() and
  // 2.) this->read_elemset()
  // have already been called, so that we already know e.g. how
  // many elems are in each set, their ids, etc.
  int offset=0;
  for (int es=0; es<num_elem_sets; ++es)
    {
      offset += (es > 0 ? num_elems_per_set[es-1] : 0);
 
      // Note: we don't actually call exII::ex_get_var() here because
      // we don't need the values. We only need the indices into that vector
      // for each (elem_id, elemset_id) tuple.
      for (int i=0; i<num_elems_per_set[es]; ++i)
        {
          dof_id_type exodus_elem_id = elemset_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;
 
          // Make key based on the elem and set ids
          // Make a NodeBCTuple key from the converted information.
          auto key = std::make_pair(converted_elem_id,
                                    static_cast<elemset_id_type>(elemset_ids[es]));
 
          // Store the array index of this (node, b_id) tuple
          elemset_array_indices.emplace(key, cast_int<unsigned int>(i));
        } // end for (i)
    } // end for (es)
}

References libMesh::ExodusII_IO_Helper::elemset_ids, libMesh::ExodusII_IO_Helper::elemset_list, libMesh::ExodusII_IO_Helper::num_elem_sets, and libMesh::ExodusII_IO_Helper::num_elems_per_set.

◆ get_exodus_version()

int libMesh::ExodusII_IO_Helper::get_exodus_version ( )

staticinherited

Returns: The ExodusII API version, in "nodot" format; e.g. 822 for 8.22

Definition at line 332 of file exodusII_io_helper.C.

{
  return EX_API_VERS_NODOT;
}

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

◆ get_init_global()

void libMesh::Nemesis_IO_Helper::get_init_global ( )

Fills: num_nodes_global, num_elems_global, num_elem_blks_global, num_node_sets_global, num_side_sets_global Call after: read_and_store_header_info() Call before: Any other get_* function from this class.

Definition at line 151 of file nemesis_io_helper.C.

{
  nemesis_err_flag =
    Nemesis::ne_get_init_global(ex_id,
                                &num_nodes_global,
                                &num_elems_global,
                                &num_elem_blks_global,
                                &num_node_sets_global,
                                &num_side_sets_global);
  EX_CHECK_ERR(nemesis_err_flag, "Error reading initial global data!");
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] " << "num_nodes_global=" << num_nodes_global << std::endl;
      libMesh::out << "[" << this->processor_id() << "] " << "num_elems_global=" << num_elems_global << std::endl;
      libMesh::out << "[" << this->processor_id() << "] " << "num_elem_blks_global=" << num_elem_blks_global << std::endl;
      libMesh::out << "[" << this->processor_id() << "] " << "num_node_sets_global=" << num_node_sets_global << std::endl;
      libMesh::out << "[" << this->processor_id() << "] " << "num_side_sets_global=" << num_side_sets_global << std::endl;
    }
}

References libMesh::ExodusII_IO_Helper::ex_id, nemesis_err_flag, num_elem_blks_global, num_elems_global, num_node_sets_global, num_nodes_global, num_side_sets_global, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

◆ get_init_info()

void libMesh::Nemesis_IO_Helper::get_init_info ( )

Definition at line 271 of file nemesis_io_helper.C.

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

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

◆ get_libmesh_elem_id()

dof_id_type libMesh::ExodusII_IO_Helper::get_libmesh_elem_id ( int exodus_elem_id )

inherited

Definition at line 2423 of file exodusII_io_helper.C.

{
  return this->get_libmesh_id(exodus_elem_id, this->elem_num_map);
}

References libMesh::ExodusII_IO_Helper::elem_num_map, and libMesh::ExodusII_IO_Helper::get_libmesh_id().

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

◆ get_libmesh_id()

dof_id_type libMesh::ExodusII_IO_Helper::get_libmesh_id	(	int	exodus_id,
		const std::vector< int > &	num_map
	)

privateinherited

Internal implementation for the two sets of functions above.

Definition at line 2429 of file exodusII_io_helper.C.

{
  // The input exodus_id is assumed to be a (1-based) index into
  // the {node,elem}_num_map, so in order to use exodus_id as an index
  // in C++, we need to first make it zero-based.
  auto exodus_id_zero_based =
    cast_int<dof_id_type>(exodus_id - 1);
 
  // Throw an informative error message rather than accessing past the
  // end of the provided num_map. If we are setting Elem unique_ids
  // based on the num_map, we don't need to do this check.
  if (!this->set_unique_ids_from_maps)
    libmesh_error_msg_if(exodus_id_zero_based >= num_map.size(),
                         "Cannot get LibMesh id for Exodus id: " << exodus_id);
 
  // If the user set the flag which stores Exodus node/elem ids as
  // unique_ids instead of regular ids, then the libmesh id we are
  // looking for is actually just "exodus_id_zero_based". Otherwise,
  // we need to look up the Node/Elem's id in the provided num_map,
  // *and* then subtract 1 from that because the entries in the
  // num_map are also 1-based.
  dof_id_type libmesh_id =
    this->set_unique_ids_from_maps ?
    cast_int<dof_id_type>(exodus_id_zero_based) :
    cast_int<dof_id_type>(num_map[exodus_id_zero_based] - 1);
 
  return libmesh_id;
}

References libMesh::ExodusII_IO_Helper::set_unique_ids_from_maps.

Referenced by libMesh::ExodusII_IO_Helper::get_libmesh_elem_id(), and libMesh::ExodusII_IO_Helper::get_libmesh_node_id().

◆ get_libmesh_node_id()

dof_id_type libMesh::ExodusII_IO_Helper::get_libmesh_node_id ( int exodus_node_id )

inherited

Helper function that takes a (1-based) Exodus node/elem id and determines the corresponding libMesh Node/Elem id.

Takes into account whether the user has chosen to set the Node/Elem unique ids based on the {node,elem}_num_map or to let libMesh set them.

Definition at line 2418 of file exodusII_io_helper.C.

{
  return this->get_libmesh_id(exodus_node_id, this->node_num_map);
}

References libMesh::ExodusII_IO_Helper::get_libmesh_id(), and libMesh::ExodusII_IO_Helper::node_num_map.

Referenced by libMesh::ExodusII_IO_Helper::read_edge_blocks(), and libMesh::ExodusII_IO_Helper::read_nodal_var_values().

◆ get_loadbal_param()

void libMesh::Nemesis_IO_Helper::get_loadbal_param ( )

Definition at line 290 of file nemesis_io_helper.C.

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

References libMesh::ExodusII_IO_Helper::ex_id, nemesis_err_flag, num_border_elems, num_border_nodes, num_elem_cmaps, num_external_nodes, num_internal_elems, num_internal_nodes, num_node_cmaps, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

◆ get_node_cmap()

void libMesh::Nemesis_IO_Helper::get_node_cmap ( )

Definition at line 431 of file nemesis_io_helper.C.

{
  node_cmap_node_ids.resize(num_node_cmaps);
  node_cmap_proc_ids.resize(num_node_cmaps);
 
  for (auto i : index_range(node_cmap_node_ids))
    {
      node_cmap_node_ids[i].resize(node_cmap_node_cnts[i]);
      node_cmap_proc_ids[i].resize(node_cmap_node_cnts[i]);
 
      // Don't call ne_get_node_cmap() if there is nothing there to
      // get, Nemesis throws an error in this case.
      if (node_cmap_node_cnts[i] > 0)
        {
          nemesis_err_flag =
            Nemesis::ne_get_node_cmap(ex_id,
                                      node_cmap_ids[i],
                                      node_cmap_node_ids[i].data(),
                                      node_cmap_proc_ids[i].data(),
                                      this->processor_id());
          EX_CHECK_ERR(nemesis_err_flag, "Error reading node cmap node and processor ids!");
        }
 
      if (verbose)
        {
          libMesh::out << "[" << this->processor_id() << "] node_cmap_node_ids[" << i << "]=";
          for (const auto & dof : node_cmap_node_ids[i])
            libMesh::out << dof << " ";
          libMesh::out << std::endl;
 
          // This is basically a vector, all entries of which are = node_cmap_ids[i]
          // Not sure if it's always guaranteed to be that or what...
          libMesh::out << "[" << this->processor_id() << "] node_cmap_proc_ids[" << i << "]=";
          for (const auto & dof : node_cmap_proc_ids[i])
            libMesh::out << dof << " ";
          libMesh::out << std::endl;
        }
    }
}

References libMesh::ExodusII_IO_Helper::ex_id, libMesh::index_range(), nemesis_err_flag, node_cmap_ids, node_cmap_node_cnts, node_cmap_node_ids, node_cmap_proc_ids, num_node_cmaps, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

◆ get_node_map()

void libMesh::Nemesis_IO_Helper::get_node_map ( )

Definition at line 351 of file nemesis_io_helper.C.

{
  node_mapi.resize(num_internal_nodes);
  node_mapb.resize(num_border_nodes);
  node_mape.resize(num_external_nodes);
 
  nemesis_err_flag =
    Nemesis::ne_get_node_map(ex_id,
                             node_mapi.empty() ? nullptr : node_mapi.data(),
                             node_mapb.empty() ? nullptr : node_mapb.data(),
                             node_mape.empty() ? nullptr : node_mape.data(),
                             this->processor_id()
                             );
  EX_CHECK_ERR(nemesis_err_flag, "Error reading node maps!");
 
  if (verbose)
    {
      // Remark: The Exodus/Nemesis node numbering is always (?) 1-based!  This means the first interior node id will
      // always be == 1.
      libMesh::out << "[" << this->processor_id() << "] " << "first interior node id=" << node_mapi[0] << std::endl;
      libMesh::out << "[" << this->processor_id() << "] " << "last interior node id=" << node_mapi.back() << std::endl;
 
      libMesh::out << "[" << this->processor_id() << "] " << "first boundary node id=" << node_mapb[0] << std::endl;
      libMesh::out << "[" << this->processor_id() << "] " << "last boundary node id=" << node_mapb.back() << std::endl;
 
      // The number of external nodes is sometimes zero, don't try to access
      // node_mape.back() in this case!
      if (num_external_nodes > 0)
        {
          libMesh::out << "[" << this->processor_id() << "] " << "first external node id=" << node_mape[0] << std::endl;
          libMesh::out << "[" << this->processor_id() << "] " << "last external node id=" << node_mape.back() << std::endl;
        }
    }
}

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

◆ get_node_set_id()

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

inherited

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

Definition at line 1185 of file exodusII_io_helper.C.

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

References libMesh::ExodusII_IO_Helper::nodeset_ids.

◆ get_node_set_name()

std::string libMesh::ExodusII_IO_Helper::get_node_set_name ( int index )

inherited

Get the node set name for the given node set index if supplied in the mesh file.

Otherwise an empty string is returned.

Definition at line 1194 of file exodusII_io_helper.C.

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

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

◆ get_nodeset_data_indices()

void libMesh::ExodusII_IO_Helper::get_nodeset_data_indices ( std::map< BoundaryInfo::NodeBCTuple, unsigned int > & bc_array_indices )

inherited

Similar to read_nodeset_data(), but instead of creating one std::map per nodeset per variable, creates a single map of (node_id, boundary_id) tuples, and stores the exo file array indexing for any/all nodeset variables on that nodeset (they are all the same).

Definition at line 4952 of file exodusII_io_helper.C.

{
  // Clear existing data, we are going to build these data structures from scratch
  bc_array_indices.clear();
 
  // Read the nodeset data.
  //
  // Note: we assume that the functions
  // 1.) this->read_nodeset_info() and
  // 2.) this->read_all_nodesets()
  // have already been called, so that we already know e.g. how
  // many nodes are in each set, their ids, etc.
  int offset=0;
  for (int ns=0; ns<num_node_sets; ++ns)
    {
      offset += (ns > 0 ? num_nodes_per_set[ns-1] : 0);
      // Note: we don't actually call exII::ex_get_var() here because
      // we don't need the values. We only need the indices into that vector
      // for each (node_id, boundary_id) tuple.
      for (int i=0; i<num_nodes_per_set[ns]; ++i)
        {
          // The read_all_nodesets() function now reads all the node ids into the
          // node_sets_node_list vector, which is of length "total_nodes_in_all_sets"
          // The old read_nodset() function is no longer called as far as I can tell,
          // and should probably be removed? The "offset" that we are using only
          // depends on the current nodeset index and the num_nodes_per_set vector,
          // which gets filled in by the call to read_all_nodesets().
          dof_id_type exodus_node_id = node_sets_node_list[i + offset];
 
          // FIXME: We should use exodus_node_num_to_libmesh for this,
          // but it apparently is never set up, so just
          // subtract 1 from the Exodus node id.
          dof_id_type converted_node_id = exodus_node_id - 1;
 
          // Make a NodeBCTuple key from the converted information.
          BoundaryInfo::NodeBCTuple key = std::make_tuple
            (converted_node_id, nodeset_ids[ns]);
 
          // Store the array index of this (node, b_id) tuple
          bc_array_indices.emplace(key, cast_int<unsigned int>(i));
        } // end for (i)
    } // end for (ns)
}

References libMesh::ExodusII_IO_Helper::node_sets_node_list, libMesh::ExodusII_IO_Helper::nodeset_ids, libMesh::ExodusII_IO_Helper::num_node_sets, and libMesh::ExodusII_IO_Helper::num_nodes_per_set.

◆ get_ns_param_global()

void libMesh::Nemesis_IO_Helper::get_ns_param_global ( )

Definition at line 210 of file nemesis_io_helper.C.

{
  if (num_node_sets_global > 0)
    {
      global_nodeset_ids.resize(num_node_sets_global);
      num_global_node_counts.resize(num_node_sets_global);
      num_global_node_df_counts.resize(num_node_sets_global);
 
      nemesis_err_flag =
        Nemesis::ne_get_ns_param_global(ex_id,
                                        global_nodeset_ids.data(),
                                        num_global_node_counts.data(),
                                        num_global_node_df_counts.data());
      EX_CHECK_ERR(nemesis_err_flag, "Error reading global nodeset parameters!");
 
      if (verbose)
        {
          libMesh::out << "[" << this->processor_id() << "] " << "Global Nodeset IDs, Node Counts, and DF counts:" << std::endl;
          for (auto bn : index_range(global_nodeset_ids))
            {
              libMesh::out << "  [" << this->processor_id() << "] "
                           << "global_nodeset_ids["<<bn<<"]=" << global_nodeset_ids[bn]
                           << ", num_global_node_counts["<<bn<<"]=" << num_global_node_counts[bn]
                           << ", num_global_node_df_counts["<<bn<<"]=" << num_global_node_df_counts[bn]
                           << std::endl;
            }
        }
    }
}

References libMesh::ExodusII_IO_Helper::ex_id, global_nodeset_ids, libMesh::index_range(), nemesis_err_flag, num_global_node_counts, num_global_node_df_counts, num_node_sets_global, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

◆ get_side_set_id()

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

inherited

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

Definition at line 1167 of file exodusII_io_helper.C.

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

References libMesh::ExodusII_IO_Helper::ss_ids.

◆ get_side_set_name()

std::string libMesh::ExodusII_IO_Helper::get_side_set_name ( int index )

inherited

Get the side set name for the given side set index if supplied in the mesh file.

Otherwise an empty string is returned.

Definition at line 1176 of file exodusII_io_helper.C.

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

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

◆ get_sideset_data_indices()

void libMesh::ExodusII_IO_Helper::get_sideset_data_indices	(	const MeshBase &	mesh,
		std::map< BoundaryInfo::BCTuple, unsigned int > &	bc_array_indices
	)

inherited

Similar to read_sideset_data(), but instead of creating one std::map per sideset per variable, creates a single map of (elem, side, boundary_id) tuples, and stores the exo file array indexing for any/all sideset variables on that sideset (they are all the same).

This function does not actually call exII::ex_get_sset_var() to get values, and can be useful if only the original ordering of (elem, side) pairs in the exo file is required in cases where a separate approach is used to read the sideset data arrays.

Definition at line 4425 of file exodusII_io_helper.C.

{
  // Clear any existing data, we are going to build this data structure from scratch
  bc_array_indices.clear();
 
  // Store the sideset data array indices.
  //
  // 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.
  int offset=0;
  for (int ss=0; ss<num_side_sets; ++ss)
    {
      offset += (ss > 0 ? num_sides_per_set[ss-1] : 0);
      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;
 
          // Conversion operator for this Elem type
          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);
 
          // 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) tuple with corresponding array index
          bc_array_indices.emplace(key, cast_int<unsigned int>(i));
        } // end for (i)
    } // end for (ss)
}

References libMesh::ExodusII_IO_Helper::elem_list, libMesh::MeshBase::elem_ptr(), libMesh::ExodusII_IO_Helper::get_conversion(), mesh, libMesh::ExodusII_IO_Helper::num_side_sets, libMesh::ExodusII_IO_Helper::num_sides_per_set, libMesh::ExodusII_IO_Helper::side_list, libMesh::ExodusII_IO_Helper::ss_ids, and libMesh::Elem::type().

◆ get_ss_param_global()

void libMesh::Nemesis_IO_Helper::get_ss_param_global ( )

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

Definition at line 174 of file nemesis_io_helper.C.

{
  if (num_side_sets_global > 0)
    {
      global_sideset_ids.resize(num_side_sets_global);
      num_global_side_counts.resize(num_side_sets_global);
 
      // df = "distribution factor", not really sure what that is.  I don't yet have a file
      // which has distribution factors so I guess we'll worry about it later...
      num_global_side_df_counts.resize(num_side_sets_global);
 
      nemesis_err_flag =
        Nemesis::ne_get_ss_param_global(ex_id,
                                        global_sideset_ids.data(),
                                        num_global_side_counts.data(),
                                        num_global_side_df_counts.data());
      EX_CHECK_ERR(nemesis_err_flag, "Error reading global sideset parameters!");
 
      if (verbose)
        {
          libMesh::out << "[" << this->processor_id() << "] " << "Global Sideset IDs, Side Counts, and DF counts:" << std::endl;
          for (auto bn : index_range(global_sideset_ids))
            {
              libMesh::out << "  [" << this->processor_id() << "] "
                           << "global_sideset_ids["<<bn<<"]=" << global_sideset_ids[bn]
                           << ", num_global_side_counts["<<bn<<"]=" << num_global_side_counts[bn]
                           << ", num_global_side_df_counts["<<bn<<"]=" << num_global_side_df_counts[bn]
                           << std::endl;
            }
        }
    }
}

References libMesh::ExodusII_IO_Helper::ex_id, global_sideset_ids, libMesh::index_range(), nemesis_err_flag, num_global_side_counts, num_global_side_df_counts, num_side_sets_global, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

◆ init_conversion_map()

void libMesh::ExodusII_IO_Helper::init_conversion_map ( )

privateinherited

Definition at line 340 of file exodusII_io_helper.C.

{
  auto convert_type = [this](ElemType type,
                             std::string_view exodus_type,
                             const std::vector<int> * node_map = nullptr,
                             const std::vector<int> * inverse_node_map = nullptr,
                             const std::vector<int> * side_map = nullptr,
                             const std::vector<int> * inverse_side_map = nullptr,
                             const std::vector<int> * shellface_map = nullptr,
                             const std::vector<int> * inverse_shellface_map = nullptr,
                             size_t shellface_index_offset = 0)
  {
    std::unique_ptr<Elem> elem = Elem::build(type);
    auto & conv = conversion_map[elem->dim()][type];
    conv.libmesh_type = type;
    conv.exodus_type = exodus_type;
    conv.node_map = node_map;
    conv.inverse_node_map = inverse_node_map;
    conv.side_map = side_map;
    conv.inverse_side_map = inverse_side_map;
    conv.shellface_map = shellface_map;
    conv.inverse_shellface_map = inverse_shellface_map;
    conv.shellface_index_offset = shellface_index_offset;
    conv.n_nodes = elem->n_nodes();
    for (int d = elem->dim()+1; d <= 3; ++d)
      conversion_map[d][type] = conv;
  };
 
  convert_type(NODEELEM, "SPHERE");
  convert_type(EDGE2, "EDGE2");
  convert_type(EDGE3, "EDGE3");
  convert_type(EDGE4, "EDGE4");
  convert_type(QUAD4, "QUAD4");
  convert_type(QUAD8, "QUAD8");
  convert_type(QUAD9, "QUAD9");
  convert_type(C0POLYGON, "NSIDED");
  {
    auto & conv = conversion_map[3][C0POLYHEDRON];
    conv.libmesh_type = C0POLYHEDRON;
    conv.exodus_type = "NFACED";
    conv.dim = 3;
    conv.n_nodes = 0;
  }
  convert_type(QUADSHELL4, "SHELL4", nullptr, nullptr, nullptr,
               /* inverse_side_map = */ &quadshell4_inverse_edge_map,
               nullptr, nullptr, /* shellface_index_offset = */ 2);
  convert_type(QUADSHELL8, "SHELL8", nullptr, nullptr, nullptr,
               /* inverse_side_map = */ &quadshell4_inverse_edge_map,
               nullptr, nullptr, /* shellface_index_offset = */ 2);
  convert_type(QUADSHELL9, "SHELL9", nullptr, nullptr, nullptr,
               /* inverse_side_map = */ &quadshell4_inverse_edge_map,
               nullptr, nullptr, /* shellface_index_offset = */ 2);
 
  convert_type(TRI3, "TRI3");
  convert_type(TRI6, "TRI6");
  convert_type(TRI7, "TRI7");
  // Exodus does weird things to triangle side mapping in 3D.  See
  // https://sandialabs.github.io/seacas-docs/html/element_types.html#tri
  conversion_map[3][TRI3].inverse_side_map = &trishell3_inverse_edge_map;
  conversion_map[3][TRI3].shellface_index_offset = 2;
  conversion_map[3][TRI6].inverse_side_map = &trishell3_inverse_edge_map;
  conversion_map[3][TRI6].shellface_index_offset = 2;
  conversion_map[3][TRI7].inverse_side_map = &trishell3_inverse_edge_map;
  conversion_map[3][TRI7].shellface_index_offset = 2;
 
  convert_type(TRISHELL3, "TRISHELL3", nullptr, nullptr, nullptr,
               /* inverse_side_map = */ &trishell3_inverse_edge_map,
               nullptr, nullptr, /* shellface_index_offset = */ 2);
  convert_type(TRI3SUBDIVISION, "TRI3");
  convert_type(HEX8, "HEX8", nullptr, nullptr,
               &hex_face_map, &hex_inverse_face_map);
  convert_type(HEX20, "HEX20", nullptr, nullptr,
               &hex_face_map, &hex_inverse_face_map);
  convert_type(HEX27, "HEX27", &hex27_node_map,
               &hex27_inverse_node_map,
               &hex_face_map, &hex_inverse_face_map);
  convert_type(TET4, "TETRA4", nullptr, nullptr,
               &tet_face_map, &tet_inverse_face_map);
  convert_type(TET10, "TETRA10", nullptr, nullptr,
               &tet_face_map, &tet_inverse_face_map);
  convert_type(TET14, "TETRA14", &tet14_node_map,
               &tet14_inverse_node_map,
               &tet_face_map, &tet_inverse_face_map);
  convert_type(PRISM6, "WEDGE", nullptr, nullptr,
               &prism_face_map, &prism_inverse_face_map);
  convert_type(PRISM15, "WEDGE15", nullptr, nullptr,
               &prism_face_map, &prism_inverse_face_map);
  convert_type(PRISM18, "WEDGE18", nullptr, nullptr,
               &prism_face_map, &prism_inverse_face_map);
  convert_type(PRISM20, "WEDGE20", &prism20_node_map,
               &prism20_inverse_node_map,
               &prism_face_map, &prism_inverse_face_map);
  convert_type(PRISM21, "WEDGE21", &prism21_node_map,
               &prism21_inverse_node_map,
               &prism_face_map, &prism_inverse_face_map);
  convert_type(PYRAMID5, "PYRAMID5");
  convert_type(PYRAMID13, "PYRAMID13");
  convert_type(PYRAMID14, "PYRAMID14");
  convert_type(PYRAMID18, "PYRAMID18");
}

References libMesh::Elem::build(), libMesh::C0POLYGON, libMesh::C0POLYHEDRON, libMesh::ExodusII_IO_Helper::conversion_map, libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM20, libMesh::PRISM21, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID18, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::QUADSHELL9, libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI3SUBDIVISION, libMesh::TRI6, libMesh::TRI7, and libMesh::TRISHELL3.

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

◆ init_element_equivalence_map()

void libMesh::ExodusII_IO_Helper::init_element_equivalence_map ( )

privateinherited

Definition at line 445 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;
 
  // EDGE4 equivalences
  element_equivalence_map["EDGE4"]  = EDGE4;
  element_equivalence_map["TRUSS4"] = EDGE4;
  element_equivalence_map["BEAM4"]  = EDGE4;
  element_equivalence_map["BAR4"]   = EDGE4;
 
  // This whole design is going to need to be refactored whenever we
  // support higher-order IGA, with one element type having variable
  // polynomiaal degree...
  element_equivalence_map["BEX_CURVE"] = 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;
  // This only supports p==2 IGA:
  element_equivalence_map["BEX_QUAD"]  = QUAD9;
 
  // QUADSHELL9 equivalences
  element_equivalence_map["SHELL9"] = QUADSHELL9;
 
  // Runtime-topology polytope equivalences
  element_equivalence_map["NSIDED"] = C0POLYGON;
  element_equivalence_map["NFACED"] = C0POLYHEDRON;
 
  // 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;
  // This only supports p==2 IGA:
  element_equivalence_map["BEX_TRIANGLE"] = TRI6;
 
  // TRI7 equivalences
  element_equivalence_map["TRI7"]      = TRI7;
 
  // 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;
  // This only supports p==2 IGA:
  element_equivalence_map["BEX_HEX"] = HEX27;
 
  // TET4 equivalences
  element_equivalence_map["TETRA"]  = TET4;
  element_equivalence_map["TETRA4"] = TET4;
 
  // TET10 equivalences
  element_equivalence_map["TETRA10"] = TET10;
  // This only supports p==2 IGA:
  element_equivalence_map["BEX_TETRA"] = TET10;
 
  // TET14 (in Exodus 8) equivalence
  element_equivalence_map["TETRA14"] = TET14;
 
  // PRISM6 equivalences
  element_equivalence_map["WEDGE"] = PRISM6;
  element_equivalence_map["WEDGE6"] = PRISM6;
 
  // PRISM15 equivalences
  element_equivalence_map["WEDGE15"] = PRISM15;
 
  // PRISM18 equivalences
  element_equivalence_map["WEDGE18"] = PRISM18;
  // This only supports p==2 IGA:
  element_equivalence_map["BEX_WEDGE"] = PRISM18;
 
  // PRISM20 equivalences
  element_equivalence_map["WEDGE20"] = PRISM20;
 
  // PRISM21 equivalences
  element_equivalence_map["WEDGE21"] = PRISM21;
 
  // PYRAMID equivalences
  element_equivalence_map["PYRAMID"]  = PYRAMID5;
  element_equivalence_map["PYRAMID5"] = PYRAMID5;
  element_equivalence_map["PYRAMID13"] = PYRAMID13;
  element_equivalence_map["PYRAMID14"] = PYRAMID14;
  element_equivalence_map["PYRAMID18"] = PYRAMID18;
}

References libMesh::C0POLYGON, libMesh::C0POLYHEDRON, libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::ExodusII_IO_Helper::element_equivalence_map, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM20, libMesh::PRISM21, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID18, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::QUADSHELL9, libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, and libMesh::TRISHELL3.

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

◆ initialize()

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

overridevirtual

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

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 754 of file nemesis_io_helper.C.

{
  // Make sure that the reference passed in is really a DistributedMesh
  // const DistributedMesh & pmesh = cast_ref<const DistributedMesh &>(mesh);
  const MeshBase & pmesh = mesh;
 
  // If _write_as_dimension is nonzero, use it to set num_dim later 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();
 
  // According to Nemesis documentation, first call when writing should be to
  // ne_put_init_info().  Our reader doesn't actually call this, but we should
  // strive to be as close to a normal nemesis file as possible...
  this->put_init_info(this->n_processors(), 1, "p");
 
 
  // Gather global "initial" information for Nemesis.  This consists of
  // three parts labeled I, II, and III below...
 
  //
  // I.) Need to compute the number of global element blocks.  To be consistent with
  // Exodus, we also incorrectly associate the number of element blocks with the
  // number of libmesh subdomains...
  //
  this->compute_num_global_elem_blocks(pmesh);
 
  //
  // II.) Determine the global number of nodesets by communication.
  // This code relies on BoundaryInfo storing side and node
  // boundary IDs separately at the time they are added to the
  // BoundaryInfo object.
  //
  this->compute_num_global_nodesets(pmesh);
 
  //
  // III.) Need to compute the global number of sidesets by communication:
  // This code relies on BoundaryInfo storing side and node
  // boundary IDs separately at the time they are added to the
  // BoundaryInfo object.
  //
  this->compute_num_global_sidesets(pmesh);
 
  // Now write the global data obtained in steps I, II, and III to the Nemesis file
  this->put_init_global(pmesh.parallel_n_nodes(),
                        pmesh.parallel_n_elem(),
                        this->num_elem_blks_global, /* I.   */
                        this->num_node_sets_global, /* II.  */
                        this->num_side_sets_global  /* III. */
                        );
 
  // Next, we'll write global element block information to the file.  This was already
  // gathered in step I. above
  this->put_eb_info_global(this->global_elem_blk_ids,
                           this->global_elem_blk_cnts);
 
 
  // Next, write global nodeset information to the file.  This was already gathered in
  // step II. above.
  this->num_global_node_df_counts.clear();
  this->num_global_node_df_counts.resize(this->global_nodeset_ids.size()); // distribution factors all zero...
  this->put_ns_param_global(this->global_nodeset_ids,
                            this->num_global_node_counts,
                            this->num_global_node_df_counts);
 
 
  // Next, write global sideset information to the file.  This was already gathered in
  // step III. above.
  this->num_global_side_df_counts.clear();
  this->num_global_side_df_counts.resize(this->global_sideset_ids.size()); // distribution factors all zero...
  this->put_ss_param_global(this->global_sideset_ids,
                            this->num_global_side_counts,
                            this->num_global_side_df_counts);
 
 
  // Before we go any further we need to derive consistent node and
  // element numbering schemes for all local elems and nodes connected
  // to local elements.
  //
  // Must be called *after* the local_subdomain_counts map has been constructed
  // by the compute_num_global_elem_blocks() function!
  this->build_element_and_node_maps(pmesh);
 
  // Next step is to write "load balance" parameters.  Several things need to
  // be computed first though...
 
  // First we'll collect IDs of border nodes.
  this->compute_border_node_ids(pmesh);
 
  // Next we'll collect numbers of internal and border elements, and internal nodes.
  // Note: "A border node does not a border element make...", that is, just because one
  // of an element's nodes has been identified as a border node, the element is not
  // necessarily a border element.  It must have a side on the boundary between processors,
  // i.e. have a face neighbor with a different processor id...
  this->compute_internal_and_border_elems_and_internal_nodes(pmesh);
 
  // Finally we are ready to write the loadbal information to the file
  this->put_loadbal_param(this->num_internal_nodes,
                          this->num_border_nodes,
                          this->num_external_nodes,
                          this->num_internal_elems,
                          this->num_border_elems,
                          this->num_node_cmaps,
                          this->num_elem_cmaps);
 
 
  // Now we need to compute the "communication map" parameters.  These are basically
  // lists of nodes and elements which need to be communicated between different processors
  // when the mesh file is read back in.
  this->compute_communication_map_parameters();
 
  // Write communication map parameters to file.
  this->put_cmap_params(this->node_cmap_ids,
                        this->node_cmap_node_cnts,
                        this->elem_cmap_ids,
                        this->elem_cmap_elem_cnts);
 
  // Ready the node communication maps.  The node IDs which
  // are communicated are the ones currently stored in
  // proc_nodes_touched_intersections.
  this->compute_node_communication_maps();
 
  // Write the packed node communication vectors to file.
  this->put_node_cmap(this->node_cmap_node_ids,
                      this->node_cmap_proc_ids);
 
  // Ready the node maps.  These have nothing to do with communication, they map
  // the nodes to internal, border, and external nodes in the file.
  this->compute_node_maps();
 
  // Call the Nemesis API to write the node maps to file.
  this->put_node_map(this->node_mapi,
                     this->node_mapb,
                     this->node_mape);
 
  // Ready the element communication maps.  This includes border
  // element IDs, sides which are on the border, and the processors to which
  // they are to be communicated...
  this->compute_elem_communication_maps();
 
  // Call the Nemesis API to write the packed element communication maps vectors to file
  this->put_elem_cmap(this->elem_cmap_elem_ids,
                      this->elem_cmap_side_ids,
                      this->elem_cmap_proc_ids);
 
  // Ready the Nemesis element maps (internal and border) for writing to file.
  this->compute_element_maps();
 
  // Call the Nemesis API to write the internal and border element IDs.
  this->put_elem_map(this->elem_mapi,
                     this->elem_mapb);
 
  // Now write Exodus-specific initialization information, some of which is
  // different when you are using Nemesis.
  this->write_exodus_initialization_info(pmesh, title_in);
} // end initialize()

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

◆ initialize_element_variables()

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

overridevirtual

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

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 2582 of file nemesis_io_helper.C.

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

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

◆ initialize_global_variables()

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

inherited

Sets up the global variables.

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

◆ initialize_nodal_variables()

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

inherited

Sets up the nodal variables.

Definition at line 3968 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 libMesh::ExodusII_IO_Helper::_nodal_vars_initialized, libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::check_existing_vars(), libMesh::ExodusII_IO_Helper::NODAL, libMesh::ExodusII_IO_Helper::nodal_var_names, libMesh::ExodusII_IO_Helper::num_nodal_vars, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::write_var_names().

◆ message() [1/2]

void libMesh::ExodusII_IO_Helper::message ( std::string_view msg )

inherited

Prints the message defined in msg.

Can be turned off if verbosity is set to 0.

Definition at line 593 of file exodusII_io_helper.C.

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

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

◆ message() [2/2]

void libMesh::ExodusII_IO_Helper::message	(	std::string_view	msg,
		int	i
	)

inherited

Prints the message defined in msg, and appends the number i to the end of the message.

Useful for printing messages in loops. Can be turned off if verbosity is set to 0.

Definition at line 600 of file exodusII_io_helper.C.

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

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

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 103 of file parallel_object.h.

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

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

◆ node_id_to_vec_id()

dof_id_type libMesh::ExodusII_IO_Helper::node_id_to_vec_id ( dof_id_type n ) const

inlineinherited

Definition at line 966 of file exodusII_io_helper.h.

  {
    if (_added_side_node_offsets.empty())
      return n;
 
    // Find the processor id that has node_id in the parallel vec
    const auto lb = std::upper_bound(_true_node_offsets.begin(),
                                     _true_node_offsets.end(), n);
    libmesh_assert(lb != _true_node_offsets.end());
    const processor_id_type p = lb - _true_node_offsets.begin();
 
    return n + (p ? _added_side_node_offsets[p-1] : 0);
  }

References libMesh::ExodusII_IO_Helper::_added_side_node_offsets, libMesh::ExodusII_IO_Helper::_true_node_offsets, and libMesh::libmesh_assert().

◆ open()

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

inherited

Opens an ExodusII mesh file named filename.

If read_only==true, the file will be opened with the EX_READ flag, otherwise it will be opened with the EX_WRITE flag.

Definition at line 692 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;
 
  {
    FPEDisabler disable_fpes;
    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 we're writing then we'll want to use the specified length;
  // if we're reading then we'll override this by what's in the file.
  int max_name_length_to_set = _max_name_length;
 
  if (read_only)
  {
    opened_for_reading = true;
    elem_node_counts.clear();
    elem_face_counts.clear();
    c0polyhedron_face_connect.clear();
 
    // ExodusII reads truncate to 32-char strings by default; we'd
    // like to support whatever's in the file, so as early as possible
    // let's find out what that is.
    int max_name_length = exII::ex_inquire_int(ex_id, exII::EX_INQ_DB_MAX_USED_NAME_LENGTH);
 
    libmesh_error_msg_if(max_name_length > MAX_LINE_LENGTH,
                         "Unexpected maximum name length of " <<
                         max_name_length << " in file " << filename <<
                         " exceeds expected " << MAX_LINE_LENGTH);
 
    // I don't think the 32 here should be necessary, but let's make
    // sure we don't accidentally make things *worse* for anyone.
    max_name_length_to_set = std::max(max_name_length, 32);
  }
  else
    opened_for_writing = true;
 
  ex_err = exII::ex_set_max_name_length(ex_id, max_name_length_to_set);
  EX_CHECK_ERR(ex_err, "Error setting max ExodusII name length.");
 
  current_filename = std::string(filename);
}

◆ print_header()

void libMesh::ExodusII_IO_Helper::print_header ( )

inherited

Prints the ExodusII mesh file header, which includes the mesh title, the number of nodes, number of elements, mesh dimension, number of sidesets, and number of nodesets.

Definition at line 889 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
                 << "Number of elem sets: \t" << num_elem_sets << std::endl;
}

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

◆ print_nodes()

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

inherited

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

Definition at line 1091 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 libMesh::ExodusII_IO_Helper::num_nodes, libMesh::ExodusII_IO_Helper::x, libMesh::ExodusII_IO_Helper::y, and libMesh::ExodusII_IO_Helper::z.

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

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

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

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

◆ put_cmap_params()

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

Outputs initial information for communication maps.

Note: The order of the arguments specified in the Nemesis User's Manual is wrong. The correct order is (ids, counts, ids, counts). Must be called after put_loadbal_param().

Definition at line 639 of file nemesis_io_helper.C.

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

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

Referenced by initialize().

◆ put_eb_info_global()

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

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

Must be called after put_init_global().

Definition at line 559 of file nemesis_io_helper.C.

{
  nemesis_err_flag =
    Nemesis::ne_put_eb_info_global(ex_id,
                                   global_elem_blk_ids_in.data(),
                                   global_elem_blk_cnts_in.data());
 
  EX_CHECK_ERR(nemesis_err_flag, "Error writing global element block information!");
}

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

Referenced by initialize().

◆ put_elem_cmap()

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

Writes information about elemental communication map.

Note: This class contains elem_cmap_elem_ids, elem_cmap_side_ids, abd elem_cmap_proc_ids which can be used when calling this function.

Must be called after put_cmap_params().

Definition at line 719 of file nemesis_io_helper.C.

{
  for (auto i : index_range(elem_cmap_ids))
    {
      nemesis_err_flag =
        Nemesis::ne_put_elem_cmap(ex_id,
                                  this->elem_cmap_ids[i],
                                  elem_cmap_elem_ids_in[i].data(),
                                  elem_cmap_side_ids_in[i].data(),
                                  elem_cmap_proc_ids_in[i].data(),
                                  this->processor_id());
 
      EX_CHECK_ERR(nemesis_err_flag, "Error writing elem communication map to file!");
    }
}

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

Referenced by initialize().

◆ put_elem_map()

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

Outputs IDs of internal and border elements.

Must be called after ne_put_loadbal_param().

Definition at line 740 of file nemesis_io_helper.C.

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

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

Referenced by initialize().

◆ put_init_global()

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

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

Definition at line 540 of file nemesis_io_helper.C.

{
  nemesis_err_flag =
    Nemesis::ne_put_init_global(ex_id,
                                num_nodes_global_in,
                                num_elems_global_in,
                                num_elem_blks_global_in,
                                num_node_sets_global_in,
                                num_side_sets_global_in);
 
  EX_CHECK_ERR(nemesis_err_flag, "Error writing initial global data!");
}

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

Referenced by initialize().

◆ put_init_info()

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

Writing functions.

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

Definition at line 524 of file nemesis_io_helper.C.

{
  nemesis_err_flag =
    Nemesis::ne_put_init_info(ex_id,
                              num_proc_in,
                              num_proc_in_file_in,
                              const_cast<char *>(ftype_in));
 
  EX_CHECK_ERR(nemesis_err_flag, "Error writing initial information!");
}

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

Referenced by initialize().

◆ put_loadbal_param()

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

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

.) processor - ID of the processor for which information is to be written

Definition at line 613 of file nemesis_io_helper.C.

{
  nemesis_err_flag =
    Nemesis::ne_put_loadbal_param(ex_id,
                                  num_internal_nodes_in,
                                  num_border_nodes_in,
                                  num_external_nodes_in,
                                  num_internal_elems_in,
                                  num_border_elems_in,
                                  num_node_cmaps_in,
                                  num_elem_cmaps_in,
                                  this->processor_id());
 
  EX_CHECK_ERR(nemesis_err_flag, "Error writing loadbal parameters!");
}

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

Referenced by initialize().

◆ put_node_cmap()

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

Outputs all of the nodal communication maps for this processor.

Internally, this function loops over all communication maps and calls Nemesis::ne_put_node_cmap() for each one.

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

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

Note: This class contains node_cmap_node_ids and node_cmap_proc_ids which can be used when calling this function.

Must be called after put_cmap_params().

Definition at line 658 of file nemesis_io_helper.C.

{
  // Print to screen what we are about to print to Nemesis file
  if (verbose)
    {
      for (auto i : index_range(node_cmap_node_ids_in))
        {
          libMesh::out << "[" << this->processor_id() << "] put_node_cmap() : nodes communicated to proc "
                       << this->node_cmap_ids[i]
                       << " = ";
          for (const auto & node_id : node_cmap_node_ids_in[i])
            libMesh::out << node_id << " ";
          libMesh::out << std::endl;
        }
 
      for (auto i : index_range(node_cmap_node_ids_in))
        {
          libMesh::out << "[" << this->processor_id() << "] put_node_cmap() : processor IDs = ";
          for (const auto & proc_id : node_cmap_proc_ids_in[i])
            libMesh::out << proc_id << " ";
          libMesh::out << std::endl;
        }
    }
 
  for (auto i : index_range(node_cmap_node_ids_in))
    {
      int * node_ids_ptr = node_cmap_node_ids_in[i].empty() ?
        nullptr : node_cmap_node_ids_in[i].data();
      int * proc_ids_ptr = node_cmap_proc_ids_in[i].empty() ?
        nullptr : node_cmap_proc_ids_in[i].data();
 
      nemesis_err_flag =
        Nemesis::ne_put_node_cmap(ex_id, this->node_cmap_ids[i],
                                  node_ids_ptr, proc_ids_ptr,
                                  this->processor_id());
 
      EX_CHECK_ERR(nemesis_err_flag, "Error writing node communication map to file!");
    }
}

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

Referenced by initialize().

◆ put_node_map()

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

Outputs IDs of internal, border, and external nodes.

LibMesh asserts that the number of external nodes is zero in the Nemesis files it reads

Definition at line 702 of file nemesis_io_helper.C.

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

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

Referenced by initialize().

◆ put_ns_param_global()

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

This function writes information about global node sets.

.) global_nodeset_ids - vector of global node set IDs .) num_global_node_counts - vector of global node counts contained in each global node set .) num_global_df_count - vector of global distribution factors in each global node set

Must be called after put_init_global()

Definition at line 573 of file nemesis_io_helper.C.

{
  // Only add nodesets if there are some
  if (global_nodeset_ids.size())
    {
      nemesis_err_flag =
        Nemesis::ne_put_ns_param_global(ex_id,
                                        global_nodeset_ids_in.data(),
                                        num_global_node_counts_in.data(),
                                        num_global_node_df_counts_in.data());
    }
 
  EX_CHECK_ERR(nemesis_err_flag, "Error writing global nodeset parameters!");
}

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

Referenced by initialize().

◆ put_ss_param_global()

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

This function writes information about global side sets.

.) global_sideset_ids - vector of global side set IDs .) num_global_side_counts - vector of global side counts contained in each global side set .) num_global_df_count - vector of global distribution factors in each global side set

Must be called after put_init_global()

Definition at line 593 of file nemesis_io_helper.C.

{
  // Only add sidesets if there are some
  if (global_sideset_ids.size())
    {
      nemesis_err_flag =
        Nemesis::ne_put_ss_param_global(ex_id,
                                        global_sideset_ids_in.data(),
                                        num_global_side_counts_in.data(),
                                        num_global_side_df_counts_in.data());
    }
 
  EX_CHECK_ERR(nemesis_err_flag, "Error writing global sideset parameters!");
}

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

Referenced by initialize().

◆ read_all_nodesets()

void libMesh::ExodusII_IO_Helper::read_all_nodesets ( )

inherited

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

{
  LOG_SCOPE("read_all_nodesets()", "ExodusII_IO_Helper");
 
  // Figure out how many nodesets there are in the file so we can
  // properly resize storage as necessary.
  num_node_sets =
    inquire
    (*this, 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 =
    inquire
    (*this, 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 =
    inquire
    (*this, 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);
 
  // Handle single-precision files
  MappedInputVector mapped_node_sets_dist_fact(node_sets_dist_fact, _single_precision);
 
  // Build exII::ex_set_spec struct
  exII::ex_set_specs set_specs = {};
  set_specs.sets_ids            = nodeset_ids.data();
  set_specs.num_entries_per_set = num_nodes_per_set.data();
  set_specs.num_dist_per_set    = num_node_df_per_set.data();
  set_specs.sets_entry_index    = node_sets_node_index.data();
  set_specs.sets_dist_index     = node_sets_dist_index.data();
  set_specs.sets_entry_list     = node_sets_node_list.data();
  set_specs.sets_extra_list     = nullptr;
  set_specs.sets_dist_fact      = total_df_in_all_sets ? mapped_node_sets_dist_fact.data() : nullptr;
 
  ex_err = exII::ex_get_concat_sets(ex_id, exII::EX_NODE_SET, &set_specs);
  EX_CHECK_ERR(ex_err, "Error reading concatenated nodesets");
 
  // Read the nodeset names from file!
  char name_buffer[libmesh_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;
    }
}

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

◆ read_and_store_header_info()

void libMesh::ExodusII_IO_Helper::read_and_store_header_info ( )

inherited

Reads an ExodusII mesh file header, and stores required information on this object.

Definition at line 794 of file exodusII_io_helper.C.

{
  // Read header params from file, storing them in this class's
  // ExodusHeaderInfo struct.  This automatically updates the local
  // num_dim, num_elem, etc. references.
  this->header_info = this->read_header();
 
  // Read the number of timesteps which are present in the file
  this->read_num_time_steps();
 
  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_NODAL, &num_nodal_vars);
  EX_CHECK_ERR(ex_err, "Error reading number of nodal variables.");
 
  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_ELEM_BLOCK, &num_elem_vars);
  EX_CHECK_ERR(ex_err, "Error reading number of elemental variables.");
 
  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_GLOBAL, &num_global_vars);
  EX_CHECK_ERR(ex_err, "Error reading number of global variables.");
 
  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_SIDE_SET, &num_sideset_vars);
  EX_CHECK_ERR(ex_err, "Error reading number of sideset variables.");
 
  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_NODE_SET, &num_nodeset_vars);
  EX_CHECK_ERR(ex_err, "Error reading number of nodeset variables.");
 
  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_ELEM_SET, &num_elemset_vars);
  EX_CHECK_ERR(ex_err, "Error reading number of elemset variables.");
 
  message("Exodus header info retrieved successfully.");
}

◆ read_bex_cv_blocks()

void libMesh::ExodusII_IO_Helper::read_bex_cv_blocks ( )

inherited

Reads the optional bex_cv_blocks from the ExodusII mesh file.

Definition at line 979 of file exodusII_io_helper.C.

{
  // If a bex blob exists, we look for Bezier Extraction coefficient
  // data there.
 
  // These APIs require newer Exodus than 5.22
#if EX_API_VERS_NODOT >= 800
  int n_blobs = exII::ex_inquire_int(ex_id, exII::EX_INQ_BLOB);
 
  if (n_blobs > 0)
    {
      std::vector<exII::ex_blob> blobs(n_blobs);
      std::vector<std::vector<char>> blob_names(n_blobs);
      for (auto i : make_range(n_blobs))
        {
          blob_names[i].resize(libmesh_max_str_length+1);
          blobs[i].name = blob_names[i].data();
        }
 
      ex_err = exII::ex_get_blobs(ex_id, blobs.data());
      EX_CHECK_ERR(ex_err, "Error getting blobs.");
 
      bool found_blob = false;
      const exII::ex_blob * my_blob = &blobs[0];
      for (const auto & blob : blobs)
        {
          if (std::string("bex_cv_blob") == blob.name)
            {
              found_blob = true;
              my_blob = &blob;
            }
        }
 
      if (!found_blob)
        libmesh_error_msg("Found no bex_cv_blob for bezier elements");
 
      const int n_blob_attr =
        exII::ex_get_attribute_count(ex_id, exII::EX_BLOB,
                                     my_blob->id);
 
      std::vector<exII::ex_attribute> attributes(n_blob_attr);
      ex_err = exII::ex_get_attribute_param(ex_id, exII::EX_BLOB,
                                            my_blob->id,
                                            attributes.data());
      EX_CHECK_ERR(ex_err, "Error getting bex blob attribute parameters.");
 
      int bex_num_dense_cv_blocks = 0;
      std::vector<int> bex_dense_cv_info;
      for (auto & attr : attributes)
        {
          if (std::string("bex_dense_cv_info") == attr.name)
            {
              const std::size_t value_count = attr.value_count;
              if (value_count % 2)
                libmesh_error_msg("Found odd number of bex_dense_cv_info");
 
              bex_dense_cv_info.resize(value_count);
              attr.values = bex_dense_cv_info.data();
              exII::ex_get_attribute(ex_id, &attr);
 
              bex_num_dense_cv_blocks = value_count / 2;
 
              libmesh_error_msg_if(bex_num_dense_cv_blocks > 1,
                                   "Found more than 1 dense bex CV block; unsure how to handle that");
            }
        }
 
      if (bex_dense_cv_info.empty())
        libmesh_error_msg("No bex_dense_cv_info found");
 
      int n_blob_vars;
      exII::ex_get_variable_param(ex_id, exII::EX_BLOB, &n_blob_vars);
      std::vector<char> var_name (libmesh_max_str_length + 1);
      for (auto v_id : make_range(1,n_blob_vars+1))
        {
          ex_err = exII::ex_get_variable_name(ex_id, exII::EX_BLOB, v_id, var_name.data());
          EX_CHECK_ERR(ex_err, "Error reading bex blob var name.");
 
          if (std::string("bex_dense_cv_blocks") == var_name.data())
            {
              std::vector<double> bex_dense_cv_blocks(my_blob->num_entry);
 
              ex_err = exII::ex_get_var(ex_id, 1, exII::EX_BLOB, v_id,
                                        my_blob->id, my_blob->num_entry,
                                        bex_dense_cv_blocks.data());
              EX_CHECK_ERR(ex_err, "Error reading bex_dense_cv_blocks.");
 
              bex_dense_constraint_vecs.clear();
              bex_dense_constraint_vecs.resize(bex_num_dense_cv_blocks);
 
              std::size_t offset = 0;
              for (auto i : IntRange<std::size_t>(0, bex_num_dense_cv_blocks))
                {
                  bex_dense_constraint_vecs[i].resize(bex_dense_cv_info[2*i]);
                  const int vecsize = bex_dense_cv_info[2*i+1];
                  for (auto & vec : bex_dense_constraint_vecs[i])
                    {
                      vec.resize(vecsize);
                      std::copy(std::next(bex_dense_cv_blocks.begin(), offset),
                                std::next(bex_dense_cv_blocks.begin(), offset + vecsize),
                                vec.begin());
                      offset += vecsize;
                    }
                }
              libmesh_assert(offset == bex_dense_cv_blocks.size());
            }
        }
    }
#endif // EX_API_VERS_NODOT >= 800
}

References libMesh::ExodusII_IO_Helper::bex_dense_constraint_vecs, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::libmesh_assert(), and libMesh::make_range().

◆ read_block_info()

void libMesh::ExodusII_IO_Helper::read_block_info ( )

inherited

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

Definition at line 1099 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[libmesh_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[libmesh_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 libMesh::ExodusII_IO_Helper::block_ids, libMesh::ExodusII_IO_Helper::edge_block_ids, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::id_to_block_names, libMesh::ExodusII_IO_Helper::id_to_edge_block_names, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::num_edge_blk, and libMesh::ExodusII_IO_Helper::num_elem_blk.

◆ read_edge_blocks()

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

inherited

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

Definition at line 1567 of file exodusII_io_helper.C.

{
  LOG_SCOPE("read_edge_blocks()", "ExodusII_IO_Helper");
 
  // 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. Since edge->key() is also not guaranteed to be
  // unique (though it is very unlikely for two distinct edges to have
  // the same key()), when we later look up an (elem_id, edge_id) pair
  // in the edge_map, we need to verify that the edge indeed matches
  // the searched edge by doing some further checks.
  typedef std::pair<dof_id_type, unsigned int> ElemEdgePair;
  std::unordered_map<dof_id_type, std::vector<ElemEdgePair>> edge_map;
  std::unique_ptr<Elem> edge_ptr;
  for (const auto & elem : mesh.element_ptr_range())
    for (auto e : elem->edge_index_range())
      {
        elem->build_edge_ptr(edge_ptr, e);
        dof_id_type edge_key = edge_ptr->key();
 
        // Creates vector if not already there
        auto & vec = edge_map[edge_key];
        vec.emplace_back(elem->id(), e);
 
        // If edge_ptr is a higher-order Elem (EDGE3 or higher) then also add
        // a map entry for the lower-order (EDGE2) element which has matching
        // vertices. This allows us to match lower-order edge blocks to edges
        // of higher-order 3D elems (e.g. HEX20, TET10) and simplifies the
        // definition of edge blocks.
        if (edge_ptr->default_order() != FIRST)
          {
            // Construct a temporary low-order edge so that we can compute its key()
            auto low_order_edge =
              Elem::build(Elem::first_order_equivalent_type(edge_ptr->type()));
 
            // Assign node pointers to low-order edge
            for (unsigned int v=0; v<edge_ptr->n_vertices(); ++v)
              low_order_edge->set_node(v, edge_ptr->node_ptr(v));
 
            // Compute the key for the temporary low-order edge we just built
            dof_id_type low_order_edge_key = low_order_edge->key();
 
            // Add this key to the map associated with the same (elem,
            // edge) pair as the higher-order edge
            auto & low_order_vec = edge_map[low_order_edge_key];
            low_order_vec.emplace_back(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 (auto [i, sz] = std::make_tuple(0u, 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)
                {
                  auto exodus_node_id = this->connect[i+n];
                  dof_id_type libmesh_node_id = this->get_libmesh_node_id(exodus_node_id);
                  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
              // will throw an error now.
              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
                  // nodes (possibly with different orientation) 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
                  mesh.elem_ptr(elem_edge_pair.first)->
                    build_edge_ptr(edge_ptr, elem_edge_pair.second);
 
                  // Determine whether this candidate edge is a "real" match,
                  // i.e. has the same nodes with a possibly different
                  // orientation. Note that here we only check that
                  // the vertices match regardless of how many nodes
                  // the edge has, which allows us to match a
                  // lower-order edge to a higher-order Elem.
                  bool is_match =
                    ((edge_ptr->node_id(0) == edge->node_id(0)) && (edge_ptr->node_id(1) == edge->node_id(1))) ||
                    ((edge_ptr->node_id(0) == edge->node_id(1)) && (edge_ptr->node_id(1) == edge->node_id(0)));
 
                  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
}

◆ read_elem_in_block()

void libMesh::ExodusII_IO_Helper::read_elem_in_block ( int block )

inherited

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

Definition at line 1322 of file exodusII_io_helper.C.

{
  LOG_SCOPE("read_elem_in_block()", "ExodusII_IO_Helper");
 
  libmesh_assert_less (block, block_ids.size());
  elem_node_counts.clear();
  elem_face_counts.clear();
 
  // 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;
  int num_node_data_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_node_data_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);
 
  // Nemesis uses "Empty" as the element type for blocks with no
  // elements on the current processor.  There is no element conversion
  // for that sentinel type, nor is one needed for an empty block.
  const bool is_bezier = is_bezier_elem(elem_type.data());
  const Conversion * conversion = nullptr;
  if (num_elem_this_blk || is_bezier)
    conversion = &get_conversion(std::string(elem_type.data()));
 
  const bool is_c0polygon =
    conversion && conversion->libmesh_elem_type() == C0POLYGON;
  const bool is_c0polyhedron =
    conversion && conversion->libmesh_elem_type() == C0POLYHEDRON;
 
  // Warn or error when 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 (is_c0polyhedron && !(num_edges_per_elem == 0) && !(num_edges_per_elem == -1))
    libmesh_error_msg("Error: Exodus NFACED element blocks with edge "
                      "connectivity are not currently supported.");
  else if (!(num_edges_per_elem == 0) && !(num_edges_per_elem == -1))
    libmesh_warning("Exodus files with extended edge connectivity not currently supported.");
  if (!is_c0polyhedron && !(num_faces_per_elem == 0) && !(num_faces_per_elem == -1))
    libmesh_warning("Exodus files with extended face connectivity not currently supported.");
 
  // If we have a Bezier element here, then we've packed constraint
  // vector connectivity at the end of the nodal connectivity, and
  // num_nodes_per_elem reflected both.
  if (is_bezier)
    {
      libmesh_assert(conversion);
      num_nodes_per_elem = conversion->n_nodes;
    }
  else if (is_c0polygon)
    {
      elem_node_counts.resize(num_elem_this_blk);
 
      if (!elem_node_counts.empty())
        {
          ex_err = exII::ex_get_entity_count_per_polyhedra
            (ex_id,
             exII::EX_ELEM_BLOCK,
             block_ids[block],
             elem_node_counts.data());
          EX_CHECK_ERR(ex_err, "Error reading polygon node counts");
        }
 
      int counted_nodes = 0;
      for (const auto count : elem_node_counts)
        counted_nodes += count;
 
      libmesh_error_msg_if(counted_nodes != num_node_data_per_elem,
                           "Error: Exodus NSIDED block "
                           << block_ids[block]
                           << " says it has " << num_node_data_per_elem
                           << " total node entries, but its per-element "
                           << "node counts sum to " << counted_nodes << ".");
 
      num_nodes_per_elem = 0;
    }
  else if (is_c0polyhedron)
    {
      if (c0polyhedron_face_connect.empty())
        this->read_face_blocks();
 
      elem_face_counts.resize(num_elem_this_blk);
 
      if (!elem_face_counts.empty())
        {
          ex_err = exII::ex_get_entity_count_per_polyhedra
            (ex_id,
             exII::EX_ELEM_BLOCK,
             block_ids[block],
             elem_face_counts.data());
          EX_CHECK_ERR(ex_err, "Error reading polyhedron face counts");
        }
 
      int counted_faces = 0;
      for (const auto count : elem_face_counts)
        counted_faces += count;
 
      libmesh_error_msg_if(counted_faces != num_faces_per_elem,
                           "Error: Exodus NFACED block "
                           << block_ids[block]
                           << " says it has " << num_faces_per_elem
                           << " total face entries, but its per-element "
                           << "face counts sum to " << counted_faces << ".");
 
      num_nodes_per_elem = 0;
    }
  else
    num_nodes_per_elem = num_node_data_per_elem;
 
  if (verbose)
    {
      libMesh::out << "Read a block of " << num_elem_this_blk
                   << " " << elem_type.data() << "(s)";
      if (is_c0polygon)
        libMesh::out << " having " << num_node_data_per_elem
                     << " total node entries.";
      else if (is_c0polyhedron)
        libMesh::out << " having " << num_faces_per_elem
                     << " total face entries.";
      else
        libMesh::out << " having " << num_nodes_per_elem
                     << " nodes per element.";
      libMesh::out << 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(is_c0polygon ?
                 num_node_data_per_elem :
                 is_c0polyhedron ?
                 num_faces_per_elem :
                 num_node_data_per_elem*num_elem_this_blk);
 
  if (!connect.empty())
    {
      ex_err = exII::ex_get_conn(ex_id,
                                 exII::EX_ELEM_BLOCK,
                                 block_ids[block],
                                 is_c0polyhedron ? nullptr : connect.data(),
                                 nullptr, // elem_edge_conn (unused)
                                 is_c0polyhedron ? connect.data() : nullptr);
 
      EX_CHECK_ERR(ex_err, "Error reading block connectivity.");
      message("Connectivity retrieved successfully for block: ", block);
    }
 
  // If we had any attributes for this block, check to see if some of
  // them were Bezier-extension attributes.
 
  // num_attr above is zero, not actually the number of block attributes?
  // ex_get_attr_param *also* gives me zero?  Really, Exodus?
#if EX_API_VERS_NODOT >= 800
  int real_n_attr = exII::ex_get_attribute_count(ex_id, exII::EX_ELEM_BLOCK, block_ids[block]);
  EX_CHECK_ERR(real_n_attr, "Error getting number of element block attributes.");
 
  if (real_n_attr > 0)
    {
      std::vector<exII::ex_attribute> attributes(real_n_attr);
 
      ex_err = exII::ex_get_attribute_param(ex_id, exII::EX_ELEM_BLOCK, block_ids[block], attributes.data());
      EX_CHECK_ERR(ex_err, "Error getting element block attribute parameters.");
 
      ex_err = exII::ex_get_attributes(ex_id, real_n_attr, attributes.data());
      EX_CHECK_ERR(ex_err, "Error getting element block attribute values.");
 
      for (auto attr : attributes)
        {
          if (std::string("bex_elem_degrees") == attr.name)
            {
              if (attr.type != exII::EX_INTEGER)
                libmesh_error_msg("Found non-integer bex_elem_degrees");
 
              if (attr.value_count > 3)
                libmesh_error_msg("Looking for at most 3 bex_elem_degrees; found " << attr.value_count);
 
              libmesh_assert(is_bezier);
 
              std::vector<int> bex_elem_degrees(3); // max dim
 
              const int * as_int = static_cast<int *>(attr.values);
              std::copy(as_int, as_int+attr.value_count, bex_elem_degrees.begin());
 
 
              // Right now Bezier extraction elements aren't possible
              // for p>2 and aren't useful for p<2, and we don't
              // support anisotropic p...
#ifndef NDEBUG
              libmesh_assert(conversion);
              for (auto d : IntRange<int>(0, conversion->dim))
                libmesh_assert_equal_to(bex_elem_degrees[d], 2);
#endif
            }
            // ex_get_attributes did a values=calloc(); free() is our job.
            if (attr.values)
              free(attr.values);
        }
    }
 
  if (is_bezier)
    {
      // We'd better have the number of cvs we expect
      if( num_node_data_per_elem > num_nodes_per_elem )
        bex_num_elem_cvs = num_node_data_per_elem / 2;
      else
        bex_num_elem_cvs = num_nodes_per_elem;
      libmesh_assert_greater_equal(bex_num_elem_cvs, 0);
 
      // The old connect vector is currently a mix of the expected
      // connectivity and any Bezier extraction connectivity;
      // disentangle that, if necessary.
      bex_cv_conn.resize(num_elem_this_blk);
      if (num_node_data_per_elem > num_nodes_per_elem)
        {
          std::vector<int> old_connect(bex_num_elem_cvs * num_elem_this_blk);
          old_connect.swap(connect);
          auto src = old_connect.data();
          auto dst = connect.data();
          for (auto e : IntRange<std::size_t>(0, num_elem_this_blk))
            {
              std::copy(src, src + bex_num_elem_cvs, dst);
              src += bex_num_elem_cvs;
              dst += bex_num_elem_cvs;
 
              bex_cv_conn[e].resize(bex_num_elem_cvs);
              std::copy(src, src + bex_num_elem_cvs,
                        bex_cv_conn[e].begin());
              src += bex_num_elem_cvs;
            }
        }
    }
 
#endif // EX_API_VERS_NODOT >= 800
}

◆ read_elem_num_map()

void libMesh::ExodusII_IO_Helper::read_elem_num_map ( )

inherited

Reads the optional node_num_map from the ExodusII mesh file.

Definition at line 1735 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 (num_elem)
    {
      // The elem_num_map may contain ids larger than num_elem.  In
      // other words, the elem_num_map is not necessarily just a
      // permutation of the "trivial" 1,2,3,...  mapping, it can
      // contain effectively "any" numbers. Therefore, to get
      // "_end_elem_id", we need to check what the max entry in the
      // elem_num_map is.
      auto it = std::max_element(elem_num_map.begin(), elem_num_map.end());
      _end_elem_id = *it;
    }
  else
    _end_elem_id = 0;
 
  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 libMesh::ExodusII_IO_Helper::_end_elem_id, libMesh::ExodusII_IO_Helper::elem_num_map, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::num_elem, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::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
	)

inherited

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

Definition at line 2329 of file exodusII_io_helper.C.

{
  LOG_SCOPE("read_elemental_var_values()", "ExodusII_IO_Helper");
 
  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_truth_table(ex_id, exII::EX_ELEM_BLOCK, 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_block(ex_id,
                                  exII::EX_ELEM_BLOCK,
                                  block_ids[i],
                                  /*elem_type=*/nullptr,
                                  &num_elem_this_blk,
                                  /*num_nodes_per_entry=*/nullptr,
                                  /*num_edges_per_entry=*/nullptr,
                                  /*num_faces_per_entry=*/nullptr,
                                  /*num_attr=*/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_var
        (ex_id,
         time_step,
         exII::EX_ELEM_BLOCK,
         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++)
        {
          // Determine the libmesh id of the element with zero-based
          // index "ex_el_num".  This function expects a one-based
          // index, so we add 1 to ex_el_num when we pass it in.
          auto libmesh_elem_id =
            this->get_libmesh_elem_id(ex_el_num + 1);
 
          // Store the elemental value in the map.
          elem_var_value_map[libmesh_elem_id] = block_elem_var_values[j];
 
          // Go to the next sequential element ID.
          ex_el_num++;
        }
    }
}

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

◆ read_elemset()

void libMesh::ExodusII_IO_Helper::read_elemset	(	int	id,
		int	offset
	)

inherited

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

Definition at line 1925 of file exodusII_io_helper.C.

{
  LOG_SCOPE("read_elemset()", "ExodusII_IO_Helper");
 
  libmesh_assert_less (id, elemset_ids.size());
  libmesh_assert_less (id, num_elems_per_set.size());
  libmesh_assert_less (id, num_elem_df_per_set.size());
  libmesh_assert_less_equal (offset, elemset_list.size());
 
  ex_err = exII::ex_get_set_param(ex_id,
                                  exII::EX_ELEM_SET,
                                  elemset_ids[id],
                                  &num_elems_per_set[id],
                                  &num_elem_df_per_set[id]);
  EX_CHECK_ERR(ex_err, "Error retrieving elemset parameters.");
  message("Parameters retrieved successfully for elemset: ", id);
 
 
  // It's OK for offset==elemset_list.size() as long as num_elems_per_set[id]==0
  // because in that case we don't actually read anything...
  #ifdef DEBUG
  if (static_cast<unsigned int>(offset) == elemset_list.size())
    libmesh_assert_equal_to (num_elems_per_set[id], 0);
  #endif
 
  // Don't call ex_get_set() unless there are actually elems there to get.
  // Exodus prints an annoying warning in DEBUG mode otherwise...
  if (num_elems_per_set[id] > 0)
    {
      ex_err = exII::ex_get_set(ex_id,
                                exII::EX_ELEM_SET,
                                elemset_ids[id],
                                &elemset_list[offset],
                                /*set_extra_list=*/nullptr);
      EX_CHECK_ERR(ex_err, "Error retrieving elemset data.");
      message("Data retrieved successfully for elemset: ", id);
 
      // Create vector containing elemset ids for each element in the set
      for (int i=0; i<num_elems_per_set[id]; i++)
        elemset_id_list[i+offset] = elemset_ids[id];
    }
}

References libMesh::ExodusII_IO_Helper::elemset_id_list, libMesh::ExodusII_IO_Helper::elemset_ids, libMesh::ExodusII_IO_Helper::elemset_list, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::num_elem_df_per_set, and libMesh::ExodusII_IO_Helper::num_elems_per_set.

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

◆ read_elemset_data()

void libMesh::ExodusII_IO_Helper::read_elemset_data	(	int	timestep,
		std::vector< std::string > &	var_names,
		std::vector< std::set< elemset_id_type > > &	elemset_ids_in,
		std::vector< std::map< std::pair< dof_id_type, elemset_id_type >, Real > > &	elemset_vals
	)

inherited

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

Definition at line 4701 of file exodusII_io_helper.C.

{
  LOG_SCOPE("read_elemset_data()", "ExodusII_IO_Helper");
 
  // This reads the elemset variable names into the local
  // elemset_var_names data structure.
  this->read_var_names(ELEMSET);
 
  // Debugging
  // libMesh::out << "elmeset variable names:" << std::endl;
  // for (const auto & name : elemset_var_names)
  //   libMesh::out << name << " ";
  // libMesh::out << std::endl;
 
  if (num_elemset_vars)
    {
      // Debugging
      // std::cout << "Reading " << num_elem_sets
      //           << " elemsets and " << num_elemset_vars
      //           << " elemset variables." << std::endl;
 
      // Read the elemset data truth table.
      std::vector<int> elemset_var_tab(num_elem_sets * num_elemset_vars);
      exII::ex_get_truth_table(ex_id,
                               exII::EX_ELEM_SET, // exII::ex_entity_type
                               num_elem_sets,
                               num_elemset_vars,
                               elemset_var_tab.data());
      EX_CHECK_ERR(ex_err, "Error reading elemset variable truth table.");
 
      // Debugging
      // libMesh::out << "Elemset variable truth table:" << std::endl;
      // for (const auto & val : elemset_var_tab)
      //   libMesh::out << val << " ";
      // libMesh::out << std::endl;
 
      // Debugging
      // for (auto i : make_range(num_elem_sets))
      //   {
      //     for (auto j : make_range(num_elemset_vars))
      //       libMesh::out << elemset_var_tab[num_elemset_vars*i + j] << " ";
      //     libMesh::out << std::endl;
      //   }
 
      // Set up/allocate space in incoming data structures. All vectors are
      // num_elemset_vars in length.
      var_names = elemset_var_names;
      elemset_ids_in.resize(num_elemset_vars);
      elemset_vals.resize(num_elemset_vars);
 
      // Read the elemset data
      int offset=0;
      for (int es=0; es<num_elem_sets; ++es)
        {
          offset += (es > 0 ? num_elems_per_set[es-1] : 0);
          for (int var=0; var<num_elemset_vars; ++var)
            {
              int is_present = elemset_var_tab[num_elemset_vars*es + var];
 
              if (is_present)
                {
                  // Debugging
                  // libMesh::out << "Variable " << var << " is present on elemset " << es << std::endl;
 
                  // Record the fact that this variable is defined on this elemset.
                  elemset_ids_in[var].insert(elemset_ids[es]);
 
                  // Note: the assumption here is that a previous call
                  // to this->read_elemset_info() has already set the
                  // values of num_elems_per_set, so we just use those values here.
                  std::vector<Real> elemset_var_vals(num_elems_per_set[es]);
                  ex_err = exII::ex_get_var
                    (ex_id,
                     timestep,
                     exII::EX_ELEM_SET, // exII::ex_entity_type
                     var + 1, // 1-based sideset variable index!
                     elemset_ids[es],
                     num_elems_per_set[es],
                     MappedInputVector(elemset_var_vals, _single_precision).data());
                  EX_CHECK_ERR(ex_err, "Error reading elemset variable.");
 
                  for (int i=0; i<num_elems_per_set[es]; ++i)
                    {
                      dof_id_type exodus_elem_id = elemset_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;
 
                      // Make key based on the elem and set ids
                      auto key = std::make_pair(converted_elem_id,
                                                static_cast<elemset_id_type>(elemset_ids[es]));
 
                      // Store value in the map
                      elemset_vals[var].emplace(key, elemset_var_vals[i]);
                    } // end for (i)
                } // end if (present)
            } // end for (var)
        } // end for (es)
    } // end if (num_elemset_vars)
}

References libMesh::ExodusII_IO_Helper::_single_precision, libMesh::ExodusII_IO_Helper::ELEMSET, libMesh::ExodusII_IO_Helper::elemset_ids, libMesh::ExodusII_IO_Helper::elemset_list, libMesh::ExodusII_IO_Helper::elemset_var_names, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::num_elem_sets, libMesh::ExodusII_IO_Helper::num_elems_per_set, libMesh::ExodusII_IO_Helper::num_elemset_vars, and libMesh::ExodusII_IO_Helper::read_var_names().

◆ read_elemset_info()

void libMesh::ExodusII_IO_Helper::read_elemset_info ( )

inherited

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

Definition at line 1838 of file exodusII_io_helper.C.

{
  elemset_ids.resize(num_elem_sets);
  if (num_elem_sets > 0)
    {
      ex_err = exII::ex_get_ids(ex_id,
                                exII::EX_ELEM_SET,
                                elemset_ids.data());
      EX_CHECK_ERR(ex_err, "Error retrieving elemset information.");
      message("All elemset information retrieved successfully.");
 
      // Resize appropriate data structures -- only do this once outside the loop
      num_elems_per_set.resize(num_elem_sets);
      num_elem_df_per_set.resize(num_elem_sets);
 
      // Inquire about the length of the concatenated elemset list
      num_elem_all_elemsets =
        inquire(*this, exII::EX_INQ_ELS_LEN,
                "Error retrieving length of the concatenated elem sets element list!");
 
      elemset_list.resize(num_elem_all_elemsets);
      elemset_id_list.resize(num_elem_all_elemsets);
 
      // Debugging
      // libMesh::out << "num_elem_all_elemsets = " << num_elem_all_elemsets << std::endl;
    }
 
  char name_buffer[libmesh_max_str_length+1];
  for (int i=0; i<num_elem_sets; ++i)
    {
      ex_err = exII::ex_get_name(ex_id, exII::EX_ELEM_SET,
                                 elemset_ids[i], name_buffer);
      EX_CHECK_ERR(ex_err, "Error getting node set name.");
      id_to_elemset_names[elemset_ids[i]] = name_buffer;
    }
  message("All elem set names retrieved successfully.");
}

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

◆ read_face_blocks()

void libMesh::ExodusII_IO_Helper::read_face_blocks ( )

inherited

Reads NSIDED face blocks used by NFACED element blocks.

Definition at line 1202 of file exodusII_io_helper.C.

{
  LOG_SCOPE("read_face_blocks()", "ExodusII_IO_Helper");
 
  if (!c0polyhedron_face_connect.empty())
    return;
 
  libmesh_error_msg_if(num_face_blk == 0,
                       "Error: Exodus NFACED element block found, "
                       "but the file has no face blocks.");
 
  std::vector<int> face_block_ids(num_face_blk);
  ex_err = exII::ex_get_ids(ex_id,
                            exII::EX_FACE_BLOCK,
                            face_block_ids.data());
  EX_CHECK_ERR(ex_err, "Error getting face block IDs.");
 
  c0polyhedron_face_connect.clear();
  c0polyhedron_face_connect.reserve(num_face);
 
  for (auto block : index_range(face_block_ids))
    {
      std::vector<char> face_type(libmesh_max_str_length+1);
      int num_face_this_blk = 0;
      int num_node_data_this_blk = 0;
      int num_edges_per_face = 0;
      int num_faces_per_face = 0;
      int num_attr_face = 0;
 
      ex_err = exII::ex_get_block(ex_id,
                                  exII::EX_FACE_BLOCK,
                                  face_block_ids[block],
                                  face_type.data(),
                                  &num_face_this_blk,
                                  &num_node_data_this_blk,
                                  &num_edges_per_face,
                                  &num_faces_per_face,
                                  &num_attr_face);
      EX_CHECK_ERR(ex_err, "Error getting face block info.");
 
      const auto & conv = get_conversion(std::string(face_type.data()));
      libmesh_error_msg_if(conv.libmesh_elem_type() != C0POLYGON,
                           "Error: NFACED polyhedron input currently expects "
                           "NSIDED face blocks, but face block "
                           << face_block_ids[block] << " has Exodus type "
                           << face_type.data() << ".");
 
      libmesh_error_msg_if
        (!(num_edges_per_face == 0) && !(num_edges_per_face == -1),
         "Error: Exodus NSIDED face block "
         << face_block_ids[block]
         << " has edge connectivity, which NFACED polyhedron input "
         << "does not currently support.");
      libmesh_error_msg_if
        (!(num_faces_per_face == 0) && !(num_faces_per_face == -1),
         "Error: Exodus NSIDED face block "
         << face_block_ids[block]
         << " has face-in-face connectivity, which NFACED polyhedron "
         << "input does not currently support.");
 
      std::vector<int> face_node_counts(num_face_this_blk);
      if (!face_node_counts.empty())
        {
          ex_err = exII::ex_get_entity_count_per_polyhedra
            (ex_id,
             exII::EX_FACE_BLOCK,
             face_block_ids[block],
             face_node_counts.data());
          EX_CHECK_ERR(ex_err, "Error reading polyhedron face node counts");
        }
 
      int counted_nodes = 0;
      for (const auto count : face_node_counts)
        counted_nodes += count;
 
      libmesh_error_msg_if(counted_nodes != num_node_data_this_blk,
                           "Error: Exodus NSIDED face block "
                           << face_block_ids[block]
                           << " says it has " << num_node_data_this_blk
                           << " total node entries, but its per-face "
                           << "node counts sum to " << counted_nodes << ".");
 
      std::vector<int> face_connect(num_node_data_this_blk);
      if (!face_connect.empty())
        {
          ex_err = exII::ex_get_conn(ex_id,
                                     exII::EX_FACE_BLOCK,
                                     face_block_ids[block],
                                     face_connect.data(),
                                     nullptr,
                                     nullptr);
          EX_CHECK_ERR(ex_err, "Error reading polyhedron face connectivity.");
        }
 
      std::size_t offset = 0;
      for (const auto count : face_node_counts)
        {
          libmesh_error_msg_if(count < 3,
                               "Error: Exodus NSIDED face block "
                               << face_block_ids[block]
                               << " has a face with only "
                               << count << " nodes.");
 
          c0polyhedron_face_connect.emplace_back
            (face_connect.begin() + offset,
             face_connect.begin() + offset + count);
          offset += count;
        }
    }
 
  libmesh_error_msg_if(c0polyhedron_face_connect.size() !=
                       cast_int<std::size_t>(num_face),
                       "Error: Exodus file says it has "
                       << num_face << " faces, but its face blocks contain "
                       << c0polyhedron_face_connect.size() << " faces.");
}

References libMesh::C0POLYGON, libMesh::ExodusII_IO_Helper::c0polyhedron_face_connect, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::get_conversion(), libMesh::index_range(), libMesh::ExodusII_IO_Helper::num_face, and libMesh::ExodusII_IO_Helper::num_face_blk.

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

◆ read_global_values()

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

inherited

Reads the vector of global variables.

Definition at line 5318 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_var
    (ex_id,
     timestep,
     exII::EX_GLOBAL,
     1, // var_index
     1, // obj_id
     num_global_vars,
     MappedInputVector(values, _single_precision).data());
 
  EX_CHECK_ERR(ex_err, "Error reading global values.");
}

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

◆ read_header()

ExodusHeaderInfo libMesh::ExodusII_IO_Helper::read_header ( ) const

inherited

Reads an ExodusII mesh file header, leaving this object's internal data structures unchanged.

Definition at line 762 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 = {};
  int err_flag = exII::ex_get_init_ext(ex_id, &params);
  EX_CHECK_ERR(err_flag, "Error retrieving header info.");
 
  // Extract required data into our struct
  ExodusHeaderInfo h;
  h.title.assign(params.title, params.title + MAX_LINE_LENGTH);
  h.num_dim = params.num_dim;
  h.num_nodes = params.num_nodes;
  h.num_elem = params.num_elem;
  h.num_elem_blk = params.num_elem_blk;
  h.num_node_sets = params.num_node_sets;
  h.num_side_sets = params.num_side_sets;
  h.num_elem_sets = params.num_elem_sets;
  h.num_edge_blk = params.num_edge_blk;
  h.num_edge = params.num_edge;
  h.num_face_blk = params.num_face_blk;
  h.num_face = params.num_face;
 
  // And return it
  return h;
}

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

◆ read_nodal_var_values()

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

inherited

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

Definition at line 2104 of file exodusII_io_helper.C.

{
  LOG_SCOPE("read_nodal_var_values()", "ExodusII_IO_Helper");
 
  // 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);
    }
 
  // Clear out any previously read nodal variable values
  this->nodal_var_values.clear();
 
  std::vector<Real> unmapped_nodal_var_values(num_nodes);
 
  // Call the Exodus API to read the nodal variable values
  ex_err = exII::ex_get_var
    (ex_id,
     time_step,
     exII::EX_NODAL,
     var_index+1,
     1, // exII::ex_entity_id, not sure exactly what this is but in the ex_get_nodal_var.c shim, they pass 1
     num_nodes,
     MappedInputVector(unmapped_nodal_var_values, _single_precision).data());
  EX_CHECK_ERR(ex_err, "Error reading nodal variable values!");
 
  for (auto i : make_range(num_nodes))
    {
      // Determine the libmesh node id implied by "i". The
      // get_libmesh_node_id() helper function expects a 1-based
      // Exodus node id, so we construct the "implied" Exodus node id
      // from "i" by adding 1.
      //
      // If the user has set the "set_unique_ids_from_maps" flag to
      // true, then calling get_libmesh_node_id(i+1) will just return
      // i, otherwise it will determine the value (with error
      // checking) using this->node_num_map.
      auto libmesh_node_id = this->get_libmesh_node_id(/*exodus_node_id=*/i+1);
 
      // Store the nodal value in the map.
      this->nodal_var_values[libmesh_node_id] = unmapped_nodal_var_values[i];
    }
}

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

◆ read_node_num_map()

void libMesh::ExodusII_IO_Helper::read_node_num_map ( )

inherited

Reads the optional node_num_map from the ExodusII mesh file.

Definition at line 955 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 libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::node_num_map, libMesh::ExodusII_IO_Helper::num_nodes, libMesh::out, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::verbose.

◆ read_nodes()

void libMesh::ExodusII_IO_Helper::read_nodes ( )

inherited

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

Definition at line 904 of file exodusII_io_helper.C.

{
  LOG_SCOPE("read_nodes()", "ExodusII_IO_Helper");
 
  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.");
    }
 
  // If a nodal attribute bex_weight exists, we get spline weights
  // from it
  int n_nodal_attr = 0;
  ex_err = exII::ex_get_attr_param(ex_id, exII::EX_NODAL, 0, & n_nodal_attr);
  EX_CHECK_ERR(ex_err, "Error getting number of nodal attributes.");
 
  if (n_nodal_attr > 0)
    {
      std::vector<std::vector<char>> attr_name_data
        (n_nodal_attr, std::vector<char>(libmesh_max_str_length + 1));
      std::vector<char *> attr_names(n_nodal_attr);
      for (auto i : index_range(attr_names))
        attr_names[i] = attr_name_data[i].data();
 
      ex_err = exII::ex_get_attr_names(ex_id, exII::EX_NODAL, 0, attr_names.data());
      EX_CHECK_ERR(ex_err, "Error getting nodal attribute names.");
 
      for (auto i : index_range(attr_names))
        if (std::string("bex_weight") == attr_names[i])
          {
            w.resize(num_nodes);
            ex_err =
              exII::ex_get_one_attr (ex_id, exII::EX_NODAL, 0, i+1,
                                     MappedInputVector(w, _single_precision).data());
            EX_CHECK_ERR(ex_err, "Error getting Bezier Extraction nodal weights");
          }
    }
}

References libMesh::ExodusII_IO_Helper::_single_precision, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::index_range(), libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::num_nodes, libMesh::ExodusII_IO_Helper::w, libMesh::ExodusII_IO_Helper::x, libMesh::ExodusII_IO_Helper::y, and libMesh::ExodusII_IO_Helper::z.

◆ read_nodeset()

void libMesh::Nemesis_IO_Helper::read_nodeset ( int id )

Reading functions.

These just allocate memory for you and call the Nemesis routines of the same name. They also handle error checking for the Nemesis return value. Be careful calling these at random, some depend on others being called first... Reads the node ids of nodeset id and stores them in the node_list member of this class.

Note: This used to be an ExodusII_IO_Helper function but it use was completely replaced by read_all_nodesets(). For now, it is still used by the Nemesis reader so we have moved it here.

Definition at line 118 of file nemesis_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 libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::message(), node_list, libMesh::ExodusII_IO_Helper::nodeset_ids, libMesh::ExodusII_IO_Helper::num_node_df_per_set, and libMesh::ExodusII_IO_Helper::num_nodes_per_set.

◆ read_nodeset_data()

void libMesh::ExodusII_IO_Helper::read_nodeset_data	(	int	timestep,
		std::vector< std::string > &	var_names,
		std::vector< std::set< boundary_id_type > > &	node_boundary_ids,
		std::vector< std::map< BoundaryInfo::NodeBCTuple, Real > > &	bc_vals
	)

inherited

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

Definition at line 4853 of file exodusII_io_helper.C.

{
  LOG_SCOPE("read_nodeset_data()", "ExodusII_IO_Helper");
 
  // This reads the sideset variable names into the local
  // sideset_var_names data structure.
  this->read_var_names(NODESET);
 
  if (num_nodeset_vars)
    {
      // Read the nodeset data truth table
      std::vector<int> nset_var_tab(num_node_sets * num_nodeset_vars);
      ex_err = exII::ex_get_truth_table
        (ex_id,
         exII::EX_NODE_SET,
         num_node_sets,
         num_nodeset_vars,
         nset_var_tab.data());
      EX_CHECK_ERR(ex_err, "Error reading nodeset variable truth table.");
 
      // Set up/allocate space in incoming data structures.
      var_names = nodeset_var_names;
      node_boundary_ids.resize(num_nodeset_vars);
      bc_vals.resize(num_nodeset_vars);
 
      // Read the nodeset data.
      //
      // Note: we assume that the functions
      // 1.) this->read_nodeset_info() and
      // 2.) this->read_all_nodesets()
      // have already been called, so that we already know e.g. how
      // many nodes are in each set, their ids, etc.
      //
      // 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.
      int offset=0;
      for (int ns=0; ns<num_node_sets; ++ns)
        {
          offset += (ns > 0 ? num_nodes_per_set[ns-1] : 0);
          for (int var=0; var<num_nodeset_vars; ++var)
            {
              int is_present = nset_var_tab[num_nodeset_vars*ns + var];
 
              if (is_present)
                {
                  // Record the fact that this variable is defined on this nodeset.
                  node_boundary_ids[var].insert(nodeset_ids[ns]);
 
                  // Note: the assumption here is that a previous call
                  // to this->read_nodeset_info() has already set the
                  // values of num_nodes_per_set, so we just use those values here.
                  std::vector<Real> nset_var_vals(num_nodes_per_set[ns]);
                  ex_err = exII::ex_get_var
                    (ex_id,
                     timestep,
                     exII::EX_NODE_SET,
                     var + 1, // 1-based nodeset variable index!
                     nodeset_ids[ns],
                     num_nodes_per_set[ns],
                     MappedInputVector(nset_var_vals, _single_precision).data());
                  EX_CHECK_ERR(ex_err, "Error reading nodeset variable.");
 
                  for (int i=0; i<num_nodes_per_set[ns]; ++i)
                    {
                      // The read_all_nodesets() function now reads all the node ids into the
                      // node_sets_node_list vector, which is of length "total_nodes_in_all_sets"
                      // The old read_nodset() function is no longer called as far as I can tell,
                      // and should probably be removed? The "offset" that we are using only
                      // depends on the current nodeset index and the num_nodes_per_set vector,
                      // which gets filled in by the call to read_all_nodesets().
                      dof_id_type exodus_node_id = node_sets_node_list[i + offset];
 
                      // FIXME: We should use exodus_node_num_to_libmesh for this,
                      // but it apparently is never set up, so just
                      // subtract 1 from the Exodus node id.
                      dof_id_type converted_node_id = exodus_node_id - 1;
 
                      // Make a NodeBCTuple key from the converted information.
                      BoundaryInfo::NodeBCTuple key = std::make_tuple
                        (converted_node_id, nodeset_ids[ns]);
 
                      // Store (node, b_id) tuples in bc_vals[var]
                      bc_vals[var].emplace(key, nset_var_vals[i]);
                    } // end for (i)
                } // end if (present)
            } // end for (var)
        } // end for (ns)
    } // end if (num_nodeset_vars)
}

References libMesh::ExodusII_IO_Helper::_single_precision, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::node_sets_node_list, libMesh::ExodusII_IO_Helper::NODESET, libMesh::ExodusII_IO_Helper::nodeset_ids, libMesh::ExodusII_IO_Helper::nodeset_var_names, libMesh::ExodusII_IO_Helper::num_node_sets, libMesh::ExodusII_IO_Helper::num_nodes_per_set, libMesh::ExodusII_IO_Helper::num_nodeset_vars, and libMesh::ExodusII_IO_Helper::read_var_names().

◆ read_nodeset_info()

void libMesh::ExodusII_IO_Helper::read_nodeset_info ( )

inherited

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

Definition at line 1809 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 outside the loop
      num_nodes_per_set.resize(num_node_sets);
      num_node_df_per_set.resize(num_node_sets);
    }
 
  char name_buffer[libmesh_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 libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::id_to_ns_names, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::nodeset_ids, libMesh::ExodusII_IO_Helper::num_node_df_per_set, libMesh::ExodusII_IO_Helper::num_node_sets, and libMesh::ExodusII_IO_Helper::num_nodes_per_set.

◆ read_num_time_steps()

void libMesh::ExodusII_IO_Helper::read_num_time_steps ( )

inherited

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

Definition at line 2096 of file exodusII_io_helper.C.

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

References libMesh::ExodusII_IO_Helper::num_time_steps.

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

◆ read_qa_records()

void libMesh::ExodusII_IO_Helper::read_qa_records ( )

inherited

Reads the QA records from an ExodusII file.

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

Definition at line 828 of file exodusII_io_helper.C.

{
  // The QA records are four MAX_STR_LENGTH-byte character strings.
  int num_qa_rec =
    inquire(*this, 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)
    {
      // Actual (num_qa_rec x 4) storage for strings. The object we
      // pass to the Exodus API will just contain pointers into the
      // qa_storage object, which will have all automatic memory
      // management.
      std::vector<std::vector<std::vector<char>>> qa_storage(num_qa_rec);
      for (auto i : make_range(num_qa_rec))
        {
          qa_storage[i].resize(4);
          for (auto j : make_range(4))
            qa_storage[i][j].resize(libmesh_max_str_length+1);
        }
 
      // inner_array_t is a fixed-size array of 4 strings
      typedef char * inner_array_t[4];
 
      // There is at least one compiler (Clang 12.0.1) that complains about
      // "a non-scalar type used in a pseudo-destructor expression" when
      // we try to instantiate a std::vector of inner_array_t objects as in:
      // std::vector<inner_array_t> qa_record(num_qa_rec);
      // So, we instead attempt to achieve the same effect with a std::unique_ptr.
      auto qa_record = std::make_unique<inner_array_t[]>(num_qa_rec);
 
      // Create data structure to be passed to Exodus API by setting
      // pointers to the actual strings which are in qa_storage.
      for (auto i : make_range(num_qa_rec))
        for (auto j : make_range(4))
          qa_record[i][j] = qa_storage[i][j].data();
 
      ex_err = exII::ex_get_qa (ex_id, qa_record.get());
      EX_CHECK_ERR(ex_err, "Error reading the QA records.");
 
      // Print the QA records
      if (verbose)
        {
          for (auto i : make_range(num_qa_rec))
            {
              libMesh::out << "QA Record: " << i << std::endl;
              for (auto j : make_range(4))
                libMesh::out << qa_record[i][j] << std::endl;
            }
        }
    }
}

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

◆ read_sideset()

void libMesh::ExodusII_IO_Helper::read_sideset	(	int	id,
		int	offset
	)

inherited

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

Definition at line 1878 of file exodusII_io_helper.C.

{
  LOG_SCOPE("read_sideset()", "ExodusII_IO_Helper");
 
  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 libMesh::ExodusII_IO_Helper::elem_list, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::id_list, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::num_df_per_set, libMesh::ExodusII_IO_Helper::num_sides_per_set, libMesh::ExodusII_IO_Helper::side_list, and libMesh::ExodusII_IO_Helper::ss_ids.

Referenced by libMesh::ExodusII_IO_Helper::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
	)

inherited

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

Definition at line 4321 of file exodusII_io_helper.C.

{
  LOG_SCOPE("read_sideset_data()", "ExodusII_IO_Helper");
 
  // 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_truth_table
        (ex_id,
         exII::EX_SIDE_SET,
         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_var
                    (ex_id,
                     timestep,
                     exII::EX_SIDE_SET,
                     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.");
 
                  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);
 
                      // 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].emplace(key, sset_var_vals[i]);
                    } // end for (i)
                } // end if (present)
            } // end for (var)
        } // end for (ss)
    } // end if (num_sideset_vars)
}

◆ read_sideset_info()

void libMesh::ExodusII_IO_Helper::read_sideset_info ( )

inherited

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

Definition at line 1774 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(*this, 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[libmesh_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.");
}

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

◆ read_time_steps()

void libMesh::ExodusII_IO_Helper::read_time_steps ( )

inherited

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

Definition at line 2079 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 libMesh::ExodusII_IO_Helper::_single_precision, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::num_time_steps, libMesh::ExodusII_IO_Helper::read_num_time_steps(), and libMesh::ExodusII_IO_Helper::time_steps.

◆ read_var_names()

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

inherited

Definition at line 2168 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;
    case NODESET:
      this->read_var_names_impl("m", num_nodeset_vars, nodeset_var_names);
      break;
    case ELEMSET:
      this->read_var_names_impl("t", num_elemset_vars, elemset_var_names);
      break;
    default:
      libmesh_error_msg("Unrecognized ExodusVarType " << type);
    }
}

Referenced by libMesh::ExodusII_IO_Helper::check_existing_vars(), libMesh::ExodusII_IO_Helper::read_elemental_var_values(), libMesh::ExodusII_IO_Helper::read_elemset_data(), libMesh::ExodusII_IO_Helper::read_nodal_var_values(), libMesh::ExodusII_IO_Helper::read_nodeset_data(), and libMesh::ExodusII_IO_Helper::read_sideset_data().

◆ read_var_names_impl()

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

overrideprotectedvirtual

read_var_names() dispatches to this function.

We need to override it slightly for Nemesis.

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 2763 of file nemesis_io_helper.C.

{
  // Most of what we need to do is the same as for Exodus
  this->ExodusII_IO_Helper::read_var_names_impl(var_type, count, result);
 
  // But with tests where we have more processors than elements,
  // Nemesis doesn't let us put variable names in files written by
  // processors owning nothing, but we may still *need* those
  // variable names on every processor, so let's sync them up...
 
  processor_id_type pid_broadcasting_names = this->processor_id();
  const std::size_t n_names = result.size();
  if (!n_names)
    pid_broadcasting_names = DofObject::invalid_processor_id;
 
  libmesh_assert(this->comm().semiverify
                 (n_names ? nullptr : &n_names));
 
  this->comm().min(pid_broadcasting_names);
 
  if (pid_broadcasting_names != DofObject::invalid_processor_id)
    this->comm().broadcast(result, pid_broadcasting_names);
}

References libMesh::Parallel::Communicator::broadcast(), libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libMesh::Parallel::Communicator::min(), libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::read_var_names_impl().

◆ set_add_sides()

void libMesh::ExodusII_IO_Helper::set_add_sides ( bool add_sides )

inlineinherited

Sets whether or not to write extra "side" elements.

This is useful for plotting SIDE_DISCONTINUOUS data.

Definition at line 1362 of file exodusII_io_helper.h.

{
  _add_sides = add_sides;
}

References libMesh::ExodusII_IO_Helper::_add_sides.

◆ set_coordinate_offset()

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

inherited

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

{
  _coordinate_offset = p;
}

References libMesh::ExodusII_IO_Helper::_coordinate_offset.

◆ set_dof_object_unique_id()

void libMesh::ExodusII_IO_Helper::set_dof_object_unique_id	(	MeshBase &	mesh,
		DofObject *	dof_object,
		int	exodus_mapped_id
	)

privateinherited

Definition at line 2476 of file exodusII_io_helper.C.

{
  if (this->set_unique_ids_from_maps)
  {
    // Exodus ids are always 1-based while libmesh ids are always
    // 0-based, so to make a libmesh unique_id here, we subtract 1
    // from the exodus_mapped_id to make it 0-based.
    auto exodus_mapped_id_zero_based =
      cast_int<dof_id_type>(exodus_mapped_id - 1);
 
    // Set added_node's unique_id to "exodus_mapped_id_zero_based".
    dof_object->set_unique_id(cast_int<unique_id_type>(exodus_mapped_id_zero_based));
 
    // Normally the Mesh is responsible for setting the unique_ids
    // of Nodes/Elems in a consistent manner, so when we set the unique_id
    // of a Node/Elem manually based on the {node,elem}_num_map, we need to
    // make sure that the "next" unique id assigned by the Mesh
    // will still be valid. We do this by making sure that the
    // next_unique_id is greater than the one we set manually. The
    // APIs for doing this are only defined when unique ids are
    // enabled.
#ifdef LIBMESH_ENABLE_UNIQUE_ID
    unique_id_type next_unique_id = mesh.next_unique_id();
    mesh.set_next_unique_id(std::max(next_unique_id, static_cast<unique_id_type>(exodus_mapped_id_zero_based + 1)));
#else
    // Avoid compiler warnings about the unused variable
    libmesh_ignore(mesh);
#endif
  }
}

References libMesh::libmesh_ignore(), mesh, libMesh::MeshBase::next_unique_id(), libMesh::MeshBase::set_next_unique_id(), libMesh::DofObject::set_unique_id(), and libMesh::ExodusII_IO_Helper::set_unique_ids_from_maps.

Referenced by libMesh::ExodusII_IO_Helper::conditionally_set_elem_unique_id(), and libMesh::ExodusII_IO_Helper::conditionally_set_node_unique_id().

◆ set_hdf5_writing()

void libMesh::ExodusII_IO_Helper::set_hdf5_writing ( bool write_hdf5 )

inherited

Set to true (the default) to write files in an HDF5-based file format (when HDF5 is available), or to false to write files in the old NetCDF3-based format.

If HDF5 is unavailable, this setting does nothing.

Definition at line 5345 of file exodusII_io_helper.C.

{
  _write_hdf5 = write_hdf5;
}

References libMesh::ExodusII_IO_Helper::_write_hdf5.

◆ set_max_name_length()

void libMesh::ExodusII_IO_Helper::set_max_name_length ( unsigned int max_length )

inherited

Set how many characters to use in names when opening a file for writing.

Definition at line 5351 of file exodusII_io_helper.C.

{
  // Opt mode error, because this may be exposed to users
  libmesh_error_msg_if (max_length > libmesh_max_str_length,
                        "Exodus maximum name length is limited to " <<
                        libmesh_max_str_length << " characters");
 
  // Devel+dbg mode assertion, because developers should do better
  libmesh_assert(!opened_for_writing);
 
  _max_name_length = max_length;
}

References libMesh::ExodusII_IO_Helper::_max_name_length, libMesh::libmesh_assert(), and libMesh::ExodusII_IO_Helper::opened_for_writing.

◆ update()

void libMesh::ExodusII_IO_Helper::update ( )

inherited

Uses ex_update() to flush buffers to file.

Definition at line 5310 of file exodusII_io_helper.C.

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

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

Referenced by write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_values(), and libMesh::ExodusII_IO_Helper::write_timestep().

◆ use_mesh_dimension_instead_of_spatial_dimension()

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

inherited

Sets the underlying value of the boolean flag _use_mesh_dimension_instead_of_spatial_dimension.

By default, the value of this flag is false.

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

Definition at line 5339 of file exodusII_io_helper.C.

{
  _use_mesh_dimension_instead_of_spatial_dimension = val;
}

References libMesh::ExodusII_IO_Helper::_use_mesh_dimension_instead_of_spatial_dimension.

◆ write_as_dimension()

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

inherited

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

{
  _write_as_dimension = dim;
}

References libMesh::ExodusII_IO_Helper::_write_as_dimension, and dim.

◆ write_complex_magnitude()

void libMesh::Nemesis_IO_Helper::write_complex_magnitude ( bool val )

Set the flag indicating whether the complex modulus should be written when complex numbers are enabled.

By default this flag is set to true.

◆ write_element_values() [1/2]

void libMesh::Nemesis_IO_Helper::write_element_values	(	const MeshBase &	mesh,
		const EquationSystems &	es,
		const std::vector< std::pair< unsigned int, unsigned int > > &	var_nums,
		int	timestep,
		const std::vector< std::set< subdomain_id_type > > &	vars_active_subdomains
	)

Writes the vector of elemental variable values, one variable and one subdomain at a time.

Definition at line 2630 of file nemesis_io_helper.C.

{
  // For each variable in names,
  //   For each subdomain in subdomain_map,
  //     If this (subdomain, variable) combination is active
  //       For each component in variable
  //         Extract element values into local_soln (localize is a collective)
  //         Write local_soln to file
  //   Update var_ctr with number of vector components for variable
  //
  unsigned int var_ctr = 0;
  for (auto v : index_range(var_nums))
    {
      const unsigned int sys_num = var_nums[v].first;
      const unsigned int var = var_nums[v].second;
      const System & system = es.get_system(sys_num);
 
      // We need to check if the constant monomial is a scalar or a vector and set the number of
      // components for the latter as per es.find_variable_numbers().
      // Even for the case where a variable is not active on any subdomain belonging to the
      // processor, we still need to know this number to update 'var_ctr'.
      const auto & var_type = system.variable_type(var);
      const unsigned int n_comps =
        (FEInterface::field_type(var_type) == TYPE_VECTOR) ?
        FEInterface::n_vec_dim(mesh, var_type) : 1;
 
      // Get list of active subdomains for variable v
      const auto & active_subdomains = vars_active_subdomains[v];
 
      for (const int sbd_id_int : global_elem_blk_ids)
        {
          const subdomain_id_type sbd_id =
            restrict_int<subdomain_id_type>(sbd_id_int);
          auto it = subdomain_map.find(sbd_id);
          const std::vector<dof_id_type> empty_vec;
          const std::vector<dof_id_type> & elem_ids =
            (it == subdomain_map.end()) ? empty_vec : it->second;
 
          // Possibly skip this (variable, subdomain) combination. Also, check that there is at
          // least one element on the subdomain... Indeed, it is possible to have zero elements,
          // e.g., when running "adaptivity_ex3" in parallel with the 'dimension=1' argument.
          if ((active_subdomains.empty() || active_subdomains.count(sbd_id)) && elem_ids.size())
            {
              std::vector<numeric_index_type> required_indices;
              required_indices.reserve(elem_ids.size());
 
              // The number of DOF components needs to be equal to the expected number so that we
              // know where to store data to correctly correspond to variable names - verify this by
              // accessing the n_comp method for the last element ID, which should return the same
              // value for all elements on a given subdomain, so we only need to check this once.
              libmesh_assert_equal_to(n_comps, mesh.elem_ref(elem_ids.back()).n_comp(sys_num, var));
 
              // Loop through the DOFs of the variable and write the values for it on each element.
              // The variable name should have been decomposed by es.find_variable_numbers().
              for (unsigned int comp = 0; comp < n_comps; ++comp)
              {
                for (const auto & id : elem_ids)
                    required_indices.push_back(mesh.elem_ref(id).dof_number(sys_num, var, comp));
 
                std::vector<Number> local_soln;
                system.current_local_solution->get(required_indices, local_soln);
 
                // reset for the next component
                required_indices.clear();
 
                // It's possible that there's nothing for us to write:
                // we may not be responsible for any elements on the
                // current subdomain.  We did still have to participate
                // in the localize() call above, however, since it is a
                // collective.
                if (local_soln.size())
                  {
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
                    int stride = write_complex_abs ? 3 : 2;
                    std::vector<Real> local_soln_buffer(local_soln.size());
                    std::transform(local_soln.begin(), local_soln.end(),
                                   local_soln_buffer.begin(), [](Number n) { return n.real(); });
                    ex_err = exII::ex_put_elem_var(ex_id,
                                                   timestep,
                                                   static_cast<int>(stride*(var_ctr+comp)+1),
                                                   static_cast<int>(sbd_id),
                                                   static_cast<int>(local_soln.size()),
                                                   MappedOutputVector(local_soln_buffer, _single_precision).data());
                    EX_CHECK_ERR(ex_err, "Error writing element real values.");
 
                    std::transform(local_soln.begin(), local_soln.end(),
                                   local_soln_buffer.begin(), [](Number n) { return n.imag(); });
                    ex_err = exII::ex_put_elem_var(ex_id,
                                                   timestep,
                                                   static_cast<int>(stride*(var_ctr+comp)+2),
                                                   static_cast<int>(sbd_id),
                                                   static_cast<int>(local_soln.size()),
                                                   MappedOutputVector(local_soln_buffer, _single_precision).data());
                    EX_CHECK_ERR(ex_err, "Error writing element imaginary values.");
 
                    if (write_complex_abs)
                      {
                        std::transform(local_soln.begin(), local_soln.end(),
                                       local_soln_buffer.begin(), [](Number n) { return std::abs(n); });
                        ex_err = exII::ex_put_elem_var(ex_id,
                                                       timestep,
                                                       static_cast<int>(stride*(var_ctr+comp)+2),
                                                       static_cast<int>(sbd_id),
                                                       static_cast<int>(local_soln.size()),
                                                       MappedOutputVector(local_soln_buffer, _single_precision).data());
                        EX_CHECK_ERR(ex_err, "Error writing element magnitudes.");
                      }
#else // LIBMESH_USE_COMPLEX_NUMBERS
                    ex_err = exII::ex_put_elem_var(ex_id,
                                                   timestep,
                                                   static_cast<int>(var_ctr+comp+1),
                                                   static_cast<int>(sbd_id),
                                                   static_cast<int>(local_soln.size()),
                                                   MappedOutputVector(local_soln, _single_precision).data());
                    EX_CHECK_ERR(ex_err, "Error writing element values.");
#endif // LIBMESH_USE_COMPLEX_NUMBERS
                  }
              } // end loop over vector components
            }
        } // end loop over active subdomains
 
        var_ctr += n_comps;
    } // end loop over vars
 
  this->update();
}

References libMesh::ExodusII_IO_Helper::_single_precision, libMesh::System::current_local_solution, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::FEInterface::field_type(), libMesh::EquationSystems::get_system(), global_elem_blk_ids, libMesh::index_range(), mesh, libMesh::FEInterface::n_vec_dim(), subdomain_map, libMesh::TYPE_VECTOR, libMesh::ExodusII_IO_Helper::update(), libMesh::System::variable_type(), and write_complex_abs.

◆ write_element_values() [2/2]

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
	)

inherited

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

{
  LOG_SCOPE("write_element_values()", "ExodusII_IO_Helper");
 
  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_variable_param(ex_id, exII::EX_ELEM_BLOCK, &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_var
            (ex_id,
             timestep,
             exII::EX_ELEM_BLOCK,
             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.");
        }
    }
 
  this->update();
}

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::_single_precision, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::get_block_id(), mesh, libMesh::MeshBase::n_elem(), libMesh::ExodusII_IO_Helper::num_elem_vars, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::update().

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

inherited

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 5082 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_variable_param(ex_id, exII::EX_ELEM_BLOCK, &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]);
 
                libmesh_error_msg_if(pos == var_names_this_sbd.end(),
                                     "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_var
              (ex_id,
               timestep,
               exII::EX_ELEM_BLOCK,
               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
 
  this->update();
}

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

◆ write_elements()

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

overridevirtual

This function is specialized to write the connectivity.

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 2269 of file nemesis_io_helper.C.

{
  // Only write elements if there are elements blocks available.
  if (this->num_elem_blks_global > 0)
    {
      // Data structure to store element block names that will be used to
      // write the element block names to file.
      NamesData names_table(this->num_elem_blks_global, MAX_STR_LENGTH);
 
      // Loop over all blocks, even if we don't have elements in each block.
      // If we don't have elements we need to write out a 0 for that block...
      for (auto i : make_range(this->num_elem_blks_global))
        {
          // Even if there are no elements for this block on the current
          // processor, we still want to write its name to file, if
          // possible. MeshBase::subdomain_name() will just return an
          // empty string if there is no name associated with the current
          // block.
          names_table.push_back_entry
            (mesh.subdomain_name(restrict_int<subdomain_id_type>(this->global_elem_blk_ids[i])));
 
          // Search for the current global block ID in the map
          if (const auto it = this->block_id_to_elem_connectivity.find( this->global_elem_blk_ids[i] );
              it == this->block_id_to_elem_connectivity.end())
            {
              // If not found, write a zero to file....
              this->ex_err = exII::ex_put_elem_block(this->ex_id,
                                                     this->global_elem_blk_ids[i],
                                                     "Empty",
                                                     0, /* n. elements in this block */
                                                     0, /* n. nodes per element */
                                                     0);  /* number of attributes per element */
 
              EX_CHECK_ERR(this->ex_err, "Error writing element block from Nemesis.");
            }
 
          // Otherwise, write the actual block information and connectivity to file
          else
            {
              subdomain_id_type block =
                cast_int<subdomain_id_type>(it->first);
              const std::vector<int> & this_block_connectivity = it->second;
              std::vector<dof_id_type> & elements_in_this_block = subdomain_map[block];
 
              // 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(elements_in_this_block[0]).type());
 
              this->num_nodes_per_elem =
                mesh.elem_ref(elements_in_this_block[0]).n_nodes();
 
              ex_err = exII::ex_put_elem_block(ex_id,
                                               block,
                                               conv.exodus_elem_type().c_str(),
                                               elements_in_this_block.size(),
                                               num_nodes_per_elem,
                                               0);
              EX_CHECK_ERR(ex_err, "Error writing element block from Nemesis.");
 
              ex_err = exII::ex_put_elem_conn(ex_id,
                                              block,
                                              this_block_connectivity.data());
              EX_CHECK_ERR(ex_err, "Error writing element connectivities from Nemesis.");
            }
        } // end loop over global block IDs
 
      // Only call this once, not in the loop above!
      ex_err = exII::ex_put_elem_num_map(ex_id,
                                         exodus_elem_num_to_libmesh.empty() ? nullptr : exodus_elem_num_to_libmesh.data());
      EX_CHECK_ERR(ex_err, "Error writing element map");
 
      // Write the element block names to file.
      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");
    } // end if (this->num_elem_blks_global > 0)
}

References block_id_to_elem_connectivity, libMesh::MeshBase::elem_ref(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::exodus_elem_num_to_libmesh, libMesh::ExodusII_IO_Helper::NamesData::get_char_star_star(), libMesh::ExodusII_IO_Helper::get_conversion(), global_elem_blk_ids, libMesh::make_range(), mesh, libMesh::Elem::n_nodes(), num_elem_blks_global, libMesh::ExodusII_IO_Helper::num_nodes_per_elem, libMesh::ExodusII_IO_Helper::NamesData::push_back_entry(), and subdomain_map.

◆ write_elemset_data()

void libMesh::ExodusII_IO_Helper::write_elemset_data	(	int	timestep,
		const std::vector< std::string > &	var_names,
		const std::vector< std::set< elemset_id_type > > &	elemset_ids_in,
		const std::vector< std::map< std::pair< dof_id_type, elemset_id_type >, Real > > &	elemset_vals
	)

inherited

Write elemset data for the requested timestep.

Definition at line 4578 of file exodusII_io_helper.C.

{
  LOG_SCOPE("write_elemset_data()", "ExodusII_IO_Helper");
 
  if ((_run_only_on_proc0) && (this->processor_id() != 0))
    return;
 
  // Write the elemset variable names to file. This function should
  // only be called once for ELEMSET 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(ELEMSET, var_names);
 
  // We now call the API to read the elemset info even though we are
  // in the middle of writing. This is a bit counter-intuitive, but it
  // seems to work provided that you have already written the mesh
  // itself... read_elemset_info() fills in the following data
  // members:
  // .) id_to_elemset_names
  // .) num_elems_per_set
  // .) num_elem_df_per_set
  // .) elemset_list
  // .) elemset_id_list
  // .) id_to_elemset_names
  this->read_elemset_info();
 
  // The "truth" table for elemset variables. elemset_var_tab is a
  // logically (num_elem_sets x num_elemset_vars) integer array of 0s and
  // 1s indicating which elemsets a given elemset variable is defined
  // on.
  std::vector<int> elemset_var_tab(num_elem_sets * var_names.size());
 
  int offset=0;
  for (int es=0; es<num_elem_sets; ++es)
    {
      // Debugging
      // libMesh::out << "Writing elemset variable values for elemset "
      //              << es << ", elemset_id = " << elemset_ids[es]
      //              << std::endl;
 
      // We know num_elems_per_set because we called read_elemset_info() above.
      offset += (es > 0 ? num_elems_per_set[es-1] : 0);
      this->read_elemset(es, offset);
 
      // For each variable in var_names, write the values for the
      // current elemset, if any.
      for (auto var : index_range(var_names))
        {
          // Debugging
          // libMesh::out << "Writing elemset variable values for var " << var << std::endl;
 
          // If this var has no values on this elemset, go to the next one.
          if (!elemset_ids_in[var].count(elemset_ids[es]))
            continue;
 
          // Otherwise, fill in this entry of the nodeset truth table.
          elemset_var_tab[es*var_names.size() + var] = 1;
 
          // Data vector that will eventually be passed to exII::ex_put_var().
          std::vector<Real> elemset_var_vals(num_elems_per_set[es]);
 
          // Get reference to the (elem_id, elemset_id) -> Real map for this variable.
          const auto & data_map = elemset_vals[var];
 
          // Loop over entries in current elemset.
          for (int i=0; i<num_elems_per_set[es]; ++i)
            {
              // Here we convert Exodus elem ids to libMesh node ids
              // simply by subtracting 1.  We should probably use the
              // exodus_elem_num_to_libmesh data structure for this,
              // but I don't think it is set up at the time when this
              // function is normally called.
              dof_id_type libmesh_elem_id = elemset_list[i + offset] - 1;
 
              // Construct a key to look up values in data_map.
              std::pair<dof_id_type, elemset_id_type> key =
                std::make_pair(libmesh_elem_id, elemset_ids[es]);
 
              // Debugging:
              // libMesh::out << "Searching for key = (" << key.first << ", " << key.second << ")" << std::endl;
 
              // We require that the user provided either no values for
              // this (var, elemset) combination (in which case we don't
              // reach this point) or a value for _every_ elem in this
              // elemset for this var, so we use the libmesh_map_find()
              // macro to check for this.
              elemset_var_vals[i] = libmesh_map_find(data_map, key);
            } // end for (node in nodeset[ns])
 
          // Write elemset values to Exodus file
          if (elemset_var_vals.size() > 0)
            {
              ex_err = exII::ex_put_var
                (ex_id,
                 timestep,
                 exII::EX_ELEM_SET,
                 var + 1, // 1-based variable index of current variable
                 elemset_ids[es],
                 num_elems_per_set[es],
                 MappedOutputVector(elemset_var_vals, _single_precision).data());
              EX_CHECK_ERR(ex_err, "Error writing elemset vars.");
            }
        } // end for (var in var_names)
    } // end for (ns)
 
  // Finally, write the elemset truth table to file.
  ex_err =
    exII::ex_put_truth_table(ex_id,
                             exII::EX_ELEM_SET, // exII::ex_entity_type
                             num_elem_sets,
                             cast_int<int>(var_names.size()),
                             elemset_var_tab.data());
  EX_CHECK_ERR(ex_err, "Error writing elemset var truth table.");
}

◆ write_elemsets()

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

inherited

Write elemsets stored on the Mesh to the exo file.

Definition at line 4085 of file exodusII_io_helper.C.

{
  LOG_SCOPE("write_elemsets()", "ExodusII_IO_Helper");
 
  if ((_run_only_on_proc0) && (this->processor_id() != 0))
    return;
 
  // TODO: Add support for named elemsets
  // NamesData names_table(elemsets.size(), _max_name_length);
 
  // We only need to write elemsets if the Mesh has an extra elem
  // integer called "elemset_code" defined on it.
  if (mesh.has_elem_integer("elemset_code"))
    {
      std::map<elemset_id_type, std::vector<int>> exodus_elemsets;
 
      unsigned int elemset_index =
        mesh.get_elem_integer_index("elemset_code");
 
      // Catch ids returned from MeshBase::get_elemsets() calls
      MeshBase::elemset_type set_ids;
      for (const auto & elem : mesh.element_ptr_range())
        {
          dof_id_type elemset_code =
            elem->get_extra_integer(elemset_index);
 
          // Look up which element set ids (if any) this elemset_code corresponds to.
          mesh.get_elemsets(elemset_code, set_ids);
 
          // Debugging
          // libMesh::out << "elemset_code = " << elemset_code << std::endl;
          // for (const auto & set_id : set_ids)
          //   libMesh::out << set_id << " ";
          // libMesh::out << std::endl;
 
          // Store this Elem id in every set to which it belongs.
          for (const auto & set_id : set_ids)
            exodus_elemsets[set_id].push_back(libmesh_elem_num_to_exodus[elem->id()]);
        }
 
      // Debugging: print contents of exodus_elemsets map
      // for (const auto & [set_id, elem_ids] : exodus_elemsets)
      //   {
      //     libMesh::out << "elemset " << set_id << ": ";
      //     for (const auto & elem_id : elem_ids)
      //       libMesh::out << elem_id << " ";
      //     libMesh::out << std::endl;
      //   }
 
      // Only continue if we actually had some elements in sets
      if (!exodus_elemsets.empty())
        {
          // Reserve space, loop over newly-created map, construct
          // exII::ex_set objects to be passed to exII::ex_put_sets(). Note:
          // we do non-const iteration since Exodus requires non-const pointers
          // to be passed to its APIs.
          std::vector<exII::ex_set> sets;
          sets.reserve(exodus_elemsets.size());
 
          for (auto & [elem_set_id, ids_vec] : exodus_elemsets)
            {
              // TODO: Add support for named elemsets
              // names_table.push_back_entry(mesh.get_elemset_name(elem_set_id));
 
              exII::ex_set & current_set = sets.emplace_back();
              current_set.id = elem_set_id;
              current_set.type = exII::EX_ELEM_SET;
              current_set.num_entry = ids_vec.size();
              current_set.num_distribution_factor = 0;
              current_set.entry_list = ids_vec.data();
              current_set.extra_list = nullptr; // extra_list is used for sidesets, not needed for elemsets
              current_set.distribution_factor_list = nullptr; // not used for elemsets
            }
 
          // Sanity check: make sure the number of elemsets we already wrote to the header
          // matches the number of elemsets we just constructed by looping over the Mesh.
          libmesh_assert_msg(num_elem_sets == cast_int<int>(exodus_elemsets.size()),
                             "Mesh has " << exodus_elemsets.size()
                             << " elemsets, but header was written with num_elem_sets == " << num_elem_sets);
          libmesh_assert_msg(num_elem_sets == cast_int<int>(mesh.n_elemsets()),
                             "mesh.n_elemsets() == " << mesh.n_elemsets()
                             << ", but header was written with num_elem_sets == " << num_elem_sets);
 
          ex_err = exII::ex_put_sets(ex_id, exodus_elemsets.size(), sets.data());
          EX_CHECK_ERR(ex_err, "Error writing elemsets");
 
          // TODO: Add support for named elemsets
          // ex_err = exII::ex_put_names(ex_id, exII::EX_ELEM_SET, names_table.get_char_star_star());
          // EX_CHECK_ERR(ex_err, "Error writing elemset names");
        } // end if (!exodus_elemsets.empty())
    } // end if (mesh.has_elem_integer("elemset_code"))
}

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::MeshBase::get_elem_integer_index(), libMesh::MeshBase::get_elemsets(), libMesh::MeshBase::has_elem_integer(), libMesh::ExodusII_IO_Helper::libmesh_elem_num_to_exodus, mesh, libMesh::MeshBase::n_elemsets(), libMesh::ExodusII_IO_Helper::num_elem_sets, and libMesh::ParallelObject::processor_id().

◆ write_exodus_initialization_info()

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

private

This function writes exodus-specific initialization information.

This information is slightly different when you are working with Nemesis, as it depends on some global information being known.

Definition at line 919 of file nemesis_io_helper.C.

{
  this->num_elem = static_cast<unsigned int>(std::distance (pmesh.active_local_elements_begin(),
                                                            pmesh.active_local_elements_end()));
 
  // Exodus will also use *global* number of side and node sets,
  // though it will not write out entries for all of them...
  this->num_side_sets =
    cast_int<int>(this->global_sideset_ids.size());
  this->num_node_sets =
    cast_int<int>(this->global_nodeset_ids.size());
 
  // We need to write the global number of blocks, even though this processor might not have
  // elements in some of them!
  this->num_elem_blk = this->num_elem_blks_global;
 
  ex_err = exII::ex_put_init(ex_id,
                             title_in.c_str(),
                             this->num_dim,
                             this->num_nodes,
                             this->num_elem,
                             this->num_elem_blk,
                             this->num_node_sets,
                             this->num_side_sets);
 
  EX_CHECK_ERR(ex_err, "Error initializing new Nemesis file.");
}

References libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, global_nodeset_ids, global_sideset_ids, libMesh::ExodusII_IO_Helper::num_elem, libMesh::ExodusII_IO_Helper::num_elem_blk, num_elem_blks_global, libMesh::ExodusII_IO_Helper::num_node_sets, and libMesh::ExodusII_IO_Helper::num_side_sets.

Referenced by initialize().

◆ write_global_values()

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

inherited

Writes the vector of global variables.

Definition at line 5286 of file exodusII_io_helper.C.

{
  if ((_run_only_on_proc0) && (this->processor_id() != 0))
    return;
 
  if (!values.empty())
    {
      ex_err = exII::ex_put_var
        (ex_id,
         timestep,
         exII::EX_GLOBAL,
         1, // var index
         0, // obj_id (not used)
         num_global_vars,
         MappedOutputVector(values, _single_precision).data());
 
      EX_CHECK_ERR(ex_err, "Error writing global values.");
 
      this->update();
    }
}

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

◆ write_information_records()

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

inherited

Writes the vector of information records.

Definition at line 5248 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(*this, 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.");
 
      this->update();
    }
}

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::err, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::update().

◆ write_nodal_coordinates()

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

overridevirtual

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

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 2224 of file nemesis_io_helper.C.

{
  auto local_num_nodes = this->exodus_node_num_to_libmesh.size();
 
  x.resize(local_num_nodes);
  y.resize(local_num_nodes);
  z.resize(local_num_nodes);
 
  // Just loop over our list outputting the nodes the way we built the map
  for (auto i : make_range(local_num_nodes))
    {
      const Point & pt = mesh.point(this->exodus_node_num_to_libmesh[i]-1);
      x[i]=pt(0);
      y[i]=pt(1);
      z[i]=pt(2);
    }
 
  if (local_num_nodes)
    {
      // Call Exodus API to write nodal coordinates...
      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 node coordinates");
 
      // And write the nodal map we created for them
      ex_err = exII::ex_put_node_num_map(ex_id, this->exodus_node_num_to_libmesh.data());
      EX_CHECK_ERR(ex_err, "Error writing node num map");
    }
  else // Does the Exodus API want us to write empty nodal coordinates?
    {
      ex_err = exII::ex_put_coord(ex_id, nullptr, nullptr, nullptr);
      EX_CHECK_ERR(ex_err, "Error writing empty node coordinates");
 
      ex_err = exII::ex_put_node_num_map(ex_id, nullptr);
      EX_CHECK_ERR(ex_err, "Error writing empty node num map");
    }
}

References libMesh::ExodusII_IO_Helper::_single_precision, libMesh::ExodusII_IO_Helper::MappedOutputVector::data(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::exodus_node_num_to_libmesh, libMesh::make_range(), mesh, libMesh::ExodusII_IO_Helper::x, libMesh::ExodusII_IO_Helper::y, and libMesh::ExodusII_IO_Helper::z.

◆ write_nodal_solution() [1/3]

void libMesh::Nemesis_IO_Helper::write_nodal_solution	(	const EquationSystems &	es,
		const std::vector< std::pair< unsigned int, unsigned int > > &	var_nums,
		int	timestep,
		const std::vector< std::string > &	output_names
	)

Outputs EquationSystems current_local_solution nodal values.

Definition at line 2450 of file nemesis_io_helper.C.

{
  const MeshBase & mesh = es.get_mesh();
 
  // FIXME - half this code might be replaceable with a call to
  // EquationSystems::build_parallel_solution_vector()...
 
  for (auto [sys_num, var] : var_nums)
    {
      const System & sys = es.get_system(sys_num);
      const std::string & name = sys.variable_name(var);
 
      auto pos = std::find(output_names.begin(), output_names.end(), name);
 
      // Skip this name if it's not supposed to be output.
      if (pos == output_names.end())
        continue;
 
      // Compute the (zero-based) index which determines which
      // variable this will be as far as Nemesis is concerned.  This
      // will be used below in the write_nodal_values() call.
      int variable_name_position =
        cast_int<int>(std::distance(output_names.begin(), pos));
 
      // Fill up a std::vector with the dofs for the current variable
      std::vector<numeric_index_type> required_indices(this->num_nodes);
 
      // Get the dof values required to write just our local part of
      // the solution vector.
      std::vector<Number> local_soln;
 
      const FEType type = sys.variable_type(var);
      if (type.family == SCALAR)
        {
          std::vector<numeric_index_type> scalar_indices;
          sys.get_dof_map().SCALAR_dof_indices(scalar_indices, var);
          for (int i=0; i<this->num_nodes; i++)
            required_indices[i] = scalar_indices[0];
          sys.current_local_solution->get(required_indices, local_soln);
        }
      else
        {
          // If we have DoFs at all nodes, e.g. for isoparametric
          // elements, this is easy:
          bool found_all_indices = true;
          for (int i=0; i<this->num_nodes; i++)
            {
              const Node & node = mesh.node_ref(this->exodus_node_num_to_libmesh[i]-1);
              if (node.n_comp(sys_num, var))
                required_indices[i] = node.dof_number(sys_num, var, 0);
              else
                {
                  found_all_indices = false;
                  break;
                }
            }
 
          if (found_all_indices)
            sys.current_local_solution->get(required_indices, local_soln);
          // Fine, we'll do it the hard way
          if (!found_all_indices)
            {
              local_soln.resize(num_nodes);
 
              const Variable & var_description = sys.variable(var);
              const DofMap & dof_map           = sys.get_dof_map();
 
              NumericVector<Number> & sys_soln(*sys.current_local_solution);
              std::vector<Number>      elem_soln;   // The finite element solution
              std::vector<Number>      nodal_soln;  // The FE solution interpolated to the nodes
              std::vector<dof_id_type> dof_indices; // The DOF indices for the finite element
 
              for (const auto & elem : mesh.active_local_element_ptr_range())
                if (var_description.active_on_subdomain(elem->subdomain_id()))
                  {
                    dof_map.dof_indices (elem, dof_indices, var);
                    elem_soln.resize(dof_indices.size());
 
                    for (auto i : index_range(dof_indices))
                      elem_soln[i] = sys_soln(dof_indices[i]);
 
                    FEInterface::nodal_soln (elem->dim(),
                                             type,
                                             elem,
                                             elem_soln,
                                             nodal_soln);
 
                    // infinite elements should be skipped...
                    if (!elem->infinite())
                      for (auto n : elem->node_index_range())
                        {
                          const std::size_t exodus_num =
                            libmesh_node_num_to_exodus[elem->node_id(n)];
                          libmesh_assert_greater(exodus_num, 0);
                          libmesh_assert_less(exodus_num-1, local_soln.size());
                          local_soln[exodus_num-1] = nodal_soln[n];
                        }
                  }
            }
        }
 
#ifndef LIBMESH_USE_COMPLEX_NUMBERS
      // Call the ExodusII_IO_Helper function to write the data.
      write_nodal_values(variable_name_position + 1, local_soln, timestep);
#else
      // We have the local (complex) values. Now extract the real,
      // imaginary, and magnitude values from them.
      std::vector<Real> real_parts(num_nodes);
      std::vector<Real> imag_parts(num_nodes);
      std::vector<Real> magnitudes(num_nodes);
 
      for (int i=0; i<num_nodes; ++i)
        {
          real_parts[i] = local_soln[i].real();
          imag_parts[i] = local_soln[i].imag();
          magnitudes[i] = std::abs(local_soln[i]);
        }
 
      // Write the real, imaginary, and magnitude values to file.
      write_nodal_values(3 * variable_name_position + 1, real_parts, timestep);
      write_nodal_values(3 * variable_name_position + 2, imag_parts, timestep);
      write_nodal_values(3 * variable_name_position + 3, magnitudes, timestep);
#endif
    }
}

References libMesh::Variable::active_on_subdomain(), libMesh::System::current_local_solution, libMesh::DofMap::dof_indices(), libMesh::DofObject::dof_number(), libMesh::ExodusII_IO_Helper::exodus_node_num_to_libmesh, libMesh::FEType::family, libMesh::System::get_dof_map(), libMesh::EquationSystems::get_mesh(), libMesh::EquationSystems::get_system(), libMesh::index_range(), libMesh::ExodusII_IO_Helper::libmesh_node_num_to_exodus, mesh, libMesh::DofObject::n_comp(), libMesh::FEInterface::nodal_soln(), libMesh::ExodusII_IO_Helper::num_nodes, libMesh::SCALAR, libMesh::DofMap::SCALAR_dof_indices(), libMesh::System::variable(), libMesh::System::variable_name(), libMesh::System::variable_type(), and libMesh::ExodusII_IO_Helper::write_nodal_values().

◆ write_nodal_solution() [2/3]

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

Takes a parallel solution vector containing the node-major solution vector for all variables and outputs it to the files.

Parameters

parallel_soln
names	A vector containing the names of all variables in parallel_soln.
timestep	To be passed to the ExodusII_IO_Helper::write_nodal_values() function.
output_names	A vector containing the names of variables in parallel_soln that should actually be written (whitelist).

Note: This version of write_nodal_solution() is called by the parallel version of Nemesis_IO::write_nodal_data(), which is called by MeshOutput::write_equation_systems() for parallel I/O formats like Nemesis. The other version is still available to continue supporting things like NamebasedIO::write_nodal_data(), but this version should be preferred when running in parallel.

Definition at line 2390 of file nemesis_io_helper.C.

{
  int num_vars = cast_int<int>(names.size());
 
  for (int c=0; c<num_vars; c++)
    {
      // Find the position of names[c] in the output_names vector, if it exists.
      auto pos = std::find(output_names.begin(), output_names.end(), names[c]);
 
      // Skip names[c] if it's not supposed to be output.
      if (pos == output_names.end())
        continue;
 
      // Compute the (zero-based) index which determines which
      // variable this will be as far as Nemesis is concerned.  This
      // will be used below in the write_nodal_values() call.
      int variable_name_position =
        cast_int<int>(std::distance(output_names.begin(), pos));
 
      // Fill up a std::vector with the dofs for the current variable
      std::vector<numeric_index_type> required_indices(this->num_nodes);
 
      for (int i=0; i<this->num_nodes; i++)
        required_indices[i] = static_cast<dof_id_type>(this->exodus_node_num_to_libmesh[i]-1) * num_vars + c;
 
      // Get the dof values required to write just our local part of
      // the solution vector.
      std::vector<Number> local_soln;
      parallel_soln.localize(local_soln, required_indices);
 
#ifndef LIBMESH_USE_COMPLEX_NUMBERS
      // Call the ExodusII_IO_Helper function to write the data.
      write_nodal_values(variable_name_position + 1, local_soln, timestep);
#else
      // We have the local (complex) values. Now extract the real,
      // imaginary, and magnitude values from them.
      std::vector<Real> real_parts(num_nodes);
      std::vector<Real> imag_parts(num_nodes);
      std::vector<Real> magnitudes(num_nodes);
 
      for (int i=0; i<num_nodes; ++i)
        {
          real_parts[i] = local_soln[i].real();
          imag_parts[i] = local_soln[i].imag();
          magnitudes[i] = std::abs(local_soln[i]);
        }
 
      // Write the real, imaginary, and magnitude values to file.
      write_nodal_values(3 * variable_name_position + 1, real_parts, timestep);
      write_nodal_values(3 * variable_name_position + 2, imag_parts, timestep);
      write_nodal_values(3 * variable_name_position + 3, magnitudes, timestep);
#endif
    }
}

References libMesh::ExodusII_IO_Helper::exodus_node_num_to_libmesh, libMesh::NumericVector< T >::localize(), libMesh::ExodusII_IO_Helper::num_nodes, and libMesh::ExodusII_IO_Helper::write_nodal_values().

◆ write_nodal_solution() [3/3]

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

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

Definition at line 2352 of file nemesis_io_helper.C.

{
  int num_vars = cast_int<int>(names.size());
  //int num_values = values.size(); // Not used?
 
  for (int c=0; c<num_vars; c++)
    {
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
      std::vector<Real> real_parts(num_nodes);
      std::vector<Real> imag_parts(num_nodes);
      std::vector<Real> magnitudes(num_nodes);
 
      for (int i=0; i<num_nodes; ++i)
        {
          Number value = values[(this->exodus_node_num_to_libmesh[i]-1)*num_vars + c];
          real_parts[i] = value.real();
          imag_parts[i] = value.imag();
          magnitudes[i] = std::abs(value);
        }
      write_nodal_values(3*c+1,real_parts,timestep);
      write_nodal_values(3*c+2,imag_parts,timestep);
      write_nodal_values(3*c+3,magnitudes,timestep);
#else
      std::vector<Number> cur_soln(this->num_nodes);
 
      // Copy out this variable's solution
      for (int i=0; i<this->num_nodes; i++)
        cur_soln[i] = values[(this->exodus_node_num_to_libmesh[i]-1)*num_vars + c];
 
      write_nodal_values(c+1,cur_soln,timestep);
#endif
    }
}

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

◆ write_nodal_values()

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

inherited

Writes the vector of values to a nodal variable.

Definition at line 5220 of file exodusII_io_helper.C.

{
  if ((_run_only_on_proc0) && (this->processor_id() != 0))
    return;
 
  if (!values.empty())
    {
      libmesh_assert_equal_to(values.size(), std::size_t(num_nodes));
 
      ex_err = exII::ex_put_var
        (ex_id,
         timestep,
         exII::EX_NODAL,
         var_id,
         1, // exII::ex_entity_id, not sure exactly what this is but in the ex_put_nodal_var.c shim, they pass 1
         num_nodes,
         MappedOutputVector(values, _single_precision).data());
 
      EX_CHECK_ERR(ex_err, "Error writing nodal values.");
 
      this->update();
    }
}

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

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

◆ write_nodeset_data()

void libMesh::ExodusII_IO_Helper::write_nodeset_data	(	int	timestep,
		const std::vector< std::string > &	var_names,
		const std::vector< std::set< boundary_id_type > > &	node_boundary_ids,
		const std::vector< std::map< BoundaryInfo::NodeBCTuple, Real > > &	bc_vals
	)

inherited

Write nodeset data for the requested timestep.

Definition at line 4473 of file exodusII_io_helper.C.

{
  LOG_SCOPE("write_nodeset_data()", "ExodusII_IO_Helper");
 
  if ((_run_only_on_proc0) && (this->processor_id() != 0))
    return;
 
  // Write the nodeset variable names to file. This function should
  // only be called once for NODESET 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(NODESET, var_names);
 
  // For all nodesets, reads and fills in the arrays:
  // nodeset_ids
  // num_nodes_per_set
  // node_sets_node_index - starting index for each nodeset in the node_sets_node_list vector
  // node_sets_node_list
  // Note: we need these arrays so that we know what data to write
  this->read_all_nodesets();
 
  // The "truth" table for nodeset variables. nset_var_tab is a
  // logically (num_node_sets x num_nset_var) integer array of 0s and
  // 1s indicating which nodesets a given nodeset variable is defined
  // on.
  std::vector<int> nset_var_tab(num_node_sets * var_names.size());
 
  for (int ns=0; ns<num_node_sets; ++ns)
  {
    // The offset into the node_sets_node_list for the current nodeset
    int offset = node_sets_node_index[ns];
 
    // For each variable in var_names, write the values for the
    // current nodeset, if any.
    for (auto var : index_range(var_names))
      {
        // If this var has no values on this nodeset, go to the next one.
        if (!node_boundary_ids[var].count(nodeset_ids[ns]))
          continue;
 
        // Otherwise, fill in this entry of the nodeset truth table.
        nset_var_tab[ns*var_names.size() + var] = 1;
 
        // Data vector that will eventually be passed to exII::ex_put_var().
        std::vector<Real> nset_var_vals(num_nodes_per_set[ns]);
 
        // Get reference to the NodeBCTuple -> Real map for this variable.
        const auto & data_map = bc_vals[var];
 
        // Loop over entries in current nodeset.
        for (int i=0; i<num_nodes_per_set[ns]; ++i)
          {
            // Here we convert Exodus node ids to libMesh node ids by
            // subtracting 1.  We should probably use the
            // exodus_node_num_to_libmesh data structure for this, but
            // I don't think it is set up at the time when
            // write_nodeset_data() would normally be called.
            dof_id_type libmesh_node_id = node_sets_node_list[i + offset] - 1;
 
            // Construct a key to look up values in data_map.
            BoundaryInfo::NodeBCTuple key =
              std::make_tuple(libmesh_node_id, nodeset_ids[ns]);
 
            // We require that the user provided either no values for
            // this (var, nodeset) combination (in which case we don't
            // reach this point) or a value for _every_ node in this
            // nodeset for this var, so we use the libmesh_map_find()
            // macro to check for this.
            nset_var_vals[i] = libmesh_map_find(data_map, key);
          } // end for (node in nodeset[ns])
 
        // Write nodeset values to Exodus file
        if (nset_var_vals.size() > 0)
          {
            ex_err = exII::ex_put_var
              (ex_id,
               timestep,
               exII::EX_NODE_SET,
               var + 1, // 1-based variable index of current variable
               nodeset_ids[ns],
               num_nodes_per_set[ns],
               MappedOutputVector(nset_var_vals, _single_precision).data());
            EX_CHECK_ERR(ex_err, "Error writing nodeset vars.");
          }
      } // end for (var in var_names)
  } // end for (ns)
 
  // Finally, write the nodeset truth table.
  ex_err =
    exII::ex_put_truth_table(ex_id,
                             exII::EX_NODE_SET,
                             num_node_sets,
                             cast_int<int>(var_names.size()),
                             nset_var_tab.data());
  EX_CHECK_ERR(ex_err, "Error writing nodeset var truth table.");
}

◆ write_nodesets()

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

overridevirtual

Writes the nodesets for this processor.

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 1934 of file nemesis_io_helper.C.

{
  // Write the nodesets.  In Nemesis, the idea is to "create space" for the global
  // set of boundary nodesets, but to only write node IDs which are local to the current
  // processor.  This is what is done in Nemesis files created by the "loadbal" script.
 
  // Store a map of vectors for boundary node IDs on this processor.
  // Use a vector of int here so it can be passed directly to Exodus.
  std::map<boundary_id_type, std::vector<int>> local_node_boundary_id_lists;
 
  // FIXME: We should build this list only one time!!  We already built it above, but we
  // did not have the libmesh to exodus node mapping at that time... for now we'll just
  // build it here again, hopefully it's small relative to the size of the entire mesh.
 
  // Build list of (node-id, bc-id) tuples.
  typedef std::tuple<dof_id_type, boundary_id_type> Tuple;
  std::vector<Tuple> bc_tuples = mesh.get_boundary_info().build_node_list();
 
  if (verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] boundary_node_list.size()="
                   << bc_tuples.size() << std::endl;
      libMesh::out << "[" << this->processor_id() << "] (boundary_node_id, boundary_id) = ";
      for (const auto & t : bc_tuples)
        libMesh::out << "(" << std::get<0>(t) << ", " << std::get<1>(t) << ") ";
      libMesh::out << std::endl;
    }
 
  // For each node in the node list, add it to the vector of node IDs for that
  // set for the local processor.  This will be used later when writing Exodus
  // nodesets.
  for (const auto & t : bc_tuples)
    {
      // Don't try to grab a reference to the vector unless the current node is attached
      // to a local element.  Otherwise, another processor will be responsible for writing it in its nodeset.
      if (const auto it = this->libmesh_node_num_to_exodus.find(std::get<0>(t));
          it != this->libmesh_node_num_to_exodus.end())
        {
          // Get reference to the vector where this node ID will be inserted.  If it
          // doesn't yet exist, this will create it.
          std::vector<int> & current_id_set = local_node_boundary_id_lists[std::get<1>(t)];
 
          // Push back Exodus-mapped node ID for this set
          // TODO: reserve space in these vectors somehow.
          current_id_set.push_back( it->second );
        }
    }
 
  // See what we got
  if (verbose)
    {
      for (const auto & [bndry_id, set] : local_node_boundary_id_lists)
        {
          libMesh::out << "[" << this->processor_id() << "] ID: " << bndry_id << ", ";
 
          // Libmesh node ID (Exodus Node ID)
          for (const auto & id : set)
            libMesh::out << id << ", ";
          libMesh::out << std::endl;
        }
    }
 
  // Loop over *global* nodeset IDs, call the Exodus API.  Note that some nodesets may be empty
  // for a given processor.
  if (global_nodeset_ids.size() > 0)
    {
      NamesData names_table(global_nodeset_ids.size(), MAX_STR_LENGTH);
 
      for (const auto & nodeset_id : this->global_nodeset_ids)
        {
          const std::string & current_ns_name =
            mesh.get_boundary_info().get_nodeset_name
              (cast_int<boundary_id_type>(nodeset_id));
 
          // Store this name in a data structure that will be used to
          // write sideset names to file.
          names_table.push_back_entry(current_ns_name);
 
          if (verbose)
            {
              libMesh::out << "[" << this->processor_id()
                           << "] Writing out Exodus nodeset info for ID: " << nodeset_id
                           << ", Name: " << current_ns_name
                           << std::endl;
            }
 
          // Convert current global_nodeset_id into an exodus ID, which can't be zero...
          int exodus_id = nodeset_id;
 
          /*
          // Exodus can't handle zero nodeset IDs (?)  Use max short here since
          // when libmesh reads it back in, it will want to store it as a short...
          if (exodus_id==0)
          exodus_id = std::numeric_limits<short>::max();
          */
 
          // Try to find this boundary ID in the local list we created
          if (const auto it = local_node_boundary_id_lists.find (cast_int<boundary_id_type>(nodeset_id));
              it == local_node_boundary_id_lists.end())
            {
              // No nodes found for this boundary ID on this processor
              if (verbose)
                libMesh::out << "[" << this->processor_id()
                             << "] No nodeset data for ID: " << nodeset_id
                             << " on this processor." << std::endl;
 
              // Call the Exodus interface to write the parameters of this node set
              this->ex_err = exII::ex_put_node_set_param(this->ex_id,
                                                         exodus_id,
                                                         0, /* No nodes for this ID */
                                                         0  /* No distribution factors */);
              EX_CHECK_ERR(this->ex_err, "Error writing nodeset parameters in Nemesis");
 
            }
          else // Boundary ID *was* found in list
            {
              // Get reference to the vector of node IDs
              const std::vector<int> & current_nodeset_ids = it->second;
 
              // Call the Exodus interface to write the parameters of this node set
              this->ex_err = exII::ex_put_node_set_param(this->ex_id,
                                                         exodus_id,
                                                         current_nodeset_ids.size(),
                                                         0  /* No distribution factors */);
 
              EX_CHECK_ERR(this->ex_err, "Error writing nodeset parameters in Nemesis");
 
              // Call Exodus interface to write the actual node IDs for this boundary ID
              this->ex_err = exII::ex_put_node_set(this->ex_id,
                                                   exodus_id,
                                                   current_nodeset_ids.data());
 
              EX_CHECK_ERR(this->ex_err, "Error writing nodesets in Nemesis");
 
            }
        } // end loop over global nodeset IDs
 
      // 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");
    } // end for loop over global nodeset IDs
}

References libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::NamesData::get_char_star_star(), global_nodeset_ids, libMesh::ExodusII_IO_Helper::libmesh_node_num_to_exodus, mesh, libMesh::out, libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO_Helper::NamesData::push_back_entry(), and libMesh::ExodusII_IO_Helper::verbose.

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

inherited

Write sideset data for the requested timestep.

Definition at line 4181 of file exodusII_io_helper.C.

{
  LOG_SCOPE("write_sideset_data()", "ExodusII_IO_Helper");
 
  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();
 
  // Write "truth" table for sideset variables.  The function
  // exII::ex_put_variable_param() must be called before
  // exII::ex_put_truth_table(). 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);
 
      // 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_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.
              libmesh_error_msg_if
                (libmesh_map_find(libmesh_elem_num_to_exodus, cast_int<int>(elem_id)) !=
                 cast_int<dof_id_type>(elem_list[i + offset]),
                 "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);
 
              // 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_var
                (ex_id,
                 timestep,
                 exII::EX_SIDE_SET,
                 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_truth_table(ex_id,
                             exII::EX_SIDE_SET,
                             num_side_sets,
                             cast_int<int>(var_names.size()),
                             sset_var_tab.data());
  EX_CHECK_ERR(ex_err, "Error writing sideset var truth table.");
}

◆ write_sidesets()

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

overridevirtual

Writes the sidesets for this processor.

Reimplemented from libMesh::ExodusII_IO_Helper.

Definition at line 2082 of file nemesis_io_helper.C.

{
  // Write the sidesets.  In Nemesis, the idea is to "create space" for the global
  // set of boundary sidesets, but to only write sideset IDs which are local to the current
  // processor.  This is what is done in Nemesis files created by the "loadbal" script.
  // See also: ExodusII_IO_Helper::write_sidesets()...
 
 
  // Store a map of vectors for boundary side IDs on this processor.
  // Use a vector of int here so it can be passed directly to Exodus.
  std::map<boundary_id_type, std::vector<int>> local_elem_boundary_id_lists;
  std::map<boundary_id_type, std::vector<int>> local_elem_boundary_id_side_lists;
 
  // FIXME: We already built this list once, we should reuse that information!
  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> bndry_elem_side_id_list =
    mesh.get_boundary_info().build_side_list();
 
  // Integer looping, skipping non-local elements
  for (const auto & t : bndry_elem_side_id_list)
    {
      // Get pointer to current Elem
      const Elem * elem = mesh.elem_ptr(std::get<0>(t));
 
      std::vector<const Elem *> family;
#ifdef LIBMESH_ENABLE_AMR
      // We need to build up active elements if AMR is enabled and add
      // them to the exodus sidesets instead of the potentially inactive "parent" elements
      // Technically we don't need to "reset" the tree since the vector was just created.
      elem->active_family_tree_by_side(family, std::get<1>(t), /*reset tree=*/false);
#else
      // If AMR is not even enabled, just push back the element itself
      family.push_back( elem );
#endif
 
      // Loop over all the elements in the family tree, store their converted IDs
      // and side IDs to the map's vectors.  TODO: Somehow reserve enough space for these
      // push_back's...
      for (const auto & tree_elem : family)
        {
          const dof_id_type f_id = tree_elem->id();
          const Elem & f = mesh.elem_ref(f_id);
 
          // If element is local, process it
          if (f.processor_id() == this->processor_id())
            {
              const auto & conv = get_conversion(f.type());
 
              // Use the libmesh to exodus data structure map to get the proper sideset IDs
              // The data structure contains the "collapsed" contiguous ids.
              //
              // We know the parent element is local, but let's be absolutely sure that all the children have been
              // actually mapped to Exodus IDs before we blindly try to add them...
              local_elem_boundary_id_lists[ std::get<2>(t) ].push_back( libmesh_map_find(libmesh_elem_num_to_exodus, f_id) );
              local_elem_boundary_id_side_lists[ std::get<2>(t) ].push_back(conv.get_inverse_side_map( std::get<1>(t) ));
            }
        }
    }
 
 
  // Loop over *global* sideset IDs, call the Exodus API.  Note that some sidesets may be empty
  // for a given processor.
  if (global_sideset_ids.size() > 0)
    {
      NamesData names_table(global_sideset_ids.size(), MAX_STR_LENGTH);
 
      for (const auto & exodus_id : this->global_sideset_ids)
        {
          const std::string & current_ss_name =
            mesh.get_boundary_info().get_sideset_name
              (cast_int<boundary_id_type>(exodus_id));
 
          // Store this name in a data structure that will be used to
          // write sideset names to file.
          names_table.push_back_entry(current_ss_name);
 
          if (verbose)
            {
              libMesh::out << "[" << this->processor_id()
                           << "] Writing out Exodus sideset info for ID: " << exodus_id
                           << ", Name: " << current_ss_name
                           << std::endl;
            }
 
          // Try to find this boundary ID in the local list we created
          if (const auto it = local_elem_boundary_id_lists.find (cast_int<boundary_id_type>(exodus_id));
              it == local_elem_boundary_id_lists.end())
            {
              // No sides found for this boundary ID on this processor
              if (verbose)
                libMesh::out << "[" << this->processor_id()
                             << "] No sideset data for ID: " << exodus_id
                             << " on this processor." << std::endl;
 
              // Call the Exodus interface to write the parameters of this side set
              this->ex_err = exII::ex_put_side_set_param(this->ex_id,
                                                         exodus_id,
                                                         0, /* No sides for this ID */
                                                         0  /* No distribution factors */);
              EX_CHECK_ERR(this->ex_err, "Error writing sideset parameters in Nemesis");
 
            }
          else // Boundary ID *was* found in list
            {
              // Get reference to the vector of elem IDs
              const std::vector<int> & current_sideset_elem_ids = it->second;
 
              // Get reference to the vector of side IDs
              std::vector<int> & current_sideset_side_ids =
                libmesh_map_find(local_elem_boundary_id_side_lists,
                                 cast_int<boundary_id_type>(exodus_id));
 
              // Call the Exodus interface to write the parameters of this side set
              this->ex_err = exII::ex_put_side_set_param(this->ex_id,
                                                         exodus_id,
                                                         current_sideset_elem_ids.size(),
                                                         0  /* No distribution factors */);
 
              EX_CHECK_ERR(this->ex_err, "Error writing sideset parameters in Nemesis");
 
              // Call Exodus interface to write the actual side IDs for this boundary ID
              this->ex_err = exII::ex_put_side_set(this->ex_id,
                                                   exodus_id,
                                                   current_sideset_elem_ids.data(),
                                                   current_sideset_side_ids.data());
 
              EX_CHECK_ERR(this->ex_err, "Error writing sidesets in Nemesis");
            }
        } // end for loop over global sideset IDs
 
      // Write sideset names to file.  Some of these may be blank strings
      // if the current processor didn't have all the sideset names for
      // any reason...
      ex_err = exII::ex_put_names(this->ex_id,
                                  exII::EX_SIDE_SET,
                                  names_table.get_char_star_star());
      EX_CHECK_ERR(ex_err, "Error writing sideset names");
 
    } // end if (global_sideset_ids.size() > 0)
}

References libMesh::Elem::active_family_tree_by_side(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::NamesData::get_char_star_star(), libMesh::ExodusII_IO_Helper::get_conversion(), global_sideset_ids, libMesh::ExodusII_IO_Helper::libmesh_elem_num_to_exodus, mesh, libMesh::out, libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO_Helper::NamesData::push_back_entry(), libMesh::Elem::type(), and libMesh::ExodusII_IO_Helper::verbose.

◆ write_timestep()

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

inherited

Writes the time for the timestep.

Definition at line 4062 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.");
 
  this->update();
}

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

◆ write_var_names()

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

protectedinherited

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 2238 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;
      }
    case NODESET:
      {
        this->write_var_names_impl("m", num_nodeset_vars, names);
        break;
      }
    case ELEMSET:
      {
        this->write_var_names_impl("t", num_elemset_vars, names);
        break;
      }
    default:
      libmesh_error_msg("Unrecognized ExodusVarType " << type);
    }
}

Referenced by libMesh::ExodusII_IO_Helper::initialize_element_variables(), initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), and libMesh::ExodusII_IO_Helper::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
	)

privateinherited

write_var_names() dispatches to this function.

Definition at line 2278 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.");
 
  // Nemesis doesn't like trying to write nodal variable names in
  // files with no nodes.
  if (!this->num_nodes)
    return;
 
  if (count > 0)
    {
      NamesData names_table(count, _max_name_length);
 
      // Store the input names in the format required by Exodus.
      for (int i=0; i != count; ++i)
        {
          if(names[i].length() > _max_name_length)
            libmesh_warning(
              "*** Warning, Exodus variable name \"" <<
              names[i] << "\" too long (current max " <<
              _max_name_length << "/" << libmesh_max_str_length <<
              " characters). Name will be truncated. ");
          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.");
    }
}

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

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

Member Data Documentation

◆ _add_sides

bool libMesh::ExodusII_IO_Helper::_add_sides = false

privateinherited

Set to true iff we want to write separate "side" elements too.

Definition at line 1133 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_add_sides(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::set_add_sides(), libMesh::ExodusII_IO_Helper::write_elements(), and libMesh::ExodusII_IO_Helper::write_nodal_coordinates().

◆ _added_side_node_offsets

std::vector<dof_id_type> libMesh::ExodusII_IO_Helper::_added_side_node_offsets

protectedinherited

If we're adding "fake" sides to visualize SIDE_DISCONTINUOUS variables, _added_side_node_offsets[p] gives us the total solution vector offset to use on processor p+1 from the nodes on those previous ranks' sides.

Definition at line 1055 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::added_node_offset_on(), libMesh::ExodusII_IO_Helper::initialize(), and libMesh::ExodusII_IO_Helper::node_id_to_vec_id().

◆ _communicator

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

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

◆ _coordinate_offset

Point libMesh::ExodusII_IO_Helper::_coordinate_offset

protectedinherited

Definition at line 1044 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::set_coordinate_offset(), and libMesh::ExodusII_IO_Helper::write_nodal_coordinates().

◆ _elem_vars_initialized

bool libMesh::ExodusII_IO_Helper::_elem_vars_initialized

protectedinherited

Definition at line 1016 of file exodusII_io_helper.h.

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

◆ _end_elem_id

int libMesh::ExodusII_IO_Helper::_end_elem_id

protectedinherited

Definition at line 1037 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::end_elem_id(), and libMesh::ExodusII_IO_Helper::read_elem_num_map().

◆ _global_vars_initialized

bool libMesh::ExodusII_IO_Helper::_global_vars_initialized

protectedinherited

Definition at line 1019 of file exodusII_io_helper.h.

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

◆ _max_name_length

unsigned int libMesh::ExodusII_IO_Helper::_max_name_length

protectedinherited

Definition at line 1034 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::create(), libMesh::ExodusII_IO_Helper::open(), libMesh::ExodusII_IO_Helper::set_max_name_length(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), and libMesh::ExodusII_IO_Helper::write_var_names_impl().

◆ _nodal_vars_initialized

bool libMesh::ExodusII_IO_Helper::_nodal_vars_initialized

protectedinherited

Definition at line 1022 of file exodusII_io_helper.h.

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

◆ _opened_by_create

bool libMesh::ExodusII_IO_Helper::_opened_by_create

protectedinherited

Definition at line 1013 of file exodusII_io_helper.h.

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

◆ _run_only_on_proc0

bool libMesh::ExodusII_IO_Helper::_run_only_on_proc0

protectedinherited

Definition at line 1010 of file exodusII_io_helper.h.

◆ _single_precision

bool libMesh::ExodusII_IO_Helper::_single_precision

protectedinherited

Definition at line 1047 of file exodusII_io_helper.h.

◆ _true_node_offsets

std::vector<dof_id_type> libMesh::ExodusII_IO_Helper::_true_node_offsets

protectedinherited

If we're adding "fake" sides to visualize SIDE_DISCONTINUOUS variables, we also need to know how many real nodes from previous ranks are taking up space in a solution vector.

Definition at line 1062 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::added_node_offset_on(), libMesh::ExodusII_IO_Helper::initialize(), and libMesh::ExodusII_IO_Helper::node_id_to_vec_id().

◆ _use_mesh_dimension_instead_of_spatial_dimension

bool libMesh::ExodusII_IO_Helper::_use_mesh_dimension_instead_of_spatial_dimension

protectedinherited

Definition at line 1027 of file exodusII_io_helper.h.

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

◆ _write_as_dimension

unsigned libMesh::ExodusII_IO_Helper::_write_as_dimension

protectedinherited

Definition at line 1041 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize(), initialize(), and libMesh::ExodusII_IO_Helper::write_as_dimension().

◆ _write_hdf5

bool libMesh::ExodusII_IO_Helper::_write_hdf5

protectedinherited

Definition at line 1031 of file exodusII_io_helper.h.

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

◆ bex_cv_conn

std::vector<std::vector<long unsigned int> > libMesh::ExodusII_IO_Helper::bex_cv_conn

inherited

Definition at line 852 of file exodusII_io_helper.h.

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

◆ bex_dense_constraint_vecs

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

inherited

Definition at line 856 of file exodusII_io_helper.h.

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

◆ bex_num_elem_cvs

unsigned int libMesh::ExodusII_IO_Helper::bex_num_elem_cvs

inherited

Definition at line 849 of file exodusII_io_helper.h.

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

◆ block_id_to_elem_connectivity

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

This is the block connectivity, i.e.

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

Definition at line 447 of file nemesis_io_helper.h.

Referenced by build_element_and_node_maps(), and write_elements().

◆ block_ids

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

inherited

Definition at line 755 of file exodusII_io_helper.h.

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

◆ border_elem_ids

std::set<unsigned> libMesh::Nemesis_IO_Helper::border_elem_ids

private

A set of border elem IDs for this processor.

Definition at line 641 of file nemesis_io_helper.h.

Referenced by compute_element_maps(), and compute_internal_and_border_elems_and_internal_nodes().

◆ border_node_ids

std::set<unsigned> libMesh::Nemesis_IO_Helper::border_node_ids

private

The set which will eventually contain the IDs of "border nodes".

These are nodes that lie on the boundary between one or more processors.

Definition at line 604 of file nemesis_io_helper.h.

Referenced by compute_border_node_ids(), and compute_node_maps().

◆ c0polyhedron_face_connect

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

inherited

Definition at line 770 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::open(), libMesh::ExodusII_IO_Helper::read_elem_in_block(), and libMesh::ExodusII_IO_Helper::read_face_blocks().

◆ connect

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

inherited

Definition at line 761 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_edge_blocks(), libMesh::ExodusII_IO_Helper::read_elem_in_block(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ conversion_map

std::map<int, std::map<ElemType, ExodusII_IO_Helper::Conversion> > libMesh::ExodusII_IO_Helper::conversion_map

privateinherited

Associates libMesh ElemTypes with node/face/edge/etc.

mappings of the corresponding Exodus element types.

We have to map based on both ElemType and mesh dimension, because Exodus treats "TRI" side numbering in two different ways depending on whether a triangle is embedded in a 2D or a 3D mesh.

Definition at line 1157 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_conversion(), and libMesh::ExodusII_IO_Helper::init_conversion_map().

◆ current_filename

std::string libMesh::ExodusII_IO_Helper::current_filename

inherited

Definition at line 939 of file exodusII_io_helper.h.

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

◆ edge_block_ids

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

inherited

Definition at line 758 of file exodusII_io_helper.h.

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

◆ elem_cmap_elem_cnts

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

Definition at line 549 of file nemesis_io_helper.h.

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

◆ elem_cmap_elem_ids

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

3 vectors of vectors for storing element communication IDs for this processor.

There will be num_elem_cmaps rows, row i will have elem_cmap_elem_cnts[i] entries. To be used with Nemesis::ne_get_elem_cmap().

Definition at line 569 of file nemesis_io_helper.h.

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

◆ elem_cmap_ids

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

Definition at line 548 of file nemesis_io_helper.h.

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

◆ elem_cmap_proc_ids

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

Definition at line 571 of file nemesis_io_helper.h.

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

◆ elem_cmap_side_ids

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

Definition at line 570 of file nemesis_io_helper.h.

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

◆ elem_face_counts

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

inherited

Definition at line 767 of file exodusII_io_helper.h.

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

◆ elem_list

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

inherited

Definition at line 816 of file exodusII_io_helper.h.

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

◆ elem_mapb

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

Vector which stores border element IDs.

Will have length num_border_elems. To be used with Nemesis::ne_get_elem_map().

Definition at line 514 of file nemesis_io_helper.h.

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

◆ elem_mapi

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

Vector which stores internal element IDs.

Will have length num_internal_elems. To be used with Nemesis::ne_get_elem_map().

Definition at line 507 of file nemesis_io_helper.h.

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

◆ elem_node_counts

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

inherited

Definition at line 764 of file exodusII_io_helper.h.

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

◆ elem_num_map

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

inherited

Definition at line 834 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::conditionally_set_elem_unique_id(), libMesh::ExodusII_IO_Helper::end_elem_id(), libMesh::ExodusII_IO_Helper::get_libmesh_elem_id(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ elem_type

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

inherited

Definition at line 859 of file exodusII_io_helper.h.

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

◆ elem_var_names

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

inherited

Definition at line 892 of file exodusII_io_helper.h.

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

◆ elem_var_values

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

inherited

Definition at line 895 of file exodusII_io_helper.h.

◆ element_equivalence_map

std::map<std::string, ElemType> libMesh::ExodusII_IO_Helper::element_equivalence_map

privateinherited

Defines equivalence classes of Exodus element types that map to libmesh ElemTypes.

Definition at line 1146 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_conversion(), and libMesh::ExodusII_IO_Helper::init_element_equivalence_map().

◆ elemset_id_list

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

inherited

Definition at line 828 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_elemset(), and libMesh::ExodusII_IO_Helper::read_elemset_info().

◆ elemset_ids

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

inherited

Definition at line 779 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_elemset_data_indices(), libMesh::ExodusII_IO_Helper::read_elemset(), libMesh::ExodusII_IO_Helper::read_elemset_data(), libMesh::ExodusII_IO_Helper::read_elemset_info(), and libMesh::ExodusII_IO_Helper::write_elemset_data().

◆ elemset_list

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

inherited

Definition at line 825 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_elemset_data_indices(), libMesh::ExodusII_IO_Helper::read_elemset(), libMesh::ExodusII_IO_Helper::read_elemset_data(), libMesh::ExodusII_IO_Helper::read_elemset_info(), and libMesh::ExodusII_IO_Helper::write_elemset_data().

◆ elemset_var_names

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

inherited

Definition at line 907 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_elemset_data(), and libMesh::ExodusII_IO_Helper::read_var_names().

◆ ex_err

int libMesh::ExodusII_IO_Helper::ex_err

inherited

Definition at line 680 of file exodusII_io_helper.h.

◆ ex_id

int libMesh::ExodusII_IO_Helper::ex_id

inherited

Definition at line 677 of file exodusII_io_helper.h.

◆ exodus_elem_num_to_libmesh

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

inherited

Definition at line 864 of file exodusII_io_helper.h.

Referenced by build_element_and_node_maps(), and write_elements().

◆ exodus_node_num_to_libmesh

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

inherited

Definition at line 869 of file exodusII_io_helper.h.

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

◆ ftype

char libMesh::Nemesis_IO_Helper::ftype

The type of file to be written.

Either 's', for a scalar load-balance file, or 'p' for a parallel file. To be used with Nemesis::ne_get_init_info().

Definition at line 396 of file nemesis_io_helper.h.

Referenced by get_init_info().

◆ global_elem_blk_cnts

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

Definition at line 431 of file nemesis_io_helper.h.

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

◆ global_elem_blk_ids

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

Read the global element block IDs and counts.

These vectors will eventually have num_elem_blks_global entries. To be used with Nemesis::ne_get_eb_info_global().

Definition at line 430 of file nemesis_io_helper.h.

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

◆ global_nodeset_ids

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

Containers for reading global nodeset information.

One vector entry per nodeset. Each vector will eventually have num_node_sets_global entries, and will be used in calls to Nemesis::ne_get_ns_param_global().

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

Definition at line 420 of file nemesis_io_helper.h.

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

◆ global_sideset_ids

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

Containers for reading global sideset (boundary conditions) information.

Each vector will eventually have num_side_sets_global entries, and be used in calls to Nemesis::ne_get_ss_param_global().

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

Definition at line 408 of file nemesis_io_helper.h.

Referenced by compute_num_global_sidesets(), get_ss_param_global(), initialize(), put_ss_param_global(), write_exodus_initialization_info(), and write_sidesets().

◆ global_var_names

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

inherited

Definition at line 898 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize_global_variables(), and libMesh::ExodusII_IO_Helper::read_var_names().

◆ header_info

ExodusHeaderInfo libMesh::ExodusII_IO_Helper::header_info

inherited

Definition at line 683 of file exodusII_io_helper.h.

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

◆ id_list

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

inherited

Definition at line 822 of file exodusII_io_helper.h.

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

◆ id_to_block_names

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

inherited

Definition at line 910 of file exodusII_io_helper.h.

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

◆ id_to_edge_block_names

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

inherited

Definition at line 911 of file exodusII_io_helper.h.

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

◆ id_to_elemset_names

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

inherited

Definition at line 914 of file exodusII_io_helper.h.

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

◆ id_to_ns_names

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

inherited

Definition at line 913 of file exodusII_io_helper.h.

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

◆ id_to_ss_names

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

inherited

Definition at line 912 of file exodusII_io_helper.h.

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

◆ internal_elem_ids

std::set<unsigned> libMesh::Nemesis_IO_Helper::internal_elem_ids

private

A set of internal elem IDs for this processor.

Definition at line 636 of file nemesis_io_helper.h.

Referenced by compute_element_maps(), and compute_internal_and_border_elems_and_internal_nodes().

◆ internal_node_ids

std::set<unsigned> libMesh::Nemesis_IO_Helper::internal_node_ids

private

A set of internal node IDs for this processor.

Definition at line 631 of file nemesis_io_helper.h.

Referenced by compute_internal_and_border_elems_and_internal_nodes(), and compute_node_maps().

◆ libmesh_elem_num_to_exodus

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

inherited

Definition at line 863 of file exodusII_io_helper.h.

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

◆ libmesh_node_num_to_exodus

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

inherited

Definition at line 868 of file exodusII_io_helper.h.

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

◆ local_subdomain_counts

std::map<subdomain_id_type, unsigned> libMesh::Nemesis_IO_Helper::local_subdomain_counts

private

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

Definition at line 598 of file nemesis_io_helper.h.

Referenced by build_element_and_node_maps(), and compute_num_global_elem_blocks().

◆ nemesis_err_flag

int libMesh::Nemesis_IO_Helper::nemesis_err_flag

Member data.

All (?) Nemesis functions return an int. If it's negative that signals an error! Internally, we use the ExodusII_IO_Helper::check_err() function to check for errors.

Definition at line 366 of file nemesis_io_helper.h.

Referenced by get_cmap_params(), get_eb_info_global(), get_elem_cmap(), get_elem_map(), get_init_global(), get_init_info(), get_loadbal_param(), get_node_cmap(), get_node_map(), get_ns_param_global(), get_ss_param_global(), put_cmap_params(), put_eb_info_global(), put_elem_cmap(), put_elem_map(), put_init_global(), put_init_info(), put_loadbal_param(), put_node_cmap(), put_node_map(), put_ns_param_global(), and put_ss_param_global().

◆ nodal_var_names

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

inherited

Definition at line 881 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::ExodusII_IO_Helper::read_nodal_var_values(), and libMesh::ExodusII_IO_Helper::read_var_names().

◆ nodal_var_values

std::map<dof_id_type, Real> libMesh::ExodusII_IO_Helper::nodal_var_values

inherited

Definition at line 886 of file exodusII_io_helper.h.

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

◆ node_cmap_ids

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

Vectors for storing the communication map parameters.

Each will eventually have length num_node_cmaps OR num_elem_cmaps as appropriate. For use with Nemesis::ne_get_cmap_params().

Definition at line 546 of file nemesis_io_helper.h.

Referenced by compute_communication_map_parameters(), compute_node_communication_maps(), get_cmap_params(), get_node_cmap(), initialize(), and put_node_cmap().

◆ node_cmap_node_cnts

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

Definition at line 547 of file nemesis_io_helper.h.

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

◆ node_cmap_node_ids

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

2 vectors of vectors for storing the node communication IDs for this processor.

There will be num_node_cmaps rows, row i will have node_cmap_node_cnts[i] entries. To be used with Nemesis::ne_get_node_cmap().

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

Definition at line 560 of file nemesis_io_helper.h.

Referenced by compute_node_communication_maps(), get_node_cmap(), and initialize().

◆ node_cmap_proc_ids

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

Definition at line 561 of file nemesis_io_helper.h.

Referenced by compute_node_communication_maps(), get_node_cmap(), and initialize().

◆ node_list

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

Definition at line 399 of file nemesis_io_helper.h.

Referenced by read_nodeset().

◆ node_mapb

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

Vector which stores border node IDs.

Will have length num_border_nodes. To be used with Nemesis::ne_get_node_map().

Definition at line 530 of file nemesis_io_helper.h.

Referenced by compute_node_maps(), get_node_map(), and initialize().

◆ node_mape

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

Vector which stores external node IDs.

Will have length num_external_nodes. To be used with Nemesis::ne_get_node_map().

Definition at line 537 of file nemesis_io_helper.h.

Referenced by compute_node_maps(), get_node_map(), and initialize().

◆ node_mapi

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

Vector which stores internal node IDs.

Will have length num_internal_nodes. To be used with Nemesis::ne_get_node_map().

Definition at line 523 of file nemesis_io_helper.h.

Referenced by compute_node_maps(), get_node_map(), and initialize().

◆ node_num_map

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

inherited

Definition at line 831 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::conditionally_set_node_unique_id(), libMesh::ExodusII_IO_Helper::get_libmesh_node_id(), libMesh::ExodusII_IO_Helper::read_node_num_map(), and libMesh::ExodusII_IO_Helper::write_nodal_coordinates().

◆ node_sets_dist_fact

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

inherited

Definition at line 813 of file exodusII_io_helper.h.

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

◆ node_sets_dist_index

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

inherited

Definition at line 805 of file exodusII_io_helper.h.

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

◆ node_sets_node_index

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

inherited

Definition at line 801 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_all_nodesets(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), and libMesh::ExodusII_IO_Helper::write_nodesets().

◆ node_sets_node_list

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

inherited

Definition at line 809 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_nodeset_data_indices(), libMesh::ExodusII_IO_Helper::read_all_nodesets(), libMesh::ExodusII_IO_Helper::read_nodeset_data(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), and libMesh::ExodusII_IO_Helper::write_nodesets().

◆ nodes_attached_to_local_elems

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

libMesh numbered node ids attached to local elems.

Definition at line 436 of file nemesis_io_helper.h.

Referenced by build_element_and_node_maps(), and compute_internal_and_border_elems_and_internal_nodes().

◆ nodeset_ids

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

inherited

Definition at line 776 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_node_set_id(), libMesh::ExodusII_IO_Helper::get_node_set_name(), libMesh::ExodusII_IO_Helper::get_nodeset_data_indices(), libMesh::ExodusII_IO_Helper::read_all_nodesets(), read_nodeset(), libMesh::ExodusII_IO_Helper::read_nodeset_data(), libMesh::ExodusII_IO_Helper::read_nodeset_info(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), and libMesh::ExodusII_IO_Helper::write_nodesets().

◆ nodeset_var_names

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

inherited

Definition at line 904 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_nodeset_data(), and libMesh::ExodusII_IO_Helper::read_var_names().

◆ num_attr

int libMesh::ExodusII_IO_Helper::num_attr

inherited

Definition at line 746 of file exodusII_io_helper.h.

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

◆ num_border_elems

int libMesh::Nemesis_IO_Helper::num_border_elems

The number of border FEM elements.

Elements local to this processor but whose FEM nodes reside on other processors as well. To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 484 of file nemesis_io_helper.h.

Referenced by compute_internal_and_border_elems_and_internal_nodes(), get_elem_map(), get_loadbal_param(), and initialize().

◆ num_border_nodes

int libMesh::Nemesis_IO_Helper::num_border_nodes

The number of FEM nodes local to a processor but residing in an element which also has FEM nodes on other processors.

To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 464 of file nemesis_io_helper.h.

Referenced by compute_border_node_ids(), compute_internal_and_border_elems_and_internal_nodes(), get_loadbal_param(), get_node_map(), and initialize().

◆ num_df_per_set

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

inherited

Definition at line 791 of file exodusII_io_helper.h.

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

◆ num_dim

int& libMesh::ExodusII_IO_Helper::num_dim

inherited

Definition at line 689 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_conversion(), libMesh::ExodusII_IO_Helper::initialize(), initialize(), and libMesh::ExodusII_IO_Helper::print_header().

◆ num_edge

int& libMesh::ExodusII_IO_Helper::num_edge

inherited

Definition at line 705 of file exodusII_io_helper.h.

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

◆ num_edge_blk

int& libMesh::ExodusII_IO_Helper::num_edge_blk

inherited

Definition at line 709 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::read_block_info(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ num_elem

int& libMesh::ExodusII_IO_Helper::num_elem

inherited

Definition at line 695 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::end_elem_id(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::write_elements(), and write_exodus_initialization_info().

◆ num_elem_all_elemsets

int libMesh::ExodusII_IO_Helper::num_elem_all_elemsets

inherited

Definition at line 752 of file exodusII_io_helper.h.

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

◆ num_elem_all_sidesets

int libMesh::ExodusII_IO_Helper::num_elem_all_sidesets

inherited

Definition at line 749 of file exodusII_io_helper.h.

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

◆ num_elem_blk

int& libMesh::ExodusII_IO_Helper::num_elem_blk

inherited

Definition at line 702 of file exodusII_io_helper.h.

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

◆ num_elem_blks_global

int libMesh::Nemesis_IO_Helper::num_elem_blks_global

Definition at line 374 of file nemesis_io_helper.h.

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

◆ num_elem_cmaps

int libMesh::Nemesis_IO_Helper::num_elem_cmaps

The number of elemental communication maps for this processor.

(One per neighboring proc?) To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 498 of file nemesis_io_helper.h.

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

◆ num_elem_df_per_set

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

inherited

Definition at line 797 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_elemset(), and libMesh::ExodusII_IO_Helper::read_elemset_info().

◆ num_elem_sets

int& libMesh::ExodusII_IO_Helper::num_elem_sets

inherited

Definition at line 725 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_elemset_data_indices(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::ExodusII_IO_Helper::read_elemset_data(), libMesh::ExodusII_IO_Helper::read_elemset_info(), libMesh::ExodusII_IO_Helper::write_elemset_data(), and libMesh::ExodusII_IO_Helper::write_elemsets().

◆ num_elem_this_blk

int libMesh::ExodusII_IO_Helper::num_elem_this_blk

inherited

Definition at line 740 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_elem_in_block(), libMesh::ExodusII_IO_Helper::read_elemental_var_values(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ num_elem_vars

int libMesh::ExodusII_IO_Helper::num_elem_vars

inherited

Definition at line 889 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize_element_variables(), initialize_element_variables(), libMesh::ExodusII_IO_Helper::read_and_store_header_info(), libMesh::ExodusII_IO_Helper::read_var_names(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), and libMesh::ExodusII_IO_Helper::write_var_names().

◆ num_elems_global

int libMesh::Nemesis_IO_Helper::num_elems_global

Definition at line 373 of file nemesis_io_helper.h.

Referenced by get_init_global().

◆ num_elems_per_set

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

inherited

Definition at line 788 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_elemset_data_indices(), libMesh::ExodusII_IO_Helper::read_elemset(), libMesh::ExodusII_IO_Helper::read_elemset_data(), libMesh::ExodusII_IO_Helper::read_elemset_info(), and libMesh::ExodusII_IO_Helper::write_elemset_data().

◆ num_elemset_vars

int libMesh::ExodusII_IO_Helper::num_elemset_vars

inherited

Definition at line 737 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_and_store_header_info(), libMesh::ExodusII_IO_Helper::read_elemset_data(), libMesh::ExodusII_IO_Helper::read_var_names(), and libMesh::ExodusII_IO_Helper::write_var_names().

◆ num_external_nodes

int libMesh::Nemesis_IO_Helper::num_external_nodes

The number of FEM nodes that reside on another processor but whose element partially resides on the current processor.

To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 471 of file nemesis_io_helper.h.

Referenced by get_loadbal_param(), get_node_map(), and initialize().

◆ num_face

int& libMesh::ExodusII_IO_Helper::num_face

inherited

Definition at line 712 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::read_face_blocks(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ num_face_blk

int& libMesh::ExodusII_IO_Helper::num_face_blk

inherited

Definition at line 716 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::read_face_blocks(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ num_global_node_counts

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

Definition at line 421 of file nemesis_io_helper.h.

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

◆ num_global_node_df_counts

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

Definition at line 422 of file nemesis_io_helper.h.

Referenced by get_ns_param_global(), and initialize().

◆ num_global_side_counts

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

Definition at line 409 of file nemesis_io_helper.h.

Referenced by compute_num_global_sidesets(), get_ss_param_global(), and initialize().

◆ num_global_side_df_counts

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

Definition at line 410 of file nemesis_io_helper.h.

Referenced by get_ss_param_global(), and initialize().

◆ num_global_vars

int libMesh::ExodusII_IO_Helper::num_global_vars

inherited

Definition at line 728 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::read_and_store_header_info(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO_Helper::read_var_names(), libMesh::ExodusII_IO_Helper::write_global_values(), and libMesh::ExodusII_IO_Helper::write_var_names().

◆ num_internal_elems

int libMesh::Nemesis_IO_Helper::num_internal_elems

The number of internal FEM elements.

Elements local to this processor. To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 477 of file nemesis_io_helper.h.

Referenced by compute_internal_and_border_elems_and_internal_nodes(), get_elem_map(), get_loadbal_param(), and initialize().

◆ num_internal_nodes

int libMesh::Nemesis_IO_Helper::num_internal_nodes

To be used with the Nemesis::ne_get_loadbal_param() routine.

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

Definition at line 457 of file nemesis_io_helper.h.

Referenced by compute_internal_and_border_elems_and_internal_nodes(), get_loadbal_param(), get_node_map(), and initialize().

◆ num_nodal_vars

int libMesh::ExodusII_IO_Helper::num_nodal_vars

inherited

Definition at line 878 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::ExodusII_IO_Helper::read_and_store_header_info(), libMesh::ExodusII_IO_Helper::read_var_names(), and libMesh::ExodusII_IO_Helper::write_var_names().

◆ num_node_cmaps

int libMesh::Nemesis_IO_Helper::num_node_cmaps

The number of nodal communication maps for this processor.

(One per neighboring proc?) To be used with the Nemesis::ne_get_loadbal_param() routine.

Definition at line 491 of file nemesis_io_helper.h.

Referenced by compute_border_node_ids(), compute_communication_map_parameters(), compute_node_communication_maps(), get_cmap_params(), get_loadbal_param(), get_node_cmap(), and initialize().

◆ num_node_df_per_set

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

inherited

Definition at line 794 of file exodusII_io_helper.h.

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

◆ num_node_sets

int& libMesh::ExodusII_IO_Helper::num_node_sets

inherited

Definition at line 719 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_nodeset_data_indices(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::ExodusII_IO_Helper::read_all_nodesets(), libMesh::ExodusII_IO_Helper::read_nodeset_data(), libMesh::ExodusII_IO_Helper::read_nodeset_info(), write_exodus_initialization_info(), and libMesh::ExodusII_IO_Helper::write_nodeset_data().

◆ num_node_sets_global

int libMesh::Nemesis_IO_Helper::num_node_sets_global

Definition at line 375 of file nemesis_io_helper.h.

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

◆ num_nodes

int& libMesh::ExodusII_IO_Helper::num_nodes

inherited

Definition at line 692 of file exodusII_io_helper.h.

◆ num_nodes_global

int libMesh::Nemesis_IO_Helper::num_nodes_global

Global initial information.

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

Definition at line 372 of file nemesis_io_helper.h.

Referenced by get_init_global().

◆ num_nodes_per_elem

int libMesh::ExodusII_IO_Helper::num_nodes_per_elem

inherited

Definition at line 743 of file exodusII_io_helper.h.

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

◆ num_nodes_per_set

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

inherited

Definition at line 785 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_nodeset_data_indices(), libMesh::ExodusII_IO_Helper::read_all_nodesets(), read_nodeset(), libMesh::ExodusII_IO_Helper::read_nodeset_data(), libMesh::ExodusII_IO_Helper::read_nodeset_info(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), and libMesh::ExodusII_IO_Helper::write_nodesets().

◆ num_nodeset_vars

int libMesh::ExodusII_IO_Helper::num_nodeset_vars

inherited

Definition at line 734 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_and_store_header_info(), libMesh::ExodusII_IO_Helper::read_nodeset_data(), libMesh::ExodusII_IO_Helper::read_var_names(), and libMesh::ExodusII_IO_Helper::write_var_names().

◆ num_proc

int libMesh::Nemesis_IO_Helper::num_proc

The number of processors for which the NEMESIS I file was created.

To be used with Nemesis::ne_get_init_info().

Definition at line 382 of file nemesis_io_helper.h.

Referenced by get_init_info().

◆ num_proc_in_file

int libMesh::Nemesis_IO_Helper::num_proc_in_file

The number of processors for which the NEMESIS I file stores information.

This is generally equal to 1 (1 CPU/file) at least for the splitting Derek gave us. To be used with Nemesis::ne_get_init_info().

Definition at line 389 of file nemesis_io_helper.h.

Referenced by get_init_info().

◆ num_side_sets

int& libMesh::ExodusII_IO_Helper::num_side_sets

inherited

Definition at line 722 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_sideset_data_indices(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::ExodusII_IO_Helper::read_sideset_data(), libMesh::ExodusII_IO_Helper::read_sideset_info(), write_exodus_initialization_info(), and libMesh::ExodusII_IO_Helper::write_sideset_data().

◆ num_side_sets_global

int libMesh::Nemesis_IO_Helper::num_side_sets_global

Definition at line 376 of file nemesis_io_helper.h.

Referenced by compute_num_global_sidesets(), get_init_global(), and get_ss_param_global().

◆ num_sides_per_set

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

inherited

Definition at line 782 of file exodusII_io_helper.h.

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

◆ num_sideset_vars

int libMesh::ExodusII_IO_Helper::num_sideset_vars

inherited

Definition at line 731 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_and_store_header_info(), libMesh::ExodusII_IO_Helper::read_sideset_data(), libMesh::ExodusII_IO_Helper::read_var_names(), and libMesh::ExodusII_IO_Helper::write_var_names().

◆ num_time_steps

int libMesh::ExodusII_IO_Helper::num_time_steps

inherited

Definition at line 872 of file exodusII_io_helper.h.

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

◆ opened_for_reading

bool libMesh::ExodusII_IO_Helper::opened_for_reading

inherited

Definition at line 929 of file exodusII_io_helper.h.

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

◆ opened_for_writing

bool libMesh::ExodusII_IO_Helper::opened_for_writing

inherited

Definition at line 925 of file exodusII_io_helper.h.

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

◆ proc_border_elem_sets

std::map<unsigned, std::set<std::pair<unsigned,unsigned> > > libMesh::Nemesis_IO_Helper::proc_border_elem_sets

private

Map between processor ID and (element,side) pairs bordering that processor ID.

Definition at line 621 of file nemesis_io_helper.h.

Referenced by compute_communication_map_parameters(), compute_elem_communication_maps(), and compute_internal_and_border_elems_and_internal_nodes().

◆ proc_nodes_touched_intersections

std::map<unsigned, std::set<unsigned> > libMesh::Nemesis_IO_Helper::proc_nodes_touched_intersections

private

Another map to store sets of intersections with each other processor (other than ourself, of course).

A node which appears in one of these vectors belongs to element owned by at least this processor and one other.

Definition at line 611 of file nemesis_io_helper.h.

Referenced by compute_border_node_ids(), compute_communication_map_parameters(), and compute_node_communication_maps().

◆ set_unique_ids_from_maps

bool libMesh::ExodusII_IO_Helper::set_unique_ids_from_maps

inherited

Definition at line 921 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_libmesh_id(), libMesh::ExodusII_IO_Helper::set_dof_object_unique_id(), libMesh::ExodusII_IO_Helper::write_elements(), and libMesh::ExodusII_IO_Helper::write_nodal_coordinates().

◆ side_list

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

inherited

Definition at line 819 of file exodusII_io_helper.h.

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

◆ sideset_var_names

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

inherited

Definition at line 901 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::read_sideset_data(), and libMesh::ExodusII_IO_Helper::read_var_names().

◆ ss_ids

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

inherited

Definition at line 773 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::get_side_set_id(), libMesh::ExodusII_IO_Helper::get_side_set_name(), libMesh::ExodusII_IO_Helper::get_sideset_data_indices(), libMesh::ExodusII_IO_Helper::read_sideset(), libMesh::ExodusII_IO_Helper::read_sideset_data(), libMesh::ExodusII_IO_Helper::read_sideset_info(), and libMesh::ExodusII_IO_Helper::write_sideset_data().

◆ subdomain_map

std::map<subdomain_id_type, std::vector<dof_id_type> > libMesh::Nemesis_IO_Helper::subdomain_map

Map of subdomains to element numbers.

Definition at line 441 of file nemesis_io_helper.h.

Referenced by build_element_and_node_maps(), write_element_values(), and write_elements().

◆ time_steps

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

inherited

Definition at line 875 of file exodusII_io_helper.h.

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

◆ title

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

inherited

Definition at line 686 of file exodusII_io_helper.h.

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

◆ verbose

bool libMesh::ExodusII_IO_Helper::verbose

inherited

Definition at line 917 of file exodusII_io_helper.h.

◆ w

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

inherited

Definition at line 846 of file exodusII_io_helper.h.

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

◆ write_complex_abs

bool libMesh::Nemesis_IO_Helper::write_complex_abs

By default, when complex numbers are enabled, for each variable we write out three values: the real part, "r_u" the imaginary part, "i_u", and the complex modulus, a_u := sqrt(r_u*r_u + i_u*i_u), which is also the value returned by std::abs(std::complex).

Since the modulus is not an independent quantity, we can set this flag to false and save some file space by not writing out.

Definition at line 582 of file nemesis_io_helper.h.

Referenced by write_element_values().

◆ x

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

inherited

Definition at line 837 of file exodusII_io_helper.h.

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

◆ y

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

inherited

Definition at line 840 of file exodusII_io_helper.h.

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

◆ z

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

inherited

Definition at line 843 of file exodusII_io_helper.h.

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

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

include/mesh/nemesis_io_helper.h
src/mesh/nemesis_io_helper.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ proc_border_elem_sets_iterator

◆ proc_nodes_touched_iterator

Member Enumeration Documentation

◆ ExodusVarType

Constructor & Destructor Documentation

◆ Nemesis_IO_Helper()

◆ ~Nemesis_IO_Helper()

Member Function Documentation

◆ added_node_offset_on()

◆ build_element_and_node_maps()

◆ check_existing_vars()

◆ close()

◆ comm()

◆ compute_border_node_ids()

◆ compute_communication_map_parameters()

◆ compute_elem_communication_maps()

◆ compute_element_maps()

◆ compute_internal_and_border_elems_and_internal_nodes()

◆ compute_node_communication_maps()

◆ compute_node_maps()

◆ compute_num_global_elem_blocks()

◆ compute_num_global_nodesets()

◆ compute_num_global_sidesets()

◆ conditionally_set_elem_unique_id()

◆ conditionally_set_node_unique_id()

◆ construct_nemesis_filename()

◆ create()

◆ end_elem_id()

◆ get_add_sides()

◆ get_block_id()

◆ get_block_name()

◆ get_cmap_params()

◆ get_complex_names()

◆ get_complex_subdomain_to_var_names()

◆ get_complex_vars_active_subdomains()

◆ get_conversion() [1/2]

◆ get_conversion() [2/2]

◆ get_eb_info_global()

◆ get_elem_cmap()

◆ get_elem_map()

◆ get_elem_type()

◆ get_elemset_data_indices()

◆ get_exodus_version()

◆ get_init_global()

◆ get_init_info()

◆ get_libmesh_elem_id()

◆ get_libmesh_id()

◆ get_libmesh_node_id()

◆ get_loadbal_param()

◆ get_node_cmap()

◆ get_node_map()

◆ get_node_set_id()

◆ get_node_set_name()

◆ get_nodeset_data_indices()

◆ get_ns_param_global()

◆ get_side_set_id()

◆ get_side_set_name()

◆ get_sideset_data_indices()

◆ get_ss_param_global()

◆ init_conversion_map()

◆ init_element_equivalence_map()

◆ initialize()

◆ initialize_element_variables()

◆ initialize_global_variables()

◆ initialize_nodal_variables()

◆ message() [1/2]

◆ message() [2/2]

◆ n_processors()

◆ node_id_to_vec_id()