libMesh
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
libMesh::Nemesis_IO_Helper Class Reference

This is the Nemesis_IO_Helper class. More...

#include <nemesis_io_helper.h>

Inheritance diagram for libMesh::Nemesis_IO_Helper:
[legend]

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. More...
 
virtual ~Nemesis_IO_Helper ()
 Destructor. More...
 
void write_complex_magnitude (bool val)
 Set the flag indicating whether the complex modulus should be written when complex numbers are enabled. More...
 
void read_nodeset (int id)
 Reading functions. More...
 
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. More...
 
void get_ss_param_global ()
 Fills: global_sideset_ids, num_global_side_counts, num_global_side_df_counts Call after: get_init_global() More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
void put_elem_map (std::vector< int > &elem_mapi, std::vector< int > &elem_mapb)
 Outputs IDs of internal and border elements. More...
 
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. More...
 
virtual void write_elements (const MeshBase &mesh, bool use_discontinuous=false) override
 This function is specialized to write the connectivity. More...
 
virtual void write_sidesets (const MeshBase &mesh) override
 Writes the sidesets for this processor. More...
 
virtual void write_nodesets (const MeshBase &mesh) override
 Writes the nodesets for this processor. More...
 
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. More...
 
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. More...
 
void build_element_and_node_maps (const MeshBase &pmesh)
 This function builds the libmesh -> exodus and exodus -> libmesh node and element maps. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
const char * get_elem_type () const
 
void set_add_sides (bool add_sides)
 Sets whether or not to write extra "side" elements. More...
 
bool get_add_sides ()
 
void open (const char *filename, bool read_only)
 Opens an ExodusII mesh file named filename. More...
 
ExodusHeaderInfo read_header () const
 Reads an ExodusII mesh file header, leaving this object's internal data structures unchanged. More...
 
void read_and_store_header_info ()
 Reads an ExodusII mesh file header, and stores required information on this object. More...
 
void read_qa_records ()
 Reads the QA records from an ExodusII file. More...
 
void print_header ()
 Prints the ExodusII mesh file header, which includes the mesh title, the number of nodes, number of elements, mesh dimension, number of sidesets, and number of nodesets. More...
 
void read_nodes ()
 Reads the nodal data (x,y,z coordinates) from the ExodusII mesh file. More...
 
void read_node_num_map ()
 Reads the optional node_num_map from the ExodusII mesh file. More...
 
void read_bex_cv_blocks ()
 Reads the optional bex_cv_blocks from the ExodusII mesh file. More...
 
void print_nodes (std::ostream &out_stream=libMesh::out)
 Prints the nodal information, by default to libMesh::out. More...
 
void read_block_info ()
 Reads information for all of the blocks in the ExodusII mesh file. More...
 
int get_block_id (int index)
 Get the block number for the given block index. More...
 
std::string get_block_name (int index)
 Get the block name for the given block index if supplied in the mesh file. More...
 
int get_side_set_id (int index)
 Get the side set id for the given side set index. More...
 
std::string get_side_set_name (int index)
 Get the side set name for the given side set index if supplied in the mesh file. More...
 
int get_node_set_id (int index)
 Get the node set id for the given node set index. More...
 
std::string get_node_set_name (int index)
 Get the node set name for the given node set index if supplied in the mesh file. More...
 
void read_elem_in_block (int block)
 Reads all of the element connectivity for block block in the ExodusII mesh file. More...
 
void read_edge_blocks (MeshBase &mesh)
 Read in edge blocks, storing information in the BoundaryInfo object. More...
 
void read_elem_num_map ()
 Reads the optional node_num_map from the ExodusII mesh file. More...
 
void read_sideset_info ()
 Reads information about all of the sidesets in the ExodusII mesh file. More...
 
void read_nodeset_info ()
 Reads information about all of the nodesets in the ExodusII mesh file. More...
 
void read_elemset_info ()
 Reads information about all of the elemsets in the ExodusII mesh file. More...
 
void read_sideset (int id, int offset)
 Reads information about sideset id and inserts it into the global sideset array at the position offset. More...
 
void read_elemset (int id, int offset)
 Reads information about elemset id and inserts it into the global elemset array at the position offset. More...
 
void read_all_nodesets ()
 New API that reads all nodesets simultaneously. More...
 
void close () noexcept
 Closes the ExodusII mesh file. More...
 
void read_time_steps ()
 Reads and stores the timesteps in the 'time_steps' array. More...
 
void read_num_time_steps ()
 Reads the number of timesteps currently stored in the Exodus file and stores it in the num_time_steps variable. More...
 
void read_nodal_var_values (std::string nodal_var_name, int time_step)
 Reads the nodal values for the variable 'nodal_var_name' at the specified time into the 'nodal_var_values' array. More...
 
void read_elemental_var_values (std::string elemental_var_name, int time_step, std::map< dof_id_type, Real > &elem_var_value_map)
 Reads elemental values for the variable 'elemental_var_name' at the specified timestep into the 'elem_var_value_map' which is passed in. More...
 
virtual void create (std::string filename)
 Opens an ExodusII mesh file named filename for writing. More...
 
void initialize_nodal_variables (std::vector< std::string > names)
 Sets up the nodal variables. More...
 
void initialize_global_variables (std::vector< std::string > names)
 Sets up the global variables. More...
 
void write_timestep (int timestep, Real time)
 Writes the time for the timestep. More...
 
void write_elemsets (const MeshBase &mesh)
 Write elemsets stored on the Mesh to the exo file. More...
 
void write_sideset_data (const MeshBase &mesh, int timestep, const std::vector< std::string > &var_names, const std::vector< std::set< boundary_id_type >> &side_ids, const std::vector< std::map< BoundaryInfo::BCTuple, Real >> &bc_vals)
 Write sideset data for the requested timestep. More...
 
void read_sideset_data (const MeshBase &mesh, int timestep, std::vector< std::string > &var_names, std::vector< std::set< boundary_id_type >> &side_ids, std::vector< std::map< BoundaryInfo::BCTuple, Real >> &bc_vals)
 Read sideset variables, if any, into the provided data structures. More...
 
void 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). More...
 
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. More...
 
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. More...
 
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). More...
 
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. More...
 
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. More...
 
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). More...
 
void write_element_values (const MeshBase &mesh, const std::vector< Real > &values, int timestep, const std::vector< std::set< subdomain_id_type >> &vars_active_subdomains)
 Writes the vector of values to the element variables. More...
 
void write_element_values_element_major (const MeshBase &mesh, const std::vector< Real > &values, int timestep, const std::vector< std::set< subdomain_id_type >> &vars_active_subdomains, const std::vector< std::string > &derived_var_names, const std::map< subdomain_id_type, std::vector< std::string >> &subdomain_to_var_names)
 Same as the function above, but assume the input 'values' vector is in element-major order, i.e. More...
 
void write_nodal_values (int var_id, const std::vector< Real > &values, int timestep)
 Writes the vector of values to a nodal variable. More...
 
void write_information_records (const std::vector< std::string > &records)
 Writes the vector of information records. More...
 
void write_global_values (const std::vector< Real > &values, int timestep)
 Writes the vector of global variables. More...
 
void update ()
 Uses ex_update() to flush buffers to file. More...
 
void read_global_values (std::vector< Real > &values, int timestep)
 Reads the vector of global variables. More...
 
void use_mesh_dimension_instead_of_spatial_dimension (bool val)
 Sets the underlying value of the boolean flag _use_mesh_dimension_instead_of_spatial_dimension. More...
 
void 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. More...
 
void write_as_dimension (unsigned dim)
 Sets the value of _write_as_dimension. More...
 
void set_coordinate_offset (Point p)
 Allows you to set a vector that is added to the coordinates of all of the nodes. More...
 
std::vector< std::string > get_complex_names (const std::vector< std::string > &names, 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. More...
 
std::map< subdomain_id_type, std::vector< std::string > > get_complex_subdomain_to_var_names (const std::map< subdomain_id_type, std::vector< std::string >> &subdomain_to_var_names, 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. More...
 
void message (std::string_view msg)
 Prints the message defined in msg. More...
 
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. More...
 
int end_elem_id () const
 
void read_var_names (ExodusVarType type)
 
const ExodusII_IO_Helper::Conversionget_conversion (const ElemType type) const
 
const ExodusII_IO_Helper::Conversionget_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::Communicatorcomm () 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. More...
 
int num_nodes_global
 Global initial information. More...
 
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. More...
 
int num_proc_in_file
 The number of processors for which the NEMESIS I file stores information. More...
 
char ftype
 The type of file to be written. More...
 
std::vector< intnode_list
 
std::vector< intglobal_sideset_ids
 Containers for reading global sideset (boundary conditions) information. More...
 
std::vector< intnum_global_side_counts
 
std::vector< intnum_global_side_df_counts
 
std::vector< intglobal_nodeset_ids
 Containers for reading global nodeset information. More...
 
std::vector< intnum_global_node_counts
 
std::vector< intnum_global_node_df_counts
 
std::vector< intglobal_elem_blk_ids
 Read the global element block IDs and counts. More...
 
std::vector< intglobal_elem_blk_cnts
 
std::set< intnodes_attached_to_local_elems
 libMesh numbered node ids attached to local elems. More...
 
std::map< subdomain_id_type, std::vector< dof_id_type > > subdomain_map
 Map of subdomains to element numbers. More...
 
std::map< int, std::vector< int > > block_id_to_elem_connectivity
 This is the block connectivity, i.e. More...
 
int num_internal_nodes
 To be used with the Nemesis::ne_get_loadbal_param() routine. More...
 
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. More...
 
int num_external_nodes
 The number of FEM nodes that reside on another processor but whose element partially resides on the current processor. More...
 
int num_internal_elems
 The number of internal FEM elements. More...
 
int num_border_elems
 The number of border FEM elements. More...
 
int num_node_cmaps
 The number of nodal communication maps for this processor. More...
 
int num_elem_cmaps
 The number of elemental communication maps for this processor. More...
 
std::vector< intelem_mapi
 Vector which stores internal element IDs. More...
 
std::vector< intelem_mapb
 Vector which stores border element IDs. More...
 
std::vector< intnode_mapi
 Vector which stores internal node IDs. More...
 
std::vector< intnode_mapb
 Vector which stores border node IDs. More...
 
std::vector< intnode_mape
 Vector which stores external node IDs. More...
 
std::vector< intnode_cmap_ids
 Vectors for storing the communication map parameters. More...
 
std::vector< intnode_cmap_node_cnts
 
std::vector< intelem_cmap_ids
 
std::vector< intelem_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. More...
 
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. More...
 
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_u*r_u + i_u*i_u), which is also the value returned by std::abs(std::complex). More...
 
int ex_id
 
int ex_err
 
ExodusHeaderInfo header_info
 
std::vector< char > & title
 
intnum_dim
 
intnum_nodes
 
intnum_elem
 
intnum_elem_blk
 
intnum_edge
 
intnum_edge_blk
 
intnum_node_sets
 
intnum_side_sets
 
intnum_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< intblock_ids
 
std::vector< intedge_block_ids
 
std::vector< intconnect
 
std::vector< intss_ids
 
std::vector< intnodeset_ids
 
std::vector< intelemset_ids
 
std::vector< intnum_sides_per_set
 
std::vector< intnum_nodes_per_set
 
std::vector< intnum_elems_per_set
 
std::vector< intnum_df_per_set
 
std::vector< intnum_node_df_per_set
 
std::vector< intnum_elem_df_per_set
 
std::vector< intnode_sets_node_index
 
std::vector< intnode_sets_dist_index
 
std::vector< intnode_sets_node_list
 
std::vector< Realnode_sets_dist_fact
 
std::vector< intelem_list
 
std::vector< intside_list
 
std::vector< intid_list
 
std::vector< intelemset_list
 
std::vector< intelemset_id_list
 
std::vector< intnode_num_map
 
std::vector< intelem_num_map
 
std::vector< Realx
 
std::vector< Realy
 
std::vector< Realz
 
std::vector< Realw
 
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_typelibmesh_elem_num_to_exodus
 
std::vector< intexodus_elem_num_to_libmesh
 
std::map< dof_id_type, dof_id_typelibmesh_node_num_to_exodus
 
std::vector< intexodus_node_num_to_libmesh
 
int num_time_steps
 
std::vector< Realtime_steps
 
int num_nodal_vars
 
std::vector< std::string > nodal_var_names
 
std::map< dof_id_type, Realnodal_var_values
 
int num_elem_vars
 
std::vector< std::string > elem_var_names
 
std::vector< Realelem_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 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. More...
 
void check_existing_vars (ExodusVarType type, std::vector< std::string > &names, std::vector< std::string > &names_from_file)
 When appending: during initialization, check that variable names in the file match those you attempt to initialize with. More...
 
void write_var_names (ExodusVarType type, const std::vector< std::string > &names)
 Wraps calls to exII::ex_put_var_names() and exII::ex_put_var_param(). More...
 

Protected Attributes

bool _run_only_on_proc0
 
bool _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
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 

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. More...
 
void compute_num_global_sidesets (const MeshBase &pmesh)
 This function uses global communication routines to determine the number of sidesets across the entire mesh. More...
 
void compute_border_node_ids (const MeshBase &pmesh)
 This function constructs the set of border node IDs present on the current mesh. More...
 
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. More...
 
void compute_communication_map_parameters ()
 This function determines the communication map parameters which will eventually be written to file. More...
 
void compute_node_communication_maps ()
 Compute the node communication maps (really just pack vectors) in preparation for writing them to file. More...
 
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. More...
 
void compute_elem_communication_maps ()
 This function computes element communication maps (really just packs vectors) in preparation for writing them to file. More...
 
void compute_element_maps ()
 This function computes element maps (really just packs vectors) which map the elements to internal and border elements. More...
 
void write_exodus_initialization_info (const MeshBase &pmesh, const std::string &title)
 This function writes exodus-specific initialization information. More...
 

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. More...
 
std::set< unsigned > border_node_ids
 The set which will eventually contain the IDs of "border nodes". More...
 
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). More...
 
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. More...
 
std::set< unsigned > internal_node_ids
 A set of internal node IDs for this processor. More...
 
std::set< unsigned > internal_elem_ids
 A set of internal elem IDs for this processor. More...
 
std::set< unsigned > border_elem_ids
 A set of border elem IDs for this processor. More...
 

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 70 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 644 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 634 of file nemesis_io_helper.h.

Member Enumeration Documentation

◆ ExodusVarType

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

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

59  :
60  ExodusII_IO_Helper(parent, verbose_in, /*run_only_on_proc0=*/false, /*single_precision=*/single_precision),
67  num_proc(0),
69  ftype('\0'),
75  num_node_cmaps(0),
76  num_elem_cmaps(0),
77  write_complex_abs(true)
78 {
79  // Warn about using untested code!
80  libmesh_experimental();
81 }
char ftype
The type of file to be written.
ExodusII_IO_Helper(const ParallelObject &parent, bool v=false, bool run_only_on_proc0=true, bool single_precision=false)
Constructor.
int num_external_nodes
The number of FEM nodes that reside on another processor but whose element partially resides on the c...
int nemesis_err_flag
Member data.
int num_node_cmaps
The number of nodal communication maps for this processor.
bool write_complex_abs
By default, when complex numbers are enabled, for each variable we write out three values: the real p...
int num_nodes_global
Global initial information.
int num_proc
The number of processors for which the NEMESIS I file was created.
int num_internal_elems
The number of internal FEM elements.
int num_elem_cmaps
The number of elemental communication maps for this processor.
int num_proc_in_file
The number of processors for which the NEMESIS I file stores information.
int num_border_nodes
The number of FEM nodes local to a processor but residing in an element which also has FEM nodes on o...
int num_internal_nodes
To be used with the Nemesis::ne_get_loadbal_param() routine.
int num_border_elems
The number of border FEM elements.

◆ ~Nemesis_IO_Helper()

libMesh::Nemesis_IO_Helper::~Nemesis_IO_Helper ( )
virtual

Destructor.

Definition at line 84 of file nemesis_io_helper.C.

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.

85 {
86  // Our destructor is called from Nemesis_IO. We close the Exodus file here since we have
87  // responsibility for managing the file's lifetime. Only call ex_update() if the file was
88  // opened for writing!
89  if (this->opened_for_writing)
90  {
91  this->ex_err = exII::ex_update(this->ex_id);
92  EX_EXCEPTIONLESS_CHECK_ERR(ex_err, "Error flushing buffers to file.");
93  }
94  this->close();
95 }
void close() noexcept
Closes the ExodusII mesh file.

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

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

916  {
917  libmesh_assert (p < _true_node_offsets.size());
918  const dof_id_type added_node_offsets =
919  (_added_side_node_offsets.empty() || !p) ? 0 :
921  return _true_node_offsets[p] + added_node_offsets;
922  }
libmesh_assert(ctx)
std::vector< dof_id_type > _true_node_offsets
If we&#39;re adding "fake" sides to visualize SIDE_DISCONTINUOUS variables, we also need to know how many...
std::vector< dof_id_type > _added_side_node_offsets
If we&#39;re adding "fake" sides to visualize SIDE_DISCONTINUOUS variables, _added_side_node_offsets[p] g...
uint8_t dof_id_type
Definition: id_types.h:67

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

References block_id_to_elem_connectivity, libMesh::ExodusII_IO_Helper::block_ids, libMesh::Elem::build(), libMesh::MeshBase::elem_ref(), libMesh::ExodusII_IO_Helper::exodus_elem_num_to_libmesh, libMesh::ExodusII_IO_Helper::exodus_node_num_to_libmesh, libMesh::ExodusII_IO_Helper::get_conversion(), libMesh::index_range(), libMesh::libmesh_assert(), libMesh::ExodusII_IO_Helper::libmesh_elem_num_to_exodus, libMesh::ExodusII_IO_Helper::libmesh_node_num_to_exodus, local_subdomain_counts, libMesh::make_range(), n_nodes, libMesh::Elem::n_nodes(), libMesh::Elem::node_id(), nodes_attached_to_local_elems, libMesh::ExodusII_IO_Helper::num_nodes, libMesh::ExodusII_IO_Helper::num_nodes_per_elem, libMesh::out, libMesh::ParallelObject::processor_id(), subdomain_map, libMesh::Elem::type(), and libMesh::ExodusII_IO_Helper::verbose.

Referenced by initialize().

1631 {
1632  // If we don't have any local subdomains, it had better be because
1633  // we don't have any local elements
1634 #ifdef DEBUG
1635  if (local_subdomain_counts.empty())
1636  {
1637  libmesh_assert(pmesh.active_local_elements_begin() ==
1638  pmesh.active_local_elements_end());
1640  }
1641 #endif
1642 
1643  // Elements have to be numbered contiguously based on what block
1644  // number they are in. Therefore we have to do a bit of work to get
1645  // the block (ie subdomain) numbers first and store them off as
1646  // block_ids.
1647 
1648  // Make sure there is no leftover information in the subdomain_map, and reserve
1649  // enough space to store the elements we need.
1650  this->subdomain_map.clear();
1651  for (const auto & [sbd_id, cnt] : local_subdomain_counts)
1652  {
1653  if (verbose)
1654  {
1655  libMesh::out << "[" << this->processor_id() << "] "
1656  << "local_subdomain_counts [" << static_cast<unsigned>(sbd_id) << "]= "
1657  << cnt
1658  << std::endl;
1659  }
1660 
1661  this->subdomain_map[sbd_id].reserve(cnt);
1662  }
1663 
1664 
1665  // First loop over the elements to figure out which elements are in which subdomain
1666  for (const auto & elem : pmesh.active_local_element_ptr_range())
1667  {
1668  // Grab the nodes while we're here.
1669  for (auto n : elem->node_index_range())
1670  this->nodes_attached_to_local_elems.insert( elem->node_id(n) );
1671 
1672  subdomain_id_type cur_subdomain = elem->subdomain_id();
1673 
1674  this->subdomain_map[cur_subdomain].push_back(elem->id());
1675  }
1676 
1677  // Set num_nodes which is used by exodusII_io_helper
1678  this->num_nodes =
1679  cast_int<int>(this->nodes_attached_to_local_elems.size());
1680 
1681  // Now come up with a 1-based numbering for these nodes
1682  this->exodus_node_num_to_libmesh.clear(); // Make sure it's empty
1683  this->exodus_node_num_to_libmesh.reserve(this->nodes_attached_to_local_elems.size());
1684 
1685  // Also make sure there's no leftover information in the map which goes the
1686  // other direction.
1687  this->libmesh_node_num_to_exodus.clear();
1688 
1689  // Set the map for nodes
1690  for (const auto & id : nodes_attached_to_local_elems)
1691  {
1692  // I.e. given exodus_node_id,
1693  // exodus_node_num_to_libmesh[ exodus_node_id ] returns the
1694  // libmesh ID for that node, plus one.
1695  // Here we index libMesh IDs with an offset of 1 because they're
1696  // the literal numbers that get written to the exodus file, but
1697  // we index Exodus IDs with an offset of 0 because we read that
1698  // exodus data into a C++ vector. Confused yet?
1699  this->exodus_node_num_to_libmesh.push_back(id+1);
1700 
1701  // Likewise, given libmesh_node_id,
1702  // libmesh_node_num_to_exodus[ libmesh_node_id] returns the
1703  // *Exodus* ID for that node. Unlike the
1704  // exodus_node_num_to_libmesh vector above, this one is a
1705  // std::map. We're never handing a data buffer from it over to
1706  // another API so we don't need to do any weird offsets with it.
1707  this->libmesh_node_num_to_exodus[id] =
1708  this->exodus_node_num_to_libmesh.size(); // should never be zero...
1709  }
1710 
1711  // Now we're going to loop over the subdomain map and build a few things right
1712  // now that we'll use later.
1713 
1714  // First make sure our data structures don't have any leftover data...
1715  this->exodus_elem_num_to_libmesh.clear();
1716  this->block_ids.clear();
1717  this->libmesh_elem_num_to_exodus.clear();
1718 
1719  // Now loop over each subdomain and get a unique numbering for the elements
1720  for (auto & [block_id, elem_ids_this_subdomain] : subdomain_map)
1721  {
1722  block_ids.push_back(block_id);
1723 
1724  // The code below assumes this subdomain block is not empty, make sure that's the case!
1725  libmesh_error_msg_if(elem_ids_this_subdomain.size() == 0,
1726  "Error, no element IDs found in subdomain " << block_id);
1727 
1728  // Use the first element in this block to get representative information.
1729  // Note that Exodus assumes all elements in a block are of the same type!
1730  // We are using that same assumption here!
1731  const auto & conv = get_conversion
1732  (pmesh.elem_ref(elem_ids_this_subdomain[0]).type());
1733  this->num_nodes_per_elem =
1734  pmesh.elem_ref(elem_ids_this_subdomain[0]).n_nodes();
1735 
1736  // Get a reference to the connectivity vector for this subdomain. This vector
1737  // is most likely empty, we are going to fill it up now.
1738  std::vector<int> & current_block_connectivity = this->block_id_to_elem_connectivity[block_id];
1739 
1740  // Just in case it's not already empty...
1741  current_block_connectivity.clear();
1742  current_block_connectivity.resize(elem_ids_this_subdomain.size() * this->num_nodes_per_elem);
1743 
1744  for (auto i : index_range(elem_ids_this_subdomain))
1745  {
1746  auto elem_id = elem_ids_this_subdomain[i];
1747 
1748  // Set the number map for elements
1749  // exodus_elem_num_to_libmesh[ exodus_node_id ] returns the
1750  // libmesh ID for that element, plus one.
1751  // Like with nodes above, we index libMesh IDs with an
1752  // offset of 1 because they're the literal numbers that get
1753  // written to the exodus file, but we index Exodus IDs with
1754  // an offset of 0 because we read that exodus data into a
1755  // C++ vector.
1756  this->exodus_elem_num_to_libmesh.push_back(elem_id+1);
1757 
1758  // Likewise, given libmesh elem_id,
1759  // libmesh_elem_num_to_exodus[ elem_id ] returns the
1760  // *Exodus* ID for that node. Unlike the
1761  // exodus_elem_num_to_libmesh vector above, this one is a
1762  // std::map. We're never handing a data buffer from it over to
1763  // another API so we don't need to do any weird offsets with it.
1764  this->libmesh_elem_num_to_exodus[elem_id] =
1765  this->exodus_elem_num_to_libmesh.size();
1766 
1767  const Elem & elem = pmesh.elem_ref(elem_id);
1768 
1769  // Exodus/Nemesis want every block to have the same element type
1770  // libmesh_assert_equal_to (elem->type(), conv.libmesh_elem_type());
1771 
1772  // But we can get away with writing e.g. HEX8 and INFHEX8 in
1773  // the same block...
1774  libmesh_assert_equal_to (elem.n_nodes(), Elem::build(conv.libmesh_elem_type(), nullptr)->n_nodes());
1775 
1776  for (auto j : make_range(this->num_nodes_per_elem))
1777  {
1778  const unsigned int connect_index = (i*this->num_nodes_per_elem)+j;
1779  const unsigned int elem_node_index = conv.get_inverse_node_map(j); // inverse node map is used for writing
1780 
1781  current_block_connectivity[connect_index] =
1782  libmesh_map_find(libmesh_node_num_to_exodus,
1783  elem.node_id(elem_node_index));
1784  }
1785  } // End loop over elems in this subdomain
1786  } // end loop over subdomain_map
1787 }
std::map< subdomain_id_type, std::vector< dof_id_type > > subdomain_map
Map of subdomains to element numbers.
TestClass subdomain_id_type
Based on the 4-byte comment warning above, this probably doesn&#39;t work with exodusII at all...
Definition: id_types.h:43
std::vector< int > exodus_elem_num_to_libmesh
const ExodusII_IO_Helper::Conversion & get_conversion(const ElemType type) const
std::map< dof_id_type, dof_id_type > libmesh_node_num_to_exodus
const dof_id_type n_nodes
Definition: tecplot_io.C:67
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:273
libmesh_assert(ctx)
std::set< int > nodes_attached_to_local_elems
libMesh numbered node ids attached to local elems.
std::map< dof_id_type, dof_id_type > libmesh_elem_num_to_exodus
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::map< int, std::vector< int > > block_id_to_elem_connectivity
This is the block connectivity, i.e.
OStreamProxy out
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134
std::vector< int > exodus_node_num_to_libmesh
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

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

References libMesh::err, libMesh::Quality::name(), 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().

3330 {
3331  // There may already be global variables in the file (for example,
3332  // if we're appending) and in that case, we
3333  // 1.) Cannot initialize them again.
3334  // 2.) Should check to be sure that the global variable names are the same.
3335 
3336  // Fills up names_from_file for us
3337  this->read_var_names(type);
3338 
3339  // Both the number of variables and their names (up to the first
3340  // MAX_STR_LENGTH characters) must match for the names we are
3341  // planning to write and the names already in the file.
3342  bool match =
3343  std::equal(names.begin(), names.end(),
3344  names_from_file.begin(),
3345  [](const std::string & a,
3346  const std::string & b) -> bool
3347  {
3348  return a.compare(/*pos=*/0, /*len=*/MAX_STR_LENGTH, b) == 0;
3349  });
3350 
3351  if (!match)
3352  {
3353  libMesh::err << "Error! The Exodus file already contains the variables:" << std::endl;
3354  for (const auto & name : names_from_file)
3355  libMesh::err << name << std::endl;
3356 
3357  libMesh::err << "And you asked to write:" << std::endl;
3358  for (const auto & name : names)
3359  libMesh::err << name << std::endl;
3360 
3361  libmesh_error_msg("Cannot overwrite existing variables in Exodus II file.");
3362  }
3363 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
void read_var_names(ExodusVarType type)

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

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

1753 {
1754  // Call ex_close on every processor that did ex_open or ex_create;
1755  // newer Exodus versions error if we try to reopen a file that
1756  // hasn't been officially closed. Don't close the file if we didn't
1757  // open it; this also raises an Exodus error.
1758 
1759  // We currently do read-only ex_open on every proc (to do read
1760  // operations on every proc), but we do ex_open and ex_create for
1761  // writes on every proc only with Nemesis files.
1763  (this->processor_id() == 0) ||
1764  (!_run_only_on_proc0))
1765  {
1767  {
1768  ex_err = exII::ex_close(ex_id);
1769  // close() is called from the destructor, so it may be called e.g.
1770  // during stack unwinding while processing an exception. In that case
1771  // we don't want to throw another exception or immediately terminate
1772  // the code, since that would prevent any possible recovery from the
1773  // exception in question. So we just log the error closing the file
1774  // and continue.
1775  if (ex_err < 0)
1776  message("Error closing Exodus file.");
1777  else
1778  message("Exodus file closed successfully.");
1779  }
1780  }
1781 
1782  // Now that the file is closed, it's no longer opened for
1783  // reading or writing.
1784  opened_for_writing = false;
1785  opened_for_reading = false;
1786  _opened_by_create = false;
1787 }
void message(std::string_view msg)
Prints the message defined in msg.
processor_id_type processor_id() const

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), compute_num_global_elem_blocks(), compute_num_global_nodesets(), compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< libMesh::Number >::create_submatrix_nosort(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::RBEIMEvaluation::distribute_bfs(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::System::get_info(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_recalculate_monitor(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_precheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::DofMap::n_constrained_dofs(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), read_var_names_impl(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

98  { return _communicator; }
const Parallel::Communicator & _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 1793 of file nemesis_io_helper.C.

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

1794 {
1795  // The set which will eventually contain the IDs of "border nodes". These are nodes
1796  // that lie on the boundary between one or more processors.
1797  //std::set<unsigned> border_node_ids;
1798 
1799  // map from processor ID to set of nodes which elements from this processor "touch",
1800  // that is,
1801  // proc_nodes_touched[p] = (set all node IDs found in elements owned by processor p)
1802  std::map<unsigned, std::set<unsigned>> proc_nodes_touched;
1803 
1804 
1805  // We are going to create a lot of intermediate data structures here, so make sure
1806  // as many as possible all cleaned up by creating scope!
1807  {
1808  // Loop over active (not just active local) elements, make sets of node IDs for each
1809  // processor which has an element that "touches" a node.
1810  for (const auto & elem : pmesh.active_element_ptr_range())
1811  {
1812  // Get reference to the set for this processor. If it does not exist
1813  // it will be created.
1814  std::set<unsigned> & set_p = proc_nodes_touched[ elem->processor_id() ];
1815 
1816  // Insert all nodes touched by this element into the set
1817  for (auto node : elem->node_index_range())
1818  set_p.insert(elem->node_id(node));
1819  }
1820 
1821  if (verbose)
1822  {
1823  libMesh::out << "[" << this->processor_id()
1824  << "] proc_nodes_touched contains "
1825  << proc_nodes_touched.size()
1826  << " sets of nodes."
1827  << std::endl;
1828 
1829  for (const auto & [proc_id, set] : proc_nodes_touched)
1830  libMesh::out << "[" << this->processor_id()
1831  << "] proc_nodes_touched[" << proc_id << "] has "
1832  << set.size()
1833  << " entries."
1834  << std::endl;
1835  }
1836 
1837 
1838  // Loop over all the sets we just created and compute intersections with the
1839  // this processor's set. Obviously, don't intersect with ourself.
1840  this->proc_nodes_touched_intersections.clear();
1841  for (auto & [proc_id, other_set] : proc_nodes_touched)
1842  {
1843  // Don't compute intersections with ourself
1844  if (proc_id == this->processor_id())
1845  continue;
1846 
1847  std::set<unsigned int> this_intersection;
1848 
1849  // Otherwise, compute intersection with other processor and ourself
1850  std::set<unsigned> & my_set = proc_nodes_touched[this->processor_id()];
1851 
1852  std::set_intersection(my_set.begin(), my_set.end(),
1853  other_set.begin(), other_set.end(),
1854  std::inserter(this_intersection, this_intersection.end()));
1855 
1856  if (!this_intersection.empty())
1857  this->proc_nodes_touched_intersections.emplace
1858  (proc_id, std::move(this_intersection));
1859  }
1860 
1861  if (verbose)
1862  {
1863  for (const auto & [proc_id, set] : proc_nodes_touched_intersections)
1864  libMesh::out << "[" << this->processor_id()
1865  << "] this->proc_nodes_touched_intersections[" << proc_id << "] has "
1866  << set.size()
1867  << " entries."
1868  << std::endl;
1869  }
1870 
1871  // The number of node communication maps is the number of other processors
1872  // with which we share nodes.
1873  this->num_node_cmaps =
1874  cast_int<int>(proc_nodes_touched_intersections.size());
1875 
1876  // We can't be connecting to more processors than exist outside
1877  // ourselves
1878  libmesh_assert_less (this->num_node_cmaps, this->n_processors());
1879 
1880  // Compute the set_union of all the preceding intersections. This will be the set of
1881  // border node IDs for this processor.
1882  for (auto & pr : proc_nodes_touched_intersections)
1883  {
1884  std::set<unsigned> & other_set = pr.second;
1885  std::set<unsigned> intermediate_result; // Don't think we can insert into one of the sets we're unioning...
1886 
1887  std::set_union(this->border_node_ids.begin(), this->border_node_ids.end(),
1888  other_set.begin(), other_set.end(),
1889  std::inserter(intermediate_result, intermediate_result.end()));
1890 
1891  // Swap our intermediate result into the final set
1892  this->border_node_ids.swap(intermediate_result);
1893  }
1894 
1895  libmesh_assert_less_equal
1896  (this->proc_nodes_touched_intersections.size(),
1897  std::size_t(this->num_node_cmaps));
1898 
1899  if (verbose)
1900  {
1901  libMesh::out << "[" << this->processor_id()
1902  << "] border_node_ids.size()=" << this->border_node_ids.size()
1903  << std::endl;
1904  }
1905  } // end scope for border node ID creation
1906 
1907  // Store the number of border node IDs to be written to Nemesis file
1908  this->num_border_nodes = cast_int<int>(this->border_node_ids.size());
1909 }
int num_node_cmaps
The number of nodal communication maps for this processor.
processor_id_type n_processors() const
std::set< unsigned > border_node_ids
The set which will eventually contain the IDs of "border nodes".
OStreamProxy out
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).
processor_id_type processor_id() const
int num_border_nodes
The number of FEM nodes local to a processor but residing in an element which also has FEM nodes on o...

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

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

1111 {
1112  // For the nodes, these are the number of entries in the sets in proc_nodes_touched_intersections
1113  // map computed above. Note: this map does not contain self-intersections so we can loop over it
1114  // directly.
1115  this->node_cmap_node_cnts.clear(); // Make sure we don't have any leftover information...
1116  this->node_cmap_ids.clear(); // Make sure we don't have any leftover information...
1117  this->node_cmap_node_cnts.resize(this->num_node_cmaps);
1118  this->node_cmap_ids.resize(this->num_node_cmaps);
1119 
1120  {
1121  unsigned cnt=0; // Index into the vector
1123  it = this->proc_nodes_touched_intersections.begin(),
1124  end = this->proc_nodes_touched_intersections.end();
1125 
1126  for (; it != end; ++it)
1127  {
1128  this->node_cmap_ids[cnt] = it->first; // The ID of the proc we communicate with
1129  this->node_cmap_node_cnts[cnt] = cast_int<int>(it->second.size()); // The number of nodes we communicate
1130  cnt++; // increment vector index!
1131  }
1132  }
1133 
1134  // Print the packed vectors we just filled
1135  if (verbose)
1136  {
1137  libMesh::out << "[" << this->processor_id() << "] node_cmap_node_cnts = ";
1138  for (const auto & node_cnt : node_cmap_node_cnts)
1139  libMesh::out << node_cnt << ", ";
1140  libMesh::out << std::endl;
1141 
1142  libMesh::out << "[" << this->processor_id() << "] node_cmap_ids = ";
1143  for (const auto & node_id : node_cmap_ids)
1144  libMesh::out << node_id << ", ";
1145  libMesh::out << std::endl;
1146  }
1147 
1148  // For the elements, we have not yet computed all this information..
1149  this->elem_cmap_elem_cnts.clear(); // Make sure we don't have any leftover information...
1150  this->elem_cmap_ids.clear(); // Make sure we don't have any leftover information...
1151  this->elem_cmap_elem_cnts.resize(this->num_elem_cmaps);
1152  this->elem_cmap_ids.resize(this->num_elem_cmaps);
1153 
1154  // Pack the elem_cmap_ids and elem_cmap_elem_cnts vectors
1155  {
1156  unsigned cnt=0; // Index into the vectors we're filling
1158  it = this->proc_border_elem_sets.begin(),
1159  end = this->proc_border_elem_sets.end();
1160 
1161  for (; it != end; ++it)
1162  {
1163  this->elem_cmap_ids[cnt] = it->first; // The ID of the proc we communicate with
1164  this->elem_cmap_elem_cnts[cnt] = cast_int<int>(it->second.size()); // The number of elems we communicate to/from that proc
1165  cnt++; // increment vector index!
1166  }
1167  }
1168 
1169  // Print the packed vectors we just filled
1170  if (verbose)
1171  {
1172  libMesh::out << "[" << this->processor_id() << "] elem_cmap_elem_cnts = ";
1173  for (const auto & elem_cnt : elem_cmap_elem_cnts)
1174  libMesh::out << elem_cnt << ", ";
1175  libMesh::out << std::endl;
1176 
1177  libMesh::out << "[" << this->processor_id() << "] elem_cmap_ids = ";
1178  for (const auto & elem_id : elem_cmap_ids)
1179  libMesh::out << elem_id << ", ";
1180  libMesh::out << std::endl;
1181  }
1182 }
std::vector< int > node_cmap_ids
Vectors for storing the communication map parameters.
int num_node_cmaps
The number of nodal communication maps for this processor.
std::map< unsigned, std::set< unsigned > >::iterator proc_nodes_touched_iterator
Typedef for an iterator into the data structure above.
std::vector< int > elem_cmap_elem_cnts
int num_elem_cmaps
The number of elemental communication maps for this processor.
OStreamProxy out
std::vector< int > elem_cmap_ids
std::vector< int > node_cmap_node_cnts
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).
processor_id_type processor_id() const
std::map< unsigned, std::set< std::pair< unsigned, unsigned > > >::iterator proc_border_elem_sets_iterator
Typedef for an iterator into the data structure above.
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.

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

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

Referenced by initialize().

959 {
960  // Make sure there is no leftover information
961  this->elem_cmap_elem_ids.clear();
962  this->elem_cmap_side_ids.clear();
963  this->elem_cmap_proc_ids.clear();
964 
965  // Allocate enough space for all our element maps
966  this->elem_cmap_elem_ids.resize(this->num_elem_cmaps);
967  this->elem_cmap_side_ids.resize(this->num_elem_cmaps);
968  this->elem_cmap_proc_ids.resize(this->num_elem_cmaps);
969  {
970  unsigned cnt=0; // Index into vectors
972  it = this->proc_border_elem_sets.begin(),
973  end = this->proc_border_elem_sets.end();
974 
975  for (; it != end; ++it)
976  {
977  // Make sure the current elem_cmap_id matches the index in our map of node intersections
978  libmesh_assert_equal_to (static_cast<unsigned>(this->elem_cmap_ids[cnt]), it->first);
979 
980  // Get reference to the set of IDs to be packed into the vector
981  std::set<std::pair<unsigned,unsigned>> & elem_set = it->second;
982 
983  // Resize the vectors to receive their payload
984  this->elem_cmap_elem_ids[cnt].resize(elem_set.size());
985  this->elem_cmap_side_ids[cnt].resize(elem_set.size());
986  this->elem_cmap_proc_ids[cnt].resize(elem_set.size());
987 
988  std::set<std::pair<unsigned,unsigned>>::iterator elem_set_iter = elem_set.begin();
989 
990  // Pack the vectors with elem IDs, side IDs, and processor IDs.
991  for (std::size_t j=0, eceis=this->elem_cmap_elem_ids[cnt].size(); j<eceis; ++j, ++elem_set_iter)
992  {
993  this->elem_cmap_elem_ids[cnt][j] =
994  libmesh_map_find(libmesh_elem_num_to_exodus, elem_set_iter->first);
995  this->elem_cmap_side_ids[cnt][j] = elem_set_iter->second; // Side ID, this has already been converted above
996  this->elem_cmap_proc_ids[cnt][j] = it->first; // All have the same processor ID
997  }
998 
999  // increment vector index to go to next processor
1000  cnt++;
1001  }
1002  } // end scope for packing
1003 }
std::vector< std::vector< int > > elem_cmap_side_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_proc_ids
std::map< dof_id_type, dof_id_type > libmesh_elem_num_to_exodus
int num_elem_cmaps
The number of elemental communication maps for this processor.
std::vector< int > elem_cmap_ids
std::map< unsigned, std::set< std::pair< unsigned, unsigned > > >::iterator proc_border_elem_sets_iterator
Typedef for an iterator into the data structure above.
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.

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

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

Referenced by initialize().

934 {
935  // Make sure we don't have any leftover info
936  this->elem_mapi.clear();
937  this->elem_mapb.clear();
938 
939  // Copy set contents into vectors
940  this->elem_mapi.resize(this->internal_elem_ids.size());
941  this->elem_mapb.resize(this->border_elem_ids.size());
942 
943  {
944  unsigned cnt = 0;
945  for (const auto & id : this->internal_elem_ids)
946  this->elem_mapi[cnt++] = libmesh_map_find(libmesh_elem_num_to_exodus, id);
947  }
948 
949  {
950  unsigned cnt = 0;
951  for (const auto & id : this->border_elem_ids)
952  this->elem_mapb[cnt++] = libmesh_map_find(libmesh_elem_num_to_exodus, id);
953  }
954 }
std::set< unsigned > border_elem_ids
A set of border elem IDs for this processor.
std::map< dof_id_type, dof_id_type > libmesh_elem_num_to_exodus
std::vector< int > elem_mapb
Vector which stores border element IDs.
std::vector< int > elem_mapi
Vector which stores internal element IDs.
std::set< unsigned > internal_elem_ids
A set of internal elem IDs for this processor.

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

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

1189 {
1190  // Set of all local, active element IDs. After we have identified border element
1191  // IDs, the set_difference between this set and the border_elem_ids set will give us
1192  // the set of internal_elem_ids.
1193  std::set<unsigned> all_elem_ids;
1194 
1195  // A set of processor IDs which elements on this processor have as
1196  // neighbors. The size of this set will determine the number of
1197  // element communication maps in Exodus.
1198  std::set<unsigned> neighboring_processor_ids;
1199 
1200  for (const auto & elem : pmesh.active_local_element_ptr_range())
1201  {
1202  // Add this Elem's ID to all_elem_ids, later we will take the difference
1203  // between this set and the set of border_elem_ids, to get the set of
1204  // internal_elem_ids.
1205  all_elem_ids.insert(elem->id());
1206 
1207  // Will be set to true if element is determined to be a border element
1208  bool is_border_elem = false;
1209 
1210  // Construct a conversion object for this Element. This will help us map
1211  // Libmesh numberings into Nemesis numberings for sides.
1212  const auto & conv = get_conversion(elem->type());
1213 
1214  // Add all this element's node IDs to the set of all node IDs.
1215  // The set of internal_node_ids will be the set difference between
1216  // the set of all nodes and the set of border nodes.
1217  //
1218  // In addition, if any node of a local node is listed in the
1219  // border nodes list, then this element goes into the proc_border_elem_sets.
1220  // Note that there is not a 1:1 correspondence between
1221  // border_elem_ids and the entries which go into proc_border_elem_sets.
1222  // The latter is for communication purposes, ie determining which elements
1223  // should be shared between processors.
1224  for (auto node : elem->node_index_range())
1225  this->nodes_attached_to_local_elems.insert(elem->node_id(node));
1226 
1227  // Loop over element's neighbors, see if it has a neighbor which is off-processor
1228  for (auto n : elem->side_index_range())
1229  {
1230  if (elem->neighbor_ptr(n) != nullptr)
1231  {
1232  unsigned neighbor_proc_id = elem->neighbor_ptr(n)->processor_id();
1233 
1234  // If my neighbor has a different processor ID, I must be a border element.
1235  // Also track the neighboring processor ID if it is are different from our processor ID
1236  if (neighbor_proc_id != this->processor_id())
1237  {
1238  is_border_elem = true;
1239  neighboring_processor_ids.insert(neighbor_proc_id);
1240 
1241  // Convert libmesh side(n) of this element into a side ID for Nemesis
1242  unsigned nemesis_side_id = conv.get_inverse_side_map(n);
1243 
1244  if (verbose)
1245  libMesh::out << "[" << this->processor_id() << "] LibMesh side "
1246  << n
1247  << " mapped to (1-based) Exodus side "
1248  << nemesis_side_id
1249  << std::endl;
1250 
1251  // Add this element's ID and the ID of the side which is on the boundary
1252  // to the set of border elements for this processor.
1253  // Note: if the set does not already exist, this creates it.
1254  this->proc_border_elem_sets[ neighbor_proc_id ].emplace(elem->id(), nemesis_side_id);
1255  }
1256  }
1257  } // end for loop over neighbors
1258 
1259  // If we're on a border element, add it to the set
1260  if (is_border_elem)
1261  this->border_elem_ids.insert( elem->id() );
1262 
1263  } // end for loop over active local elements
1264 
1265  // Take the set_difference between all elements and border elements to get internal
1266  // element IDs
1267  std::set_difference(all_elem_ids.begin(), all_elem_ids.end(),
1268  this->border_elem_ids.begin(), this->border_elem_ids.end(),
1269  std::inserter(this->internal_elem_ids, this->internal_elem_ids.end()));
1270 
1271  // Take the set_difference between all nodes and border nodes to get internal nodes
1272  std::set_difference(this->nodes_attached_to_local_elems.begin(), this->nodes_attached_to_local_elems.end(),
1273  this->border_node_ids.begin(), this->border_node_ids.end(),
1274  std::inserter(this->internal_node_ids, this->internal_node_ids.end()));
1275 
1276  if (verbose)
1277  {
1278  libMesh::out << "[" << this->processor_id() << "] neighboring_processor_ids = ";
1279  for (const auto & id : neighboring_processor_ids)
1280  libMesh::out << id << " ";
1281  libMesh::out << std::endl;
1282  }
1283 
1284  // The size of the neighboring_processor_ids set should be the number of element communication maps
1285  this->num_elem_cmaps =
1286  cast_int<int>(neighboring_processor_ids.size());
1287 
1288  if (verbose)
1289  libMesh::out << "[" << this->processor_id() << "] "
1290  << "Number of neighboring processor IDs="
1291  << this->num_elem_cmaps
1292  << std::endl;
1293 
1294  if (verbose)
1295  {
1296  // Print out counts of border elements for each processor
1297  for (const auto & [proc_id, set] : proc_border_elem_sets)
1298  {
1299  libMesh::out << "[" << this->processor_id() << "] "
1300  << "Proc "
1301  << proc_id << " communicates "
1302  << set.size() << " elements." << std::endl;
1303  }
1304  }
1305 
1306  // Store the number of internal and border elements, and the number of internal nodes,
1307  // to be written to the Nemesis file.
1308  this->num_internal_elems =
1309  cast_int<int>(this->internal_elem_ids.size());
1310  this->num_border_elems =
1311  cast_int<int>(this->border_elem_ids.size());
1312  this->num_internal_nodes =
1313  cast_int<int>(this->internal_node_ids.size());
1314 
1315  if (verbose)
1316  {
1317  libMesh::out << "[" << this->processor_id() << "] num_internal_nodes=" << this->num_internal_nodes << std::endl;
1318  libMesh::out << "[" << this->processor_id() << "] num_border_nodes=" << this->num_border_nodes << std::endl;
1319  libMesh::out << "[" << this->processor_id() << "] num_border_elems=" << this->num_border_elems << std::endl;
1320  libMesh::out << "[" << this->processor_id() << "] num_internal_elems=" << this->num_internal_elems << std::endl;
1321  }
1322 }
const ExodusII_IO_Helper::Conversion & get_conversion(const ElemType type) const
std::set< unsigned > border_elem_ids
A set of border elem IDs for this processor.
std::set< unsigned > internal_node_ids
A set of internal node IDs for this processor.
std::set< unsigned > border_node_ids
The set which will eventually contain the IDs of "border nodes".
std::set< int > nodes_attached_to_local_elems
libMesh numbered node ids attached to local elems.
int num_internal_elems
The number of internal FEM elements.
int num_elem_cmaps
The number of elemental communication maps for this processor.
OStreamProxy out
processor_id_type processor_id() const
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.
int num_border_nodes
The number of FEM nodes local to a processor but residing in an element which also has FEM nodes on o...
int num_internal_nodes
To be used with the Nemesis::ne_get_loadbal_param() routine.
std::set< unsigned > internal_elem_ids
A set of internal elem IDs for this processor.
int num_border_elems
The number of border FEM elements.

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

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

1039 {
1040  // Make sure there's no left-over information
1041  this->node_cmap_node_ids.clear();
1042  this->node_cmap_proc_ids.clear();
1043 
1044  libmesh_assert_less_equal
1045  (this->proc_nodes_touched_intersections.size(),
1046  std::size_t(this->num_node_cmaps));
1047 
1048  // Allocate enough space for all our node maps
1049  this->node_cmap_node_ids.resize(this->num_node_cmaps);
1050  this->node_cmap_proc_ids.resize(this->num_node_cmaps);
1051  {
1052  unsigned cnt=0; // Index into vectors
1054  it = this->proc_nodes_touched_intersections.begin(),
1055  end = this->proc_nodes_touched_intersections.end();
1056 
1057  for (; it != end; ++it)
1058  {
1059  // Make sure the current node_cmap_id matches the index in our map of node intersections
1060  libmesh_assert_equal_to (static_cast<unsigned>(this->node_cmap_ids[cnt]), it->first);
1061 
1062  // Get reference to the set of IDs to be packed into the vector.
1063  std::set<unsigned> & node_set = it->second;
1064 
1065  // Resize the vectors to receive their payload
1066  this->node_cmap_node_ids[cnt].resize(node_set.size());
1067  this->node_cmap_proc_ids[cnt].resize(node_set.size());
1068 
1069  std::set<unsigned>::iterator node_set_iter = node_set.begin();
1070 
1071  // Pack the vectors with node IDs and processor IDs.
1072  for (std::size_t j=0, nceis=this->node_cmap_node_ids[cnt].size(); j<nceis; ++j, ++node_set_iter)
1073  {
1074  this->node_cmap_node_ids[cnt][j] =
1075  libmesh_map_find(libmesh_node_num_to_exodus, *node_set_iter);
1076  this->node_cmap_proc_ids[cnt][j] = it->first;
1077  }
1078 
1079  // increment vector index to go to next processor
1080  cnt++;
1081  }
1082  } // end scope for packing
1083 
1084  // Print out the vectors we just packed
1085  if (verbose)
1086  {
1087  for (auto i : index_range(this->node_cmap_node_ids))
1088  {
1089  libMesh::out << "[" << this->processor_id() << "] nodes communicated to proc "
1090  << this->node_cmap_ids[i]
1091  << " = ";
1092  for (const auto & node_id : this->node_cmap_node_ids[i])
1093  libMesh::out << node_id << " ";
1094  libMesh::out << std::endl;
1095  }
1096 
1097  for (const auto & id_vec : this->node_cmap_node_ids)
1098  {
1099  libMesh::out << "[" << this->processor_id() << "] processor ID node communicated to = ";
1100  for (const auto & proc_id : id_vec)
1101  libMesh::out << proc_id << " ";
1102  libMesh::out << std::endl;
1103  }
1104  }
1105 }
std::vector< int > node_cmap_ids
Vectors for storing the communication map parameters.
int num_node_cmaps
The number of nodal communication maps for this processor.
std::vector< std::vector< int > > node_cmap_proc_ids
std::map< dof_id_type, dof_id_type > libmesh_node_num_to_exodus
std::map< unsigned, std::set< unsigned > >::iterator proc_nodes_touched_iterator
Typedef for an iterator into the data structure above.
std::unordered_set< const Node * > & node_set
Definition: mesh_tools.C:2102
OStreamProxy out
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::vector< std::vector< int > > node_cmap_node_ids
2 vectors of vectors for storing the node communication IDs for this processor.
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

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

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

Referenced by initialize().

1010 {
1011  // Make sure we don't have any leftover information
1012  this->node_mapi.clear();
1013  this->node_mapb.clear();
1014  this->node_mape.clear();
1015 
1016  // Make sure there's enough space to hold all our node IDs
1017  this->node_mapi.resize(this->internal_node_ids.size());
1018  this->node_mapb.resize(this->border_node_ids.size());
1019 
1020  // Copy set contents into vectors
1021  {
1022  unsigned cnt = 0;
1023  for (const auto & id : this->internal_node_ids)
1024  this->node_mapi[cnt++] = libmesh_map_find(libmesh_node_num_to_exodus, id);
1025  }
1026 
1027  {
1028  unsigned cnt=0;
1029  for (const auto & id : this->border_node_ids)
1030  this->node_mapb[cnt++] = libmesh_map_find(libmesh_node_num_to_exodus, id);
1031  }
1032 }
std::vector< int > node_mape
Vector which stores external node IDs.
std::map< dof_id_type, dof_id_type > libmesh_node_num_to_exodus
std::set< unsigned > internal_node_ids
A set of internal node IDs for this processor.
std::vector< int > node_mapi
Vector which stores internal node IDs.
std::set< unsigned > border_node_ids
The set which will eventually contain the IDs of "border nodes".
std::vector< int > node_mapb
Vector which stores border node IDs.

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

References TIMPI::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(), TIMPI::Communicator::sum(), and libMesh::ExodusII_IO_Helper::verbose.

Referenced by initialize().

1531 {
1532  // 1.) Loop over active local elements, build up set of subdomain IDs.
1533  std::set<subdomain_id_type> global_subdomain_ids;
1534 
1535  // This map keeps track of the number of elements in each subdomain over all processors
1536  std::map<subdomain_id_type, unsigned> global_subdomain_counts;
1537 
1538  for (const auto & elem : pmesh.active_local_element_ptr_range())
1539  {
1540  subdomain_id_type cur_subdomain = elem->subdomain_id();
1541 
1542  /*
1543  // We can't have a zero subdomain ID in Exodus (for some reason?)
1544  // so map zero subdomains to a max value...
1545  if (cur_subdomain == 0)
1546  cur_subdomain = std::numeric_limits<subdomain_id_type>::max();
1547  */
1548 
1549  global_subdomain_ids.insert(cur_subdomain);
1550 
1551  // Increment the count of elements in this subdomain
1552  global_subdomain_counts[cur_subdomain]++;
1553  }
1554 
1555  // We're next going to this->comm().sum the subdomain counts, so save the local counts
1556  this->local_subdomain_counts = global_subdomain_counts;
1557 
1558  {
1559  // 2.) Copy local subdomain IDs into a vector for communication
1560  std::vector<subdomain_id_type> global_subdomain_ids_vector(global_subdomain_ids.begin(),
1561  global_subdomain_ids.end());
1562 
1563  // 3.) Gather them into an enlarged vector
1564  this->comm().allgather(global_subdomain_ids_vector);
1565 
1566  // 4.) Insert any new IDs into the set (any duplicates will be dropped)
1567  global_subdomain_ids.insert(global_subdomain_ids_vector.begin(),
1568  global_subdomain_ids_vector.end());
1569  }
1570 
1571  // 5.) Now global_subdomain_ids actually contains a global list of all subdomain IDs
1572  this->num_elem_blks_global =
1573  cast_int<int>(global_subdomain_ids.size());
1574 
1575  // Print the number of elements found locally in each subdomain
1576  if (verbose)
1577  {
1578  libMesh::out << "[" << this->processor_id() << "] ";
1579  for (const auto & [subdomain_id, cnt] : global_subdomain_counts)
1580  {
1581  libMesh::out << "ID: "
1582  << static_cast<unsigned>(subdomain_id)
1583  << ", Count: " << cnt << ", ";
1584  }
1585  libMesh::out << std::endl;
1586  }
1587 
1588  // 6.) this->comm().sum up the number of elements in each block. We know the global
1589  // subdomain IDs, so pack them into a vector one by one. Use a vector of int since
1590  // that is what Nemesis wants
1591  this->global_elem_blk_cnts.resize(global_subdomain_ids.size());
1592 
1593  unsigned cnt=0;
1594  // Find the entry in the local map, note: if not found, will be created with 0 default value, which is OK...
1595  for (const auto & id : global_subdomain_ids)
1596  this->global_elem_blk_cnts[cnt++] = global_subdomain_counts[id];
1597 
1598  // Sum up subdomain counts from all processors
1599  this->comm().sum(this->global_elem_blk_cnts);
1600 
1601  if (verbose)
1602  {
1603  libMesh::out << "[" << this->processor_id() << "] global_elem_blk_cnts = ";
1604  for (const auto & bc : this->global_elem_blk_cnts)
1605  libMesh::out << bc << ", ";
1606  libMesh::out << std::endl;
1607  }
1608 
1609  // 7.) Create a vector<int> from the global_subdomain_ids set, for passing to Nemesis
1610  this->global_elem_blk_ids.clear();
1611  this->global_elem_blk_ids.insert(this->global_elem_blk_ids.end(), // pos
1612  global_subdomain_ids.begin(),
1613  global_subdomain_ids.end());
1614 
1615  if (verbose)
1616  {
1617  libMesh::out << "[" << this->processor_id() << "] global_elem_blk_ids = ";
1618  for (const auto & id : this->global_elem_blk_ids)
1619  libMesh::out << id << ", ";
1620  libMesh::out << std::endl;
1621  }
1622 
1623 
1624  // 8.) We will call put_eb_info_global later, it must be called after this->put_init_global().
1625 }
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
TestClass subdomain_id_type
Based on the 4-byte comment warning above, this probably doesn&#39;t work with exodusII at all...
Definition: id_types.h:43
void sum(T &r) const
const Parallel::Communicator & comm() const
std::vector< int > global_elem_blk_ids
Read the global element block IDs and counts.
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...
OStreamProxy out
processor_id_type processor_id() const
std::vector< int > global_elem_blk_cnts

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

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

Referenced by initialize().

1420 {
1421  std::set<boundary_id_type> local_node_boundary_ids;
1422 
1423  // 1.) Get reference to the set of node boundary IDs *for this processor*
1424  std::set<boundary_id_type> global_node_boundary_ids
1425  (pmesh.get_boundary_info().get_node_boundary_ids().begin(),
1426  pmesh.get_boundary_info().get_node_boundary_ids().end());
1427 
1428  // Save a copy of the local_node_boundary_ids...
1429  local_node_boundary_ids = global_node_boundary_ids;
1430 
1431  // 2.) Gather boundary node IDs from other processors
1432  this->comm().set_union(global_node_boundary_ids);
1433 
1434  // 3.) Now global_node_boundary_ids actually contains a global list of all node boundary IDs
1435  this->num_node_sets_global =
1436  cast_int<int>(global_node_boundary_ids.size());
1437 
1438  // 4.) Create a vector<int> from the global_node_boundary_ids set
1439  this->global_nodeset_ids.clear();
1440  this->global_nodeset_ids.insert(this->global_nodeset_ids.end(),
1441  global_node_boundary_ids.begin(),
1442  global_node_boundary_ids.end());
1443 
1444  if (verbose)
1445  {
1446  libMesh::out << "[" << this->processor_id() << "] global_nodeset_ids = ";
1447  for (const auto & id : global_nodeset_ids)
1448  libMesh::out << id << ", ";
1449  libMesh::out << std::endl;
1450 
1451  libMesh::out << "[" << this->processor_id() << "] local_node_boundary_ids = ";
1452  for (const auto & id : local_node_boundary_ids)
1453  libMesh::out << id << ", ";
1454  libMesh::out << std::endl;
1455  }
1456 
1457  // 7.) We also need to know the number of nodes which is in each of the nodesets, globally.
1458 
1459  // Build list of (node-id, bc-id) tuples.
1460  typedef std::tuple<dof_id_type, boundary_id_type> Tuple;
1461  std::vector<Tuple> bc_tuples = pmesh.get_boundary_info().build_node_list();
1462 
1463  if (verbose)
1464  {
1465  libMesh::out << "[" << this->processor_id() << "] boundary_node_list.size()="
1466  << bc_tuples.size() << std::endl;
1467  libMesh::out << "[" << this->processor_id() << "] (boundary_node_id, boundary_id) = ";
1468  for (const auto & t : bc_tuples)
1469  libMesh::out << "(" << std::get<0>(t) << ", " << std::get<1>(t) << ") ";
1470  libMesh::out << std::endl;
1471  }
1472 
1473  // Now get the global information. In this case, we only want to count boundary
1474  // information for nodes *owned* by this processor, so there are no duplicates.
1475 
1476  // Make sure we don't have any left over information
1477  this->num_global_node_counts.clear();
1478  this->num_global_node_counts.resize(this->global_nodeset_ids.size());
1479 
1480  // Unfortunately, we can't just count up all occurrences of a given id,
1481  // that would give us duplicate entries when we do the parallel summation.
1482  // So instead, only count entries for nodes owned by this processor.
1483  // Start by getting rid of all non-local node entries from the vectors.
1484  std::vector<Tuple>::iterator
1485  it = bc_tuples.begin(),
1486  new_end = bc_tuples.end();
1487 
1488  while (it != new_end)
1489  {
1490  if (pmesh.node_ptr(std::get<0>(*it))->processor_id() != this->processor_id())
1491  {
1492  // Back up the new end iterators to prepare for swap
1493  --new_end;
1494 
1495  // Swap places, the non-local node will now be "past-the-end"
1496  std::swap(*it, *new_end);
1497  }
1498  else // node is local, go to next
1499  ++it;
1500  }
1501 
1502  // Erase from "new" end to old end.
1503  bc_tuples.erase(new_end, bc_tuples.end());
1504 
1505  // Now we can do the local count for each ID...
1506  for (auto i : index_range(global_nodeset_ids))
1507  {
1508  int id = this->global_nodeset_ids[i];
1509  this->num_global_node_counts[i] =
1510  cast_int<int>(std::count_if(bc_tuples.begin(),
1511  bc_tuples.end(),
1512  [id](const Tuple & t)->bool { return std::get<1>(t) == id; }));
1513  }
1514 
1515  // And finally we can sum them up
1516  this->comm().sum(this->num_global_node_counts);
1517 
1518  if (verbose)
1519  {
1520  libMesh::out << "[" << this->processor_id() << "] num_global_node_counts = ";
1521  for (const auto & cnt : num_global_node_counts)
1522  libMesh::out << cnt << ", ";
1523  libMesh::out << std::endl;
1524  }
1525 }
std::vector< int > num_global_node_counts
std::vector< int > global_nodeset_ids
Containers for reading global nodeset information.
void sum(T &r) const
const Parallel::Communicator & comm() const
OStreamProxy out
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
void set_union(T &data, const unsigned int root_id) const

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

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

Referenced by initialize().

1327 {
1328  // 1.) Get reference to the set of side boundary IDs
1329  std::set<boundary_id_type> global_side_boundary_ids
1330  (pmesh.get_boundary_info().get_side_boundary_ids().begin(),
1331  pmesh.get_boundary_info().get_side_boundary_ids().end());
1332 
1333  // 2.) Gather boundary side IDs from other processors
1334  this->comm().set_union(global_side_boundary_ids);
1335 
1336  // 3.) Now global_side_boundary_ids actually contains a global list of all side boundary IDs
1337  this->num_side_sets_global =
1338  cast_int<int>(global_side_boundary_ids.size());
1339 
1340  // 4.) Pack these sidesets into a vector so they can be written by Nemesis
1341  this->global_sideset_ids.clear(); // Make sure there is no leftover information
1342  this->global_sideset_ids.insert(this->global_sideset_ids.end(),
1343  global_side_boundary_ids.begin(),
1344  global_side_boundary_ids.end());
1345 
1346  if (verbose)
1347  {
1348  libMesh::out << "[" << this->processor_id() << "] global_sideset_ids = ";
1349  for (const auto & id : this->global_sideset_ids)
1350  libMesh::out << id << ", ";
1351  libMesh::out << std::endl;
1352  }
1353 
1354  // We also need global counts of sides in each of the sidesets.
1355  // Build a list of (elem, side, bc) tuples.
1356  typedef std::tuple<dof_id_type, unsigned short int, boundary_id_type> Tuple;
1357  std::vector<Tuple> bc_triples = pmesh.get_boundary_info().build_side_list();
1358 
1359  // Iterators to the beginning and end of the current range.
1360  std::vector<Tuple>::iterator
1361  it = bc_triples.begin(),
1362  new_end = bc_triples.end();
1363 
1364  while (it != new_end)
1365  {
1366  if (pmesh.elem_ref(std::get<0>(*it)).processor_id() != this->processor_id())
1367  {
1368  // Back up the new end iterators to prepare for swap
1369  --new_end;
1370 
1371  // Swap places, the non-local elem will now be "past-the-end"
1372  std::swap (*it, *new_end);
1373  }
1374  else // elem is local, go to next
1375  ++it;
1376  }
1377 
1378  // Erase from "new" end to old.
1379  bc_triples.erase(new_end, bc_triples.end());
1380 
1381  this->num_global_side_counts.clear(); // Make sure we don't have any leftover information
1382  this->num_global_side_counts.resize(this->global_sideset_ids.size());
1383 
1384  // Get the count for each global sideset ID
1385  for (auto i : index_range(global_sideset_ids))
1386  {
1387  int id = global_sideset_ids[i];
1388  this->num_global_side_counts[i] =
1389  cast_int<int>(std::count_if(bc_triples.begin(),
1390  bc_triples.end(),
1391  [id](const Tuple & t)->bool { return std::get<2>(t) == id; }));
1392  }
1393 
1394  if (verbose)
1395  {
1396  libMesh::out << "[" << this->processor_id() << "] num_global_side_counts = ";
1397  for (const auto & cnt : this->num_global_side_counts)
1398  libMesh::out << cnt << ", ";
1399  libMesh::out << std::endl;
1400  }
1401 
1402  // Finally sum up the result
1403  this->comm().sum(this->num_global_side_counts);
1404 
1405  if (verbose)
1406  {
1407  libMesh::out << "[" << this->processor_id() << "] num_global_side_counts = ";
1408  for (const auto & cnt : this->num_global_side_counts)
1409  libMesh::out << cnt << ", ";
1410  libMesh::out << std::endl;
1411  }
1412 }
std::vector< int > global_sideset_ids
Containers for reading global sideset (boundary conditions) information.
void sum(T &r) const
const Parallel::Communicator & comm() const
std::vector< int > num_global_side_counts
OStreamProxy out
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
void set_union(T &data, const unsigned int root_id) const

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

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

2792 {
2793  // Build a filename for this processor. This code is cut-n-pasted from the read function
2794  // and should probably be put into a separate function...
2795  std::ostringstream file_oss;
2796 
2797  // We have to be a little careful here: Nemesis left pads its file
2798  // numbers based on the number of processors, so for example on 10
2799  // processors, we'd have:
2800  // mesh.e.10.00
2801  // mesh.e.10.01
2802  // mesh.e.10.02
2803  // ...
2804  // mesh.e.10.09
2805 
2806  // And on 100 you'd have:
2807  // mesh.e.100.000
2808  // mesh.e.100.001
2809  // ...
2810  // mesh.e.128.099
2811 
2812  // Find the length of the highest processor ID
2813  file_oss << (this->n_processors());
2814  unsigned int field_width = cast_int<unsigned int>(file_oss.str().size());
2815 
2816  if (verbose)
2817  libMesh::out << "field_width=" << field_width << std::endl;
2818 
2819  file_oss.str(""); // reset the string stream
2820  file_oss << base_filename
2821  << '.' << this->n_processors()
2822  << '.' << std::setfill('0') << std::setw(field_width) << this->processor_id();
2823 
2824  // Return the resulting string
2825  return file_oss.str();
2826 }
processor_id_type n_processors() const
OStreamProxy out
processor_id_type processor_id() const

◆ create()

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

Opens an ExodusII mesh file named filename for writing.

Definition at line 2125 of file exodusII_io_helper.C.

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

2126 {
2127  // If we're processor 0, always create the file.
2128  // If we running on all procs, e.g. as one of several Nemesis files, also
2129  // call create there.
2130  if ((this->processor_id() == 0) || (!_run_only_on_proc0))
2131  {
2132  int
2133  comp_ws = 0,
2134  io_ws = 0;
2135 
2136  if (_single_precision)
2137  {
2138  comp_ws = cast_int<int>(sizeof(float));
2139  io_ws = cast_int<int>(sizeof(float));
2140  }
2141  // Fall back on double precision when necessary since ExodusII
2142  // doesn't seem to support long double
2143  else
2144  {
2145  comp_ws = cast_int<int>
2146  (std::min(sizeof(Real), sizeof(double)));
2147  io_ws = cast_int<int>
2148  (std::min(sizeof(Real), sizeof(double)));
2149  }
2150 
2151  // By default we just open the Exodus file in "EX_CLOBBER" mode,
2152  // which, according to "ncdump -k", writes the file in "64-bit
2153  // offset" mode, which is a NETCDF3 file format.
2154  int mode = EX_CLOBBER;
2155 
2156  // If HDF5 is available, by default we will write Exodus files
2157  // in a more modern NETCDF4-compatible format. For this file
2158  // type, "ncdump -k" will report "netCDF-4".
2159 #ifdef LIBMESH_HAVE_HDF5
2160  if (this->_write_hdf5)
2161  {
2162  mode |= EX_NETCDF4;
2163  mode |= EX_NOCLASSIC;
2164  }
2165 #endif
2166 
2167  ex_id = exII::ex_create(filename.c_str(), mode, &comp_ws, &io_ws);
2168 
2169  EX_CHECK_ERR(ex_id, "Error creating ExodusII/Nemesis mesh file.");
2170 
2171  if (verbose)
2172  libMesh::out << "File created successfully." << std::endl;
2173  }
2174 
2175  opened_for_writing = true;
2176  _opened_by_create = true;
2177  current_filename = filename;
2178 }
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
OStreamProxy out
processor_id_type processor_id() const

◆ end_elem_id()

int libMesh::ExodusII_IO_Helper::end_elem_id ( ) const
inlineinherited

◆ get_add_sides()

bool libMesh::ExodusII_IO_Helper::get_add_sides ( )
inlineinherited

Definition at line 1295 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::_add_sides.

1296 {
1297  return _add_sides;
1298 }
bool _add_sides
Set to true iff we want to write separate "side" elements too.

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

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

1071 {
1072  libmesh_assert_less (index, block_ids.size());
1073 
1074  return block_ids[index];
1075 }

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

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

1080 {
1081  libmesh_assert_less (index, block_ids.size());
1082 
1083  return id_to_block_names[block_ids[index]];
1084 }
std::map< int, std::string > id_to_block_names

◆ get_cmap_params()

void libMesh::Nemesis_IO_Helper::get_cmap_params ( )

Definition at line 369 of file nemesis_io_helper.C.

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.

370 {
375 
377  Nemesis::ne_get_cmap_params(ex_id,
378  node_cmap_ids.empty() ? nullptr : node_cmap_ids.data(),
379  node_cmap_node_cnts.empty() ? nullptr : node_cmap_node_cnts.data(),
380  elem_cmap_ids.empty() ? nullptr : elem_cmap_ids.data(),
381  elem_cmap_elem_cnts.empty() ? nullptr : elem_cmap_elem_cnts.data(),
382  this->processor_id());
383  EX_CHECK_ERR(nemesis_err_flag, "Error reading cmap parameters!");
384 
385 
386  if (verbose)
387  {
388  libMesh::out << "[" << this->processor_id() << "] ";
389  for (auto i : index_range(node_cmap_ids))
390  libMesh::out << "node_cmap_ids[" << i << "]=" << node_cmap_ids[i] << " ";
391  libMesh::out << std::endl;
392 
393  libMesh::out << "[" << this->processor_id() << "] ";
394  for (auto i : index_range(node_cmap_node_cnts))
395  libMesh::out << "node_cmap_node_cnts[" << i << "]=" << node_cmap_node_cnts[i] << " ";
396  libMesh::out << std::endl;
397 
398  libMesh::out << "[" << this->processor_id() << "] ";
399  for (auto i : index_range(elem_cmap_ids))
400  libMesh::out << "elem_cmap_ids[" << i << "]=" << elem_cmap_ids[i] << " ";
401  libMesh::out << std::endl;
402 
403  libMesh::out << "[" << this->processor_id() << "] ";
404  for (auto i : index_range(elem_cmap_elem_cnts))
405  libMesh::out << "elem_cmap_elem_cnts[" << i << "]=" << elem_cmap_elem_cnts[i] << " ";
406  libMesh::out << std::endl;
407  }
408 }
std::vector< int > node_cmap_ids
Vectors for storing the communication map parameters.
int nemesis_err_flag
Member data.
int num_node_cmaps
The number of nodal communication maps for this processor.
std::vector< int > elem_cmap_elem_cnts
int num_elem_cmaps
The number of elemental communication maps for this processor.
OStreamProxy out
std::vector< int > elem_cmap_ids
std::vector< int > node_cmap_node_cnts
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

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

References libMesh::Quality::name().

4674 {
4675  std::vector<std::string> complex_names;
4676 
4677  // This will loop over all names and create new "complex" names
4678  // (i.e. names that start with r_, i_ or a_)
4679  for (const auto & name : names)
4680  {
4681  complex_names.push_back("r_" + name);
4682  complex_names.push_back("i_" + name);
4683  if (write_complex_abs)
4684  complex_names.push_back("a_" + name);
4685  }
4686 
4687  return complex_names;
4688 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42

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

4720 {
4721  // Eventual return value
4722  std::map<subdomain_id_type, std::vector<std::string>> ret;
4723 
4724  unsigned int num_complex_outputs = write_complex_abs ? 3 : 2;
4725 
4726  for (const auto & pr : subdomain_to_var_names)
4727  {
4728  // Initialize entry for current subdomain
4729  auto & vec = ret[pr.first];
4730 
4731  // Get list of non-complex variable names active on this subdomain.
4732  const auto & varnames = pr.second;
4733 
4734  // Allocate space for the complex-valued entries
4735  vec.reserve(num_complex_outputs * varnames.size());
4736 
4737  // For each varname in the input map, write three variable names
4738  // to the output formed by prepending "r_", "i_", and "a_",
4739  // respectively.
4740  for (const auto & varname : varnames)
4741  {
4742  vec.push_back("r_" + varname);
4743  vec.push_back("i_" + varname);
4744  if (write_complex_abs)
4745  vec.push_back("a_" + varname);
4746  }
4747  }
4748  return ret;
4749 }

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

4697 {
4698  std::vector<std::set<subdomain_id_type>> complex_vars_active_subdomains;
4699 
4700  for (auto & s : vars_active_subdomains)
4701  {
4702  // Push back the same data enough times for the real, imag, (and
4703  // possibly modulus) for the complex-valued solution.
4704  complex_vars_active_subdomains.push_back(s);
4705  complex_vars_active_subdomains.push_back(s);
4706  if (write_complex_abs)
4707  complex_vars_active_subdomains.push_back(s);
4708  }
4709 
4710  return complex_vars_active_subdomains;
4711 }

◆ get_conversion() [1/2]

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

◆ get_conversion() [2/2]

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

Definition at line 543 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::element_equivalence_map, and libMesh::ExodusII_IO_Helper::get_conversion().

544 {
545  // Do only upper-case comparisons
546  std::transform(type_str.begin(), type_str.end(), type_str.begin(), ::toupper);
547  return get_conversion (libmesh_map_find(element_equivalence_map, type_str));
548 }
const ExodusII_IO_Helper::Conversion & get_conversion(const ElemType type) const
std::map< std::string, ElemType > element_equivalence_map
Defines equivalence classes of Exodus element types that map to libmesh ElemTypes.

◆ get_eb_info_global()

void libMesh::Nemesis_IO_Helper::get_eb_info_global ( )

Definition at line 223 of file nemesis_io_helper.C.

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.

224 {
227 
228  if (num_elem_blks_global > 0)
229  {
231  Nemesis::ne_get_eb_info_global(ex_id,
232  global_elem_blk_ids.data(),
233  global_elem_blk_cnts.data());
234  EX_CHECK_ERR(nemesis_err_flag, "Error reading global element block info!");
235  }
236 
237  if (verbose)
238  {
239  libMesh::out << "[" << this->processor_id() << "] " << "Global Element Block IDs and Counts:" << std::endl;
240  for (auto bn : index_range(global_elem_blk_ids))
241  {
242  libMesh::out << " [" << this->processor_id() << "] "
243  << "global_elem_blk_ids[" << bn << "]=" << global_elem_blk_ids[bn]
244  << ", global_elem_blk_cnts[" << bn << "]=" << global_elem_blk_cnts[bn]
245  << std::endl;
246  }
247  }
248 }
int nemesis_err_flag
Member data.
std::vector< int > global_elem_blk_ids
Read the global element block IDs and counts.
OStreamProxy out
processor_id_type processor_id() const
std::vector< int > global_elem_blk_cnts
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

◆ get_elem_cmap()

void libMesh::Nemesis_IO_Helper::get_elem_cmap ( )

Definition at line 454 of file nemesis_io_helper.C.

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.

455 {
459 
460  for (auto i : index_range(elem_cmap_elem_ids))
461  {
465 
466  if (elem_cmap_elem_cnts[i] > 0)
467  {
469  Nemesis::ne_get_elem_cmap(ex_id,
470  elem_cmap_ids[i],
471  elem_cmap_elem_ids[i].data(),
472  elem_cmap_side_ids[i].data(),
473  elem_cmap_proc_ids[i].data(),
474  this->processor_id());
475  EX_CHECK_ERR(nemesis_err_flag, "Error reading elem cmap elem, side, and processor ids!");
476  }
477 
478  if (verbose)
479  {
480  libMesh::out << "[" << this->processor_id() << "] elem_cmap_elem_ids[" << i << "]=";
481  for (const auto & dof : elem_cmap_elem_ids[i])
482  libMesh::out << dof << " ";
483  libMesh::out << std::endl;
484 
485  // These must be the (local) side IDs (in the ExodusII face numbering scheme)
486  // of the sides shared across processors.
487  libMesh::out << "[" << this->processor_id() << "] elem_cmap_side_ids[" << i << "]=";
488  for (const auto & dof : elem_cmap_side_ids[i])
489  libMesh::out << dof << " ";
490  libMesh::out << std::endl;
491 
492  // This is basically a vector, all entries of which are = elem_cmap_ids[i]
493  // Not sure if it's always guaranteed to be that or what...
494  libMesh::out << "[" << this->processor_id() << "] elem_cmap_proc_ids[" << i << "]=";
495  for (const auto & dof : elem_cmap_proc_ids[i])
496  libMesh::out << dof << " ";
497  libMesh::out << std::endl;
498  }
499  }
500 }
int nemesis_err_flag
Member data.
std::vector< std::vector< int > > elem_cmap_side_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_proc_ids
std::vector< int > elem_cmap_elem_cnts
int num_elem_cmaps
The number of elemental communication maps for this processor.
OStreamProxy out
std::vector< int > elem_cmap_ids
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

◆ get_elem_map()

void libMesh::Nemesis_IO_Helper::get_elem_map ( )

Definition at line 301 of file nemesis_io_helper.C.

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.

302 {
304  elem_mapb.resize(num_border_elems);
305 
307  Nemesis::ne_get_elem_map(ex_id,
308  elem_mapi.empty() ? nullptr : elem_mapi.data(),
309  elem_mapb.empty() ? nullptr : elem_mapb.data(),
310  this->processor_id()
311  );
312  EX_CHECK_ERR(nemesis_err_flag, "Error reading element maps!");
313 
314 
315  if (verbose)
316  {
317  libMesh::out << "[" << this->processor_id() << "] elem_mapi[i] = ";
318  for (auto i : make_range(num_internal_elems-1))
319  libMesh::out << elem_mapi[i] << ", ";
320  libMesh::out << "... " << elem_mapi.back() << std::endl;
321 
322  libMesh::out << "[" << this->processor_id() << "] elem_mapb[i] = ";
323  for (auto i : make_range(std::min(10, num_border_elems-1)))
324  libMesh::out << elem_mapb[i] << ", ";
325  libMesh::out << "... " << elem_mapb.back() << std::endl;
326  }
327 }
int nemesis_err_flag
Member data.
int num_internal_elems
The number of internal FEM elements.
OStreamProxy out
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134
std::vector< int > elem_mapb
Vector which stores border element IDs.
processor_id_type processor_id() const
std::vector< int > elem_mapi
Vector which stores internal element IDs.
int num_border_elems
The number of border FEM elements.

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

References libMesh::ExodusII_IO_Helper::elem_type.

551 {
552  return elem_type.data();
553 }

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

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.

4117 {
4118  // Clear existing data, we are going to build these data structures from scratch
4119  elemset_array_indices.clear();
4120 
4121  // Read the elemset data.
4122  //
4123  // Note: we assume that the functions
4124  // 1.) this->read_elemset_info() and
4125  // 2.) this->read_elemset()
4126  // have already been called, so that we already know e.g. how
4127  // many elems are in each set, their ids, etc.
4128  int offset=0;
4129  for (int es=0; es<num_elem_sets; ++es)
4130  {
4131  offset += (es > 0 ? num_elems_per_set[es-1] : 0);
4132 
4133  // Note: we don't actually call exII::ex_get_var() here because
4134  // we don't need the values. We only need the indices into that vector
4135  // for each (elem_id, elemset_id) tuple.
4136  for (int i=0; i<num_elems_per_set[es]; ++i)
4137  {
4138  dof_id_type exodus_elem_id = elemset_list[i + offset];
4139 
4140  // FIXME: We should use exodus_elem_num_to_libmesh for this,
4141  // but it apparently is never set up, so just
4142  // subtract 1 from the Exodus elem id.
4143  dof_id_type converted_elem_id = exodus_elem_id - 1;
4144 
4145  // Make key based on the elem and set ids
4146  // Make a NodeBCTuple key from the converted information.
4147  auto key = std::make_pair(converted_elem_id,
4148  static_cast<elemset_id_type>(elemset_ids[es]));
4149 
4150  // Store the array index of this (node, b_id) tuple
4151  elemset_array_indices.emplace(key, cast_int<unsigned int>(i));
4152  } // end for (i)
4153  } // end for (es)
4154 }
std::vector< int > num_elems_per_set
uint8_t dof_id_type
Definition: id_types.h:67

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

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

314 {
315  return EX_API_VERS_NODOT;
316 }

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

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

133 {
135  Nemesis::ne_get_init_global(ex_id,
141  EX_CHECK_ERR(nemesis_err_flag, "Error reading initial global data!");
142 
143  if (verbose)
144  {
145  libMesh::out << "[" << this->processor_id() << "] " << "num_nodes_global=" << num_nodes_global << std::endl;
146  libMesh::out << "[" << this->processor_id() << "] " << "num_elems_global=" << num_elems_global << std::endl;
147  libMesh::out << "[" << this->processor_id() << "] " << "num_elem_blks_global=" << num_elem_blks_global << std::endl;
148  libMesh::out << "[" << this->processor_id() << "] " << "num_node_sets_global=" << num_node_sets_global << std::endl;
149  libMesh::out << "[" << this->processor_id() << "] " << "num_side_sets_global=" << num_side_sets_global << std::endl;
150  }
151 }
int nemesis_err_flag
Member data.
int num_nodes_global
Global initial information.
OStreamProxy out
processor_id_type processor_id() const

◆ get_init_info()

void libMesh::Nemesis_IO_Helper::get_init_info ( )

Definition at line 252 of file nemesis_io_helper.C.

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

253 {
255  Nemesis::ne_get_init_info(ex_id,
256  &num_proc,
258  &ftype);
259  EX_CHECK_ERR(nemesis_err_flag, "Error reading initial info!");
260 
261  if (verbose)
262  {
263  libMesh::out << "[" << this->processor_id() << "] " << "num_proc=" << num_proc << std::endl;
264  libMesh::out << "[" << this->processor_id() << "] " << "num_proc_in_file=" << num_proc_in_file << std::endl;
265  libMesh::out << "[" << this->processor_id() << "] " << "ftype=" << ftype << std::endl;
266  }
267 }
char ftype
The type of file to be written.
int nemesis_err_flag
Member data.
int num_proc
The number of processors for which the NEMESIS I file was created.
OStreamProxy out
int num_proc_in_file
The number of processors for which the NEMESIS I file stores information.
processor_id_type processor_id() const

◆ get_loadbal_param()

void libMesh::Nemesis_IO_Helper::get_loadbal_param ( )

Definition at line 271 of file nemesis_io_helper.C.

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

272 {
274  Nemesis::ne_get_loadbal_param(ex_id,
282  this->processor_id() // The ID of the processor for which info is to be read
283  );
284  EX_CHECK_ERR(nemesis_err_flag, "Error reading load balance parameters!");
285 
286 
287  if (verbose)
288  {
289  libMesh::out << "[" << this->processor_id() << "] " << "num_internal_nodes=" << num_internal_nodes << std::endl;
290  libMesh::out << "[" << this->processor_id() << "] " << "num_border_nodes=" << num_border_nodes << std::endl;
291  libMesh::out << "[" << this->processor_id() << "] " << "num_external_nodes=" << num_external_nodes << std::endl;
292  libMesh::out << "[" << this->processor_id() << "] " << "num_internal_elems=" << num_internal_elems << std::endl;
293  libMesh::out << "[" << this->processor_id() << "] " << "num_border_elems=" << num_border_elems << std::endl;
294  libMesh::out << "[" << this->processor_id() << "] " << "num_node_cmaps=" << num_node_cmaps << std::endl;
295  libMesh::out << "[" << this->processor_id() << "] " << "num_elem_cmaps=" << num_elem_cmaps << std::endl;
296  }
297 }
int num_external_nodes
The number of FEM nodes that reside on another processor but whose element partially resides on the c...
int nemesis_err_flag
Member data.
int num_node_cmaps
The number of nodal communication maps for this processor.
int num_internal_elems
The number of internal FEM elements.
int num_elem_cmaps
The number of elemental communication maps for this processor.
OStreamProxy out
processor_id_type processor_id() const
int num_border_nodes
The number of FEM nodes local to a processor but residing in an element which also has FEM nodes on o...
int num_internal_nodes
To be used with the Nemesis::ne_get_loadbal_param() routine.
int num_border_elems
The number of border FEM elements.

◆ get_node_cmap()

void libMesh::Nemesis_IO_Helper::get_node_cmap ( )

Definition at line 412 of file nemesis_io_helper.C.

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.

413 {
416 
417  for (auto i : index_range(node_cmap_node_ids))
418  {
421 
422  // Don't call ne_get_node_cmap() if there is nothing there to
423  // get, Nemesis throws an error in this case.
424  if (node_cmap_node_cnts[i] > 0)
425  {
427  Nemesis::ne_get_node_cmap(ex_id,
428  node_cmap_ids[i],
429  node_cmap_node_ids[i].data(),
430  node_cmap_proc_ids[i].data(),
431  this->processor_id());
432  EX_CHECK_ERR(nemesis_err_flag, "Error reading node cmap node and processor ids!");
433  }
434 
435  if (verbose)
436  {
437  libMesh::out << "[" << this->processor_id() << "] node_cmap_node_ids[" << i << "]=";
438  for (const auto & dof : node_cmap_node_ids[i])
439  libMesh::out << dof << " ";
440  libMesh::out << std::endl;
441 
442  // This is basically a vector, all entries of which are = node_cmap_ids[i]
443  // Not sure if it's always guaranteed to be that or what...
444  libMesh::out << "[" << this->processor_id() << "] node_cmap_proc_ids[" << i << "]=";
445  for (const auto & dof : node_cmap_proc_ids[i])
446  libMesh::out << dof << " ";
447  libMesh::out << std::endl;
448  }
449  }
450 }
std::vector< int > node_cmap_ids
Vectors for storing the communication map parameters.
int nemesis_err_flag
Member data.
int num_node_cmaps
The number of nodal communication maps for this processor.
std::vector< std::vector< int > > node_cmap_proc_ids
OStreamProxy out
std::vector< int > node_cmap_node_cnts
std::vector< std::vector< int > > node_cmap_node_ids
2 vectors of vectors for storing the node communication IDs for this processor.
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

◆ get_node_map()

void libMesh::Nemesis_IO_Helper::get_node_map ( )

Definition at line 332 of file nemesis_io_helper.C.

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

333 {
335  node_mapb.resize(num_border_nodes);
337 
339  Nemesis::ne_get_node_map(ex_id,
340  node_mapi.empty() ? nullptr : node_mapi.data(),
341  node_mapb.empty() ? nullptr : node_mapb.data(),
342  node_mape.empty() ? nullptr : node_mape.data(),
343  this->processor_id()
344  );
345  EX_CHECK_ERR(nemesis_err_flag, "Error reading node maps!");
346 
347  if (verbose)
348  {
349  // Remark: The Exodus/Nemesis node numbering is always (?) 1-based! This means the first interior node id will
350  // always be == 1.
351  libMesh::out << "[" << this->processor_id() << "] " << "first interior node id=" << node_mapi[0] << std::endl;
352  libMesh::out << "[" << this->processor_id() << "] " << "last interior node id=" << node_mapi.back() << std::endl;
353 
354  libMesh::out << "[" << this->processor_id() << "] " << "first boundary node id=" << node_mapb[0] << std::endl;
355  libMesh::out << "[" << this->processor_id() << "] " << "last boundary node id=" << node_mapb.back() << std::endl;
356 
357  // The number of external nodes is sometimes zero, don't try to access
358  // node_mape.back() in this case!
359  if (num_external_nodes > 0)
360  {
361  libMesh::out << "[" << this->processor_id() << "] " << "first external node id=" << node_mape[0] << std::endl;
362  libMesh::out << "[" << this->processor_id() << "] " << "last external node id=" << node_mape.back() << std::endl;
363  }
364  }
365 }
int num_external_nodes
The number of FEM nodes that reside on another processor but whose element partially resides on the c...
int nemesis_err_flag
Member data.
std::vector< int > node_mape
Vector which stores external node IDs.
std::vector< int > node_mapi
Vector which stores internal node IDs.
OStreamProxy out
std::vector< int > node_mapb
Vector which stores border node IDs.
processor_id_type processor_id() const
int num_border_nodes
The number of FEM nodes local to a processor but residing in an element which also has FEM nodes on o...
int num_internal_nodes
To be used with the Nemesis::ne_get_loadbal_param() routine.

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

References libMesh::ExodusII_IO_Helper::nodeset_ids.

1107 {
1108  libmesh_assert_less (index, nodeset_ids.size());
1109 
1110  return nodeset_ids[index];
1111 }

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

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

1116 {
1117  libmesh_assert_less (index, nodeset_ids.size());
1118 
1119  return id_to_ns_names[nodeset_ids[index]];
1120 }
std::map< int, std::string > id_to_ns_names

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

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.

4259 {
4260  // Clear existing data, we are going to build these data structures from scratch
4261  bc_array_indices.clear();
4262 
4263  // Read the nodeset data.
4264  //
4265  // Note: we assume that the functions
4266  // 1.) this->read_nodeset_info() and
4267  // 2.) this->read_all_nodesets()
4268  // have already been called, so that we already know e.g. how
4269  // many nodes are in each set, their ids, etc.
4270  int offset=0;
4271  for (int ns=0; ns<num_node_sets; ++ns)
4272  {
4273  offset += (ns > 0 ? num_nodes_per_set[ns-1] : 0);
4274  // Note: we don't actually call exII::ex_get_var() here because
4275  // we don't need the values. We only need the indices into that vector
4276  // for each (node_id, boundary_id) tuple.
4277  for (int i=0; i<num_nodes_per_set[ns]; ++i)
4278  {
4279  // The read_all_nodesets() function now reads all the node ids into the
4280  // node_sets_node_list vector, which is of length "total_nodes_in_all_sets"
4281  // The old read_nodset() function is no longer called as far as I can tell,
4282  // and should probably be removed? The "offset" that we are using only
4283  // depends on the current nodeset index and the num_nodes_per_set vector,
4284  // which gets filled in by the call to read_all_nodesets().
4285  dof_id_type exodus_node_id = node_sets_node_list[i + offset];
4286 
4287  // FIXME: We should use exodus_node_num_to_libmesh for this,
4288  // but it apparently is never set up, so just
4289  // subtract 1 from the Exodus node id.
4290  dof_id_type converted_node_id = exodus_node_id - 1;
4291 
4292  // Make a NodeBCTuple key from the converted information.
4293  BoundaryInfo::NodeBCTuple key = std::make_tuple
4294  (converted_node_id, nodeset_ids[ns]);
4295 
4296  // Store the array index of this (node, b_id) tuple
4297  bc_array_indices.emplace(key, cast_int<unsigned int>(i));
4298  } // end for (i)
4299  } // end for (ns)
4300 }
std::tuple< dof_id_type, boundary_id_type > NodeBCTuple
As above, but the library creates and fills in a vector of (node-id, bc-id) pairs and returns it to t...
std::vector< int > node_sets_node_list
std::vector< int > num_nodes_per_set
uint8_t dof_id_type
Definition: id_types.h:67

◆ get_ns_param_global()

void libMesh::Nemesis_IO_Helper::get_ns_param_global ( )

Definition at line 191 of file nemesis_io_helper.C.

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.

192 {
193  if (num_node_sets_global > 0)
194  {
198 
200  Nemesis::ne_get_ns_param_global(ex_id,
201  global_nodeset_ids.data(),
202  num_global_node_counts.data(),
204  EX_CHECK_ERR(nemesis_err_flag, "Error reading global nodeset parameters!");
205 
206  if (verbose)
207  {
208  libMesh::out << "[" << this->processor_id() << "] " << "Global Nodeset IDs, Node Counts, and DF counts:" << std::endl;
209  for (auto bn : index_range(global_nodeset_ids))
210  {
211  libMesh::out << " [" << this->processor_id() << "] "
212  << "global_nodeset_ids["<<bn<<"]=" << global_nodeset_ids[bn]
213  << ", num_global_node_counts["<<bn<<"]=" << num_global_node_counts[bn]
214  << ", num_global_node_df_counts["<<bn<<"]=" << num_global_node_df_counts[bn]
215  << std::endl;
216  }
217  }
218  }
219 }
std::vector< int > num_global_node_counts
std::vector< int > global_nodeset_ids
Containers for reading global nodeset information.
int nemesis_err_flag
Member data.
std::vector< int > num_global_node_df_counts
OStreamProxy out
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

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

References libMesh::ExodusII_IO_Helper::ss_ids.

1089 {
1090  libmesh_assert_less (index, ss_ids.size());
1091 
1092  return ss_ids[index];
1093 }

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

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

1098 {
1099  libmesh_assert_less (index, ss_ids.size());
1100 
1101  return id_to_ss_names[ss_ids[index]];
1102 }
std::map< int, std::string > id_to_ss_names

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

References libMesh::ExodusII_IO_Helper::elem_list, libMesh::MeshBase::elem_ptr(), libMesh::ExodusII_IO_Helper::get_conversion(), libMesh::ExodusII_IO_Helper::Conversion::get_side_map(), 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().

3733 {
3734  // Clear any existing data, we are going to build this data structure from scratch
3735  bc_array_indices.clear();
3736 
3737  // Store the sideset data array indices.
3738  //
3739  // Note: we assume that read_sideset() has already been called
3740  // for each sideset, so the required values in elem_list and
3741  // side_list are already present.
3742  int offset=0;
3743  for (int ss=0; ss<num_side_sets; ++ss)
3744  {
3745  offset += (ss > 0 ? num_sides_per_set[ss-1] : 0);
3746  for (int i=0; i<num_sides_per_set[ss]; ++i)
3747  {
3748  dof_id_type exodus_elem_id = elem_list[i + offset];
3749  unsigned int exodus_side_id = side_list[i + offset];
3750 
3751  // FIXME: We should use exodus_elem_num_to_libmesh for this,
3752  // but it apparently is never set up, so just
3753  // subtract 1 from the Exodus elem id.
3754  dof_id_type converted_elem_id = exodus_elem_id - 1;
3755 
3756  // Conversion operator for this Elem type
3757  const auto & conv = get_conversion(mesh.elem_ptr(converted_elem_id)->type());
3758 
3759  // Map from Exodus side id to libmesh side id.
3760  // Note: the mapping is defined on 0-based indices, so subtract
3761  // 1 before doing the mapping.
3762  unsigned int converted_side_id = conv.get_side_map(exodus_side_id - 1);
3763 
3764  // Make a BCTuple key from the converted information.
3765  BoundaryInfo::BCTuple key = std::make_tuple
3766  (converted_elem_id,
3767  converted_side_id,
3768  ss_ids[ss]);
3769 
3770  // Store (elem, side, b_id) tuple with corresponding array index
3771  bc_array_indices.emplace(key, cast_int<unsigned int>(i));
3772  } // end for (i)
3773  } // end for (ss)
3774 }
std::tuple< dof_id_type, unsigned short int, boundary_id_type > BCTuple
As above, but the library creates and fills in a vector of (elem-id, side-id, bc-id) triplets and ret...
std::vector< int > num_sides_per_set
MeshBase & mesh
const ExodusII_IO_Helper::Conversion & get_conversion(const ElemType type) const
virtual const Elem * elem_ptr(const dof_id_type i) const =0
virtual ElemType type() const =0
uint8_t dof_id_type
Definition: id_types.h:67

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

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.

156 {
157  if (num_side_sets_global > 0)
158  {
161 
162  // df = "distribution factor", not really sure what that is. I don't yet have a file
163  // which has distribution factors so I guess we'll worry about it later...
165 
167  Nemesis::ne_get_ss_param_global(ex_id,
168  global_sideset_ids.data(),
169  num_global_side_counts.data(),
171  EX_CHECK_ERR(nemesis_err_flag, "Error reading global sideset parameters!");
172 
173  if (verbose)
174  {
175  libMesh::out << "[" << this->processor_id() << "] " << "Global Sideset IDs, Side Counts, and DF counts:" << std::endl;
176  for (auto bn : index_range(global_sideset_ids))
177  {
178  libMesh::out << " [" << this->processor_id() << "] "
179  << "global_sideset_ids["<<bn<<"]=" << global_sideset_ids[bn]
180  << ", num_global_side_counts["<<bn<<"]=" << num_global_side_counts[bn]
181  << ", num_global_side_df_counts["<<bn<<"]=" << num_global_side_df_counts[bn]
182  << std::endl;
183  }
184  }
185  }
186 }
std::vector< int > global_sideset_ids
Containers for reading global sideset (boundary conditions) information.
int nemesis_err_flag
Member data.
std::vector< int > num_global_side_df_counts
std::vector< int > num_global_side_counts
OStreamProxy out
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

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

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::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_blks_global, num_elem_cmaps, num_external_nodes, num_global_node_counts, num_global_node_df_counts, num_global_side_counts, num_global_side_df_counts, num_internal_elems, num_internal_nodes, num_node_cmaps, num_node_sets_global, num_side_sets_global, libMesh::MeshBase::parallel_n_elem(), libMesh::MeshBase::parallel_n_nodes(), put_cmap_params(), put_eb_info_global(), put_elem_cmap(), put_elem_map(), put_init_global(), put_init_info(), put_loadbal_param(), put_node_cmap(), put_node_map(), put_ns_param_global(), put_ss_param_global(), and write_exodus_initialization_info().

736 {
737  // Make sure that the reference passed in is really a DistributedMesh
738  // const DistributedMesh & pmesh = cast_ref<const DistributedMesh &>(mesh);
739  const MeshBase & pmesh = mesh;
740 
741  // If _write_as_dimension is nonzero, use it to set num_dim later in the Exodus file.
745  num_dim = mesh.mesh_dimension();
746  else
747  num_dim = mesh.spatial_dimension();
748 
749  // According to Nemesis documentation, first call when writing should be to
750  // ne_put_init_info(). Our reader doesn't actually call this, but we should
751  // strive to be as close to a normal nemesis file as possible...
752  this->put_init_info(this->n_processors(), 1, "p");
753 
754 
755  // Gather global "initial" information for Nemesis. This consists of
756  // three parts labeled I, II, and III below...
757 
758  //
759  // I.) Need to compute the number of global element blocks. To be consistent with
760  // Exodus, we also incorrectly associate the number of element blocks with the
761  // number of libmesh subdomains...
762  //
763  this->compute_num_global_elem_blocks(pmesh);
764 
765  //
766  // II.) Determine the global number of nodesets by communication.
767  // This code relies on BoundaryInfo storing side and node
768  // boundary IDs separately at the time they are added to the
769  // BoundaryInfo object.
770  //
771  this->compute_num_global_nodesets(pmesh);
772 
773  //
774  // III.) Need to compute the global number of sidesets by communication:
775  // This code relies on BoundaryInfo storing side and node
776  // boundary IDs separately at the time they are added to the
777  // BoundaryInfo object.
778  //
779  this->compute_num_global_sidesets(pmesh);
780 
781  // Now write the global data obtained in steps I, II, and III to the Nemesis file
782  this->put_init_global(pmesh.parallel_n_nodes(),
783  pmesh.parallel_n_elem(),
784  this->num_elem_blks_global, /* I. */
785  this->num_node_sets_global, /* II. */
786  this->num_side_sets_global /* III. */
787  );
788 
789  // Next, we'll write global element block information to the file. This was already
790  // gathered in step I. above
792  this->global_elem_blk_cnts);
793 
794 
795  // Next, write global nodeset information to the file. This was already gathered in
796  // step II. above.
797  this->num_global_node_df_counts.clear();
798  this->num_global_node_df_counts.resize(this->global_nodeset_ids.size()); // distribution factors all zero...
802 
803 
804  // Next, write global sideset information to the file. This was already gathered in
805  // step III. above.
806  this->num_global_side_df_counts.clear();
807  this->num_global_side_df_counts.resize(this->global_sideset_ids.size()); // distribution factors all zero...
811 
812 
813  // Before we go any further we need to derive consistent node and
814  // element numbering schemes for all local elems and nodes connected
815  // to local elements.
816  //
817  // Must be called *after* the local_subdomain_counts map has been constructed
818  // by the compute_num_global_elem_blocks() function!
819  this->build_element_and_node_maps(pmesh);
820 
821  // Next step is to write "load balance" parameters. Several things need to
822  // be computed first though...
823 
824  // First we'll collect IDs of border nodes.
825  this->compute_border_node_ids(pmesh);
826 
827  // Next we'll collect numbers of internal and border elements, and internal nodes.
828  // Note: "A border node does not a border element make...", that is, just because one
829  // of an element's nodes has been identified as a border node, the element is not
830  // necessarily a border element. It must have a side on the boundary between processors,
831  // i.e. have a face neighbor with a different processor id...
833 
834  // Finally we are ready to write the loadbal information to the file
836  this->num_border_nodes,
837  this->num_external_nodes,
838  this->num_internal_elems,
839  this->num_border_elems,
840  this->num_node_cmaps,
841  this->num_elem_cmaps);
842 
843 
844  // Now we need to compute the "communication map" parameters. These are basically
845  // lists of nodes and elements which need to be communicated between different processors
846  // when the mesh file is read back in.
848 
849  // Write communication map parameters to file.
850  this->put_cmap_params(this->node_cmap_ids,
851  this->node_cmap_node_cnts,
852  this->elem_cmap_ids,
853  this->elem_cmap_elem_cnts);
854 
855  // Ready the node communication maps. The node IDs which
856  // are communicated are the ones currently stored in
857  // proc_nodes_touched_intersections.
859 
860  // Write the packed node communication vectors to file.
861  this->put_node_cmap(this->node_cmap_node_ids,
862  this->node_cmap_proc_ids);
863 
864  // Ready the node maps. These have nothing to do with communication, they map
865  // the nodes to internal, border, and external nodes in the file.
866  this->compute_node_maps();
867 
868  // Call the Nemesis API to write the node maps to file.
869  this->put_node_map(this->node_mapi,
870  this->node_mapb,
871  this->node_mape);
872 
873  // Ready the element communication maps. This includes border
874  // element IDs, sides which are on the border, and the processors to which
875  // they are to be communicated...
877 
878  // Call the Nemesis API to write the packed element communication maps vectors to file
879  this->put_elem_cmap(this->elem_cmap_elem_ids,
880  this->elem_cmap_side_ids,
881  this->elem_cmap_proc_ids);
882 
883  // Ready the Nemesis element maps (internal and border) for writing to file.
884  this->compute_element_maps();
885 
886  // Call the Nemesis API to write the internal and border element IDs.
887  this->put_elem_map(this->elem_mapi,
888  this->elem_mapb);
889 
890  // Now write Exodus-specific initialization information, some of which is
891  // different when you are using Nemesis.
892  this->write_exodus_initialization_info(pmesh, title_in);
893 } // end initialize()
std::vector< int > num_global_node_counts
void compute_element_maps()
This function computes element maps (really just packs vectors) which map the elements to internal an...
std::vector< int > global_nodeset_ids
Containers for reading global nodeset information.
std::vector< int > global_sideset_ids
Containers for reading global sideset (boundary conditions) information.
void compute_num_global_nodesets(const MeshBase &pmesh)
This function uses global communication routines to determine the number of nodesets across the entir...
std::vector< int > node_cmap_ids
Vectors for storing the communication map parameters.
int num_external_nodes
The number of FEM nodes that reside on another processor but whose element partially resides on the c...
std::vector< int > node_mape
Vector which stores external node IDs.
void compute_elem_communication_maps()
This function computes element communication maps (really just packs vectors) in preparation for writ...
void compute_num_global_elem_blocks(const MeshBase &pmesh)
This function uses global communication routines to determine the number of element blocks across the...
MeshBase & mesh
int num_node_cmaps
The number of nodal communication maps for this processor.
void put_elem_map(std::vector< int > &elem_mapi, std::vector< int > &elem_mapb)
Outputs IDs of internal and border elements.
std::vector< int > num_global_node_df_counts
std::vector< std::vector< int > > elem_cmap_side_ids
std::vector< std::vector< int > > node_cmap_proc_ids
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_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...
void compute_border_node_ids(const MeshBase &pmesh)
This function constructs the set of border 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 fil...
std::vector< int > num_global_side_df_counts
void build_element_and_node_maps(const MeshBase &pmesh)
This function builds the libmesh -> exodus and exodus -> libmesh node and element maps...
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 ...
processor_id_type n_processors() const
std::vector< int > num_global_side_counts
std::vector< int > global_elem_blk_ids
Read the global element block IDs and counts.
std::vector< std::vector< int > > elem_cmap_elem_ids
3 vectors of vectors for storing element communication IDs for this processor.
std::vector< int > node_mapi
Vector which stores internal node IDs.
std::vector< std::vector< int > > elem_cmap_proc_ids
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 compute_num_global_sidesets(const MeshBase &pmesh)
This function uses global communication routines to determine the number of sidesets across the entir...
int num_internal_elems
The number of internal FEM elements.
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 ...
void compute_node_maps()
Compute the node maps (really just pack vectors) which map the nodes to internal, border...
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_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.
std::vector< int > elem_cmap_elem_cnts
int num_elem_cmaps
The number of elemental communication maps for this processor.
std::vector< int > elem_cmap_ids
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.
std::vector< int > node_cmap_node_cnts
void write_exodus_initialization_info(const MeshBase &pmesh, const std::string &title)
This function writes exodus-specific initialization information.
void put_init_info(unsigned num_proc, unsigned num_proc_in_file, const char *ftype)
Writing functions.
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.
std::vector< int > elem_mapb
Vector which stores border element IDs.
std::vector< int > node_mapb
Vector which stores border node IDs.
std::vector< std::vector< int > > node_cmap_node_ids
2 vectors of vectors for storing the node communication IDs for this processor.
std::vector< int > global_elem_blk_cnts
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 "who...
std::vector< int > elem_mapi
Vector which stores internal element IDs.
int num_border_nodes
The number of FEM nodes local to a processor but residing in an element which also has FEM nodes on o...
int num_internal_nodes
To be used with the Nemesis::ne_get_loadbal_param() routine.
int num_border_elems
The number of border FEM elements.

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

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

2586 {
2587  // Quick return if there are no element variables to write
2588  if (names.size() == 0)
2589  return;
2590 
2591  // Quick return if we have already called this function
2593  return;
2594 
2595  // Be sure that variables in the file match what we are asking for
2596  if (num_elem_vars > 0)
2597  {
2598  this->check_existing_vars(ELEMENTAL, names, this->elem_var_names);
2599  return;
2600  }
2601 
2602  // Set the flag so we can skip this stuff on subsequent calls to
2603  // initialize_element_variables()
2604  _elem_vars_initialized = true;
2605 
2606  this->write_var_names(ELEMENTAL, names);
2607 
2608  // Create a truth table from global_elem_blk_ids and the information
2609  // in vars_active_subdomains. Create a truth table of
2610  // size global_elem_blk_ids.size() * names.size().
2611  std::vector<int> truth_tab(global_elem_blk_ids.size() * names.size());
2612  for (auto blk : index_range(global_elem_blk_ids))
2613  for (auto var : index_range(names))
2614  if (vars_active_subdomains[var].empty() ||
2615  vars_active_subdomains[var].count(cast_int<subdomain_id_type>(global_elem_blk_ids[blk])))
2616  truth_tab[names.size() * blk + var] = 1;
2617 
2618  // Write truth table to file.
2619  if (truth_tab.size())
2620  {
2621  ex_err = exII::ex_put_elem_var_tab(ex_id,
2622  cast_int<int>(global_elem_blk_ids.size()),
2623  cast_int<int>(names.size()),
2624  truth_tab.data());
2625  EX_CHECK_ERR(ex_err, "Error writing element truth table.");
2626  }
2627 }
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().
std::vector< std::string > elem_var_names
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 ...
std::vector< int > global_elem_blk_ids
Read the global element block IDs and counts.
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

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

References libMesh::ExodusII_IO_Helper::_global_vars_initialized, libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::check_existing_vars(), libMesh::ExodusII_IO_Helper::GLOBAL, libMesh::ExodusII_IO_Helper::global_var_names, libMesh::ExodusII_IO_Helper::num_global_vars, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::write_var_names().

3302 {
3303  if ((_run_only_on_proc0) && (this->processor_id() != 0))
3304  return;
3305 
3306  // Quick return if there are no global variables to write
3307  if (names.size() == 0)
3308  return;
3309 
3311  return;
3312 
3313  // Be sure that variables in the file match what we are asking for
3314  if (num_global_vars > 0)
3315  {
3316  this->check_existing_vars(GLOBAL, names, this->global_var_names);
3317  return;
3318  }
3319 
3320  _global_vars_initialized = true;
3321 
3322  this->write_var_names(GLOBAL, names);
3323 }
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().
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 ...
std::vector< std::string > global_var_names
processor_id_type processor_id() const

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

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

3274 {
3275  if ((_run_only_on_proc0) && (this->processor_id() != 0))
3276  return;
3277 
3278  // Quick return if there are no nodal variables to write
3279  if (names.size() == 0)
3280  return;
3281 
3282  // Quick return if we have already called this function
3284  return;
3285 
3286  // Be sure that variables in the file match what we are asking for
3287  if (num_nodal_vars > 0)
3288  {
3289  this->check_existing_vars(NODAL, names, this->nodal_var_names);
3290  return;
3291  }
3292 
3293  // Set the flag so we can skip the rest of this function on subsequent calls.
3294  _nodal_vars_initialized = true;
3295 
3296  this->write_var_names(NODAL, names);
3297 }
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().
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 ...
std::vector< std::string > nodal_var_names
processor_id_type processor_id() const

◆ message() [1/2]

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

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

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

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

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

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

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), compute_border_node_ids(), construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

104  {
105  processor_id_type returnval =
106  cast_int<processor_id_type>(_communicator.size());
107  libmesh_assert(returnval); // We never have an empty comm
108  return returnval;
109  }
const Parallel::Communicator & _communicator
processor_id_type size() const
uint8_t processor_id_type
libmesh_assert(ctx)

◆ 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 896 of file exodusII_io_helper.h.

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

897  {
898  if (_added_side_node_offsets.empty())
899  return n;
900 
901  // Find the processor id that has node_id in the parallel vec
902  const auto lb = std::upper_bound(_true_node_offsets.begin(),
903  _true_node_offsets.end(), n);
904  libmesh_assert(lb != _true_node_offsets.end());
905  const processor_id_type p = lb - _true_node_offsets.begin();
906 
907  return n + (p ? _added_side_node_offsets[p-1] : 0);
908  }
uint8_t processor_id_type
libmesh_assert(ctx)
std::vector< dof_id_type > _true_node_offsets
If we&#39;re adding "fake" sides to visualize SIDE_DISCONTINUOUS variables, we also need to know how many...
std::vector< dof_id_type > _added_side_node_offsets
If we&#39;re adding "fake" sides to visualize SIDE_DISCONTINUOUS variables, _added_side_node_offsets[p] g...

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

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

657 {
658  // Version of Exodus you are using
659  float ex_version = 0.;
660 
661  int comp_ws = 0;
662 
663  if (_single_precision)
664  comp_ws = cast_int<int>(sizeof(float));
665 
666  // Fall back on double precision when necessary since ExodusII
667  // doesn't seem to support long double
668  else
669  comp_ws = cast_int<int>(std::min(sizeof(Real), sizeof(double)));
670 
671  // Word size in bytes of the floating point data as they are stored
672  // in the ExodusII file. "If this argument is 0, the word size of the
673  // floating point data already stored in the file is returned"
674  int io_ws = 0;
675 
676  ex_id = exII::ex_open(filename,
677  read_only ? EX_READ : EX_WRITE,
678  &comp_ws,
679  &io_ws,
680  &ex_version);
681 
682  std::string err_msg = std::string("Error opening ExodusII mesh file: ") + std::string(filename);
683  EX_CHECK_ERR(ex_id, err_msg);
684  if (verbose) libMesh::out << "File opened successfully." << std::endl;
685 
686  if (read_only)
687  opened_for_reading = true;
688  else
689  opened_for_writing = true;
690 
691  current_filename = std::string(filename);
692 }
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
OStreamProxy out

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

References libMesh::ExodusII_IO_Helper::num_dim, libMesh::ExodusII_IO_Helper::num_elem, libMesh::ExodusII_IO_Helper::num_elem_blk, libMesh::ExodusII_IO_Helper::num_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.

812 {
813  if (verbose)
814  libMesh::out << "Title: \t" << title.data() << std::endl
815  << "Mesh Dimension: \t" << num_dim << std::endl
816  << "Number of Nodes: \t" << num_nodes << std::endl
817  << "Number of elements: \t" << num_elem << std::endl
818  << "Number of elt blocks: \t" << num_elem_blk << std::endl
819  << "Number of node sets: \t" << num_node_sets << std::endl
820  << "Number of side sets: \t" << num_side_sets << std::endl
821  << "Number of elem sets: \t" << num_elem_sets << std::endl;
822 }
std::vector< char > & title
OStreamProxy out

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

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

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

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

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), compute_border_node_ids(), compute_communication_map_parameters(), compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), compute_node_communication_maps(), compute_num_global_elem_blocks(), compute_num_global_nodesets(), compute_num_global_sidesets(), construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), get_cmap_params(), get_eb_info_global(), get_elem_cmap(), get_elem_map(), libMesh::MeshBase::get_info(), libMesh::DofMap::get_info(), get_init_global(), get_init_info(), get_loadbal_param(), libMesh::DofMap::get_local_constraints(), get_node_cmap(), get_node_map(), get_ns_param_global(), get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), put_cmap_params(), put_elem_cmap(), put_elem_map(), put_loadbal_param(), put_node_cmap(), put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), read_var_names_impl(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), MeshInputTest::testAbaqusRead(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

115  { return cast_int<processor_id_type>(_communicator.rank()); }
processor_id_type rank() const
const Parallel::Communicator & _communicator

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

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

Referenced by initialize().

624 {
626  Nemesis::ne_put_cmap_params(ex_id,
627  node_cmap_ids_in.empty() ? nullptr : node_cmap_ids_in.data(),
628  node_cmap_node_cnts_in.empty() ? nullptr : node_cmap_node_cnts_in.data(),
629  elem_cmap_ids_in.empty() ? nullptr : elem_cmap_ids_in.data(),
630  elem_cmap_elem_cnts_in.empty() ? nullptr : elem_cmap_elem_cnts_in.data(),
631  this->processor_id());
632 
633  EX_CHECK_ERR(nemesis_err_flag, "Error writing cmap parameters!");
634 }
int nemesis_err_flag
Member data.
processor_id_type processor_id() const

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

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

Referenced by initialize().

542 {
544  Nemesis::ne_put_eb_info_global(ex_id,
545  global_elem_blk_ids_in.data(),
546  global_elem_blk_cnts_in.data());
547 
548  EX_CHECK_ERR(nemesis_err_flag, "Error writing global element block information!");
549 }
int nemesis_err_flag
Member data.

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

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

Referenced by initialize().

703 {
704  for (auto i : index_range(elem_cmap_ids))
705  {
707  Nemesis::ne_put_elem_cmap(ex_id,
708  this->elem_cmap_ids[i],
709  elem_cmap_elem_ids_in[i].data(),
710  elem_cmap_side_ids_in[i].data(),
711  elem_cmap_proc_ids_in[i].data(),
712  this->processor_id());
713 
714  EX_CHECK_ERR(nemesis_err_flag, "Error writing elem communication map to file!");
715  }
716 }
int nemesis_err_flag
Member data.
std::vector< int > elem_cmap_ids
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

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

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

Referenced by initialize().

723 {
725  Nemesis::ne_put_elem_map(ex_id,
726  elem_mapi_in.empty() ? nullptr : elem_mapi_in.data(),
727  elem_mapb_in.empty() ? nullptr : elem_mapb_in.data(),
728  this->processor_id());
729 
730  EX_CHECK_ERR(nemesis_err_flag, "Error writing Nemesis internal and border element maps to file!");
731 }
int nemesis_err_flag
Member data.
processor_id_type processor_id() const

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

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

Referenced by initialize().

526 {
528  Nemesis::ne_put_init_global(ex_id,
529  num_nodes_global_in,
530  num_elems_global_in,
531  num_elem_blks_global_in,
532  num_node_sets_global_in,
533  num_side_sets_global_in);
534 
535  EX_CHECK_ERR(nemesis_err_flag, "Error writing initial global data!");
536 }
int nemesis_err_flag
Member data.

◆ put_init_info()

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

Writing functions.

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

Definition at line 505 of file nemesis_io_helper.C.

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

Referenced by initialize().

508 {
510  Nemesis::ne_put_init_info(ex_id,
511  num_proc_in,
512  num_proc_in_file_in,
513  const_cast<char *>(ftype_in));
514 
515  EX_CHECK_ERR(nemesis_err_flag, "Error writing initial information!");
516 }
int nemesis_err_flag
Member data.

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

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

Referenced by initialize().

601 {
603  Nemesis::ne_put_loadbal_param(ex_id,
604  num_internal_nodes_in,
605  num_border_nodes_in,
606  num_external_nodes_in,
607  num_internal_elems_in,
608  num_border_elems_in,
609  num_node_cmaps_in,
610  num_elem_cmaps_in,
611  this->processor_id());
612 
613  EX_CHECK_ERR(nemesis_err_flag, "Error writing loadbal parameters!");
614 }
int nemesis_err_flag
Member data.
processor_id_type processor_id() const

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

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

641 {
642  // Print to screen what we are about to print to Nemesis file
643  if (verbose)
644  {
645  for (auto i : index_range(node_cmap_node_ids_in))
646  {
647  libMesh::out << "[" << this->processor_id() << "] put_node_cmap() : nodes communicated to proc "
648  << this->node_cmap_ids[i]
649  << " = ";
650  for (const auto & node_id : node_cmap_node_ids_in[i])
651  libMesh::out << node_id << " ";
652  libMesh::out << std::endl;
653  }
654 
655  for (auto i : index_range(node_cmap_node_ids_in))
656  {
657  libMesh::out << "[" << this->processor_id() << "] put_node_cmap() : processor IDs = ";
658  for (const auto & proc_id : node_cmap_proc_ids_in[i])
659  libMesh::out << proc_id << " ";
660  libMesh::out << std::endl;
661  }
662  }
663 
664  for (auto i : index_range(node_cmap_node_ids_in))
665  {
666  int * node_ids_ptr = node_cmap_node_ids_in[i].empty() ?
667  nullptr : node_cmap_node_ids_in[i].data();
668  int * proc_ids_ptr = node_cmap_proc_ids_in[i].empty() ?
669  nullptr : node_cmap_proc_ids_in[i].data();
670 
672  Nemesis::ne_put_node_cmap(ex_id, this->node_cmap_ids[i],
673  node_ids_ptr, proc_ids_ptr,
674  this->processor_id());
675 
676  EX_CHECK_ERR(nemesis_err_flag, "Error writing node communication map to file!");
677  }
678 }
std::vector< int > node_cmap_ids
Vectors for storing the communication map parameters.
int nemesis_err_flag
Member data.
OStreamProxy out
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

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

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

Referenced by initialize().

686 {
688  Nemesis::ne_put_node_map(ex_id,
689  node_mapi_in.empty() ? nullptr : node_mapi_in.data(),
690  node_mapb_in.empty() ? nullptr : node_mapb_in.data(),
691  node_mape_in.empty() ? nullptr : node_mape_in.data(),
692  this->processor_id());
693 
694  EX_CHECK_ERR(nemesis_err_flag, "Error writing Nemesis internal and border node maps to file!");
695 }
int nemesis_err_flag
Member data.
processor_id_type processor_id() const

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

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

Referenced by initialize().

557 {
558  // Only add nodesets if there are some
559  if (global_nodeset_ids.size())
560  {
562  Nemesis::ne_put_ns_param_global(ex_id,
563  global_nodeset_ids_in.data(),
564  num_global_node_counts_in.data(),
565  num_global_node_df_counts_in.data());
566  }
567 
568  EX_CHECK_ERR(nemesis_err_flag, "Error writing global nodeset parameters!");
569 }
std::vector< int > global_nodeset_ids
Containers for reading global nodeset information.
int nemesis_err_flag
Member data.

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

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

Referenced by initialize().

577 {
578  // Only add sidesets if there are some
579  if (global_sideset_ids.size())
580  {
582  Nemesis::ne_put_ss_param_global(ex_id,
583  global_sideset_ids_in.data(),
584  num_global_side_counts_in.data(),
585  num_global_side_df_counts_in.data());
586  }
587 
588  EX_CHECK_ERR(nemesis_err_flag, "Error writing global sideset parameters!");
589 }
std::vector< int > global_sideset_ids
Containers for reading global sideset (boundary conditions) information.
int nemesis_err_flag
Member data.

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

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

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

1683 {
1684  LOG_SCOPE("read_all_nodesets()", "ExodusII_IO_Helper");
1685 
1686  // Figure out how many nodesets there are in the file so we can
1687  // properly resize storage as necessary.
1688  num_node_sets =
1689  inquire
1690  (*this, exII::EX_INQ_NODE_SETS,
1691  "Error retrieving number of node sets");
1692 
1693  // Figure out how many nodes there are in all the nodesets.
1694  int total_nodes_in_all_sets =
1695  inquire
1696  (*this, exII::EX_INQ_NS_NODE_LEN,
1697  "Error retrieving number of nodes in all node sets.");
1698 
1699  // Figure out how many distribution factors there are in all the nodesets.
1700  int total_df_in_all_sets =
1701  inquire
1702  (*this, exII::EX_INQ_NS_DF_LEN,
1703  "Error retrieving number of distribution factors in all node sets.");
1704 
1705  // If there are no nodesets, there's nothing to read in.
1706  if (num_node_sets == 0)
1707  return;
1708 
1709  // Allocate space to read all the nodeset data.
1710  // Use existing class members where possible to avoid shadowing
1711  nodeset_ids.clear(); nodeset_ids.resize(num_node_sets);
1716  node_sets_node_list.clear(); node_sets_node_list.resize(total_nodes_in_all_sets);
1717  node_sets_dist_fact.clear(); node_sets_dist_fact.resize(total_df_in_all_sets);
1718 
1719  // Handle single-precision files
1720  MappedInputVector mapped_node_sets_dist_fact(node_sets_dist_fact, _single_precision);
1721 
1722  // Build exII::ex_set_spec struct
1723  exII::ex_set_specs set_specs = {};
1724  set_specs.sets_ids = nodeset_ids.data();
1725  set_specs.num_entries_per_set = num_nodes_per_set.data();
1726  set_specs.num_dist_per_set = num_node_df_per_set.data();
1727  set_specs.sets_entry_index = node_sets_node_index.data();
1728  set_specs.sets_dist_index = node_sets_dist_index.data();
1729  set_specs.sets_entry_list = node_sets_node_list.data();
1730  set_specs.sets_extra_list = nullptr;
1731  set_specs.sets_dist_fact = total_df_in_all_sets ? mapped_node_sets_dist_fact.data() : nullptr;
1732 
1733  ex_err = exII::ex_get_concat_sets(ex_id, exII::EX_NODE_SET, &set_specs);
1734  EX_CHECK_ERR(ex_err, "Error reading concatenated nodesets");
1735 
1736  // Read the nodeset names from file!
1737  char name_buffer[MAX_STR_LENGTH+1];
1738  for (int i=0; i<num_node_sets; ++i)
1739  {
1740  ex_err = exII::ex_get_name
1741  (ex_id,
1742  exII::EX_NODE_SET,
1743  nodeset_ids[i],
1744  name_buffer);
1745  EX_CHECK_ERR(ex_err, "Error getting node set name.");
1746  id_to_ns_names[nodeset_ids[i]] = name_buffer;
1747  }
1748 }
std::vector< int > node_sets_node_index
std::vector< int > num_node_df_per_set
std::vector< int > node_sets_node_list
std::map< int, std::string > id_to_ns_names
std::vector< int > num_nodes_per_set
std::vector< Real > node_sets_dist_fact
std::vector< int > node_sets_dist_index

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

References libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::header_info, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::num_elem_vars, libMesh::ExodusII_IO_Helper::num_elemset_vars, libMesh::ExodusII_IO_Helper::num_global_vars, libMesh::ExodusII_IO_Helper::num_nodal_vars, libMesh::ExodusII_IO_Helper::num_nodeset_vars, libMesh::ExodusII_IO_Helper::num_sideset_vars, libMesh::ExodusII_IO_Helper::read_header(), and libMesh::ExodusII_IO_Helper::read_num_time_steps().

728 {
729  // Read header params from file, storing them in this class's
730  // ExodusHeaderInfo struct. This automatically updates the local
731  // num_dim, num_elem, etc. references.
732  this->header_info = this->read_header();
733 
734  // Read the number of timesteps which are present in the file
735  this->read_num_time_steps();
736 
737  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_NODAL, &num_nodal_vars);
738  EX_CHECK_ERR(ex_err, "Error reading number of nodal variables.");
739 
740  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_ELEM_BLOCK, &num_elem_vars);
741  EX_CHECK_ERR(ex_err, "Error reading number of elemental variables.");
742 
743  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_GLOBAL, &num_global_vars);
744  EX_CHECK_ERR(ex_err, "Error reading number of global variables.");
745 
746  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_SIDE_SET, &num_sideset_vars);
747  EX_CHECK_ERR(ex_err, "Error reading number of sideset variables.");
748 
749  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_NODE_SET, &num_nodeset_vars);
750  EX_CHECK_ERR(ex_err, "Error reading number of nodeset variables.");
751 
752  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_ELEM_SET, &num_elemset_vars);
753  EX_CHECK_ERR(ex_err, "Error reading number of elemset variables.");
754 
755  message("Exodus header info retrieved successfully.");
756 }
ExodusHeaderInfo read_header() const
Reads an ExodusII mesh file header, leaving this object&#39;s internal data structures unchanged...
void message(std::string_view msg)
Prints the message defined in msg.
void read_num_time_steps()
Reads the number of timesteps currently stored in the Exodus file and stores it in the num_time_steps...

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

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

902 {
903  // If a bex blob exists, we look for Bezier Extraction coefficient
904  // data there.
905 
906  // These APIs require newer Exodus than 5.22
907 #if EX_API_VERS_NODOT >= 800
908  int n_blobs = exII::ex_inquire_int(ex_id, exII::EX_INQ_BLOB);
909 
910  if (n_blobs > 0)
911  {
912  std::vector<exII::ex_blob> blobs(n_blobs);
913  std::vector<std::vector<char>> blob_names(n_blobs);
914  for (auto i : make_range(n_blobs))
915  {
916  blob_names[i].resize(MAX_STR_LENGTH+1);
917  blobs[i].name = blob_names[i].data();
918  }
919 
920  ex_err = exII::ex_get_blobs(ex_id, blobs.data());
921  EX_CHECK_ERR(ex_err, "Error getting blobs.");
922 
923  bool found_blob = false;
924  const exII::ex_blob * my_blob = &blobs[0];
925  for (const auto & blob : blobs)
926  {
927  if (std::string("bex_cv_blob") == blob.name)
928  {
929  found_blob = true;
930  my_blob = &blob;
931  }
932  }
933 
934  if (!found_blob)
935  libmesh_error_msg("Found no bex_cv_blob for bezier elements");
936 
937  const int n_blob_attr =
938  exII::ex_get_attribute_count(ex_id, exII::EX_BLOB,
939  my_blob->id);
940 
941  std::vector<exII::ex_attribute> attributes(n_blob_attr);
942  ex_err = exII::ex_get_attribute_param(ex_id, exII::EX_BLOB,
943  my_blob->id,
944  attributes.data());
945  EX_CHECK_ERR(ex_err, "Error getting bex blob attribute parameters.");
946 
947  int bex_num_dense_cv_blocks = 0;
948  std::vector<int> bex_dense_cv_info;
949  for (auto & attr : attributes)
950  {
951  if (std::string("bex_dense_cv_info") == attr.name)
952  {
953  const std::size_t value_count = attr.value_count;
954  if (value_count % 2)
955  libmesh_error_msg("Found odd number of bex_dense_cv_info");
956 
957  bex_dense_cv_info.resize(value_count);
958  attr.values = bex_dense_cv_info.data();
959  exII::ex_get_attribute(ex_id, &attr);
960 
961  bex_num_dense_cv_blocks = value_count / 2;
962 
963  libmesh_error_msg_if(bex_num_dense_cv_blocks > 1,
964  "Found more than 1 dense bex CV block; unsure how to handle that");
965  }
966  }
967 
968  if (bex_dense_cv_info.empty())
969  libmesh_error_msg("No bex_dense_cv_info found");
970 
971  int n_blob_vars;
972  exII::ex_get_variable_param(ex_id, exII::EX_BLOB, &n_blob_vars);
973  std::vector<char> var_name (MAX_STR_LENGTH + 1);
974  for (auto v_id : make_range(1,n_blob_vars+1))
975  {
976  ex_err = exII::ex_get_variable_name(ex_id, exII::EX_BLOB, v_id, var_name.data());
977  EX_CHECK_ERR(ex_err, "Error reading bex blob var name.");
978 
979  if (std::string("bex_dense_cv_blocks") == var_name.data())
980  {
981  std::vector<double> bex_dense_cv_blocks(my_blob->num_entry);
982 
983  ex_err = exII::ex_get_var(ex_id, 1, exII::EX_BLOB, v_id,
984  my_blob->id, my_blob->num_entry,
985  bex_dense_cv_blocks.data());
986  EX_CHECK_ERR(ex_err, "Error reading bex_dense_cv_blocks.");
987 
989  bex_dense_constraint_vecs.resize(bex_num_dense_cv_blocks);
990 
991  std::size_t offset = 0;
992  for (auto i : IntRange<std::size_t>(0, bex_num_dense_cv_blocks))
993  {
994  bex_dense_constraint_vecs[i].resize(bex_dense_cv_info[2*i]);
995  for (auto & vec : bex_dense_constraint_vecs[i])
996  {
997  const int vecsize = bex_dense_cv_info[2*i+1];
998  vec.resize(vecsize);
999  std::copy(&bex_dense_cv_blocks[offset],
1000  &bex_dense_cv_blocks[offset+vecsize],
1001  vec.begin());
1002  offset += vecsize;
1003  }
1004  }
1005  }
1006  }
1007  }
1008 #endif // EX_API_VERS_NODOT >= 800
1009 }
The IntRange templated class is intended to make it easy to loop over integers which are indices of a...
Definition: int_range.h:53
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134
std::vector< std::vector< std::vector< Real > > > bex_dense_constraint_vecs

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

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.

1021 {
1022  if (num_elem_blk)
1023  {
1024  // Read all element block IDs.
1025  block_ids.resize(num_elem_blk);
1026  ex_err = exII::ex_get_ids(ex_id,
1027  exII::EX_ELEM_BLOCK,
1028  block_ids.data());
1029 
1030  EX_CHECK_ERR(ex_err, "Error getting block IDs.");
1031  message("All block IDs retrieved successfully.");
1032 
1033  char name_buffer[MAX_STR_LENGTH+1];
1034  for (int i=0; i<num_elem_blk; ++i)
1035  {
1036  ex_err = exII::ex_get_name(ex_id, exII::EX_ELEM_BLOCK,
1037  block_ids[i], name_buffer);
1038  EX_CHECK_ERR(ex_err, "Error getting block name.");
1039  id_to_block_names[block_ids[i]] = name_buffer;
1040  }
1041  message("All block names retrieved successfully.");
1042  }
1043 
1044  if (num_edge_blk)
1045  {
1046  // Read all edge block IDs.
1047  edge_block_ids.resize(num_edge_blk);
1048  ex_err = exII::ex_get_ids(ex_id,
1049  exII::EX_EDGE_BLOCK,
1050  edge_block_ids.data());
1051 
1052  EX_CHECK_ERR(ex_err, "Error getting edge block IDs.");
1053  message("All edge block IDs retrieved successfully.");
1054 
1055  // Read in edge block names
1056  char name_buffer[MAX_STR_LENGTH+1];
1057  for (int i=0; i<num_edge_blk; ++i)
1058  {
1059  ex_err = exII::ex_get_name(ex_id, exII::EX_EDGE_BLOCK,
1060  edge_block_ids[i], name_buffer);
1061  EX_CHECK_ERR(ex_err, "Error getting block name.");
1062  id_to_edge_block_names[edge_block_ids[i]] = name_buffer;
1063  }
1064  message("All edge block names retrieved successfully.");
1065  }
1066 }
std::map< int, std::string > id_to_edge_block_names
void message(std::string_view msg)
Prints the message defined in msg.
std::map< int, std::string > id_to_block_names
std::vector< int > edge_block_ids

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

References libMesh::BoundaryInfo::add_edge(), libMesh::Elem::build(), libMesh::ExodusII_IO_Helper::connect, libMesh::ExodusII_IO_Helper::edge_block_ids, libMesh::BoundaryInfo::edgeset_name(), libMesh::MeshBase::elem_ptr(), libMesh::ExodusII_IO_Helper::elem_type, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::FIRST, libMesh::Elem::first_order_equivalent_type(), libMesh::MeshBase::get_boundary_info(), libMesh::ExodusII_IO_Helper::get_conversion(), libMesh::ExodusII_IO_Helper::id_to_edge_block_names, mesh, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::node_num_map, libMesh::MeshBase::node_ptr(), and libMesh::ExodusII_IO_Helper::num_edge_blk.

1284 {
1285  LOG_SCOPE("read_edge_blocks()", "ExodusII_IO_Helper");
1286 
1287  // Check for quick return if there are no edge blocks.
1288  if (num_edge_blk == 0)
1289  return;
1290 
1291  // Build data structure that we can quickly search for edges
1292  // and then add required BoundaryInfo information. This is a
1293  // map from edge->key() to a list of (elem_id, edge_id) pairs
1294  // for the Edge in question. Since edge->key() is edge orientation
1295  // invariant, this map does not distinguish different orientations
1296  // of the same Edge. Since edge->key() is also not guaranteed to be
1297  // unique (though it is very unlikely for two distinct edges to have
1298  // the same key()), when we later look up an (elem_id, edge_id) pair
1299  // in the edge_map, we need to verify that the edge indeed matches
1300  // the searched edge by doing some further checks.
1301  typedef std::pair<dof_id_type, unsigned int> ElemEdgePair;
1302  std::unordered_map<dof_id_type, std::vector<ElemEdgePair>> edge_map;
1303  std::unique_ptr<Elem> edge_ptr;
1304  for (const auto & elem : mesh.element_ptr_range())
1305  for (auto e : elem->edge_index_range())
1306  {
1307  elem->build_edge_ptr(edge_ptr, e);
1308  dof_id_type edge_key = edge_ptr->key();
1309 
1310  // Creates vector if not already there
1311  auto & vec = edge_map[edge_key];
1312  vec.emplace_back(elem->id(), e);
1313 
1314  // If edge_ptr is a higher-order Elem (EDGE3 or higher) then also add
1315  // a map entry for the lower-order (EDGE2) element which has matching
1316  // vertices. This allows us to match lower-order edge blocks to edges
1317  // of higher-order 3D elems (e.g. HEX20, TET10) and simplifies the
1318  // definition of edge blocks.
1319  if (edge_ptr->default_order() != FIRST)
1320  {
1321  // Construct a temporary low-order edge so that we can compute its key()
1322  auto low_order_edge =
1324 
1325  // Assign node pointers to low-order edge
1326  for (unsigned int v=0; v<edge_ptr->n_vertices(); ++v)
1327  low_order_edge->set_node(v) = edge_ptr->node_ptr(v);
1328 
1329  // Compute the key for the temporary low-order edge we just built
1330  dof_id_type low_order_edge_key = low_order_edge->key();
1331 
1332  // Add this key to the map associated with the same (elem,
1333  // edge) pair as the higher-order edge
1334  auto & low_order_vec = edge_map[low_order_edge_key];
1335  low_order_vec.emplace_back(elem->id(), e);
1336  }
1337  }
1338 
1339  // Get reference to the mesh's BoundaryInfo object, as we will be
1340  // adding edges to this below.
1342 
1343  for (const auto & edge_block_id : edge_block_ids)
1344  {
1345  // exII::ex_get_block() output parameters. Unlike the other
1346  // "extended" APIs, exII::ex_get_block() does not use a
1347  // parameter struct.
1348  int num_edge_this_blk = 0;
1349  int num_nodes_per_edge = 0;
1350  int num_edges_per_edge = 0;
1351  int num_faces_per_edge = 0;
1352  int num_attr_per_edge = 0;
1353  ex_err = exII::ex_get_block(ex_id,
1354  exII::EX_EDGE_BLOCK,
1355  edge_block_id,
1356  elem_type.data(),
1357  &num_edge_this_blk,
1358  &num_nodes_per_edge,
1359  &num_edges_per_edge, // 0 or -1 for edge blocks
1360  &num_faces_per_edge, // 0 or -1 for edge blocks
1361  &num_attr_per_edge);
1362 
1363  EX_CHECK_ERR(ex_err, "Error getting edge block info.");
1364  message("Info retrieved successfully for block: ", edge_block_id);
1365 
1366  // Read in the connectivity of the edges of this block,
1367  // watching out for the case where we actually have no
1368  // elements in this block (possible with parallel files)
1369  connect.resize(num_nodes_per_edge * num_edge_this_blk);
1370 
1371  if (!connect.empty())
1372  {
1373  ex_err = exII::ex_get_conn(ex_id,
1374  exII::EX_EDGE_BLOCK,
1375  edge_block_id,
1376  connect.data(), // node_conn
1377  nullptr, // elem_edge_conn (unused)
1378  nullptr); // elem_face_conn (unused)
1379 
1380  EX_CHECK_ERR(ex_err, "Error reading block connectivity.");
1381  message("Connectivity retrieved successfully for block: ", edge_block_id);
1382 
1383  // All edge types have an identity mapping from the corresponding
1384  // Exodus type, so we don't need to bother with mapping ids, but
1385  // we do need to know what kind of elements to build.
1386  const auto & conv = get_conversion(std::string(elem_type.data()));
1387 
1388  // Loop over indices in connectivity array, build edge elements,
1389  // look them up in the edge_map.
1390  for (unsigned int i=0, sz=connect.size(); i<sz; i+=num_nodes_per_edge)
1391  {
1392  auto edge = Elem::build(conv.libmesh_elem_type());
1393  for (int n=0; n<num_nodes_per_edge; ++n)
1394  {
1395  int exodus_node_id = connect[i+n];
1396  int exodus_node_id_zero_based = exodus_node_id - 1;
1397  int libmesh_node_id = node_num_map[exodus_node_id_zero_based] - 1;
1398 
1399  edge->set_node(n) = mesh.node_ptr(libmesh_node_id);
1400  }
1401 
1402  // Compute key for the edge Elem we just built.
1403  dof_id_type edge_key = edge->key();
1404 
1405  // If this key is not found in the edge_map, which is
1406  // supposed to include every edge in the Mesh, then we
1407  // will throw an error now.
1408  auto & elem_edge_pair_vec =
1409  libmesh_map_find(edge_map, edge_key);
1410 
1411  for (const auto & elem_edge_pair : elem_edge_pair_vec)
1412  {
1413  // We only want to match edges which have the same
1414  // nodes (possibly with different orientation) to the one in the
1415  // Exodus file, otherwise we ignore this elem_edge_pair.
1416  //
1417  // Note: this also handles the situation where two
1418  // edges have the same key (hash collision) as then
1419  // this check avoids a false positive.
1420 
1421  // Build edge indicated by elem_edge_pair
1422  mesh.elem_ptr(elem_edge_pair.first)->
1423  build_edge_ptr(edge_ptr, elem_edge_pair.second);
1424 
1425  // Determine whether this candidate edge is a "real" match,
1426  // i.e. has the same nodes with a possibly different
1427  // orientation. Note that here we only check that
1428  // the vertices match regardless of how many nodes
1429  // the edge has, which allows us to match a
1430  // lower-order edge to a higher-order Elem.
1431  bool is_match =
1432  ((edge_ptr->node_id(0) == edge->node_id(0)) && (edge_ptr->node_id(1) == edge->node_id(1))) ||
1433  ((edge_ptr->node_id(0) == edge->node_id(1)) && (edge_ptr->node_id(1) == edge->node_id(0)));
1434 
1435  if (is_match)
1436  {
1437  // Add this (elem, edge, id) combo to the BoundaryInfo object.
1438  bi.add_edge(elem_edge_pair.first,
1439  elem_edge_pair.second,
1440  edge_block_id);
1441  }
1442  } // end loop over elem_edge_pairs
1443  } // end loop over connectivity array
1444 
1445  // Set edgeset name in the BoundaryInfo object.
1446  bi.edgeset_name(edge_block_id) = id_to_edge_block_names[edge_block_id];
1447  } // end if !connect.empty()
1448  } // end for edge_block_id : edge_block_ids
1449 }
std::map< int, std::string > id_to_edge_block_names
MeshBase & mesh
const ExodusII_IO_Helper::Conversion & get_conversion(const ElemType type) const
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition: mesh_base.h:159
void message(std::string_view msg)
Prints the message defined in msg.
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:273
The BoundaryInfo class contains information relevant to boundary conditions including storing faces...
Definition: boundary_info.h:57
virtual const Elem * elem_ptr(const dof_id_type i) const =0
std::string & edgeset_name(boundary_id_type id)
virtual const Node * node_ptr(const dof_id_type i) const =0
std::vector< int > edge_block_ids
static ElemType first_order_equivalent_type(const ElemType et)
Definition: elem.C:2692
uint8_t dof_id_type
Definition: id_types.h:67
void add_edge(const dof_id_type elem, const unsigned short int edge, const boundary_id_type id)
Add edge edge of element number elem with boundary id id to the boundary information data structure...

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

References libMesh::ExodusII_IO_Helper::bex_cv_conn, libMesh::ExodusII_IO_Helper::bex_num_elem_cvs, libMesh::ExodusII_IO_Helper::block_ids, libMesh::ExodusII_IO_Helper::connect, libMesh::ExodusII_IO_Helper::elem_type, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::get_conversion(), libMesh::libmesh_assert(), libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::num_attr, libMesh::ExodusII_IO_Helper::num_elem_this_blk, libMesh::ExodusII_IO_Helper::num_nodes_per_elem, libMesh::out, and libMesh::ExodusII_IO_Helper::verbose.

1126 {
1127  LOG_SCOPE("read_elem_in_block()", "ExodusII_IO_Helper");
1128 
1129  libmesh_assert_less (block, block_ids.size());
1130 
1131  // Unlike the other "extended" APIs, this one does not use a parameter struct.
1132  int num_edges_per_elem = 0;
1133  int num_faces_per_elem = 0;
1134  int num_node_data_per_elem = 0;
1135  ex_err = exII::ex_get_block(ex_id,
1136  exII::EX_ELEM_BLOCK,
1137  block_ids[block],
1138  elem_type.data(),
1140  &num_node_data_per_elem,
1141  &num_edges_per_elem, // 0 or -1 if no "extended" block info
1142  &num_faces_per_elem, // 0 or -1 if no "extended" block info
1143  &num_attr);
1144 
1145  EX_CHECK_ERR(ex_err, "Error getting block info.");
1146  message("Info retrieved successfully for block: ", block);
1147 
1148  // Warn that we don't currently support reading blocks with extended info.
1149  // Note: the docs say -1 will be returned for this but I found that it was
1150  // actually 0, so not sure which it will be in general.
1151  if (!(num_edges_per_elem == 0) && !(num_edges_per_elem == -1))
1152  libmesh_warning("Exodus files with extended edge connectivity not currently supported.");
1153  if (!(num_faces_per_elem == 0) && !(num_faces_per_elem == -1))
1154  libmesh_warning("Exodus files with extended face connectivity not currently supported.");
1155 
1156  // If we have a Bezier element here, then we've packed constraint
1157  // vector connectivity at the end of the nodal connectivity, and
1158  // num_nodes_per_elem reflected both.
1159  const bool is_bezier = is_bezier_elem(elem_type.data());
1160  if (is_bezier)
1161  {
1162  const auto & conv = get_conversion(std::string(elem_type.data()));
1163  num_nodes_per_elem = conv.n_nodes;
1164  }
1165  else
1166  num_nodes_per_elem = num_node_data_per_elem;
1167 
1168  if (verbose)
1169  libMesh::out << "Read a block of " << num_elem_this_blk
1170  << " " << elem_type.data() << "(s)"
1171  << " having " << num_nodes_per_elem
1172  << " nodes per element." << std::endl;
1173 
1174  // Read in the connectivity of the elements of this block,
1175  // watching out for the case where we actually have no
1176  // elements in this block (possible with parallel files)
1177  connect.resize(num_node_data_per_elem*num_elem_this_blk);
1178 
1179  if (!connect.empty())
1180  {
1181  ex_err = exII::ex_get_conn(ex_id,
1182  exII::EX_ELEM_BLOCK,
1183  block_ids[block],
1184  connect.data(), // node_conn
1185  nullptr, // elem_edge_conn (unused)
1186  nullptr); // elem_face_conn (unused)
1187 
1188  EX_CHECK_ERR(ex_err, "Error reading block connectivity.");
1189  message("Connectivity retrieved successfully for block: ", block);
1190  }
1191 
1192  // If we had any attributes for this block, check to see if some of
1193  // them were Bezier-extension attributes.
1194 
1195  // num_attr above is zero, not actually the number of block attributes?
1196  // ex_get_attr_param *also* gives me zero? Really, Exodus?
1197 #if EX_API_VERS_NODOT >= 800
1198  int real_n_attr = exII::ex_get_attribute_count(ex_id, exII::EX_ELEM_BLOCK, block_ids[block]);
1199  EX_CHECK_ERR(real_n_attr, "Error getting number of element block attributes.");
1200 
1201  if (real_n_attr > 0)
1202  {
1203  std::vector<exII::ex_attribute> attributes(real_n_attr);
1204 
1205  ex_err = exII::ex_get_attribute_param(ex_id, exII::EX_ELEM_BLOCK, block_ids[block], attributes.data());
1206  EX_CHECK_ERR(ex_err, "Error getting element block attribute parameters.");
1207 
1208  ex_err = exII::ex_get_attributes(ex_id, real_n_attr, attributes.data());
1209  EX_CHECK_ERR(ex_err, "Error getting element block attribute values.");
1210 
1211  for (auto attr : attributes)
1212  {
1213  if (std::string("bex_elem_degrees") == attr.name)
1214  {
1215  if (attr.type != exII::EX_INTEGER)
1216  libmesh_error_msg("Found non-integer bex_elem_degrees");
1217 
1218  if (attr.value_count > 3)
1219  libmesh_error_msg("Looking for at most 3 bex_elem_degrees; found " << attr.value_count);
1220 
1221  libmesh_assert(is_bezier);
1222 
1223  std::vector<int> bex_elem_degrees(3); // max dim
1224 
1225  const int * as_int = static_cast<int *>(attr.values);
1226  std::copy(as_int, as_int+attr.value_count, bex_elem_degrees.begin());
1227 
1228 
1229  // Right now Bezier extraction elements aren't possible
1230  // for p>2 and aren't useful for p<2, and we don't
1231  // support anisotropic p...
1232 #ifndef NDEBUG
1233  const auto & conv = get_conversion(std::string(elem_type.data()));
1234 
1235  for (auto d : IntRange<int>(0, conv.dim))
1236  libmesh_assert_equal_to(bex_elem_degrees[d], 2);
1237 #endif
1238  }
1239  // ex_get_attributes did a values=calloc(); free() is our job.
1240  if (attr.values)
1241  free(attr.values);
1242  }
1243  }
1244 
1245  if (is_bezier)
1246  {
1247  // We'd better have the number of cvs we expect
1248  if( num_node_data_per_elem > num_nodes_per_elem )
1249  bex_num_elem_cvs = num_node_data_per_elem / 2;
1250  else
1252  libmesh_assert_greater_equal(bex_num_elem_cvs, 0);
1253 
1254  // The old connect vector is currently a mix of the expected
1255  // connectivity and any Bezier extraction connectivity;
1256  // disentangle that, if necessary.
1258  if (num_node_data_per_elem > num_nodes_per_elem)
1259  {
1260  std::vector<int> old_connect(bex_num_elem_cvs * num_elem_this_blk);
1261  old_connect.swap(connect);
1262  auto src = old_connect.data();
1263  auto dst = connect.data();
1264  for (auto e : IntRange<std::size_t>(0, num_elem_this_blk))
1265  {
1266  std::copy(src, src + bex_num_elem_cvs, dst);
1267  src += bex_num_elem_cvs;
1268  dst += bex_num_elem_cvs;
1269 
1270  bex_cv_conn[e].resize(bex_num_elem_cvs);
1271  std::copy(src, src + bex_num_elem_cvs,
1272  bex_cv_conn[e].begin());
1273  src += bex_num_elem_cvs;
1274  }
1275  }
1276  }
1277 
1278 #endif // EX_API_VERS_NODOT >= 800
1279 }
The IntRange templated class is intended to make it easy to loop over integers which are indices of a...
Definition: int_range.h:53
const ExodusII_IO_Helper::Conversion & get_conversion(const ElemType type) const
void message(std::string_view msg)
Prints the message defined in msg.
libmesh_assert(ctx)
OStreamProxy out
std::vector< std::vector< long unsigned int > > bex_cv_conn

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

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.

1454 {
1455  elem_num_map.resize(num_elem);
1456 
1457  // Note: we cannot use the exII::ex_get_num_map() here because it
1458  // (apparently) does not behave like ex_get_elem_num_map() when
1459  // there is no elem number map in the file: it throws an error
1460  // instead of returning a default identity array (1,2,3,...).
1461  ex_err = exII::ex_get_elem_num_map
1462  (ex_id, elem_num_map.empty() ? nullptr : elem_num_map.data());
1463 
1464  EX_CHECK_ERR(ex_err, "Error retrieving element number map.");
1465  message("Element numbering map retrieved successfully.");
1466 
1467  if (num_elem)
1468  {
1469  auto it = std::max_element(elem_num_map.begin(), elem_num_map.end());
1470  _end_elem_id = *it;
1471  }
1472  else
1473  _end_elem_id = 0;
1474 
1475  if (verbose)
1476  {
1477  libMesh::out << "[" << this->processor_id() << "] elem_num_map[i] = ";
1478  for (unsigned int i=0; i<static_cast<unsigned int>(std::min(10, num_elem-1)); ++i)
1479  libMesh::out << elem_num_map[i] << ", ";
1480  libMesh::out << "... " << elem_num_map.back() << std::endl;
1481  }
1482 }
void message(std::string_view msg)
Prints the message defined in msg.
OStreamProxy out
processor_id_type processor_id() const

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

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

2040 {
2041  LOG_SCOPE("read_elemental_var_values()", "ExodusII_IO_Helper");
2042 
2043  this->read_var_names(ELEMENTAL);
2044 
2045  // See if we can find the variable we are looking for
2046  unsigned int var_index = 0;
2047  bool found = false;
2048 
2049  // Do a linear search for elem_var_name in elemental_var_names
2050  for (; var_index != elem_var_names.size(); ++var_index)
2051  if (elem_var_names[var_index] == elemental_var_name)
2052  {
2053  found = true;
2054  break;
2055  }
2056 
2057  if (!found)
2058  {
2059  libMesh::err << "Available variables: " << std::endl;
2060  for (const auto & var_name : elem_var_names)
2061  libMesh::err << var_name << std::endl;
2062 
2063  libmesh_error_msg("Unable to locate variable named: " << elemental_var_name);
2064  }
2065 
2066  // Sequential index which we can use to look up the element ID in the elem_num_map.
2067  unsigned ex_el_num = 0;
2068 
2069  // Element variable truth table
2070  std::vector<int> var_table(block_ids.size() * elem_var_names.size());
2071  exII::ex_get_truth_table(ex_id, exII::EX_ELEM_BLOCK, block_ids.size(), elem_var_names.size(), var_table.data());
2072 
2073  for (unsigned i=0; i<static_cast<unsigned>(num_elem_blk); i++)
2074  {
2075  ex_err = exII::ex_get_block(ex_id,
2076  exII::EX_ELEM_BLOCK,
2077  block_ids[i],
2078  /*elem_type=*/nullptr,
2080  /*num_nodes_per_entry=*/nullptr,
2081  /*num_edges_per_entry=*/nullptr,
2082  /*num_faces_per_entry=*/nullptr,
2083  /*num_attr=*/nullptr);
2084  EX_CHECK_ERR(ex_err, "Error getting number of elements in block.");
2085 
2086  // If the current variable isn't active on this subdomain, advance
2087  // the index by the number of elements on this block and go to the
2088  // next loop iteration.
2089  if (!var_table[elem_var_names.size()*i + var_index])
2090  {
2091  ex_el_num += num_elem_this_blk;
2092  continue;
2093  }
2094 
2095  std::vector<Real> block_elem_var_values(num_elem_this_blk);
2096 
2097  ex_err = exII::ex_get_var
2098  (ex_id,
2099  time_step,
2100  exII::EX_ELEM_BLOCK,
2101  var_index+1,
2102  block_ids[i],
2104  MappedInputVector(block_elem_var_values, _single_precision).data());
2105  EX_CHECK_ERR(ex_err, "Error getting elemental values.");
2106 
2107  for (unsigned j=0; j<static_cast<unsigned>(num_elem_this_blk); j++)
2108  {
2109  // Use the elem_num_map to obtain the ID of this element in the Exodus file,
2110  // and remember to subtract 1 since libmesh is zero-based and Exodus is 1-based.
2111  unsigned mapped_elem_id = this->elem_num_map[ex_el_num] - 1;
2112 
2113  // Store the elemental value in the map.
2114  elem_var_value_map[mapped_elem_id] = block_elem_var_values[j];
2115 
2116  // Go to the next sequential element ID.
2117  ex_el_num++;
2118  }
2119  }
2120 }
OStreamProxy err
std::vector< std::string > elem_var_names
void read_var_names(ExodusVarType type)

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

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

1638 {
1639  LOG_SCOPE("read_elemset()", "ExodusII_IO_Helper");
1640 
1641  libmesh_assert_less (id, elemset_ids.size());
1642  libmesh_assert_less (id, num_elems_per_set.size());
1643  libmesh_assert_less (id, num_elem_df_per_set.size());
1644  libmesh_assert_less_equal (offset, elemset_list.size());
1645 
1646  ex_err = exII::ex_get_set_param(ex_id,
1647  exII::EX_ELEM_SET,
1648  elemset_ids[id],
1649  &num_elems_per_set[id],
1650  &num_elem_df_per_set[id]);
1651  EX_CHECK_ERR(ex_err, "Error retrieving elemset parameters.");
1652  message("Parameters retrieved successfully for elemset: ", id);
1653 
1654 
1655  // It's OK for offset==elemset_list.size() as long as num_elems_per_set[id]==0
1656  // because in that case we don't actually read anything...
1657  #ifdef DEBUG
1658  if (static_cast<unsigned int>(offset) == elemset_list.size())
1659  libmesh_assert_equal_to (num_elems_per_set[id], 0);
1660  #endif
1661 
1662  // Don't call ex_get_set() unless there are actually elems there to get.
1663  // Exodus prints an annoying warning in DEBUG mode otherwise...
1664  if (num_elems_per_set[id] > 0)
1665  {
1666  ex_err = exII::ex_get_set(ex_id,
1667  exII::EX_ELEM_SET,
1668  elemset_ids[id],
1669  &elemset_list[offset],
1670  /*set_extra_list=*/nullptr);
1671  EX_CHECK_ERR(ex_err, "Error retrieving elemset data.");
1672  message("Data retrieved successfully for elemset: ", id);
1673 
1674  // Create vector containing elemset ids for each element in the set
1675  for (int i=0; i<num_elems_per_set[id]; i++)
1676  elemset_id_list[i+offset] = elemset_ids[id];
1677  }
1678 }
std::vector< int > num_elems_per_set
void message(std::string_view msg)
Prints the message defined in msg.
std::vector< int > elemset_id_list
std::vector< int > num_elem_df_per_set

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

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

4011 {
4012  LOG_SCOPE("read_elemset_data()", "ExodusII_IO_Helper");
4013 
4014  // This reads the elemset variable names into the local
4015  // elemset_var_names data structure.
4016  this->read_var_names(ELEMSET);
4017 
4018  // Debugging
4019  // libMesh::out << "elmeset variable names:" << std::endl;
4020  // for (const auto & name : elemset_var_names)
4021  // libMesh::out << name << " ";
4022  // libMesh::out << std::endl;
4023 
4024  if (num_elemset_vars)
4025  {
4026  // Debugging
4027  // std::cout << "Reading " << num_elem_sets
4028  // << " elemsets and " << num_elemset_vars
4029  // << " elemset variables." << std::endl;
4030 
4031  // Read the elemset data truth table.
4032  std::vector<int> elemset_var_tab(num_elem_sets * num_elemset_vars);
4033  exII::ex_get_truth_table(ex_id,
4034  exII::EX_ELEM_SET, // exII::ex_entity_type
4035  num_elem_sets,
4037  elemset_var_tab.data());
4038  EX_CHECK_ERR(ex_err, "Error reading elemset variable truth table.");
4039 
4040  // Debugging
4041  // libMesh::out << "Elemset variable truth table:" << std::endl;
4042  // for (const auto & val : elemset_var_tab)
4043  // libMesh::out << val << " ";
4044  // libMesh::out << std::endl;
4045 
4046  // Debugging
4047  // for (auto i : make_range(num_elem_sets))
4048  // {
4049  // for (auto j : make_range(num_elemset_vars))
4050  // libMesh::out << elemset_var_tab[num_elemset_vars*i + j] << " ";
4051  // libMesh::out << std::endl;
4052  // }
4053 
4054  // Set up/allocate space in incoming data structures. All vectors are
4055  // num_elemset_vars in length.
4056  var_names = elemset_var_names;
4057  elemset_ids_in.resize(num_elemset_vars);
4058  elemset_vals.resize(num_elemset_vars);
4059 
4060  // Read the elemset data
4061  int offset=0;
4062  for (int es=0; es<num_elem_sets; ++es)
4063  {
4064  offset += (es > 0 ? num_elems_per_set[es-1] : 0);
4065  for (int var=0; var<num_elemset_vars; ++var)
4066  {
4067  int is_present = elemset_var_tab[num_elemset_vars*es + var];
4068 
4069  if (is_present)
4070  {
4071  // Debugging
4072  // libMesh::out << "Variable " << var << " is present on elemset " << es << std::endl;
4073 
4074  // Record the fact that this variable is defined on this elemset.
4075  elemset_ids_in[var].insert(elemset_ids[es]);
4076 
4077  // Note: the assumption here is that a previous call
4078  // to this->read_elemset_info() has already set the
4079  // values of num_elems_per_set, so we just use those values here.
4080  std::vector<Real> elemset_var_vals(num_elems_per_set[es]);
4081  ex_err = exII::ex_get_var
4082  (ex_id,
4083  timestep,
4084  exII::EX_ELEM_SET, // exII::ex_entity_type
4085  var + 1, // 1-based sideset variable index!
4086  elemset_ids[es],
4087  num_elems_per_set[es],
4088  MappedInputVector(elemset_var_vals, _single_precision).data());
4089  EX_CHECK_ERR(ex_err, "Error reading elemset variable.");
4090 
4091  for (int i=0; i<num_elems_per_set[es]; ++i)
4092  {
4093  dof_id_type exodus_elem_id = elemset_list[i + offset];
4094 
4095  // FIXME: We should use exodus_elem_num_to_libmesh for this,
4096  // but it apparently is never set up, so just
4097  // subtract 1 from the Exodus elem id.
4098  dof_id_type converted_elem_id = exodus_elem_id - 1;
4099 
4100  // Make key based on the elem and set ids
4101  auto key = std::make_pair(converted_elem_id,
4102  static_cast<elemset_id_type>(elemset_ids[es]));
4103 
4104  // Store value in the map
4105  elemset_vals[var].emplace(key, elemset_var_vals[i]);
4106  } // end for (i)
4107  } // end if (present)
4108  } // end for (var)
4109  } // end for (es)
4110  } // end if (num_elemset_vars)
4111 }
std::vector< int > num_elems_per_set
void read_var_names(ExodusVarType type)
std::vector< std::string > elemset_var_names
uint8_t dof_id_type
Definition: id_types.h:67

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

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::id_to_elemset_names, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::num_elem_all_elemsets, libMesh::ExodusII_IO_Helper::num_elem_df_per_set, libMesh::ExodusII_IO_Helper::num_elem_sets, and libMesh::ExodusII_IO_Helper::num_elems_per_set.

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

1551 {
1552  elemset_ids.resize(num_elem_sets);
1553  if (num_elem_sets > 0)
1554  {
1555  ex_err = exII::ex_get_ids(ex_id,
1556  exII::EX_ELEM_SET,
1557  elemset_ids.data());
1558  EX_CHECK_ERR(ex_err, "Error retrieving elemset information.");
1559  message("All elemset information retrieved successfully.");
1560 
1561  // Resize appropriate data structures -- only do this once outside the loop
1564 
1565  // Inquire about the length of the concatenated elemset list
1567  inquire(*this, exII::EX_INQ_ELS_LEN,
1568  "Error retrieving length of the concatenated elem sets element list!");
1569 
1572 
1573  // Debugging
1574  // libMesh::out << "num_elem_all_elemsets = " << num_elem_all_elemsets << std::endl;
1575  }
1576 
1577  char name_buffer[MAX_STR_LENGTH+1];
1578  for (int i=0; i<num_elem_sets; ++i)
1579  {
1580  ex_err = exII::ex_get_name(ex_id, exII::EX_ELEM_SET,
1581  elemset_ids[i], name_buffer);
1582  EX_CHECK_ERR(ex_err, "Error getting node set name.");
1583  id_to_elemset_names[elemset_ids[i]] = name_buffer;
1584  }
1585  message("All elem set names retrieved successfully.");
1586 }
std::vector< int > num_elems_per_set
void message(std::string_view msg)
Prints the message defined in msg.
std::map< int, std::string > id_to_elemset_names
std::vector< int > elemset_id_list
std::vector< int > num_elem_df_per_set

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

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

4624 {
4625  if ((_run_only_on_proc0) && (this->processor_id() != 0))
4626  return;
4627 
4628  values.clear();
4629  values.resize(num_global_vars);
4630  ex_err = exII::ex_get_var
4631  (ex_id,
4632  timestep,
4633  exII::EX_GLOBAL,
4634  1, // var_index
4635  1, // obj_id
4637  MappedInputVector(values, _single_precision).data());
4638 
4639  EX_CHECK_ERR(ex_err, "Error reading global values.");
4640 }
processor_id_type processor_id() const

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

References libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusHeaderInfo::num_dim, libMesh::ExodusHeaderInfo::num_edge, libMesh::ExodusHeaderInfo::num_edge_blk, libMesh::ExodusHeaderInfo::num_elem, libMesh::ExodusHeaderInfo::num_elem_blk, libMesh::ExodusHeaderInfo::num_elem_sets, libMesh::ExodusHeaderInfo::num_node_sets, libMesh::ExodusHeaderInfo::num_nodes, libMesh::ExodusHeaderInfo::num_side_sets, and libMesh::ExodusHeaderInfo::title.

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

698 {
699  // Read init params using newer API that reads into a struct. For
700  // backwards compatibility, assign local member values from struct
701  // afterwards. Note: using the new API allows us to automatically
702  // read edge and face block/set information if it's present in the
703  // file.
704  exII::ex_init_params params = {};
705  int err_flag = exII::ex_get_init_ext(ex_id, &params);
706  EX_CHECK_ERR(err_flag, "Error retrieving header info.");
707 
708  // Extract required data into our struct
710  h.title.assign(params.title, params.title + MAX_LINE_LENGTH);
711  h.num_dim = params.num_dim;
712  h.num_nodes = params.num_nodes;
713  h.num_elem = params.num_elem;
714  h.num_elem_blk = params.num_elem_blk;
715  h.num_node_sets = params.num_node_sets;
716  h.num_side_sets = params.num_side_sets;
717  h.num_elem_sets = params.num_elem_sets;
718  h.num_edge_blk = params.num_edge_blk;
719  h.num_edge = params.num_edge;
720 
721  // And return it
722  return h;
723 }
This class is used as both an external data structure for passing around Exodus file header informati...
std::vector< char > title

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

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::NODAL, libMesh::ExodusII_IO_Helper::nodal_var_names, libMesh::ExodusII_IO_Helper::nodal_var_values, libMesh::ExodusII_IO_Helper::node_num_map, libMesh::ExodusII_IO_Helper::num_nodes, and libMesh::ExodusII_IO_Helper::read_var_names().

1817 {
1818  LOG_SCOPE("read_nodal_var_values()", "ExodusII_IO_Helper");
1819 
1820  // Read the nodal variable names from file, so we can see if we have the one we're looking for
1821  this->read_var_names(NODAL);
1822 
1823  // See if we can find the variable we are looking for
1824  unsigned int var_index = 0;
1825  bool found = false;
1826 
1827  // Do a linear search for nodal_var_name in nodal_var_names
1828  for (; var_index<nodal_var_names.size(); ++var_index)
1829  {
1830  found = (nodal_var_names[var_index] == nodal_var_name);
1831  if (found)
1832  break;
1833  }
1834 
1835  if (!found)
1836  {
1837  libMesh::err << "Available variables: " << std::endl;
1838  for (const auto & var_name : nodal_var_names)
1839  libMesh::err << var_name << std::endl;
1840 
1841  libmesh_error_msg("Unable to locate variable named: " << nodal_var_name);
1842  }
1843 
1844  // Clear out any previously read nodal variable values
1845  nodal_var_values.clear();
1846 
1847  std::vector<Real> unmapped_nodal_var_values(num_nodes);
1848 
1849  // Call the Exodus API to read the nodal variable values
1850  ex_err = exII::ex_get_var
1851  (ex_id,
1852  time_step,
1853  exII::EX_NODAL,
1854  var_index+1,
1855  1, // exII::ex_entity_id, not sure exactly what this is but in the ex_get_nodal_var.c shim, they pass 1
1856  num_nodes,
1857  MappedInputVector(unmapped_nodal_var_values, _single_precision).data());
1858  EX_CHECK_ERR(ex_err, "Error reading nodal variable values!");
1859 
1860  for (unsigned i=0; i<static_cast<unsigned>(num_nodes); i++)
1861  {
1862  libmesh_assert_less(i, this->node_num_map.size());
1863 
1864  // Use the node_num_map to obtain the ID of this node in the Exodus file,
1865  // and remember to subtract 1 since libmesh is zero-based and Exodus is 1-based.
1866  const unsigned mapped_node_id = this->node_num_map[i] - 1;
1867 
1868  libmesh_assert_less(i, unmapped_nodal_var_values.size());
1869 
1870  // Store the nodal value in the map.
1871  nodal_var_values[mapped_node_id] = unmapped_nodal_var_values[i];
1872  }
1873 }
OStreamProxy err
std::map< dof_id_type, Real > nodal_var_values
void read_var_names(ExodusVarType type)
std::vector< std::string > nodal_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 877 of file exodusII_io_helper.C.

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.

878 {
879  node_num_map.resize(num_nodes);
880 
881  // Note: we cannot use the exII::ex_get_num_map() here because it
882  // (apparently) does not behave like ex_get_node_num_map() when
883  // there is no node number map in the file: it throws an error
884  // instead of returning a default identity array (1,2,3,...).
885  ex_err = exII::ex_get_node_num_map
886  (ex_id, node_num_map.empty() ? nullptr : node_num_map.data());
887 
888  EX_CHECK_ERR(ex_err, "Error retrieving nodal number map.");
889  message("Nodal numbering map retrieved successfully.");
890 
891  if (verbose)
892  {
893  libMesh::out << "[" << this->processor_id() << "] node_num_map[i] = ";
894  for (unsigned int i=0; i<static_cast<unsigned int>(std::min(10, num_nodes-1)); ++i)
895  libMesh::out << node_num_map[i] << ", ";
896  libMesh::out << "... " << node_num_map.back() << std::endl;
897  }
898 }
void message(std::string_view msg)
Prints the message defined in msg.
OStreamProxy out
processor_id_type processor_id() const

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

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.

827 {
828  LOG_SCOPE("read_nodes()", "ExodusII_IO_Helper");
829 
830  x.resize(num_nodes);
831  y.resize(num_nodes);
832  z.resize(num_nodes);
833 
834  if (num_nodes)
835  {
836  ex_err = exII::ex_get_coord
837  (ex_id,
838  MappedInputVector(x, _single_precision).data(),
839  MappedInputVector(y, _single_precision).data(),
840  MappedInputVector(z, _single_precision).data());
841 
842  EX_CHECK_ERR(ex_err, "Error retrieving nodal data.");
843  message("Nodal data retrieved successfully.");
844  }
845 
846  // If a nodal attribute bex_weight exists, we get spline weights
847  // from it
848  int n_nodal_attr = 0;
849  ex_err = exII::ex_get_attr_param(ex_id, exII::EX_NODAL, 0, & n_nodal_attr);
850  EX_CHECK_ERR(ex_err, "Error getting number of nodal attributes.");
851 
852  if (n_nodal_attr > 0)
853  {
854  std::vector<std::vector<char>> attr_name_data
855  (n_nodal_attr, std::vector<char>(MAX_STR_LENGTH + 1));
856  std::vector<char *> attr_names(n_nodal_attr);
857  for (auto i : index_range(attr_names))
858  attr_names[i] = attr_name_data[i].data();
859 
860  ex_err = exII::ex_get_attr_names(ex_id, exII::EX_NODAL, 0, attr_names.data());
861  EX_CHECK_ERR(ex_err, "Error getting nodal attribute names.");
862 
863  for (auto i : index_range(attr_names))
864  if (std::string("bex_weight") == attr_names[i])
865  {
866  w.resize(num_nodes);
867  ex_err =
868  exII::ex_get_one_attr (ex_id, exII::EX_NODAL, 0, i+1,
869  MappedInputVector(w, _single_precision).data());
870  EX_CHECK_ERR(ex_err, "Error getting Bezier Extraction nodal weights");
871  }
872  }
873 }
void message(std::string_view msg)
Prints the message defined in msg.
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

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

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.

100 {
101  libmesh_assert_less (id, nodeset_ids.size());
102  libmesh_assert_less (id, num_nodes_per_set.size());
103  libmesh_assert_less (id, num_node_df_per_set.size());
104 
105  ex_err = exII::ex_get_set_param(ex_id,
106  exII::EX_NODE_SET,
107  nodeset_ids[id],
108  &num_nodes_per_set[id],
109  &num_node_df_per_set[id]);
110  EX_CHECK_ERR(ex_err, "Error retrieving nodeset parameters.");
111  message("Parameters retrieved successfully for nodeset: ", id);
112 
113  node_list.resize(num_nodes_per_set[id]);
114 
115  // Don't call ex_get_set unless there are actually nodes there to get.
116  // Exodus prints an annoying warning message in DEBUG mode otherwise...
117  if (num_nodes_per_set[id] > 0)
118  {
119  ex_err = exII::ex_get_set(ex_id,
120  exII::EX_NODE_SET,
121  nodeset_ids[id],
122  node_list.data(),
123  nullptr); // set_extra_list, ignored for node sets
124 
125  EX_CHECK_ERR(ex_err, "Error retrieving nodeset data.");
126  message("Data retrieved successfully for nodeset: ", id);
127  }
128 }
std::vector< int > node_list
void message(std::string_view msg)
Prints the message defined in msg.
std::vector< int > num_node_df_per_set
std::vector< int > 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 4159 of file exodusII_io_helper.C.

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

4163 {
4164  LOG_SCOPE("read_nodeset_data()", "ExodusII_IO_Helper");
4165 
4166  // This reads the sideset variable names into the local
4167  // sideset_var_names data structure.
4168  this->read_var_names(NODESET);
4169 
4170  if (num_nodeset_vars)
4171  {
4172  // Read the nodeset data truth table
4173  std::vector<int> nset_var_tab(num_node_sets * num_nodeset_vars);
4174  ex_err = exII::ex_get_truth_table
4175  (ex_id,
4176  exII::EX_NODE_SET,
4177  num_node_sets,
4179  nset_var_tab.data());
4180  EX_CHECK_ERR(ex_err, "Error reading nodeset variable truth table.");
4181 
4182  // Set up/allocate space in incoming data structures.
4183  var_names = nodeset_var_names;
4184  node_boundary_ids.resize(num_nodeset_vars);
4185  bc_vals.resize(num_nodeset_vars);
4186 
4187  // Read the nodeset data.
4188  //
4189  // Note: we assume that the functions
4190  // 1.) this->read_nodeset_info() and
4191  // 2.) this->read_all_nodesets()
4192  // have already been called, so that we already know e.g. how
4193  // many nodes are in each set, their ids, etc.
4194  //
4195  // TODO: As a future optimization, we could read only the values
4196  // requested by the user by looking at the input parameter
4197  // var_names and checking whether it already has entries in
4198  // it.
4199  int offset=0;
4200  for (int ns=0; ns<num_node_sets; ++ns)
4201  {
4202  offset += (ns > 0 ? num_nodes_per_set[ns-1] : 0);
4203  for (int var=0; var<num_nodeset_vars; ++var)
4204  {
4205  int is_present = nset_var_tab[num_nodeset_vars*ns + var];
4206 
4207  if (is_present)
4208  {
4209  // Record the fact that this variable is defined on this nodeset.
4210  node_boundary_ids[var].insert(nodeset_ids[ns]);
4211 
4212  // Note: the assumption here is that a previous call
4213  // to this->read_nodeset_info() has already set the
4214  // values of num_nodes_per_set, so we just use those values here.
4215  std::vector<Real> nset_var_vals(num_nodes_per_set[ns]);
4216  ex_err = exII::ex_get_var
4217  (ex_id,
4218  timestep,
4219  exII::EX_NODE_SET,
4220  var + 1, // 1-based nodeset variable index!
4221  nodeset_ids[ns],
4222  num_nodes_per_set[ns],
4223  MappedInputVector(nset_var_vals, _single_precision).data());
4224  EX_CHECK_ERR(ex_err, "Error reading nodeset variable.");
4225 
4226  for (int i=0; i<num_nodes_per_set[ns]; ++i)
4227  {
4228  // The read_all_nodesets() function now reads all the node ids into the
4229  // node_sets_node_list vector, which is of length "total_nodes_in_all_sets"
4230  // The old read_nodset() function is no longer called as far as I can tell,
4231  // and should probably be removed? The "offset" that we are using only
4232  // depends on the current nodeset index and the num_nodes_per_set vector,
4233  // which gets filled in by the call to read_all_nodesets().
4234  dof_id_type exodus_node_id = node_sets_node_list[i + offset];
4235 
4236  // FIXME: We should use exodus_node_num_to_libmesh for this,
4237  // but it apparently is never set up, so just
4238  // subtract 1 from the Exodus node id.
4239  dof_id_type converted_node_id = exodus_node_id - 1;
4240 
4241  // Make a NodeBCTuple key from the converted information.
4242  BoundaryInfo::NodeBCTuple key = std::make_tuple
4243  (converted_node_id, nodeset_ids[ns]);
4244 
4245  // Store (node, b_id) tuples in bc_vals[var]
4246  bc_vals[var].emplace(key, nset_var_vals[i]);
4247  } // end for (i)
4248  } // end if (present)
4249  } // end for (var)
4250  } // end for (ns)
4251  } // end if (num_nodeset_vars)
4252 }
std::vector< std::string > nodeset_var_names
std::tuple< dof_id_type, boundary_id_type > NodeBCTuple
As above, but the library creates and fills in a vector of (node-id, bc-id) pairs and returns it to t...
void read_var_names(ExodusVarType type)
std::vector< int > node_sets_node_list
std::vector< int > num_nodes_per_set
uint8_t dof_id_type
Definition: id_types.h:67

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

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.

1522 {
1523  nodeset_ids.resize(num_node_sets);
1524  if (num_node_sets > 0)
1525  {
1526  ex_err = exII::ex_get_ids(ex_id,
1527  exII::EX_NODE_SET,
1528  nodeset_ids.data());
1529  EX_CHECK_ERR(ex_err, "Error retrieving nodeset information.");
1530  message("All nodeset information retrieved successfully.");
1531 
1532  // Resize appropriate data structures -- only do this once outside the loop
1535  }
1536 
1537  char name_buffer[MAX_STR_LENGTH+1];
1538  for (int i=0; i<num_node_sets; ++i)
1539  {
1540  ex_err = exII::ex_get_name(ex_id, exII::EX_NODE_SET,
1541  nodeset_ids[i], name_buffer);
1542  EX_CHECK_ERR(ex_err, "Error getting node set name.");
1543  id_to_ns_names[nodeset_ids[i]] = name_buffer;
1544  }
1545  message("All node set names retrieved successfully.");
1546 }
void message(std::string_view msg)
Prints the message defined in msg.
std::vector< int > num_node_df_per_set
std::map< int, std::string > id_to_ns_names
std::vector< int > 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 1808 of file exodusII_io_helper.C.

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

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

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

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

762 {
763  // The QA records are four MAX_STR_LENGTH-byte character strings.
764  int num_qa_rec =
765  inquire(*this, exII::EX_INQ_QA, "Error retrieving number of QA records");
766 
767  if (verbose)
768  libMesh::out << "Found "
769  << num_qa_rec
770  << " QA record(s) in the Exodus file."
771  << std::endl;
772 
773  if (num_qa_rec > 0)
774  {
775  // How to dynamically allocate an array of fixed-size char * arrays in C++.
776  // http://stackoverflow.com/questions/8529359/creating-a-dynamic-sized-array-of-fixed-sized-int-arrays-in-c
777  typedef char * inner_array_t[4];
778  inner_array_t * qa_record = new inner_array_t[num_qa_rec];
779 
780  for (int i=0; i<num_qa_rec; i++)
781  for (int j=0; j<4; j++)
782  qa_record[i][j] = new char[MAX_STR_LENGTH+1];
783 
784  ex_err = exII::ex_get_qa (ex_id, qa_record);
785  EX_CHECK_ERR(ex_err, "Error reading the QA records.");
786 
787  // Print the QA records
788  if (verbose)
789  {
790  for (int i=0; i<num_qa_rec; i++)
791  {
792  libMesh::out << "QA Record: " << i << std::endl;
793  for (int j=0; j<4; j++)
794  libMesh::out << qa_record[i][j] << std::endl;
795  }
796  }
797 
798 
799  // Clean up dynamically-allocated memory
800  for (int i=0; i<num_qa_rec; i++)
801  for (int j=0; j<4; j++)
802  delete [] qa_record[i][j];
803 
804  delete [] qa_record;
805  }
806 }
OStreamProxy out

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

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

1591 {
1592  LOG_SCOPE("read_sideset()", "ExodusII_IO_Helper");
1593 
1594  libmesh_assert_less (id, ss_ids.size());
1595  libmesh_assert_less (id, num_sides_per_set.size());
1596  libmesh_assert_less (id, num_df_per_set.size());
1597  libmesh_assert_less_equal (offset, elem_list.size());
1598  libmesh_assert_less_equal (offset, side_list.size());
1599 
1600  ex_err = exII::ex_get_set_param(ex_id,
1601  exII::EX_SIDE_SET,
1602  ss_ids[id],
1603  &num_sides_per_set[id],
1604  &num_df_per_set[id]);
1605  EX_CHECK_ERR(ex_err, "Error retrieving sideset parameters.");
1606  message("Parameters retrieved successfully for sideset: ", id);
1607 
1608 
1609  // It's OK for offset==elem_list.size() as long as num_sides_per_set[id]==0
1610  // because in that case we don't actually read anything...
1611 #ifdef DEBUG
1612  if (static_cast<unsigned int>(offset) == elem_list.size() ||
1613  static_cast<unsigned int>(offset) == side_list.size() )
1614  libmesh_assert_equal_to (num_sides_per_set[id], 0);
1615 #endif
1616 
1617 
1618  // Don't call ex_get_set unless there are actually sides there to get.
1619  // Exodus prints an annoying warning in DEBUG mode otherwise...
1620  if (num_sides_per_set[id] > 0)
1621  {
1622  ex_err = exII::ex_get_set(ex_id,
1623  exII::EX_SIDE_SET,
1624  ss_ids[id],
1625  &elem_list[offset],
1626  &side_list[offset]);
1627  EX_CHECK_ERR(ex_err, "Error retrieving sideset data.");
1628  message("Data retrieved successfully for sideset: ", id);
1629 
1630  for (int i=0; i<num_sides_per_set[id]; i++)
1631  id_list[i+offset] = ss_ids[id];
1632  }
1633 }
std::vector< int > num_sides_per_set
void message(std::string_view msg)
Prints the message defined in msg.
std::vector< int > num_df_per_set

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

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

3632 {
3633  LOG_SCOPE("read_sideset_data()", "ExodusII_IO_Helper");
3634 
3635  // This reads the sideset variable names into the local
3636  // sideset_var_names data structure.
3637  this->read_var_names(SIDESET);
3638 
3639  if (num_sideset_vars)
3640  {
3641  // Read the sideset data truth table
3642  std::vector<int> sset_var_tab(num_side_sets * num_sideset_vars);
3643  ex_err = exII::ex_get_truth_table
3644  (ex_id,
3645  exII::EX_SIDE_SET,
3646  num_side_sets,
3648  sset_var_tab.data());
3649  EX_CHECK_ERR(ex_err, "Error reading sideset variable truth table.");
3650 
3651  // Set up/allocate space in incoming data structures.
3652  var_names = sideset_var_names;
3653  side_ids.resize(num_sideset_vars);
3654  bc_vals.resize(num_sideset_vars);
3655 
3656  // Read the sideset data.
3657  //
3658  // Note: we assume that read_sideset() has already been called
3659  // for each sideset, so the required values in elem_list and
3660  // side_list are already present.
3661  //
3662  // TODO: As a future optimization, we could read only the values
3663  // requested by the user by looking at the input parameter
3664  // var_names and checking whether it already has entries in
3665  // it. We could do the same thing with the input side_ids
3666  // container and only read values for requested sidesets.
3667  int offset=0;
3668  for (int ss=0; ss<num_side_sets; ++ss)
3669  {
3670  offset += (ss > 0 ? num_sides_per_set[ss-1] : 0);
3671  for (int var=0; var<num_sideset_vars; ++var)
3672  {
3673  int is_present = sset_var_tab[num_sideset_vars*ss + var];
3674 
3675  if (is_present)
3676  {
3677  // Record the fact that this variable is defined on this sideset.
3678  side_ids[var].insert(ss_ids[ss]);
3679 
3680  // Note: the assumption here is that a previous call
3681  // to this->read_sideset_info() has already set the
3682  // values of num_sides_per_set, so we just use those values here.
3683  std::vector<Real> sset_var_vals(num_sides_per_set[ss]);
3684  ex_err = exII::ex_get_var
3685  (ex_id,
3686  timestep,
3687  exII::EX_SIDE_SET,
3688  var + 1, // 1-based sideset variable index!
3689  ss_ids[ss],
3690  num_sides_per_set[ss],
3691  MappedInputVector(sset_var_vals, _single_precision).data());
3692  EX_CHECK_ERR(ex_err, "Error reading sideset variable.");
3693 
3694  for (int i=0; i<num_sides_per_set[ss]; ++i)
3695  {
3696  dof_id_type exodus_elem_id = elem_list[i + offset];
3697  unsigned int exodus_side_id = side_list[i + offset];
3698 
3699  // FIXME: We should use exodus_elem_num_to_libmesh for this,
3700  // but it apparently is never set up, so just
3701  // subtract 1 from the Exodus elem id.
3702  dof_id_type converted_elem_id = exodus_elem_id - 1;
3703 
3704  // Map Exodus side id to libmesh side id.
3705  // Map from Exodus side ids to libmesh side ids.
3706  const auto & conv = get_conversion(mesh.elem_ptr(converted_elem_id)->type());
3707 
3708  // Map from Exodus side id to libmesh side id.
3709  // Note: the mapping is defined on 0-based indices, so subtract
3710  // 1 before doing the mapping.
3711  unsigned int converted_side_id = conv.get_side_map(exodus_side_id - 1);
3712 
3713  // Make a BCTuple key from the converted information.
3714  BoundaryInfo::BCTuple key = std::make_tuple
3715  (converted_elem_id,
3716  converted_side_id,
3717  ss_ids[ss]);
3718 
3719  // Store (elem, side, b_id) tuples in bc_vals[var]
3720  bc_vals[var].emplace(key, sset_var_vals[i]);
3721  } // end for (i)
3722  } // end if (present)
3723  } // end for (var)
3724  } // end for (ss)
3725  } // end if (num_sideset_vars)
3726 }
std::tuple< dof_id_type, unsigned short int, boundary_id_type > BCTuple
As above, but the library creates and fills in a vector of (elem-id, side-id, bc-id) triplets and ret...
std::vector< std::string > sideset_var_names
std::vector< int > num_sides_per_set
MeshBase & mesh
const ExodusII_IO_Helper::Conversion & get_conversion(const ElemType type) const
void read_var_names(ExodusVarType type)
virtual const Elem * elem_ptr(const dof_id_type i) const =0
virtual ElemType type() const =0
uint8_t dof_id_type
Definition: id_types.h:67

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

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::id_to_ss_names, libMesh::ExodusII_IO_Helper::message(), libMesh::ExodusII_IO_Helper::num_df_per_set, libMesh::ExodusII_IO_Helper::num_elem_all_sidesets, libMesh::ExodusII_IO_Helper::num_side_sets, libMesh::ExodusII_IO_Helper::num_sides_per_set, libMesh::ExodusII_IO_Helper::side_list, and libMesh::ExodusII_IO_Helper::ss_ids.

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

1487 {
1488  ss_ids.resize(num_side_sets);
1489  if (num_side_sets > 0)
1490  {
1491  ex_err = exII::ex_get_ids(ex_id,
1492  exII::EX_SIDE_SET,
1493  ss_ids.data());
1494  EX_CHECK_ERR(ex_err, "Error retrieving sideset information.");
1495  message("All sideset information retrieved successfully.");
1496 
1497  // Resize appropriate data structures -- only do this once outside the loop
1499  num_df_per_set.resize(num_side_sets);
1500 
1501  // Inquire about the length of the concatenated side sets element list
1502  num_elem_all_sidesets = inquire(*this, exII::EX_INQ_SS_ELEM_LEN, "Error retrieving length of the concatenated side sets element list!");
1503 
1506  id_list.resize (num_elem_all_sidesets);
1507  }
1508 
1509  char name_buffer[MAX_STR_LENGTH+1];
1510  for (int i=0; i<num_side_sets; ++i)
1511  {
1512  ex_err = exII::ex_get_name(ex_id, exII::EX_SIDE_SET,
1513  ss_ids[i], name_buffer);
1514  EX_CHECK_ERR(ex_err, "Error getting side set name.");
1515  id_to_ss_names[ss_ids[i]] = name_buffer;
1516  }
1517  message("All side set names retrieved successfully.");
1518 }
std::vector< int > num_sides_per_set
std::map< int, std::string > id_to_ss_names
void message(std::string_view msg)
Prints the message defined in msg.
std::vector< int > num_df_per_set

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

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.

1792 {
1793  // Make sure we have an up-to-date count of the number of time steps in the file.
1794  this->read_num_time_steps();
1795 
1796  if (num_time_steps > 0)
1797  {
1798  time_steps.resize(num_time_steps);
1799  ex_err = exII::ex_get_all_times
1800  (ex_id,
1801  MappedInputVector(time_steps, _single_precision).data());
1802  EX_CHECK_ERR(ex_err, "Error reading timesteps!");
1803  }
1804 }
std::vector< Real > time_steps
void read_num_time_steps()
Reads the number of timesteps currently stored in the Exodus file and stores it in the num_time_steps...

◆ read_var_names()

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

Definition at line 1877 of file exodusII_io_helper.C.

References libMesh::ExodusII_IO_Helper::elem_var_names, libMesh::ExodusII_IO_Helper::ELEMENTAL, libMesh::ExodusII_IO_Helper::ELEMSET, libMesh::ExodusII_IO_Helper::elemset_var_names, libMesh::ExodusII_IO_Helper::GLOBAL, libMesh::ExodusII_IO_Helper::global_var_names, libMesh::ExodusII_IO_Helper::NODAL, libMesh::ExodusII_IO_Helper::nodal_var_names, libMesh::ExodusII_IO_Helper::NODESET, libMesh::ExodusII_IO_Helper::nodeset_var_names, libMesh::ExodusII_IO_Helper::num_elem_vars, libMesh::ExodusII_IO_Helper::num_elemset_vars, libMesh::ExodusII_IO_Helper::num_global_vars, libMesh::ExodusII_IO_Helper::num_nodal_vars, libMesh::ExodusII_IO_Helper::num_nodeset_vars, libMesh::ExodusII_IO_Helper::num_sideset_vars, libMesh::ExodusII_IO_Helper::read_var_names_impl(), libMesh::ExodusII_IO_Helper::SIDESET, and libMesh::ExodusII_IO_Helper::sideset_var_names.

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

1878 {
1879  switch (type)
1880  {
1881  case NODAL:
1883  break;
1884  case ELEMENTAL:
1886  break;
1887  case GLOBAL:
1889  break;
1890  case SIDESET:
1892  break;
1893  case NODESET:
1895  break;
1896  case ELEMSET:
1898  break;
1899  default:
1900  libmesh_error_msg("Unrecognized ExodusVarType " << type);
1901  }
1902 }
std::vector< std::string > sideset_var_names
std::vector< std::string > elem_var_names
virtual void read_var_names_impl(const char *var_type, int &count, std::vector< std::string > &result)
read_var_names() dispatches to this function.
std::vector< std::string > nodeset_var_names
std::vector< std::string > global_var_names
std::vector< std::string > elemset_var_names
std::vector< std::string > nodal_var_names

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

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

2766 {
2767  // Most of what we need to do is the same as for Exodus
2768  this->ExodusII_IO_Helper::read_var_names_impl(var_type, count, result);
2769 
2770  // But with tests where we have more processors than elements,
2771  // Nemesis doesn't let us put variable names in files written by
2772  // processors owning nothing, but we may still *need* those
2773  // variable names on every processor, so let's sync them up...
2774 
2775  processor_id_type pid_broadcasting_names = this->processor_id();
2776  const std::size_t n_names = result.size();
2777  if (!n_names)
2778  pid_broadcasting_names = DofObject::invalid_processor_id;
2779 
2780  libmesh_assert(this->comm().semiverify
2781  (n_names ? nullptr : &n_names));
2782 
2783  this->comm().min(pid_broadcasting_names);
2784 
2785  if (pid_broadcasting_names != DofObject::invalid_processor_id)
2786  this->comm().broadcast(result, pid_broadcasting_names);
2787 }
virtual void read_var_names_impl(const char *var_type, int &count, std::vector< std::string > &result)
read_var_names() dispatches to this function.
const Parallel::Communicator & comm() const
uint8_t processor_id_type
void min(const T &r, T &o, Request &req) const
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:488
libmesh_assert(ctx)
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
processor_id_type processor_id() const

◆ 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 1289 of file exodusII_io_helper.h.

References libMesh::ExodusII_IO_Helper::_add_sides.

1290 {
1291  _add_sides = add_sides;
1292 }
bool _add_sides
Set to true iff we want to write separate "side" elements too.

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

References libMesh::ExodusII_IO_Helper::_coordinate_offset.

4666 {
4667  _coordinate_offset = p;
4668 }

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

References libMesh::ExodusII_IO_Helper::_write_hdf5.

4651 {
4652  _write_hdf5 = write_hdf5;
4653 }

◆ update()

void libMesh::ExodusII_IO_Helper::update ( )
inherited

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

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

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

4659 {
4661 }
unsigned int 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 2632 of file nemesis_io_helper.C.

References std::abs(), libMesh::CONSTANT, libMesh::System::current_local_solution, libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::EquationSystems::get_system(), global_elem_blk_ids, libMesh::if(), libMesh::index_range(), mesh, libMesh::MONOMIAL_VEC, subdomain_map, libMesh::ExodusII_IO_Helper::update(), libMesh::System::variable_type(), and write_complex_abs.

2637 {
2638  // For each variable in names,
2639  // For each subdomain in subdomain_map,
2640  // If this (subdomain, variable) combination is active
2641  // For each component in variable
2642  // Extract element values into local_soln (localize is a collective)
2643  // Write local_soln to file
2644  // Update var_ctr with number of vector components for variable
2645  //
2646  unsigned int var_ctr = 0;
2647  for (auto v : index_range(var_nums))
2648  {
2649  const unsigned int sys_num = var_nums[v].first;
2650  const unsigned int var = var_nums[v].second;
2651  const System & system = es.get_system(sys_num);
2652 
2653  // We need to check if the constant monomial is a scalar or a vector and set the number of
2654  // components as the mesh dimension for the latter case as per es.find_variable_numbers().
2655  // Even for the case where a variable is not active on any subdomain belonging to the
2656  // processor, we still need to know this number to update 'var_ctr'.
2657  const unsigned int n_comps =
2658  (system.variable_type(var) == FEType(CONSTANT, MONOMIAL_VEC)) ? mesh.mesh_dimension() : 1;
2659 
2660  // Get list of active subdomains for variable v
2661  const auto & active_subdomains = vars_active_subdomains[v];
2662 
2663  for (const int sbd_id_int : global_elem_blk_ids)
2664  {
2665  const subdomain_id_type sbd_id =
2666  cast_int<subdomain_id_type>(sbd_id_int);
2667  auto it = subdomain_map.find(sbd_id);
2668  const std::vector<dof_id_type> empty_vec;
2669  const std::vector<dof_id_type> & elem_ids =
2670  (it == subdomain_map.end()) ? empty_vec : it->second;
2671 
2672  // Possibly skip this (variable, subdomain) combination. Also, check that there is at
2673  // least one element on the subdomain... Indeed, it is possible to have zero elements,
2674  // e.g., when running "adaptivity_ex3" in parallel with the 'dimension=1' argument.
2675  if ((active_subdomains.empty() || active_subdomains.count(sbd_id)) && elem_ids.size())
2676  {
2677  std::vector<numeric_index_type> required_indices;
2678  required_indices.reserve(elem_ids.size());
2679 
2680  // The number of DOF components needs to be equal to the expected number so that we
2681  // know where to store data to correctly correspond to variable names - verify this by
2682  // accessing the n_comp method for the last element ID, which should return the same
2683  // value for all elements on a given subdomain, so we only need to check this once.
2684  libmesh_assert_equal_to(n_comps, mesh.elem_ref(elem_ids.back()).n_comp(sys_num, var));
2685 
2686  // Loop through the DOFs of the variable and write the values for it on each element.
2687  // The variable name should have been decomposed by es.find_variable_numbers().
2688  for (unsigned int comp = 0; comp < n_comps; ++comp)
2689  {
2690  for (const auto & id : elem_ids)
2691  required_indices.push_back(mesh.elem_ref(id).dof_number(sys_num, var, comp));
2692 
2693  std::vector<Number> local_soln;
2694  system.current_local_solution->get(required_indices, local_soln);
2695 
2696  // reset for the next component
2697  required_indices.clear();
2698 
2699  // It's possible that there's nothing for us to write:
2700  // we may not be responsible for any elements on the
2701  // current subdomain. We did still have to participate
2702  // in the localize() call above, however, since it is a
2703  // collective.
2704  if (local_soln.size())
2705  {
2706 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
2707  int stride = write_complex_abs ? 3 : 2;
2708  std::vector<Real> local_soln_buffer(local_soln.size());
2709  std::transform(local_soln.begin(), local_soln.end(),
2710  local_soln_buffer.begin(), [](Number n) { return n.real(); });
2711  ex_err = exII::ex_put_elem_var(ex_id,
2712  timestep,
2713  static_cast<int>(stride*(var_ctr+comp)+1),
2714  static_cast<int>(sbd_id),
2715  static_cast<int>(local_soln.size()),
2716  local_soln_buffer.data());
2717  EX_CHECK_ERR(ex_err, "Error writing element real values.");
2718 
2719  std::transform(local_soln.begin(), local_soln.end(),
2720  local_soln_buffer.begin(), [](Number n) { return n.imag(); });
2721  ex_err = exII::ex_put_elem_var(ex_id,
2722  timestep,
2723  static_cast<int>(stride*(var_ctr+comp)+2),
2724  static_cast<int>(sbd_id),
2725  static_cast<int>(local_soln.size()),
2726  local_soln_buffer.data());
2727  EX_CHECK_ERR(ex_err, "Error writing element imaginary values.");
2728 
2729  if (write_complex_abs)
2730  {
2731  std::transform(local_soln.begin(), local_soln.end(),
2732  local_soln_buffer.begin(), [](Number n) { return std::abs(n); });
2733  ex_err = exII::ex_put_elem_var(ex_id,
2734  timestep,
2735  static_cast<int>(stride*(var_ctr+comp)+2),
2736  static_cast<int>(sbd_id),
2737  static_cast<int>(local_soln.size()),
2738  local_soln_buffer.data());
2739  EX_CHECK_ERR(ex_err, "Error writing element magnitudes.");
2740  }
2741 #else // LIBMESH_USE_COMPLEX_NUMBERS
2742  ex_err = exII::ex_put_elem_var(ex_id,
2743  timestep,
2744  static_cast<int>(var_ctr+comp+1),
2745  static_cast<int>(sbd_id),
2746  static_cast<int>(local_soln.size()),
2747  local_soln.data());
2748  EX_CHECK_ERR(ex_err, "Error writing element values.");
2749 #endif // LIBMESH_USE_COMPLEX_NUMBERS
2750  }
2751  } // end loop over vector components
2752  }
2753  } // end loop over active subdomains
2754 
2755  var_ctr += n_comps;
2756  } // end loop over vars
2757 
2758  this->update();
2759 }
std::map< subdomain_id_type, std::vector< dof_id_type > > subdomain_map
Map of subdomains to element numbers.
TestClass subdomain_id_type
Based on the 4-byte comment warning above, this probably doesn&#39;t work with exodusII at all...
Definition: id_types.h:43
MeshBase & mesh
bool write_complex_abs
By default, when complex numbers are enabled, for each variable we write out three values: the real p...
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:57
void update()
Uses ex_update() to flush buffers to file.
std::vector< int > global_elem_blk_ids
Read the global element block IDs and counts.
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

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

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::MeshTools::n_elem(), libMesh::MeshBase::n_elem(), libMesh::ExodusII_IO_Helper::num_elem_vars, libMesh::ParallelObject::processor_id(), and libMesh::ExodusII_IO_Helper::update().

4307 {
4308  LOG_SCOPE("write_element_values()", "ExodusII_IO_Helper");
4309 
4310  if ((_run_only_on_proc0) && (this->processor_id() != 0))
4311  return;
4312 
4313  // Ask the file how many element vars it has, store it in the num_elem_vars variable.
4314  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_ELEM_BLOCK, &num_elem_vars);
4315  EX_CHECK_ERR(ex_err, "Error reading number of elemental variables.");
4316 
4317  // We will eventually loop over the element blocks (subdomains) and
4318  // write the data one block at a time. Build a data structure that
4319  // maps each subdomain to a list of element ids it contains.
4320  std::map<subdomain_id_type, std::vector<unsigned int>> subdomain_map;
4321  for (const auto & elem : mesh.active_element_ptr_range())
4322  subdomain_map[elem->subdomain_id()].push_back(elem->id());
4323 
4324  // Use mesh.n_elem() to access into the values vector rather than
4325  // the number of elements the Exodus writer thinks the mesh has,
4326  // which may not include inactive elements.
4328 
4329  // Sanity check: we must have an entry in vars_active_subdomains for
4330  // each variable that we are potentially writing out.
4331  libmesh_assert_equal_to
4332  (vars_active_subdomains.size(),
4333  static_cast<unsigned>(num_elem_vars));
4334 
4335  // For each variable, create a 'data' array which holds all the elemental variable
4336  // values *for a given block* on this processor, then write that data vector to file
4337  // before moving onto the next block.
4338  for (unsigned int var_id=0; var_id<static_cast<unsigned>(num_elem_vars); ++var_id)
4339  {
4340  // The size of the subdomain map is the number of blocks.
4341  auto it = subdomain_map.begin();
4342 
4343  // Reference to the set of active subdomains for the current variable.
4344  const auto & active_subdomains
4345  = vars_active_subdomains[var_id];
4346 
4347  for (unsigned int j=0; it!=subdomain_map.end(); ++it, ++j)
4348  {
4349  // Skip any variable/subdomain pairs that are inactive.
4350  // Note that if active_subdomains is empty, it is interpreted
4351  // as being active on *all* subdomains.
4352  if (!(active_subdomains.empty() || active_subdomains.count(it->first)))
4353  continue;
4354 
4355  // Get reference to list of elem ids which are in the
4356  // current subdomain and count, allocate storage to hold
4357  // data that will be written to file.
4358  const auto & elem_nums = it->second;
4359  const unsigned int num_elems_this_block =
4360  cast_int<unsigned int>(elem_nums.size());
4361  std::vector<Real> data(num_elems_this_block);
4362 
4363  // variable-major ordering is:
4364  // (u1, u2, u3, ..., uN), (v1, v2, v3, ..., vN), ...
4365  // where N is the number of elements.
4366  for (unsigned int k=0; k<num_elems_this_block; ++k)
4367  data[k] = values[var_id*n_elem + elem_nums[k]];
4368 
4369  ex_err = exII::ex_put_var
4370  (ex_id,
4371  timestep,
4372  exII::EX_ELEM_BLOCK,
4373  var_id+1,
4374  this->get_block_id(j),
4375  num_elems_this_block,
4376  MappedOutputVector(data, _single_precision).data());
4377 
4378  EX_CHECK_ERR(ex_err, "Error writing element values.");
4379  }
4380  }
4381 
4382  this->update();
4383 }
dof_id_type n_elem(const MeshBase::const_element_iterator &begin, const MeshBase::const_element_iterator &end)
Count up the number of elements of a specific type (as defined by an iterator range).
Definition: mesh_tools.C:850
MeshBase & mesh
void update()
Uses ex_update() to flush buffers to file.
virtual dof_id_type n_elem() const =0
processor_id_type processor_id() const
int get_block_id(int index)
Get the block number for the given block index.
uint8_t dof_id_type
Definition: id_types.h:67

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

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::_single_precision, libMesh::ExodusII_IO_Helper::MappedOutputVector::data(), distance(), 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().

4394 {
4395  if ((_run_only_on_proc0) && (this->processor_id() != 0))
4396  return;
4397 
4398  // Ask the file how many element vars it has, store it in the num_elem_vars variable.
4399  ex_err = exII::ex_get_variable_param(ex_id, exII::EX_ELEM_BLOCK, &num_elem_vars);
4400  EX_CHECK_ERR(ex_err, "Error reading number of elemental variables.");
4401 
4402  // We will eventually loop over the element blocks (subdomains) and
4403  // write the data one block (subdomain) at a time. Build a data
4404  // structure that keeps track of how many elements are in each
4405  // subdomain. This will allow us to reserve space in the data vector
4406  // we are going to write.
4407  std::map<subdomain_id_type, unsigned int> subdomain_to_n_elem;
4408  for (const auto & elem : mesh.active_element_ptr_range())
4409  subdomain_to_n_elem[elem->subdomain_id()] += 1;
4410 
4411  // Sanity check: we must have an entry in vars_active_subdomains for
4412  // each variable that we are potentially writing out.
4413  libmesh_assert_equal_to
4414  (vars_active_subdomains.size(),
4415  static_cast<unsigned>(num_elem_vars));
4416 
4417  // The size of the subdomain map is the number of blocks.
4418  auto subdomain_to_n_elem_iter = subdomain_to_n_elem.begin();
4419 
4420  // Store range of active Elem pointers. We are going to loop over
4421  // the elements n_vars * n_subdomains times, so let's make sure
4422  // the predicated iterators aren't slowing us down too much.
4423  ConstElemRange elem_range
4424  (mesh.active_elements_begin(),
4425  mesh.active_elements_end());
4426 
4427  for (unsigned int sbd_idx=0;
4428  subdomain_to_n_elem_iter != subdomain_to_n_elem.end();
4429  ++subdomain_to_n_elem_iter, ++sbd_idx)
4430  for (unsigned int var_id=0; var_id<static_cast<unsigned>(num_elem_vars); ++var_id)
4431  {
4432  // Reference to the set of active subdomains for the current variable.
4433  const auto & active_subdomains
4434  = vars_active_subdomains[var_id];
4435 
4436  // If the vars_active_subdomains container passed to this function
4437  // has an empty entry, it means the variable really is not active on
4438  // _any_ subdomains, not that it is active on _all_ subdomains. This
4439  // is just due to the way that we build the vars_active_subdomains
4440  // container.
4441  if (!active_subdomains.count(subdomain_to_n_elem_iter->first))
4442  continue;
4443 
4444  // Vector to hold values that will be written to Exodus file.
4445  std::vector<Real> data;
4446  data.reserve(subdomain_to_n_elem_iter->second);
4447 
4448  unsigned int values_offset = 0;
4449  for (auto & elem : elem_range)
4450  {
4451  // We'll use the Elem's subdomain id in several places below.
4452  subdomain_id_type sbd_id = elem->subdomain_id();
4453 
4454  // Get reference to the list of variable names defining
4455  // the indexing for the current Elem's subdomain.
4456  auto subdomain_to_var_names_iter =
4457  subdomain_to_var_names.find(sbd_id);
4458 
4459  // It's possible, but unusual, for there to be an Elem
4460  // from a subdomain that has no active variables from the
4461  // set of variables we are currently writing. If that
4462  // happens, we can just go to the next Elem because we
4463  // don't need to advance the offset into the values
4464  // vector, etc.
4465  if (subdomain_to_var_names_iter == subdomain_to_var_names.end())
4466  continue;
4467 
4468  const auto & var_names_this_sbd
4469  = subdomain_to_var_names_iter->second;
4470 
4471  // Only extract values if Elem is in the current subdomain.
4472  if (sbd_id == subdomain_to_n_elem_iter->first)
4473  {
4474  // Location of current var_id in the list of all variables on this
4475  // subdomain. FIXME: linear search but it's over a typically relatively
4476  // short vector of active variable names on this subdomain. We could do
4477  // a nested std::map<string,index> instead of a std::vector where the
4478  // location of the string is implicitly the index..
4479  auto pos =
4480  std::find(var_names_this_sbd.begin(),
4481  var_names_this_sbd.end(),
4482  derived_var_names[var_id]);
4483 
4484  libmesh_error_msg_if(pos == var_names_this_sbd.end(),
4485  "Derived name " << derived_var_names[var_id] << " not found!");
4486 
4487  // Find the current variable's location in the list of all variable
4488  // names on the current Elem's subdomain.
4489  auto true_index =
4490  std::distance(var_names_this_sbd.begin(), pos);
4491 
4492  data.push_back(values[values_offset + true_index]);
4493  }
4494 
4495  // The "true" offset is how much we have to advance the index for each Elem
4496  // in this subdomain.
4497  auto true_offset = var_names_this_sbd.size();
4498 
4499  // Increment to the next Elem's values
4500  values_offset += true_offset;
4501  } // for elem
4502 
4503  // Now write 'data' to Exodus file, in single precision if requested.
4504  if (!data.empty())
4505  {
4506  ex_err = exII::ex_put_var
4507  (ex_id,
4508  timestep,
4509  exII::EX_ELEM_BLOCK,
4510  var_id+1,
4511  this->get_block_id(sbd_idx),
4512  data.size(),
4513  MappedOutputVector(data, _single_precision).data());
4514 
4515  EX_CHECK_ERR(ex_err, "Error writing element values.");
4516  }
4517  } // for each var_id
4518 
4519  this->update();
4520 }
MeshBase & mesh
The StoredRange class defines a contiguous, divisible set of objects.
Definition: stored_range.h:54
Real distance(const Point &p)
void update()
Uses ex_update() to flush buffers to file.
processor_id_type processor_id() const
int get_block_id(int index)
Get the block number for the given block index.

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

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.

2270 {
2271  // Only write elements if there are elements blocks available.
2272  if (this->num_elem_blks_global > 0)
2273  {
2274  // Data structure to store element block names that will be used to
2275  // write the element block names to file.
2276  NamesData names_table(this->num_elem_blks_global, MAX_STR_LENGTH);
2277 
2278  // Loop over all blocks, even if we don't have elements in each block.
2279  // If we don't have elements we need to write out a 0 for that block...
2280  for (auto i : make_range(this->num_elem_blks_global))
2281  {
2282  // Even if there are no elements for this block on the current
2283  // processor, we still want to write its name to file, if
2284  // possible. MeshBase::subdomain_name() will just return an
2285  // empty string if there is no name associated with the current
2286  // block.
2287  names_table.push_back_entry
2288  (mesh.subdomain_name(cast_int<subdomain_id_type>(this->global_elem_blk_ids[i])));
2289 
2290  // Search for the current global block ID in the map
2291  std::map<int, std::vector<int>>::iterator it =
2292  this->block_id_to_elem_connectivity.find( this->global_elem_blk_ids[i] );
2293 
2294  // If not found, write a zero to file....
2295  if (it == this->block_id_to_elem_connectivity.end())
2296  {
2297  this->ex_err = exII::ex_put_elem_block(this->ex_id,
2298  this->global_elem_blk_ids[i],
2299  "Empty",
2300  0, /* n. elements in this block */
2301  0, /* n. nodes per element */
2302  0); /* number of attributes per element */
2303 
2304  EX_CHECK_ERR(this->ex_err, "Error writing element block from Nemesis.");
2305  }
2306 
2307  // Otherwise, write the actual block information and connectivity to file
2308  else
2309  {
2310  subdomain_id_type block =
2311  cast_int<subdomain_id_type>(it->first);
2312  std::vector<int> & this_block_connectivity = it->second;
2313  std::vector<dof_id_type> & elements_in_this_block = subdomain_map[block];
2314 
2315  // Use the first element in this block to get representative information.
2316  // Note that Exodus assumes all elements in a block are of the same type!
2317  // We are using that same assumption here!
2318  const auto & conv =
2319  get_conversion(mesh.elem_ref(elements_in_this_block[0]).type());
2320 
2321  this->num_nodes_per_elem =
2322  mesh.elem_ref(elements_in_this_block[0]).n_nodes();
2323 
2324  ex_err = exII::ex_put_elem_block(ex_id,
2325  block,
2326  conv.exodus_elem_type().c_str(),
2327  elements_in_this_block.size(),
2329  0);
2330  EX_CHECK_ERR(ex_err, "Error writing element block from Nemesis.");
2331 
2332  ex_err = exII::ex_put_elem_conn(ex_id,
2333  block,
2334  this_block_connectivity.data());
2335  EX_CHECK_ERR(ex_err, "Error writing element connectivities from Nemesis.");
2336  }
2337  } // end loop over global block IDs
2338 
2339  // Only call this once, not in the loop above!
2340  ex_err = exII::ex_put_elem_num_map(ex_id,
2341  exodus_elem_num_to_libmesh.empty() ? nullptr : exodus_elem_num_to_libmesh.data());
2342  EX_CHECK_ERR(ex_err, "Error writing element map");
2343 
2344  // Write the element block names to file.
2345  ex_err = exII::ex_put_names(ex_id, exII::EX_ELEM_BLOCK, names_table.get_char_star_star());
2346  EX_CHECK_ERR(ex_err, "Error writing element block names");
2347  } // end if (this->num_elem_blks_global > 0)
2348 }
std::map< subdomain_id_type, std::vector< dof_id_type > > subdomain_map
Map of subdomains to element numbers.
TestClass subdomain_id_type
Based on the 4-byte comment warning above, this probably doesn&#39;t work with exodusII at all...
Definition: id_types.h:43
std::vector< int > exodus_elem_num_to_libmesh
MeshBase & mesh
const ExodusII_IO_Helper::Conversion & get_conversion(const ElemType type) const
std::vector< int > global_elem_blk_ids
Read the global element block IDs and counts.
std::map< int, std::vector< int > > block_id_to_elem_connectivity
This is the block connectivity, i.e.
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134

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

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, 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::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::index_range(), libMesh::ExodusII_IO_Helper::num_elem_sets, libMesh::ExodusII_IO_Helper::num_elems_per_set, libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO_Helper::read_elemset(), libMesh::ExodusII_IO_Helper::read_elemset_info(), and libMesh::ExodusII_IO_Helper::write_var_names().

3888 {
3889  LOG_SCOPE("write_elemset_data()", "ExodusII_IO_Helper");
3890 
3891  if ((_run_only_on_proc0) && (this->processor_id() != 0))
3892  return;
3893 
3894  // Write the elemset variable names to file. This function should
3895  // only be called once for ELEMSET variables, repeated calls to
3896  // write_var_names() overwrites/changes the order of names that were
3897  // there previously, and will mess up any data that has already been
3898  // written.
3899  this->write_var_names(ELEMSET, var_names);
3900 
3901  // We now call the API to read the elemset info even though we are
3902  // in the middle of writing. This is a bit counter-intuitive, but it
3903  // seems to work provided that you have already written the mesh
3904  // itself... read_elemset_info() fills in the following data
3905  // members:
3906  // .) id_to_elemset_names
3907  // .) num_elems_per_set
3908  // .) num_elem_df_per_set
3909  // .) elemset_list
3910  // .) elemset_id_list
3911  // .) id_to_elemset_names
3912  this->read_elemset_info();
3913 
3914  // The "truth" table for elemset variables. elemset_var_tab is a
3915  // logically (num_elem_sets x num_elemset_vars) integer array of 0s and
3916  // 1s indicating which elemsets a given elemset variable is defined
3917  // on.
3918  std::vector<int> elemset_var_tab(num_elem_sets * var_names.size());
3919 
3920  int offset=0;
3921  for (int es=0; es<num_elem_sets; ++es)
3922  {
3923  // Debugging
3924  // libMesh::out << "Writing elemset variable values for elemset "
3925  // << es << ", elemset_id = " << elemset_ids[es]
3926  // << std::endl;
3927 
3928  // We know num_elems_per_set because we called read_elemset_info() above.
3929  offset += (es > 0 ? num_elems_per_set[es-1] : 0);
3930  this->read_elemset(es, offset);
3931 
3932  // For each variable in var_names, write the values for the
3933  // current elemset, if any.
3934  for (auto var : index_range(var_names))
3935  {
3936  // Debugging
3937  // libMesh::out << "Writing elemset variable values for var " << var << std::endl;
3938 
3939  // If this var has no values on this elemset, go to the next one.
3940  if (!elemset_ids_in[var].count(elemset_ids[es]))
3941  continue;
3942 
3943  // Otherwise, fill in this entry of the nodeset truth table.
3944  elemset_var_tab[es*var_names.size() + var] = 1;
3945 
3946  // Data vector that will eventually be passed to exII::ex_put_var().
3947  std::vector<Real> elemset_var_vals(num_elems_per_set[es]);
3948 
3949  // Get reference to the (elem_id, elemset_id) -> Real map for this variable.
3950  const auto & data_map = elemset_vals[var];
3951 
3952  // Loop over entries in current elemset.
3953  for (int i=0; i<num_elems_per_set[es]; ++i)
3954  {
3955  // Here we convert Exodus elem ids to libMesh node ids
3956  // simply by subtracting 1. We should probably use the
3957  // exodus_elem_num_to_libmesh data structure for this,
3958  // but I don't think it is set up at the time when this
3959  // function is normally called.
3960  dof_id_type libmesh_elem_id = elemset_list[i + offset] - 1;
3961 
3962  // Construct a key to look up values in data_map.
3963  std::pair<dof_id_type, elemset_id_type> key =
3964  std::make_pair(libmesh_elem_id, elemset_ids[es]);
3965 
3966  // Debugging:
3967  // libMesh::out << "Searching for key = (" << key.first << ", " << key.second << ")" << std::endl;
3968 
3969  // We require that the user provided either no values for
3970  // this (var, elemset) combination (in which case we don't
3971  // reach this point) or a value for _every_ elem in this
3972  // elemset for this var, so we use the libmesh_map_find()
3973  // macro to check for this.
3974  elemset_var_vals[i] = libmesh_map_find(data_map, key);
3975  } // end for (node in nodeset[ns])
3976 
3977  // Write elemset values to Exodus file
3978  if (elemset_var_vals.size() > 0)
3979  {
3980  ex_err = exII::ex_put_var
3981  (ex_id,
3982  timestep,
3983  exII::EX_ELEM_SET,
3984  var + 1, // 1-based variable index of current variable
3985  elemset_ids[es],
3986  num_elems_per_set[es],
3987  MappedOutputVector(elemset_var_vals, _single_precision).data());
3988  EX_CHECK_ERR(ex_err, "Error writing elemset vars.");
3989  }
3990  } // end for (var in var_names)
3991  } // end for (ns)
3992 
3993  // Finally, write the elemset truth table to file.
3994  ex_err =
3995  exII::ex_put_truth_table(ex_id,
3996  exII::EX_ELEM_SET, // exII::ex_entity_type
3997  num_elem_sets,
3998  cast_int<int>(var_names.size()),
3999  elemset_var_tab.data());
4000  EX_CHECK_ERR(ex_err, "Error writing elemset var truth table.");
4001 }
std::vector< int > num_elems_per_set
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().
void read_elemset(int id, int offset)
Reads information about elemset id and inserts it into the global elemset array at the position offse...
void read_elemset_info()
Reads information about all of the elemsets in the ExodusII mesh file.
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
uint8_t dof_id_type
Definition: id_types.h:67

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

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

3391 {
3392  LOG_SCOPE("write_elemsets()", "ExodusII_IO_Helper");
3393 
3394  if ((_run_only_on_proc0) && (this->processor_id() != 0))
3395  return;
3396 
3397  // TODO: Add support for named elemsets
3398  // NamesData names_table(elemsets.size(), MAX_STR_LENGTH);
3399 
3400  // We only need to write elemsets if the Mesh has an extra elem
3401  // integer called "elemset_code" defined on it.
3402  if (mesh.has_elem_integer("elemset_code"))
3403  {
3404  std::map<elemset_id_type, std::vector<int>> exodus_elemsets;
3405 
3406  unsigned int elemset_index =
3407  mesh.get_elem_integer_index("elemset_code");
3408 
3409  // Catch ids returned from MeshBase::get_elemsets() calls
3410  MeshBase::elemset_type set_ids;
3411  for (const auto & elem : mesh.element_ptr_range())
3412  {
3413  dof_id_type elemset_code =
3414  elem->get_extra_integer(elemset_index);
3415 
3416  // Look up which element set ids (if any) this elemset_code corresponds to.
3417  mesh.get_elemsets(elemset_code, set_ids);
3418 
3419  // Debugging
3420  // libMesh::out << "elemset_code = " << elemset_code << std::endl;
3421  // for (const auto & set_id : set_ids)
3422  // libMesh::out << set_id << " ";
3423  // libMesh::out << std::endl;
3424 
3425  // Store this Elem id in every set to which it belongs.
3426  for (const auto & set_id : set_ids)
3427  exodus_elemsets[set_id].push_back(libmesh_elem_num_to_exodus[elem->id()]);
3428  }
3429 
3430  // Debugging: print contents of exodus_elemsets map
3431  // for (const auto & [set_id, elem_ids] : exodus_elemsets)
3432  // {
3433  // libMesh::out << "elemset " << set_id << ": ";
3434  // for (const auto & elem_id : elem_ids)
3435  // libMesh::out << elem_id << " ";
3436  // libMesh::out << std::endl;
3437  // }
3438 
3439  // Only continue if we actually had some elements in sets
3440  if (!exodus_elemsets.empty())
3441  {
3442  // Reserve space, loop over newly-created map, construct
3443  // exII::ex_set objects to be passed to exII::ex_put_sets(). Note:
3444  // we do non-const iteration since Exodus requires non-const pointers
3445  // to be passed to its APIs.
3446  std::vector<exII::ex_set> sets;
3447  sets.reserve(exodus_elemsets.size());
3448 
3449  for (auto & [elem_set_id, ids_vec] : exodus_elemsets)
3450  {
3451  // TODO: Add support for named elemsets
3452  // names_table.push_back_entry(mesh.get_elemset_name(elem_set_id));
3453 
3454  exII::ex_set & current_set = sets.emplace_back();
3455  current_set.id = elem_set_id;
3456  current_set.type = exII::EX_ELEM_SET;
3457  current_set.num_entry = ids_vec.size();
3458  current_set.num_distribution_factor = 0;
3459  current_set.entry_list = ids_vec.data();
3460  current_set.extra_list = nullptr; // extra_list is used for sidesets, not needed for elemsets
3461  current_set.distribution_factor_list = nullptr; // not used for elemsets
3462  }
3463 
3464  // Sanity check: make sure the number of elemsets we already wrote to the header
3465  // matches the number of elemsets we just constructed by looping over the Mesh.
3466  libmesh_assert_msg(num_elem_sets == cast_int<int>(exodus_elemsets.size()),
3467  "Mesh has " << exodus_elemsets.size()
3468  << " elemsets, but header was written with num_elem_sets == " << num_elem_sets);
3469  libmesh_assert_msg(num_elem_sets == cast_int<int>(mesh.n_elemsets()),
3470  "mesh.n_elemsets() == " << mesh.n_elemsets()
3471  << ", but header was written with num_elem_sets == " << num_elem_sets);
3472 
3473  ex_err = exII::ex_put_sets(ex_id, exodus_elemsets.size(), sets.data());
3474  EX_CHECK_ERR(ex_err, "Error writing elemsets");
3475 
3476  // TODO: Add support for named elemsets
3477  // ex_err = exII::ex_put_names(ex_id, exII::EX_ELEM_SET, names_table.get_char_star_star());
3478  // EX_CHECK_ERR(ex_err, "Error writing elemset names");
3479  } // end if (!exodus_elemsets.empty())
3480  } // end if (mesh.has_elem_integer("elemset_code"))
3481 }
bool has_elem_integer(std::string_view name) const
Definition: mesh_base.C:590
MeshBase & mesh
void get_elemsets(dof_id_type elemset_code, MeshBase::elemset_type &id_set_to_fill) const
Look up the element sets for a given elemset code and vice-versa.
Definition: mesh_base.C:381
unsigned int get_elem_integer_index(std::string_view name) const
Definition: mesh_base.C:578
unsigned int n_elemsets() const
Returns the number of unique elemset ids which have been added via add_elemset_code(), which is the size of the _all_elemset_ids set.
Definition: mesh_base.C:376
std::map< dof_id_type, dof_id_type > libmesh_elem_num_to_exodus
std::set< elemset_id_type > elemset_type
Typedef for the "set" container used to store elemset ids.
Definition: mesh_base.h:297
processor_id_type processor_id() const
uint8_t dof_id_type
Definition: id_types.h:67

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

References distance(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, global_nodeset_ids, global_sideset_ids, libMesh::ExodusII_IO_Helper::num_dim, libMesh::ExodusII_IO_Helper::num_elem, libMesh::ExodusII_IO_Helper::num_elem_blk, num_elem_blks_global, libMesh::ExodusII_IO_Helper::num_node_sets, libMesh::ExodusII_IO_Helper::num_nodes, and libMesh::ExodusII_IO_Helper::num_side_sets.

Referenced by initialize().

902 {
903  this->num_elem = static_cast<unsigned int>(std::distance (pmesh.active_local_elements_begin(),
904  pmesh.active_local_elements_end()));
905 
906  // Exodus will also use *global* number of side and node sets,
907  // though it will not write out entries for all of them...
908  this->num_side_sets =
909  cast_int<int>(this->global_sideset_ids.size());
910  this->num_node_sets =
911  cast_int<int>(this->global_nodeset_ids.size());
912 
913  // We need to write the global number of blocks, even though this processor might not have
914  // elements in some of them!
915  this->num_elem_blk = this->num_elem_blks_global;
916 
917  ex_err = exII::ex_put_init(ex_id,
918  title_in.c_str(),
919  this->num_dim,
920  this->num_nodes,
921  this->num_elem,
922  this->num_elem_blk,
923  this->num_node_sets,
924  this->num_side_sets);
925 
926  EX_CHECK_ERR(ex_err, "Error initializing new Nemesis file.");
927 }
std::vector< int > global_nodeset_ids
Containers for reading global nodeset information.
std::vector< int > global_sideset_ids
Containers for reading global sideset (boundary conditions) information.
Real distance(const Point &p)

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

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

4592 {
4593  if ((_run_only_on_proc0) && (this->processor_id() != 0))
4594  return;
4595 
4596  if (!values.empty())
4597  {
4598  ex_err = exII::ex_put_var
4599  (ex_id,
4600  timestep,
4601  exII::EX_GLOBAL,
4602  1, // var index
4603  0, // obj_id (not used)
4605  MappedOutputVector(values, _single_precision).data());
4606 
4607  EX_CHECK_ERR(ex_err, "Error writing global values.");
4608 
4609  this->update();
4610  }
4611 }
void update()
Uses ex_update() to flush buffers to file.
processor_id_type processor_id() const

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

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

4554 {
4555  if ((_run_only_on_proc0) && (this->processor_id() != 0))
4556  return;
4557 
4558  // There may already be information records in the file (for
4559  // example, if we're appending) and in that case, according to the
4560  // Exodus documentation, writing more information records is not
4561  // supported.
4562  int num_info = inquire(*this, exII::EX_INQ_INFO, "Error retrieving the number of information records from file!");
4563  if (num_info > 0)
4564  {
4565  libMesh::err << "Warning! The Exodus file already contains information records.\n"
4566  << "Exodus does not support writing additional records in this situation."
4567  << std::endl;
4568  return;
4569  }
4570 
4571  int num_records = cast_int<int>(records.size());
4572 
4573  if (num_records > 0)
4574  {
4575  NamesData info(num_records, MAX_LINE_LENGTH);
4576 
4577  // If an entry is longer than MAX_LINE_LENGTH characters it's not an error, we just
4578  // write the first MAX_LINE_LENGTH characters to the file.
4579  for (const auto & record : records)
4580  info.push_back_entry(record);
4581 
4582  ex_err = exII::ex_put_info(ex_id, num_records, info.get_char_star_star());
4583  EX_CHECK_ERR(ex_err, "Error writing global values.");
4584 
4585  this->update();
4586  }
4587 }
OStreamProxy err
MPI_Info info
void update()
Uses ex_update() to flush buffers to file.
processor_id_type processor_id() const

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

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

2211 {
2212  auto local_num_nodes = this->exodus_node_num_to_libmesh.size();
2213 
2214  x.resize(local_num_nodes);
2215  y.resize(local_num_nodes);
2216  z.resize(local_num_nodes);
2217 
2218  // Just loop over our list outputting the nodes the way we built the map
2219  for (auto i : make_range(local_num_nodes))
2220  {
2221  const Point & pt = mesh.point(this->exodus_node_num_to_libmesh[i]-1);
2222  x[i]=pt(0);
2223  y[i]=pt(1);
2224  z[i]=pt(2);
2225  }
2226 
2227  if (local_num_nodes)
2228  {
2229  if (_single_precision)
2230  {
2231  std::vector<float>
2232  x_single(x.begin(), x.end()),
2233  y_single(y.begin(), y.end()),
2234  z_single(z.begin(), z.end());
2235 
2236  ex_err = exII::ex_put_coord(ex_id,
2237  x_single.data(),
2238  y_single.data(),
2239  z_single.data());
2240  }
2241  else
2242  {
2243  // Call Exodus API to write nodal coordinates...
2244  ex_err = exII::ex_put_coord(ex_id,
2245  x.data(),
2246  y.data(),
2247  z.data());
2248  }
2249  EX_CHECK_ERR(ex_err, "Error writing node coordinates");
2250 
2251  // And write the nodal map we created for them
2252  ex_err = exII::ex_put_node_num_map(ex_id, this->exodus_node_num_to_libmesh.data());
2253  EX_CHECK_ERR(ex_err, "Error writing node num map");
2254  }
2255  else // Does the Exodus API want us to write empty nodal coordinates?
2256  {
2257  ex_err = exII::ex_put_coord(ex_id, nullptr, nullptr, nullptr);
2258  EX_CHECK_ERR(ex_err, "Error writing empty node coordinates");
2259 
2260  ex_err = exII::ex_put_node_num_map(ex_id, nullptr);
2261  EX_CHECK_ERR(ex_err, "Error writing empty node num map");
2262  }
2263 }
MeshBase & mesh
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:134
std::vector< int > exodus_node_num_to_libmesh

◆ write_nodal_solution() [1/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
namesA vector containing the names of all variables in parallel_soln.
timestepTo be passed to the ExodusII_IO_Helper::write_nodal_values() function.
output_namesA 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 2392 of file nemesis_io_helper.C.

References std::abs(), distance(), 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().

2396 {
2397  int num_vars = cast_int<int>(names.size());
2398 
2399  for (int c=0; c<num_vars; c++)
2400  {
2401  // Find the position of names[c] in the output_names vector, if it exists.
2402  auto pos = std::find(output_names.begin(), output_names.end(), names[c]);
2403 
2404  // Skip names[c] if it's not supposed to be output.
2405  if (pos == output_names.end())
2406  continue;
2407 
2408  // Compute the (zero-based) index which determines which
2409  // variable this will be as far as Nemesis is concerned. This
2410  // will be used below in the write_nodal_values() call.
2411  int variable_name_position =
2412  cast_int<int>(std::distance(output_names.begin(), pos));
2413 
2414  // Fill up a std::vector with the dofs for the current variable
2415  std::vector<numeric_index_type> required_indices(this->num_nodes);
2416 
2417  for (int i=0; i<this->num_nodes; i++)
2418  required_indices[i] = static_cast<dof_id_type>(this->exodus_node_num_to_libmesh[i]-1) * num_vars + c;
2419 
2420  // Get the dof values required to write just our local part of
2421  // the solution vector.
2422  std::vector<Number> local_soln;
2423  parallel_soln.localize(local_soln, required_indices);
2424 
2425 #ifndef LIBMESH_USE_COMPLEX_NUMBERS
2426  // Call the ExodusII_IO_Helper function to write the data.
2427  write_nodal_values(variable_name_position + 1, local_soln, timestep);
2428 #else
2429  // We have the local (complex) values. Now extract the real,
2430  // imaginary, and magnitude values from them.
2431  std::vector<Real> real_parts(num_nodes);
2432  std::vector<Real> imag_parts(num_nodes);
2433  std::vector<Real> magnitudes(num_nodes);
2434 
2435  for (int i=0; i<num_nodes; ++i)
2436  {
2437  real_parts[i] = local_soln[i].real();
2438  imag_parts[i] = local_soln[i].imag();
2439  magnitudes[i] = std::abs(local_soln[i]);
2440  }
2441 
2442  // Write the real, imaginary, and magnitude values to file.
2443  write_nodal_values(3 * variable_name_position + 1, real_parts, timestep);
2444  write_nodal_values(3 * variable_name_position + 2, imag_parts, timestep);
2445  write_nodal_values(3 * variable_name_position + 3, magnitudes, timestep);
2446 #endif
2447  }
2448 }
void write_nodal_values(int var_id, const std::vector< Real > &values, int timestep)
Writes the vector of values to a nodal variable.
Real distance(const Point &p)
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:57
std::vector< int > exodus_node_num_to_libmesh
virtual void localize(std::vector< T > &v_local) const =0
Creates a copy of the global vector in the local vector v_local.

◆ write_nodal_solution() [2/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 2452 of file nemesis_io_helper.C.

References std::abs(), libMesh::Variable::active_on_subdomain(), libMesh::System::current_local_solution, distance(), 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::Quality::name(), 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().

2456 {
2457  const MeshBase & mesh = es.get_mesh();
2458 
2459  // FIXME - half this code might be replaceable with a call to
2460  // EquationSystems::build_parallel_solution_vector()...
2461 
2462  for (auto [sys_num, var] : var_nums)
2463  {
2464  const System & sys = es.get_system(sys_num);
2465  const std::string & name = sys.variable_name(var);
2466 
2467  auto pos = std::find(output_names.begin(), output_names.end(), name);
2468 
2469  // Skip this name if it's not supposed to be output.
2470  if (pos == output_names.end())
2471  continue;
2472 
2473  // Compute the (zero-based) index which determines which
2474  // variable this will be as far as Nemesis is concerned. This
2475  // will be used below in the write_nodal_values() call.
2476  int variable_name_position =
2477  cast_int<int>(std::distance(output_names.begin(), pos));
2478 
2479  // Fill up a std::vector with the dofs for the current variable
2480  std::vector<numeric_index_type> required_indices(this->num_nodes);
2481 
2482  // Get the dof values required to write just our local part of
2483  // the solution vector.
2484  std::vector<Number> local_soln;
2485 
2486  const FEType type = sys.variable_type(var);
2487  if (type.family == SCALAR)
2488  {
2489  std::vector<numeric_index_type> scalar_indices;
2490  sys.get_dof_map().SCALAR_dof_indices(scalar_indices, var);
2491  for (int i=0; i<this->num_nodes; i++)
2492  required_indices[i] = scalar_indices[0];
2493  sys.current_local_solution->get(required_indices, local_soln);
2494  }
2495  else
2496  {
2497  // If we have DoFs at all nodes, e.g. for isoparametric
2498  // elements, this is easy:
2499  bool found_all_indices = true;
2500  for (int i=0; i<this->num_nodes; i++)
2501  {
2502  const Node & node = mesh.node_ref(this->exodus_node_num_to_libmesh[i]-1);
2503  if (node.n_comp(sys_num, var))
2504  required_indices[i] = node.dof_number(sys_num, var, 0);
2505  else
2506  {
2507  found_all_indices = false;
2508  break;
2509  }
2510  }
2511 
2512  if (found_all_indices)
2513  sys.current_local_solution->get(required_indices, local_soln);
2514  // Fine, we'll do it the hard way
2515  if (!found_all_indices)
2516  {
2517  local_soln.resize(num_nodes);
2518 
2519  const Variable & var_description = sys.variable(var);
2520  const DofMap & dof_map = sys.get_dof_map();
2521 
2522  NumericVector<Number> & sys_soln(*sys.current_local_solution);
2523  std::vector<Number> elem_soln; // The finite element solution
2524  std::vector<Number> nodal_soln; // The FE solution interpolated to the nodes
2525  std::vector<dof_id_type> dof_indices; // The DOF indices for the finite element
2526 
2527  for (const auto & elem : mesh.active_local_element_ptr_range())
2528  if (var_description.active_on_subdomain(elem->subdomain_id()))
2529  {
2530  dof_map.dof_indices (elem, dof_indices, var);
2531  elem_soln.resize(dof_indices.size());
2532 
2533  for (auto i : index_range(dof_indices))
2534  elem_soln[i] = sys_soln(dof_indices[i]);
2535 
2536  FEInterface::nodal_soln (elem->dim(),
2537  type,
2538  elem,
2539  elem_soln,
2540  nodal_soln);
2541 
2542  // infinite elements should be skipped...
2543  if (!elem->infinite())
2544  for (auto n : elem->node_index_range())
2545  {
2546  const std::size_t exodus_num =
2547  libmesh_node_num_to_exodus[elem->node_id(n)];
2548  libmesh_assert_greater(exodus_num, 0);
2549  libmesh_assert_less(exodus_num-1, local_soln.size());
2550  local_soln[exodus_num-1] = nodal_soln[n];
2551  }
2552  }
2553  }
2554  }
2555 
2556 #ifndef LIBMESH_USE_COMPLEX_NUMBERS
2557  // Call the ExodusII_IO_Helper function to write the data.
2558  write_nodal_values(variable_name_position + 1, local_soln, timestep);
2559 #else
2560  // We have the local (complex) values. Now extract the real,
2561  // imaginary, and magnitude values from them.
2562  std::vector<Real> real_parts(num_nodes);
2563  std::vector<Real> imag_parts(num_nodes);
2564  std::vector<Real> magnitudes(num_nodes);
2565 
2566  for (int i=0; i<num_nodes; ++i)
2567  {
2568  real_parts[i] = local_soln[i].real();
2569  imag_parts[i] = local_soln[i].imag();
2570  magnitudes[i] = std::abs(local_soln[i]);
2571  }
2572 
2573  // Write the real, imaginary, and magnitude values to file.
2574  write_nodal_values(3 * variable_name_position + 1, real_parts, timestep);
2575  write_nodal_values(3 * variable_name_position + 2, imag_parts, timestep);
2576  write_nodal_values(3 * variable_name_position + 3, magnitudes, timestep);
2577 #endif
2578  }
2579 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
MeshBase & mesh
void write_nodal_values(int var_id, const std::vector< Real > &values, int timestep)
Writes the vector of values to a nodal variable.
Real distance(const Point &p)
std::map< dof_id_type, dof_id_type > libmesh_node_num_to_exodus
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:57
static void nodal_soln(const unsigned int dim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln, bool add_p_level=true)
Build the nodal soln from the element soln.
Definition: fe_interface.C:868
std::vector< int > exodus_node_num_to_libmesh
template class LIBMESH_EXPORT NumericVector< Number >
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111

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

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

2357 {
2358  int num_vars = cast_int<int>(names.size());
2359  //int num_values = values.size(); // Not used?
2360 
2361  for (int c=0; c<num_vars; c++)
2362  {
2363 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
2364  std::vector<Real> real_parts(num_nodes);
2365  std::vector<Real> imag_parts(num_nodes);
2366  std::vector<Real> magnitudes(num_nodes);
2367 
2368  for (int i=0; i<num_nodes; ++i)
2369  {
2370  Number value = values[(this->exodus_node_num_to_libmesh[i]-1)*num_vars + c];
2371  real_parts[i] = value.real();
2372  imag_parts[i] = value.imag();
2373  magnitudes[i] = std::abs(value);
2374  }
2375  write_nodal_values(3*c+1,real_parts,timestep);
2376  write_nodal_values(3*c+2,imag_parts,timestep);
2377  write_nodal_values(3*c+3,magnitudes,timestep);
2378 #else
2379  std::vector<Number> cur_soln(this->num_nodes);
2380 
2381  // Copy out this variable's solution
2382  for (int i=0; i<this->num_nodes; i++)
2383  cur_soln[i] = values[(this->exodus_node_num_to_libmesh[i]-1)*num_vars + c];
2384 
2385  write_nodal_values(c+1,cur_soln,timestep);
2386 #endif
2387  }
2388 }
void write_nodal_values(int var_id, const std::vector< Real > &values, int timestep)
Writes the vector of values to a nodal variable.
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
Definition: type_vector.h:57
static const bool value
Definition: xdr_io.C:54
std::vector< int > exodus_node_num_to_libmesh

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

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

4528 {
4529  if ((_run_only_on_proc0) && (this->processor_id() != 0))
4530  return;
4531 
4532  if (!values.empty())
4533  {
4534  libmesh_assert_equal_to(values.size(), std::size_t(num_nodes));
4535 
4536  ex_err = exII::ex_put_var
4537  (ex_id,
4538  timestep,
4539  exII::EX_NODAL,
4540  var_id,
4541  1, // exII::ex_entity_id, not sure exactly what this is but in the ex_put_nodal_var.c shim, they pass 1
4542  num_nodes,
4543  MappedOutputVector(values, _single_precision).data());
4544 
4545  EX_CHECK_ERR(ex_err, "Error writing nodal values.");
4546 
4547  this->update();
4548  }
4549 }
void update()
Uses ex_update() to flush buffers to file.
processor_id_type processor_id() const

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

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::index_range(), libMesh::ExodusII_IO_Helper::node_sets_node_index, libMesh::ExodusII_IO_Helper::node_sets_node_list, libMesh::ExodusII_IO_Helper::NODESET, libMesh::ExodusII_IO_Helper::nodeset_ids, libMesh::ExodusII_IO_Helper::num_node_sets, libMesh::ExodusII_IO_Helper::num_nodes_per_set, libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO_Helper::read_all_nodesets(), and libMesh::ExodusII_IO_Helper::write_var_names().

3783 {
3784  LOG_SCOPE("write_nodeset_data()", "ExodusII_IO_Helper");
3785 
3786  if ((_run_only_on_proc0) && (this->processor_id() != 0))
3787  return;
3788 
3789  // Write the nodeset variable names to file. This function should
3790  // only be called once for NODESET variables, repeated calls to
3791  // write_var_names() overwrites/changes the order of names that were
3792  // there previously, and will mess up any data that has already been
3793  // written.
3794  this->write_var_names(NODESET, var_names);
3795 
3796  // For all nodesets, reads and fills in the arrays:
3797  // nodeset_ids
3798  // num_nodes_per_set
3799  // node_sets_node_index - starting index for each nodeset in the node_sets_node_list vector
3800  // node_sets_node_list
3801  // Note: we need these arrays so that we know what data to write
3802  this->read_all_nodesets();
3803 
3804  // The "truth" table for nodeset variables. nset_var_tab is a
3805  // logically (num_node_sets x num_nset_var) integer array of 0s and
3806  // 1s indicating which nodesets a given nodeset variable is defined
3807  // on.
3808  std::vector<int> nset_var_tab(num_node_sets * var_names.size());
3809 
3810  for (int ns=0; ns<num_node_sets; ++ns)
3811  {
3812  // The offset into the node_sets_node_list for the current nodeset
3813  int offset = node_sets_node_index[ns];
3814 
3815  // For each variable in var_names, write the values for the
3816  // current nodeset, if any.
3817  for (auto var : index_range(var_names))
3818  {
3819  // If this var has no values on this nodeset, go to the next one.
3820  if (!node_boundary_ids[var].count(nodeset_ids[ns]))
3821  continue;
3822 
3823  // Otherwise, fill in this entry of the nodeset truth table.
3824  nset_var_tab[ns*var_names.size() + var] = 1;
3825 
3826  // Data vector that will eventually be passed to exII::ex_put_var().
3827  std::vector<Real> nset_var_vals(num_nodes_per_set[ns]);
3828 
3829  // Get reference to the NodeBCTuple -> Real map for this variable.
3830  const auto & data_map = bc_vals[var];
3831 
3832  // Loop over entries in current nodeset.
3833  for (int i=0; i<num_nodes_per_set[ns]; ++i)
3834  {
3835  // Here we convert Exodus node ids to libMesh node ids by
3836  // subtracting 1. We should probably use the
3837  // exodus_node_num_to_libmesh data structure for this, but
3838  // I don't think it is set up at the time when
3839  // write_nodeset_data() would normally be called.
3840  dof_id_type libmesh_node_id = node_sets_node_list[i + offset] - 1;
3841 
3842  // Construct a key to look up values in data_map.
3844  std::make_tuple(libmesh_node_id, nodeset_ids[ns]);
3845 
3846  // We require that the user provided either no values for
3847  // this (var, nodeset) combination (in which case we don't
3848  // reach this point) or a value for _every_ node in this
3849  // nodeset for this var, so we use the libmesh_map_find()
3850  // macro to check for this.
3851  nset_var_vals[i] = libmesh_map_find(data_map, key);
3852  } // end for (node in nodeset[ns])
3853 
3854  // Write nodeset values to Exodus file
3855  if (nset_var_vals.size() > 0)
3856  {
3857  ex_err = exII::ex_put_var
3858  (ex_id,
3859  timestep,
3860  exII::EX_NODE_SET,
3861  var + 1, // 1-based variable index of current variable
3862  nodeset_ids[ns],
3863  num_nodes_per_set[ns],
3864  MappedOutputVector(nset_var_vals, _single_precision).data());
3865  EX_CHECK_ERR(ex_err, "Error writing nodeset vars.");
3866  }
3867  } // end for (var in var_names)
3868  } // end for (ns)
3869 
3870  // Finally, write the nodeset truth table.
3871  ex_err =
3872  exII::ex_put_truth_table(ex_id,
3873  exII::EX_NODE_SET,
3874  num_node_sets,
3875  cast_int<int>(var_names.size()),
3876  nset_var_tab.data());
3877  EX_CHECK_ERR(ex_err, "Error writing nodeset var truth table.");
3878 }
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().
std::vector< int > node_sets_node_index
std::tuple< dof_id_type, boundary_id_type > NodeBCTuple
As above, but the library creates and fills in a vector of (node-id, bc-id) pairs and returns it to t...
void read_all_nodesets()
New API that reads all nodesets simultaneously.
std::vector< int > node_sets_node_list
std::vector< int > num_nodes_per_set
processor_id_type processor_id() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
uint8_t dof_id_type
Definition: id_types.h:67

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

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

1916 {
1917  // Write the nodesets. In Nemesis, the idea is to "create space" for the global
1918  // set of boundary nodesets, but to only write node IDs which are local to the current
1919  // processor. This is what is done in Nemesis files created by the "loadbal" script.
1920 
1921  // Store a map of vectors for boundary node IDs on this processor.
1922  // Use a vector of int here so it can be passed directly to Exodus.
1923  std::map<boundary_id_type, std::vector<int>> local_node_boundary_id_lists;
1924 
1925  // FIXME: We should build this list only one time!! We already built it above, but we
1926  // did not have the libmesh to exodus node mapping at that time... for now we'll just
1927  // build it here again, hopefully it's small relative to the size of the entire mesh.
1928 
1929  // Build list of (node-id, bc-id) tuples.
1930  typedef std::tuple<dof_id_type, boundary_id_type> Tuple;
1931  std::vector<Tuple> bc_tuples = mesh.get_boundary_info().build_node_list();
1932 
1933  if (verbose)
1934  {
1935  libMesh::out << "[" << this->processor_id() << "] boundary_node_list.size()="
1936  << bc_tuples.size() << std::endl;
1937  libMesh::out << "[" << this->processor_id() << "] (boundary_node_id, boundary_id) = ";
1938  for (const auto & t : bc_tuples)
1939  libMesh::out << "(" << std::get<0>(t) << ", " << std::get<1>(t) << ") ";
1940  libMesh::out << std::endl;
1941  }
1942 
1943  // For each node in the node list, add it to the vector of node IDs for that
1944  // set for the local processor. This will be used later when writing Exodus
1945  // nodesets.
1946  for (const auto & t : bc_tuples)
1947  {
1948  // Don't try to grab a reference to the vector unless the current node is attached
1949  // to a local element. Otherwise, another processor will be responsible for writing it in its nodeset.
1950  const auto it = this->libmesh_node_num_to_exodus.find(std::get<0>(t));
1951 
1952  if (it != this->libmesh_node_num_to_exodus.end())
1953  {
1954  // Get reference to the vector where this node ID will be inserted. If it
1955  // doesn't yet exist, this will create it.
1956  std::vector<int> & current_id_set = local_node_boundary_id_lists[std::get<1>(t)];
1957 
1958  // Push back Exodus-mapped node ID for this set
1959  // TODO: reserve space in these vectors somehow.
1960  current_id_set.push_back( it->second );
1961  }
1962  }
1963 
1964  // See what we got
1965  if (verbose)
1966  {
1967  for (const auto & [bndry_id, set] : local_node_boundary_id_lists)
1968  {
1969  libMesh::out << "[" << this->processor_id() << "] ID: " << bndry_id << ", ";
1970 
1971  // Libmesh node ID (Exodus Node ID)
1972  for (const auto & id : set)
1973  libMesh::out << id << ", ";
1974  libMesh::out << std::endl;
1975  }
1976  }
1977 
1978  // Loop over *global* nodeset IDs, call the Exodus API. Note that some nodesets may be empty
1979  // for a given processor.
1980  if (global_nodeset_ids.size() > 0)
1981  {
1982  NamesData names_table(global_nodeset_ids.size(), MAX_STR_LENGTH);
1983 
1984  for (const auto & nodeset_id : this->global_nodeset_ids)
1985  {
1986  const std::string & current_ns_name =
1987  mesh.get_boundary_info().get_nodeset_name
1988  (cast_int<boundary_id_type>(nodeset_id));
1989 
1990  // Store this name in a data structure that will be used to
1991  // write sideset names to file.
1992  names_table.push_back_entry(current_ns_name);
1993 
1994  if (verbose)
1995  {
1996  libMesh::out << "[" << this->processor_id()
1997  << "] Writing out Exodus nodeset info for ID: " << nodeset_id
1998  << ", Name: " << current_ns_name
1999  << std::endl;
2000  }
2001 
2002  // Convert current global_nodeset_id into an exodus ID, which can't be zero...
2003  int exodus_id = nodeset_id;
2004 
2005  /*
2006  // Exodus can't handle zero nodeset IDs (?) Use max short here since
2007  // when libmesh reads it back in, it will want to store it as a short...
2008  if (exodus_id==0)
2009  exodus_id = std::numeric_limits<short>::max();
2010  */
2011 
2012  // Try to find this boundary ID in the local list we created
2013  auto it =
2014  local_node_boundary_id_lists.find (cast_int<boundary_id_type>(nodeset_id));
2015 
2016  // No nodes found for this boundary ID on this processor
2017  if (it == local_node_boundary_id_lists.end())
2018  {
2019  if (verbose)
2020  libMesh::out << "[" << this->processor_id()
2021  << "] No nodeset data for ID: " << nodeset_id
2022  << " on this processor." << std::endl;
2023 
2024  // Call the Exodus interface to write the parameters of this node set
2025  this->ex_err = exII::ex_put_node_set_param(this->ex_id,
2026  exodus_id,
2027  0, /* No nodes for this ID */
2028  0 /* No distribution factors */);
2029  EX_CHECK_ERR(this->ex_err, "Error writing nodeset parameters in Nemesis");
2030 
2031  }
2032  else // Boundary ID *was* found in list
2033  {
2034  // Get reference to the vector of node IDs
2035  std::vector<int> & current_nodeset_ids = it->second;
2036 
2037  // Call the Exodus interface to write the parameters of this node set
2038  this->ex_err = exII::ex_put_node_set_param(this->ex_id,
2039  exodus_id,
2040  current_nodeset_ids.size(),
2041  0 /* No distribution factors */);
2042 
2043  EX_CHECK_ERR(this->ex_err, "Error writing nodeset parameters in Nemesis");
2044 
2045  // Call Exodus interface to write the actual node IDs for this boundary ID
2046  this->ex_err = exII::ex_put_node_set(this->ex_id,
2047  exodus_id,
2048  current_nodeset_ids.data());
2049 
2050  EX_CHECK_ERR(this->ex_err, "Error writing nodesets in Nemesis");
2051 
2052  }
2053  } // end loop over global nodeset IDs
2054 
2055  // Write out the nodeset names
2056  ex_err = exII::ex_put_names(ex_id,
2057  exII::EX_NODE_SET,
2058  names_table.get_char_star_star());
2059  EX_CHECK_ERR(ex_err, "Error writing nodeset names");
2060  } // end for loop over global nodeset IDs
2061 }
std::vector< int > global_nodeset_ids
Containers for reading global nodeset information.
MeshBase & mesh
std::map< dof_id_type, dof_id_type > libmesh_node_num_to_exodus
OStreamProxy out
processor_id_type processor_id() const

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

References libMesh::ExodusII_IO_Helper::_run_only_on_proc0, libMesh::ExodusII_IO_Helper::_single_precision, libMesh::ExodusII_IO_Helper::elem_list, libMesh::MeshBase::elem_ptr(), libMesh::ExodusII_IO_Helper::ex_err, libMesh::ExodusII_IO_Helper::ex_id, libMesh::ExodusII_IO_Helper::get_conversion(), libMesh::ExodusII_IO_Helper::Conversion::get_side_map(), libMesh::index_range(), libMesh::ExodusII_IO_Helper::libmesh_elem_num_to_exodus, mesh, libMesh::ExodusII_IO_Helper::num_side_sets, libMesh::ExodusII_IO_Helper::num_sides_per_set, libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO_Helper::read_sideset(), libMesh::ExodusII_IO_Helper::read_sideset_info(), side_id, libMesh::ExodusII_IO_Helper::side_list, libMesh::ExodusII_IO_Helper::SIDESET, libMesh::ExodusII_IO_Helper::ss_ids, libMesh::Elem::type(), and libMesh::ExodusII_IO_Helper::write_var_names().

3492 {
3493  LOG_SCOPE("write_sideset_data()", "ExodusII_IO_Helper");
3494 
3495  if ((_run_only_on_proc0) && (this->processor_id() != 0))
3496  return;
3497 
3498  // Write the sideset variable names to file. This function should
3499  // only be called once for SIDESET variables, repeated calls to
3500  // write_var_names overwrites/changes the order of names that were
3501  // there previously, and will mess up any data that has already been
3502  // written.
3503  this->write_var_names(SIDESET, var_names);
3504 
3505  // I hope that we are allowed to call read_sideset_info() even
3506  // though we are in the middle of writing? It seems to work provided
3507  // that you have already written the mesh itself... read_sideset_info()
3508  // fills in the following data members:
3509  // .) num_side_sets
3510  // .) ss_ids
3511  this->read_sideset_info();
3512 
3513  // Write "truth" table for sideset variables. The function
3514  // exII::ex_put_variable_param() must be called before
3515  // exII::ex_put_truth_table(). For us, this happens during the call
3516  // to ExodusII_IO_Helper::write_var_names(). sset_var_tab is a logically
3517  // (num_side_sets x num_sset_var) integer array of 0s and 1s
3518  // indicating which sidesets a given sideset variable is defined on.
3519  std::vector<int> sset_var_tab(num_side_sets * var_names.size());
3520 
3521  // We now call read_sideset() once per sideset and write any sideset
3522  // variable values which are defined there.
3523  int offset=0;
3524  for (int ss=0; ss<num_side_sets; ++ss)
3525  {
3526  // We don't know num_sides_per_set for each set until we call
3527  // read_sideset(). The values for each sideset are stored (using
3528  // the offsets) into the 'elem_list' and 'side_list' arrays of
3529  // this class.
3530  offset += (ss > 0 ? num_sides_per_set[ss-1] : 0);
3531  this->read_sideset(ss, offset);
3532 
3533  // For each variable in var_names, write the values for the
3534  // current sideset, if any.
3535  for (auto var : index_range(var_names))
3536  {
3537  // If this var has no values on this sideset, go to the next one.
3538  if (!side_ids[var].count(ss_ids[ss]))
3539  continue;
3540 
3541  // Otherwise, fill in this entry of the sideset truth table.
3542  sset_var_tab[ss*var_names.size() + var] = 1;
3543 
3544  // Data vector that will eventually be passed to exII::ex_put_var().
3545  std::vector<Real> sset_var_vals(num_sides_per_set[ss]);
3546 
3547  // Get reference to the BCTuple -> Real map for this variable.
3548  const auto & data_map = bc_vals[var];
3549 
3550  // Loop over elem_list, side_list entries in current sideset.
3551  for (int i=0; i<num_sides_per_set[ss]; ++i)
3552  {
3553  // Get elem_id and side_id from the respective lists that
3554  // are filled in by calling read_sideset().
3555  //
3556  // Note: these are Exodus-specific ids, so we have to convert them
3557  // to libmesh ids, as that is what will be in the bc_tuples.
3558  //
3559  // TODO: we should probably consult the exodus_elem_num_to_libmesh
3560  // mapping in order to figure out which libmesh element id 'elem_id'
3561  // actually corresponds to here, instead of just assuming it will be
3562  // off by one. Unfortunately that data structure does not seem to
3563  // be used at the moment. If we assume that write_sideset_data() is
3564  // always called following write(), then this should be a fairly safe
3565  // assumption...
3566  dof_id_type elem_id = elem_list[i + offset] - 1;
3567  unsigned int side_id = side_list[i + offset] - 1;
3568 
3569  // Sanity check: make sure that the "off by one"
3570  // assumption we used above to set 'elem_id' is valid.
3571  libmesh_error_msg_if
3572  (libmesh_map_find(libmesh_elem_num_to_exodus, cast_int<int>(elem_id)) !=
3573  cast_int<dof_id_type>(elem_list[i + offset]),
3574  "Error mapping Exodus elem id to libmesh elem id.");
3575 
3576  // Map from Exodus side ids to libmesh side ids.
3577  const auto & conv = get_conversion(mesh.elem_ptr(elem_id)->type());
3578 
3579  // Map from Exodus side ids to libmesh side ids.
3580  unsigned int converted_side_id = conv.get_side_map(side_id);
3581 
3582  // Construct a key so we can quickly see whether there is any
3583  // data for this variable in the map.
3584  BoundaryInfo::BCTuple key = std::make_tuple
3585  (elem_id,
3586  converted_side_id,
3587  ss_ids[ss]);
3588 
3589  // Find the data for this (elem,side,id) tuple. Throw an
3590  // error if not found. Then store value in vector which
3591  // will be passed to Exodus.
3592  sset_var_vals[i] = libmesh_map_find(data_map, key);
3593  } // end for (i)
3594 
3595  // As far as I can tell, there is no "concat" version of writing
3596  // sideset data, you have to call ex_put_sset_var() once per (variable,
3597  // sideset) pair.
3598  if (sset_var_vals.size() > 0)
3599  {
3600  ex_err = exII::ex_put_var
3601  (ex_id,
3602  timestep,
3603  exII::EX_SIDE_SET,
3604  var + 1, // 1-based variable index of current variable
3605  ss_ids[ss],
3606  num_sides_per_set[ss],
3607  MappedOutputVector(sset_var_vals, _single_precision).data());
3608  EX_CHECK_ERR(ex_err, "Error writing sideset vars.");
3609  }
3610  } // end for (var)
3611  } // end for (ss)
3612 
3613  // Finally, write the sideset truth table.
3614  ex_err =
3615  exII::ex_put_truth_table(ex_id,
3616  exII::EX_SIDE_SET,
3617  num_side_sets,
3618  cast_int<int>(var_names.size()),
3619  sset_var_tab.data());
3620  EX_CHECK_ERR(ex_err, "Error writing sideset var truth table.");
3621 }
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().
std::tuple< dof_id_type, unsigned short int, boundary_id_type > BCTuple
As above, but the library creates and fills in a vector of (elem-id, side-id, bc-id) triplets and ret...
std::vector< int > num_sides_per_set
void read_sideset_info()
Reads information about all of the sidesets in the ExodusII mesh file.
const boundary_id_type side_id
MeshBase & mesh
const ExodusII_IO_Helper::Conversion & get_conversion(const ElemType type) const
std::map< dof_id_type, dof_id_type > libmesh_elem_num_to_exodus
virtual const Elem * elem_ptr(const dof_id_type i) const =0
void read_sideset(int id, int offset)
Reads information about sideset id and inserts it into the global sideset array at the position offse...
processor_id_type processor_id() const
virtual ElemType type() const =0
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
uint8_t dof_id_type
Definition: id_types.h:67

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

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

2067 {
2068  // Write the sidesets. In Nemesis, the idea is to "create space" for the global
2069  // set of boundary sidesets, but to only write sideset IDs which are local to the current
2070  // processor. This is what is done in Nemesis files created by the "loadbal" script.
2071  // See also: ExodusII_IO_Helper::write_sidesets()...
2072 
2073 
2074  // Store a map of vectors for boundary side IDs on this processor.
2075  // Use a vector of int here so it can be passed directly to Exodus.
2076  std::map<boundary_id_type, std::vector<int>> local_elem_boundary_id_lists;
2077  std::map<boundary_id_type, std::vector<int>> local_elem_boundary_id_side_lists;
2078 
2079  // FIXME: We already built this list once, we should reuse that information!
2080  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> bndry_elem_side_id_list =
2081  mesh.get_boundary_info().build_side_list();
2082 
2083  // Integer looping, skipping non-local elements
2084  for (const auto & t : bndry_elem_side_id_list)
2085  {
2086  // Get pointer to current Elem
2087  const Elem * elem = mesh.elem_ptr(std::get<0>(t));
2088 
2089  std::vector<const Elem *> family;
2090 #ifdef LIBMESH_ENABLE_AMR
2091  // We need to build up active elements if AMR is enabled and add
2092  // them to the exodus sidesets instead of the potentially inactive "parent" elements
2093  // Technically we don't need to "reset" the tree since the vector was just created.
2094  elem->active_family_tree_by_side(family, std::get<1>(t), /*reset tree=*/false);
2095 #else
2096  // If AMR is not even enabled, just push back the element itself
2097  family.push_back( elem );
2098 #endif
2099 
2100  // Loop over all the elements in the family tree, store their converted IDs
2101  // and side IDs to the map's vectors. TODO: Somehow reserve enough space for these
2102  // push_back's...
2103  for (const auto & tree_elem : family)
2104  {
2105  const dof_id_type f_id = tree_elem->id();
2106  const Elem & f = mesh.elem_ref(f_id);
2107 
2108  // If element is local, process it
2109  if (f.processor_id() == this->processor_id())
2110  {
2111  const auto & conv = get_conversion(f.type());
2112 
2113  // Use the libmesh to exodus data structure map to get the proper sideset IDs
2114  // The data structure contains the "collapsed" contiguous ids.
2115  //
2116  // We know the parent element is local, but let's be absolutely sure that all the children have been
2117  // actually mapped to Exodus IDs before we blindly try to add them...
2118  local_elem_boundary_id_lists[ std::get<2>(t) ].push_back( libmesh_map_find(libmesh_elem_num_to_exodus, f_id) );
2119  local_elem_boundary_id_side_lists[ std::get<2>(t) ].push_back(conv.get_inverse_side_map( std::get<1>(t) ));
2120  }
2121  }
2122  }
2123 
2124 
2125  // Loop over *global* sideset IDs, call the Exodus API. Note that some sidesets may be empty
2126  // for a given processor.
2127  if (global_sideset_ids.size() > 0)
2128  {
2129  NamesData names_table(global_sideset_ids.size(), MAX_STR_LENGTH);
2130 
2131  for (const auto & exodus_id : this->global_sideset_ids)
2132  {
2133  const std::string & current_ss_name =
2134  mesh.get_boundary_info().get_sideset_name
2135  (cast_int<boundary_id_type>(exodus_id));
2136 
2137  // Store this name in a data structure that will be used to
2138  // write sideset names to file.
2139  names_table.push_back_entry(current_ss_name);
2140 
2141  if (verbose)
2142  {
2143  libMesh::out << "[" << this->processor_id()
2144  << "] Writing out Exodus sideset info for ID: " << exodus_id
2145  << ", Name: " << current_ss_name
2146  << std::endl;
2147  }
2148 
2149  // Try to find this boundary ID in the local list we created
2150  auto it =
2151  local_elem_boundary_id_lists.find (cast_int<boundary_id_type>(exodus_id));
2152 
2153  // No sides found for this boundary ID on this processor
2154  if (it == local_elem_boundary_id_lists.end())
2155  {
2156  if (verbose)
2157  libMesh::out << "[" << this->processor_id()
2158  << "] No sideset data for ID: " << exodus_id
2159  << " on this processor." << std::endl;
2160 
2161  // Call the Exodus interface to write the parameters of this side set
2162  this->ex_err = exII::ex_put_side_set_param(this->ex_id,
2163  exodus_id,
2164  0, /* No sides for this ID */
2165  0 /* No distribution factors */);
2166  EX_CHECK_ERR(this->ex_err, "Error writing sideset parameters in Nemesis");
2167 
2168  }
2169  else // Boundary ID *was* found in list
2170  {
2171  // Get reference to the vector of elem IDs
2172  std::vector<int> & current_sideset_elem_ids = it->second;
2173 
2174  // Get reference to the vector of side IDs
2175  std::vector<int> & current_sideset_side_ids =
2176  libmesh_map_find(local_elem_boundary_id_side_lists,
2177  cast_int<boundary_id_type>(exodus_id));
2178 
2179  // Call the Exodus interface to write the parameters of this side set
2180  this->ex_err = exII::ex_put_side_set_param(this->ex_id,
2181  exodus_id,
2182  current_sideset_elem_ids.size(),
2183  0 /* No distribution factors */);
2184 
2185  EX_CHECK_ERR(this->ex_err, "Error writing sideset parameters in Nemesis");
2186 
2187  // Call Exodus interface to write the actual side IDs for this boundary ID
2188  this->ex_err = exII::ex_put_side_set(this->ex_id,
2189  exodus_id,
2190  current_sideset_elem_ids.data(),
2191  current_sideset_side_ids.data());
2192 
2193  EX_CHECK_ERR(this->ex_err, "Error writing sidesets in Nemesis");
2194  }
2195  } // end for loop over global sideset IDs
2196 
2197  // Write sideset names to file. Some of these may be blank strings
2198  // if the current processor didn't have all the sideset names for
2199  // any reason...
2200  ex_err = exII::ex_put_names(this->ex_id,
2201  exII::EX_SIDE_SET,
2202  names_table.get_char_star_star());
2203  EX_CHECK_ERR(ex_err, "Error writing sideset names");
2204 
2205  } // end if (global_sideset_ids.size() > 0)
2206 }
std::vector< int > global_sideset_ids
Containers for reading global sideset (boundary conditions) information.
MeshBase & mesh
const ExodusII_IO_Helper::Conversion & get_conversion(const ElemType type) const
std::map< dof_id_type, dof_id_type > libmesh_elem_num_to_exodus
OStreamProxy out
processor_id_type processor_id() const
uint8_t dof_id_type
Definition: id_types.h:67

◆ write_timestep()

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

Writes the time for the timestep.

Definition at line 3367 of file exodusII_io_helper.C.

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

3368 {
3369  if ((_run_only_on_proc0) && (this->processor_id() != 0))
3370  return;
3371 
3372  if (_single_precision)
3373  {
3374  float cast_time = float(time);
3375  ex_err = exII::ex_put_time(ex_id, timestep, &cast_time);
3376  }
3377  else
3378  {
3379  double cast_time = double(time);
3380  ex_err = exII::ex_put_time(ex_id, timestep, &cast_time);
3381  }
3382  EX_CHECK_ERR(ex_err, "Error writing timestep.");
3383 
3384  this->update();
3385 }
void update()
Uses ex_update() to flush buffers to file.
processor_id_type processor_id() const

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

References libMesh::ExodusII_IO_Helper::ELEMENTAL, libMesh::ExodusII_IO_Helper::ELEMSET, libMesh::ExodusII_IO_Helper::GLOBAL, libMesh::ExodusII_IO_Helper::NODAL, libMesh::ExodusII_IO_Helper::NODESET, libMesh::ExodusII_IO_Helper::num_elem_vars, libMesh::ExodusII_IO_Helper::num_elemset_vars, libMesh::ExodusII_IO_Helper::num_global_vars, libMesh::ExodusII_IO_Helper::num_nodal_vars, libMesh::ExodusII_IO_Helper::num_nodeset_vars, libMesh::ExodusII_IO_Helper::num_sideset_vars, libMesh::ExodusII_IO_Helper::SIDESET, and libMesh::ExodusII_IO_Helper::write_var_names_impl().

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

1949 {
1950  switch (type)
1951  {
1952  case NODAL:
1953  this->write_var_names_impl("n", num_nodal_vars, names);
1954  break;
1955  case ELEMENTAL:
1956  this->write_var_names_impl("e", num_elem_vars, names);
1957  break;
1958  case GLOBAL:
1959  this->write_var_names_impl("g", num_global_vars, names);
1960  break;
1961  case SIDESET:
1962  {
1963  // Note: calling this function *sets* num_sideset_vars to the
1964  // number of entries in the 'names' vector, num_sideset_vars
1965  // does not already need to be set before calling this.
1966  this->write_var_names_impl("s", num_sideset_vars, names);
1967  break;
1968  }
1969  case NODESET:
1970  {
1971  this->write_var_names_impl("m", num_nodeset_vars, names);
1972  break;
1973  }
1974  case ELEMSET:
1975  {
1976  this->write_var_names_impl("t", num_elemset_vars, names);
1977  break;
1978  }
1979  default:
1980  libmesh_error_msg("Unrecognized ExodusVarType " << type);
1981  }
1982 }
void write_var_names_impl(const char *var_type, int &count, const std::vector< std::string > &names)
write_var_names() dispatches to this function.

Member Data Documentation

◆ _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 982 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

◆ _coordinate_offset

Point libMesh::ExodusII_IO_Helper::_coordinate_offset
protectedinherited

◆ _elem_vars_initialized

bool libMesh::ExodusII_IO_Helper::_elem_vars_initialized
protectedinherited

◆ _end_elem_id

int libMesh::ExodusII_IO_Helper::_end_elem_id
protectedinherited

◆ _global_vars_initialized

bool libMesh::ExodusII_IO_Helper::_global_vars_initialized
protectedinherited

◆ _nodal_vars_initialized

bool libMesh::ExodusII_IO_Helper::_nodal_vars_initialized
protectedinherited

◆ _opened_by_create

bool libMesh::ExodusII_IO_Helper::_opened_by_create
protectedinherited

◆ _run_only_on_proc0

bool libMesh::ExodusII_IO_Helper::_run_only_on_proc0
protectedinherited

◆ _single_precision

bool libMesh::ExodusII_IO_Helper::_single_precision
protectedinherited

◆ _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 989 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

◆ _write_as_dimension

unsigned libMesh::ExodusII_IO_Helper::_write_as_dimension
protectedinherited

◆ _write_hdf5

bool libMesh::ExodusII_IO_Helper::_write_hdf5
protectedinherited

◆ bex_cv_conn

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

◆ bex_dense_constraint_vecs

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

◆ bex_num_elem_cvs

unsigned int libMesh::ExodusII_IO_Helper::bex_num_elem_cvs
inherited

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

◆ 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 659 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 622 of file nemesis_io_helper.h.

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

◆ connect

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

◆ current_filename

std::string libMesh::ExodusII_IO_Helper::current_filename
inherited

◆ edge_block_ids

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

◆ elem_cmap_elem_cnts

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

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

◆ elem_cmap_proc_ids

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

Definition at line 589 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 588 of file nemesis_io_helper.h.

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

◆ elem_list

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

◆ 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 532 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 525 of file nemesis_io_helper.h.

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

◆ elem_num_map

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

◆ elem_type

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

◆ elem_var_names

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

◆ elem_var_values

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

Definition at line 829 of file exodusII_io_helper.h.

◆ elemset_id_list

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

◆ elemset_ids

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

◆ elemset_list

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

◆ elemset_var_names

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

◆ ex_err

int libMesh::ExodusII_IO_Helper::ex_err
inherited

Definition at line 630 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::close(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), initialize_element_variables(), libMesh::ExodusII_IO_Helper::read_all_nodesets(), libMesh::ExodusII_IO_Helper::read_and_store_header_info(), libMesh::ExodusII_IO_Helper::read_bex_cv_blocks(), libMesh::ExodusII_IO_Helper::read_block_info(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), libMesh::ExodusII_IO_Helper::read_elem_in_block(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_elemental_var_values(), libMesh::ExodusII_IO_Helper::read_elemset(), libMesh::ExodusII_IO_Helper::read_elemset_data(), libMesh::ExodusII_IO_Helper::read_elemset_info(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO_Helper::read_nodal_var_values(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::ExodusII_IO_Helper::read_nodes(), read_nodeset(), libMesh::ExodusII_IO_Helper::read_nodeset_data(), libMesh::ExodusII_IO_Helper::read_nodeset_info(), libMesh::ExodusII_IO_Helper::read_qa_records(), libMesh::ExodusII_IO_Helper::read_sideset(), libMesh::ExodusII_IO_Helper::read_sideset_data(), libMesh::ExodusII_IO_Helper::read_sideset_info(), libMesh::ExodusII_IO_Helper::read_time_steps(), libMesh::ExodusII_IO_Helper::read_var_names_impl(), libMesh::ExodusII_IO_Helper::update(), write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), write_elements(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), write_exodus_initialization_info(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::ExodusII_IO_Helper::write_information_records(), write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_sideset_data(), write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_timestep(), libMesh::ExodusII_IO_Helper::write_var_names_impl(), and ~Nemesis_IO_Helper().

◆ ex_id

int libMesh::ExodusII_IO_Helper::ex_id
inherited

Definition at line 627 of file exodusII_io_helper.h.

Referenced by libMesh::ExodusII_IO_Helper::close(), libMesh::ExodusII_IO_Helper::create(), get_cmap_params(), get_eb_info_global(), get_elem_cmap(), get_elem_map(), get_init_global(), get_init_info(), get_loadbal_param(), get_node_cmap(), get_node_map(), get_ns_param_global(), get_ss_param_global(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), initialize_element_variables(), libMesh::ExodusII_IO_Helper::open(), put_cmap_params(), put_eb_info_global(), put_elem_cmap(), put_elem_map(), put_init_global(), put_init_info(), put_loadbal_param(), put_node_cmap(), put_node_map(), put_ns_param_global(), put_ss_param_global(), libMesh::ExodusII_IO_Helper::read_all_nodesets(), libMesh::ExodusII_IO_Helper::read_and_store_header_info(), libMesh::ExodusII_IO_Helper::read_bex_cv_blocks(), libMesh::ExodusII_IO_Helper::read_block_info(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), libMesh::ExodusII_IO_Helper::read_elem_in_block(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_elemental_var_values(), libMesh::ExodusII_IO_Helper::read_elemset(), libMesh::ExodusII_IO_Helper::read_elemset_data(), libMesh::ExodusII_IO_Helper::read_elemset_info(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO_Helper::read_header(), libMesh::ExodusII_IO_Helper::read_nodal_var_values(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::ExodusII_IO_Helper::read_nodes(), read_nodeset(), libMesh::ExodusII_IO_Helper::read_nodeset_data(), libMesh::ExodusII_IO_Helper::read_nodeset_info(), libMesh::ExodusII_IO_Helper::read_qa_records(), libMesh::ExodusII_IO_Helper::read_sideset(), libMesh::ExodusII_IO_Helper::read_sideset_data(), libMesh::ExodusII_IO_Helper::read_sideset_info(), libMesh::ExodusII_IO_Helper::read_time_steps(), libMesh::ExodusII_IO_Helper::read_var_names_impl(), libMesh::ExodusII_IO_Helper::update(), write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), write_elements(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), write_exodus_initialization_info(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::ExodusII_IO_Helper::write_information_records(), write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_sideset_data(), write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_timestep(), libMesh::ExodusII_IO_Helper::write_var_names_impl(), and ~Nemesis_IO_Helper().

◆ exodus_elem_num_to_libmesh

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

Definition at line 798 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

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

◆ 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 448 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 438 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 426 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

◆ header_info

ExodusHeaderInfo libMesh::ExodusII_IO_Helper::header_info
inherited

◆ id_list

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

◆ id_to_block_names

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

◆ id_to_edge_block_names

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

◆ id_to_elemset_names

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

◆ id_to_ns_names

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

◆ id_to_ss_names

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

◆ 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 654 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 649 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

◆ libmesh_node_num_to_exodus

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

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

◆ nodal_var_names

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

◆ nodal_var_values

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

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

◆ 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 578 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 579 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 417 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 548 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 555 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 541 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

◆ node_sets_dist_fact

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

◆ node_sets_dist_index

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

◆ node_sets_node_index

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

◆ node_sets_node_list

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

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

◆ nodeset_var_names

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

◆ num_attr

int libMesh::ExodusII_IO_Helper::num_attr
inherited

◆ 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 502 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 482 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

◆ num_dim

int& libMesh::ExodusII_IO_Helper::num_dim
inherited

◆ num_edge

int& libMesh::ExodusII_IO_Helper::num_edge
inherited

Definition at line 655 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

◆ num_elem

int& libMesh::ExodusII_IO_Helper::num_elem
inherited

◆ num_elem_all_elemsets

int libMesh::ExodusII_IO_Helper::num_elem_all_elemsets
inherited

◆ num_elem_all_sidesets

int libMesh::ExodusII_IO_Helper::num_elem_all_sidesets
inherited

◆ num_elem_blk

int& libMesh::ExodusII_IO_Helper::num_elem_blk
inherited

◆ num_elem_blks_global

int libMesh::Nemesis_IO_Helper::num_elem_blks_global

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

◆ num_elem_sets

int& libMesh::ExodusII_IO_Helper::num_elem_sets
inherited

◆ num_elem_this_blk

int libMesh::ExodusII_IO_Helper::num_elem_this_blk
inherited

◆ num_elem_vars

int libMesh::ExodusII_IO_Helper::num_elem_vars
inherited

◆ num_elems_global

int libMesh::Nemesis_IO_Helper::num_elems_global

Definition at line 391 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

◆ num_elemset_vars

int libMesh::ExodusII_IO_Helper::num_elemset_vars
inherited

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

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

◆ num_global_node_counts

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

◆ num_global_node_df_counts

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

Definition at line 440 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

◆ num_global_side_df_counts

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

Definition at line 428 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

◆ 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 495 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 475 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

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

◆ num_node_sets

int& libMesh::ExodusII_IO_Helper::num_node_sets
inherited

◆ num_node_sets_global

int libMesh::Nemesis_IO_Helper::num_node_sets_global

◆ num_nodes

int& libMesh::ExodusII_IO_Helper::num_nodes
inherited

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

◆ num_nodes_per_set

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

◆ num_nodeset_vars

int libMesh::ExodusII_IO_Helper::num_nodeset_vars
inherited

◆ 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 400 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 407 of file nemesis_io_helper.h.

Referenced by get_init_info().

◆ num_side_sets

int& libMesh::ExodusII_IO_Helper::num_side_sets
inherited

◆ num_side_sets_global

int libMesh::Nemesis_IO_Helper::num_side_sets_global

◆ num_sides_per_set

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

◆ num_sideset_vars

int libMesh::ExodusII_IO_Helper::num_sideset_vars
inherited

◆ num_time_steps

int libMesh::ExodusII_IO_Helper::num_time_steps
inherited

◆ opened_for_reading

bool libMesh::ExodusII_IO_Helper::opened_for_reading
inherited

◆ opened_for_writing

bool libMesh::ExodusII_IO_Helper::opened_for_writing
inherited

◆ 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 639 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 629 of file nemesis_io_helper.h.

Referenced by compute_border_node_ids(), compute_communication_map_parameters(), and compute_node_communication_maps().

◆ side_list

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

◆ sideset_var_names

std::vector<std::string> libMesh::ExodusII_IO_Helper::sideset_var_names
inherited

◆ ss_ids

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

◆ 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 459 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 809 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

◆ verbose

bool libMesh::ExodusII_IO_Helper::verbose
inherited

◆ w

std::vector<Real> libMesh::ExodusII_IO_Helper::w
inherited

Definition at line 780 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 600 of file nemesis_io_helper.h.

Referenced by write_element_values().

◆ x

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

◆ y

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

◆ z

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

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