libMesh::ExodusII_IO Class Reference

Handles reading and writing of Exodus binary files. More...

#include <exodusII_io.h>

Inheritance diagram for libMesh::ExodusII_IO:

Public Member Functions

 ExodusII_IO (MeshBase &mesh, bool single_precision=false)
 
virtual ~ExodusII_IO ()
 
virtual void read (const std::string &name) libmesh_override
 
virtual void write (const std::string &fname) libmesh_override
 
void verbose (bool set_verbosity)
 
const std::vector< Real > & get_time_steps ()
 
int get_num_time_steps ()
 
void copy_nodal_solution (System &system, std::string var_name, unsigned int timestep=1)
 
void copy_nodal_solution (System &system, std::string system_var_name, std::string exodus_var_name, unsigned int timestep=1)
 
void copy_elemental_solution (System &system, std::string system_var_name, std::string exodus_var_name, unsigned int timestep=1)
 
void read_elemental_variable (std::string elemental_var_name, unsigned int timestep, std::map< unsigned int, Real > &unique_id_to_value_map)
 
void read_global_variable (std::vector< std::string > global_var_names, unsigned int timestep, std::vector< Real > &global_values)
 
void write_discontinuous_exodusII (const std::string &name, const EquationSystems &es, const std::set< std::string > *system_names=libmesh_nullptr)
 
void write_timestep_discontinuous (const std::string &fname, const EquationSystems &es, const int timestep, const Real time, const std::set< std::string > *system_names=libmesh_nullptr)
 
void write_element_data (const EquationSystems &es)
 
virtual void write_nodal_data (const std::string &, const std::vector< Number > &, const std::vector< std::string > &) libmesh_override
 
void write_nodal_data_discontinuous (const std::string &, const std::vector< Number > &, const std::vector< std::string > &)
 
void write_global_data (const std::vector< Number > &, const std::vector< std::string > &)
 
void write_information_records (const std::vector< std::string > &)
 
void write_timestep (const std::string &fname, const EquationSystems &es, const int timestep, const Real time, const std::set< std::string > *system_names=libmesh_nullptr)
 
void set_output_variables (const std::vector< std::string > &output_variables, bool allow_empty=true)
 
void use_mesh_dimension_instead_of_spatial_dimension (bool val)
 
void write_as_dimension (unsigned dim)
 
void set_coordinate_offset (Point p)
 
void append (bool val)
 
const std::vector< std::string > & get_elem_var_names ()
 
const std::vector< std::string > & get_nodal_var_names ()
 
virtual void write_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=libmesh_nullptr)
 
virtual void write_nodal_data (const std::string &, const NumericVector< Number > &, const std::vector< std::string > &)
 
unsigned int & ascii_precision ()
 
const Parallel::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Protected Member Functions

MeshBasemesh ()
 
void set_n_partitions (unsigned int n_parts)
 
void skip_comment_lines (std::istream &in, const char comment_start)
 
const MeshBasemesh () const
 

Protected Attributes

std::vector< bool > elems_of_dimension
 
const bool _is_parallel_format
 
const bool _serial_only_needed_on_proc_0
 
const Parallel::Communicator_communicator
 

Private Member Functions

void write_nodal_data_common (std::string fname, const std::vector< std::string > &names, bool continuous=true)
 

Private Attributes

std::unique_ptr< ExodusII_IO_Helperexio_helper
 
int _timestep
 
bool _verbose
 
bool _append
 
std::vector< std::string > _output_variables
 
bool _allow_empty_variables
 

Detailed Description

Handles reading and writing of Exodus binary files.

The ExodusII_IO class implements reading meshes in the ExodusII file format from Sandia National Labs. By default, LibMesh expects ExodusII files to have a ".exd" or ".e" file extension.

Author
Benjamin Kirk
John Peterson
Date
2004

Definition at line 52 of file exodusII_io.h.

Constructor & Destructor Documentation

libMesh::ExodusII_IO::ExodusII_IO ( MeshBase mesh,
bool  single_precision = false 
)
explicit

Constructor. Takes a writable reference to a mesh object. This is the constructor required to read a mesh.

Definition at line 45 of file exodusII_io.C.

51  :
52  MeshInput<MeshBase> (mesh),
53  MeshOutput<MeshBase> (mesh,
54  /* is_parallel_format = */ false,
55  /* serial_only_needed_on_proc_0 = */ true),
57 #ifdef LIBMESH_HAVE_EXODUS_API
58  exio_helper(new ExodusII_IO_Helper(*this, false, true, single_precision)),
59  _timestep(1),
60  _verbose(false),
61  _append(false),
62 #endif
64 {
65 }
ParallelObject(const Parallel::Communicator &comm_in)
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
libMesh::ExodusII_IO::~ExodusII_IO ( )
virtual

Destructor.

Definition at line 132 of file exodusII_io.C.

References exio_helper.

Referenced by get_elem_var_names().

133 {
134  exio_helper->close();
135 }
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307

Member Function Documentation

void libMesh::ExodusII_IO::append ( bool  val)

If true, this flag will cause the ExodusII_IO object to attempt to open an existing file for writing, rather than creating a new file. Obviously this will only work if the file already exists.

Definition at line 449 of file exodusII_io.C.

References _append.

Referenced by get_elem_var_names().

450 {
451  _append = val;
452 }
unsigned int& libMesh::MeshOutput< MeshBase >::ascii_precision ( )
inherited

Return/set the precision to use when writing ASCII files.

By default we use numeric_limits<Real>::digits10 + 2, which should be enough to write out to ASCII and get the exact same Real back when reading in.

Referenced by libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_new_impl(), and libMesh::GMVIO::write_ascii_old_impl().

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 87 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_petsc_snes_fd_residual(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_mffd_residual(), libMesh::__libmesh_petsc_snes_postcheck(), libMesh::__libmesh_petsc_snes_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::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::ImplicitSystem::add_matrix(), libMesh::System::add_vector(), libMesh::EigenSparseLinearSolver< T >::adjoint_solve(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::DofMap::attach_matrix(), libMesh::Parallel::BinSorter< KeyType, IdxType >::binsort(), libMesh::Parallel::Sort< KeyType, IdxType >::binsort(), libMesh::MeshCommunication::broadcast(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Parallel::Histogram< KeyType, IdxType >::build_histogram(), libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::DistributedVector< T >::clone(), libMesh::EigenSparseVector< T >::clone(), libMesh::LaspackVector< T >::clone(), libMesh::EpetraVector< T >::clone(), libMesh::PetscVector< T >::clone(), libMesh::EpetraVector< T >::close(), libMesh::Parallel::Sort< KeyType, IdxType >::communicate_bins(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), copy_elemental_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), 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::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::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_nelem_target(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::EquationSystems::get_solution(), libMesh::LocationMap< T >::init(), libMesh::TopologyMap::init(), libMesh::TimeSolver::init(), libMesh::TaoOptimizationSolver< T >::init(), libMesh::PetscNonlinearSolver< T >::init(), libMesh::DistributedVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::PetscVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ParmetisPartitioner::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), 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_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::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_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::DistributedVector< T >::max(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshSerializer::MeshSerializer(), libMesh::DistributedVector< T >::min(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), 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::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::LinearPartitioner::partition_range(), libMesh::MetisPartitioner::partition_range(), 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::SparseMatrix< T >::print(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshCommunication::redistribute(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::CheckpointIO::select_split_config(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::split_mesh(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::DistributedVector< T >::zero_clone(), libMesh::EigenSparseVector< T >::zero_clone(), libMesh::LaspackVector< T >::zero_clone(), libMesh::EpetraVector< T >::zero_clone(), and libMesh::PetscVector< T >::zero_clone().

88  { return _communicator; }
const Parallel::Communicator & _communicator
void libMesh::ExodusII_IO::copy_elemental_solution ( System system,
std::string  system_var_name,
std::string  exodus_var_name,
unsigned int  timestep = 1 
)

If we read in a elemental solution while reading in a mesh, we can attempt to copy that elemental solution into an EquationSystems object.

Definition at line 510 of file exodusII_io.C.

References libMesh::ParallelObject::comm(), libMesh::CONSTANT, libMesh::DofObject::dof_number(), end, exio_helper, libMesh::MeshInput< MT >::mesh(), libMesh::MONOMIAL, libMesh::DofObject::n_comp(), libMesh::System::number(), libMesh::Parallel::Communicator::rank(), libMesh::System::solution, libMesh::System::update(), libMesh::System::variable_number(), and libMesh::System::variable_type().

Referenced by get_elem_var_names().

514 {
515  if (system.comm().rank() == 0)
516  {
517  if (!exio_helper->opened_for_reading)
518  libmesh_error_msg("ERROR, ExodusII file must be opened for reading before copying an elemental solution!");
519 
520  // Map from element ID to elemental variable value. We need to use
521  // a map here rather than a vector (e.g. elem_var_values) since the
522  // libmesh element numbering can contain "holes". This is the case
523  // if we are reading elemental var values from an adaptively refined
524  // mesh that has not been sequentially renumbered.
525  std::map<dof_id_type, Real> elem_var_value_map;
526  exio_helper->read_elemental_var_values(exodus_var_name, timestep, elem_var_value_map);
527 
528  const unsigned int var_num = system.variable_number(system_var_name);
529  if (system.variable_type(var_num) != FEType(CONSTANT, MONOMIAL))
530  libmesh_error_msg("Error! Trying to copy elemental solution into a variable that is not of CONSTANT MONOMIAL type.");
531 
532  std::map<dof_id_type, Real>::iterator
533  it = elem_var_value_map.begin(),
534  end = elem_var_value_map.end();
535 
536  for (; it!=end; ++it)
537  {
538  const Elem * elem = MeshInput<MeshBase>::mesh().query_elem_ptr(it->first);
539 
540  if (elem && elem->n_comp(system.number(), var_num) > 0)
541  {
542  dof_id_type dof_index = elem->dof_number(system.number(), var_num, 0);
543  system.solution->set (dof_index, it->second);
544  }
545  }
546  }
547 
548  system.solution->close();
549  system.update();
550 }
IterBase * end
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
uint8_t dof_id_type
Definition: id_types.h:64
void libMesh::ExodusII_IO::copy_nodal_solution ( System system,
std::string  var_name,
unsigned int  timestep = 1 
)

Backward compatibility version of function that takes a single variable name.

Deprecated:
Use the version of copy_nodal_solution() that takes two names.

Definition at line 78 of file exodusII_io.C.

Referenced by get_elem_var_names().

81 {
82  libmesh_deprecated();
83  copy_nodal_solution(system, var_name, var_name, timestep);
84 }
void copy_nodal_solution(System &system, std::string var_name, unsigned int timestep=1)
Definition: exodusII_io.C:78
void libMesh::ExodusII_IO::copy_nodal_solution ( System system,
std::string  system_var_name,
std::string  exodus_var_name,
unsigned int  timestep = 1 
)

If we read in a nodal solution while reading in a mesh, we can attempt to copy that nodal solution into an EquationSystems object.

Definition at line 478 of file exodusII_io.C.

References libMesh::DofObject::dof_number(), exio_helper, libMesh::MeshInput< MT >::mesh(), libMesh::DofObject::n_comp(), libMesh::System::number(), libMesh::System::solution, libMesh::System::update(), and libMesh::System::variable_number().

482 {
483  if (!exio_helper->opened_for_reading)
484  libmesh_error_msg("ERROR, ExodusII file must be opened for reading before copying a nodal solution!");
485 
486  exio_helper->read_nodal_var_values(exodus_var_name, timestep);
487 
488  const unsigned int var_num = system.variable_number(system_var_name);
489 
490  for (std::size_t i=0; i<exio_helper->nodal_var_values.size(); ++i)
491  {
492  const Node * node = MeshInput<MeshBase>::mesh().query_node_ptr(i);
493 
494  if (node && node->n_comp(system.number(), var_num) > 0)
495  {
496  dof_id_type dof_index = node->dof_number(system.number(), var_num, 0);
497 
498  // If the dof_index is local to this processor, set the value
499  if ((dof_index >= system.solution->first_local_index()) && (dof_index < system.solution->last_local_index()))
500  system.solution->set (dof_index, exio_helper->nodal_var_values[i]);
501  }
502  }
503 
504  system.solution->close();
505  system.update();
506 }
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
uint8_t dof_id_type
Definition: id_types.h:64
const std::vector< std::string > & libMesh::ExodusII_IO::get_nodal_var_names ( )

Return list of the nodal variable names

Definition at line 1005 of file exodusII_io.C.

References exio_helper, and libMesh::ExodusII_IO_Helper::NODAL.

Referenced by get_elem_var_names().

1006 {
1007  exio_helper->read_var_names(ExodusII_IO_Helper::NODAL);
1008  return exio_helper->nodal_var_names;
1009 }
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
int libMesh::ExodusII_IO::get_num_time_steps ( )
Returns
The number of timesteps currently stored in the Exodus file.

Knowing the number of time steps currently stored in the file is sometimes necessary when appending, so we can know where to start writing new data. Throws an error if the file is not currently open for reading or writing.

Definition at line 467 of file exodusII_io.C.

References exio_helper.

Referenced by get_elem_var_names().

468 {
469  if (!exio_helper->opened_for_reading && !exio_helper->opened_for_writing)
470  libmesh_error_msg("ERROR, ExodusII file must be opened for reading or writing before calling ExodusII_IO::get_num_time_steps()!");
471 
472  exio_helper->read_num_time_steps();
473  return exio_helper->num_time_steps;
474 }
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
const std::vector< Real > & libMesh::ExodusII_IO::get_time_steps ( )
Returns
An array containing the timesteps in the file.

Definition at line 456 of file exodusII_io.C.

References exio_helper.

Referenced by get_elem_var_names().

457 {
458  if (!exio_helper->opened_for_reading)
459  libmesh_error_msg("ERROR, ExodusII file must be opened for reading before calling ExodusII_IO::get_time_steps()!");
460 
461  exio_helper->read_time_steps();
462  return exio_helper->time_steps;
463 }
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
MeshBase & libMesh::MeshInput< MeshBase >::mesh ( )
protectedinherited
Returns
The object as a writable reference.

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::TetGenIO::element_in(), libMesh::UNVIO::elements_in(), libMesh::UNVIO::elements_out(), libMesh::UNVIO::groups_in(), libMesh::TetGenIO::node_in(), libMesh::UNVIO::nodes_in(), libMesh::UNVIO::nodes_out(), libMesh::GMVIO::read(), read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_bcs(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::UCDIO::read_implementation(), libMesh::UNVIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::CheckpointIO::read_nodes(), libMesh::CheckpointIO::read_nodesets(), libMesh::CheckpointIO::read_remote_elem(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::CheckpointIO::read_subdomain_names(), libMesh::UCDIO::UCDIO(), libMesh::VTKIO::VTKIO(), libMesh::TetGenIO::write(), write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::CheckpointIO::write_bcs(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), write_element_data(), libMesh::UCDIO::write_implementation(), libMesh::GmshIO::write_mesh(), libMesh::UCDIO::write_nodal_data(), write_nodal_data(), write_nodal_data_common(), write_nodal_data_discontinuous(), libMesh::CheckpointIO::write_nodesets(), libMesh::XdrIO::write_parallel(), libMesh::GmshIO::write_post(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), and libMesh::CheckpointIO::write_subdomain_names().

processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
The number of processors in the group.

Definition at line 93 of file parallel_object.h.

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

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::MeshCommunication::broadcast(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::get_solution(), libMesh::DistributedVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), 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::SparsityPattern::Build::parallel_sync(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

94  { return cast_int<processor_id_type>(_communicator.size()); }
unsigned int size() const
Definition: parallel.h:725
const Parallel::Communicator & _communicator
processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
Returns
The rank of this processor in the group.

Definition at line 99 of file parallel_object.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::MeshCommunication::broadcast(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::ParmetisPartitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DofMap::build_sparsity(), libMesh::DistributedMesh::clear(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::EquationSystems::get_solution(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::DistributedVector< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), 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::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), 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::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MetisPartitioner::partition_range(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NumericVector< T >::print_global(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::CheckpointIO::select_split_config(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::MeshTools::weight(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_elements(), write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), write_nodal_data(), write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and write_timestep_discontinuous().

100  { return cast_int<processor_id_type>(_communicator.rank()); }
const Parallel::Communicator & _communicator
unsigned int rank() const
Definition: parallel.h:723
void libMesh::ExodusII_IO::read ( const std::string &  name)
virtual

This method implements reading a mesh from a specified file. Open the file named name and read the mesh in Sandia National Lab's ExodusII format. This is the method to use for reading in meshes generated by cubit. Works in 2D for TRIs, TRI6s, QUAD s, and QUAD9s. Works in 3D for TET4s, TET10s, HEX8s, and HEX27s.

Implements libMesh::MeshInput< MeshBase >.

Definition at line 139 of file exodusII_io.C.

References libMesh::MeshBase::add_elem(), libMesh::BoundaryInfo::add_node(), libMesh::MeshBase::add_point(), libMesh::BoundaryInfo::add_shellface(), libMesh::BoundaryInfo::add_side(), libMesh::ExodusII_IO_Helper::ElementMaps::assign_conversion(), libMesh::Elem::build(), libMesh::MeshBase::clear(), libMesh::Elem::dim(), libMesh::MeshBase::elem_ref(), libMesh::MeshInput< MeshBase >::elems_of_dimension, libMesh::Utility::enum_to_string(), exio_helper, libMesh::MeshBase::get_boundary_info(), libMesh::ExodusII_IO_Helper::Conversion::get_shellface_index_offset(), libMesh::ExodusII_IO_Helper::Conversion::get_side_map(), libMesh::DofObject::id(), libMesh::ExodusII_IO_Helper::Conversion::invalid_id, libMesh::MeshInput< MT >::mesh(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::node_ptr(), libMesh::BoundaryInfo::nodeset_name(), libMesh::MeshBase::reserve_elem(), libMesh::MeshBase::reserve_nodes(), libMesh::DofObject::set_id(), libMesh::MeshBase::set_mesh_dimension(), libMesh::Elem::set_node(), libMesh::BoundaryInfo::sideset_name(), libMesh::Elem::subdomain_id(), and libMesh::MeshBase::subdomain_name().

Referenced by get_elem_var_names(), libMesh::NameBasedIO::read(), and libMesh::Nemesis_IO::read().

140 {
141  // Get a reference to the mesh we are reading
142  MeshBase & mesh = MeshInput<MeshBase>::mesh();
143 
144  // Clear any existing mesh data
145  mesh.clear();
146 
147  // Keep track of what kinds of elements this file contains
148  elems_of_dimension.clear();
149  elems_of_dimension.resize(4, false);
150 
151  // Instantiate the ElementMaps interface
152  ExodusII_IO_Helper::ElementMaps em;
153 
154  // Open the exodus file in EX_READ mode
155  exio_helper->open(fname.c_str(), /*read_only=*/true);
156 
157  // Get header information from exodus file
158  exio_helper->read_header();
159 
160  // Read the QA records
161  exio_helper->read_qa_records();
162 
163  // Print header information
164  exio_helper->print_header();
165 
166  // Read nodes from the exodus file
167  exio_helper->read_nodes();
168 
169  // Reserve space for the nodes.
170  mesh.reserve_nodes(exio_helper->num_nodes);
171 
172  // Read the node number map from the Exodus file. This is
173  // required if we want to preserve the numbering of nodes as it
174  // exists in the Exodus file. If the Exodus file does not contain
175  // a node_num_map, the identity map is returned by this call.
176  exio_helper->read_node_num_map();
177 
178  // Loop over the nodes, create Nodes with local processor_id 0.
179  for (int i=0; i<exio_helper->num_nodes; i++)
180  {
181  // Use the node_num_map to get the correct ID for Exodus
182  int exodus_id = exio_helper->node_num_map[i];
183 
184  // Catch the node that was added to the mesh
185  Node * added_node = mesh.add_point (Point(exio_helper->x[i], exio_helper->y[i], exio_helper->z[i]), exodus_id-1);
186 
187  // If the Mesh assigned an ID different from what is in the
188  // Exodus file, we should probably error.
189  if (added_node->id() != static_cast<unsigned>(exodus_id-1))
190  libmesh_error_msg("Error! Mesh assigned node ID " \
191  << added_node->id() \
192  << " which is different from the (zero-based) Exodus ID " \
193  << exodus_id-1 \
194  << "!");
195  }
196 
197  // This assert is no longer valid if the nodes are not numbered
198  // sequentially starting from 1 in the Exodus file.
199  // libmesh_assert_equal_to (static_cast<unsigned int>(exio_helper->num_nodes), mesh.n_nodes());
200 
201  // Get information about all the blocks
202  exio_helper->read_block_info();
203 
204  // Reserve space for the elements
205  mesh.reserve_elem(exio_helper->num_elem);
206 
207  // Read the element number map from the Exodus file. This is
208  // required if we want to preserve the numbering of elements as it
209  // exists in the Exodus file. If the Exodus file does not contain
210  // an elem_num_map, the identity map is returned by this call.
211  exio_helper->read_elem_num_map();
212 
213  // Read in the element connectivity for each block.
214  int nelem_last_block = 0;
215 
216  // Loop over all the blocks
217  for (int i=0; i<exio_helper->num_elem_blk; i++)
218  {
219  // Read the information for block i
220  exio_helper->read_elem_in_block (i);
221  int subdomain_id = exio_helper->get_block_id(i);
222 
223  // populate the map of names
224  std::string subdomain_name = exio_helper->get_block_name(i);
225  if (!subdomain_name.empty())
226  mesh.subdomain_name(static_cast<subdomain_id_type>(subdomain_id)) = subdomain_name;
227 
228  // Set any relevant node/edge maps for this element
229  const std::string type_str (exio_helper->get_elem_type());
230  const ExodusII_IO_Helper::Conversion conv = em.assign_conversion(type_str);
231 
232  // Loop over all the faces in this block
233  int jmax = nelem_last_block+exio_helper->num_elem_this_blk;
234  for (int j=nelem_last_block; j<jmax; j++)
235  {
236  Elem * elem = Elem::build (conv.get_canonical_type()).release();
237  libmesh_assert (elem);
238  elem->subdomain_id() = static_cast<subdomain_id_type>(subdomain_id) ;
239 
240  // Use the elem_num_map to obtain the ID of this element in the Exodus file
241  int exodus_id = exio_helper->elem_num_map[j];
242 
243  // Assign this element the same ID it had in the Exodus
244  // file, but make it zero-based by subtracting 1. Note:
245  // some day we could use 1-based numbering in libmesh and
246  // thus match the Exodus numbering exactly, but at the
247  // moment libmesh is zero-based.
248  elem->set_id(exodus_id-1);
249 
250  // Record that we have seen an element of dimension elem->dim()
251  elems_of_dimension[elem->dim()] = true;
252 
253  // Catch the Elem pointer that the Mesh throws back
254  elem = mesh.add_elem (elem);
255 
256  // If the Mesh assigned an ID different from what is in the
257  // Exodus file, we should probably error.
258  if (elem->id() != static_cast<unsigned>(exodus_id-1))
259  libmesh_error_msg("Error! Mesh assigned ID " \
260  << elem->id() \
261  << " which is different from the (zero-based) Exodus ID " \
262  << exodus_id-1 \
263  << "!");
264 
265  // Set all the nodes for this element
266  for (int k=0; k<exio_helper->num_nodes_per_elem; k++)
267  {
268  // global index
269  int gi = (j-nelem_last_block)*exio_helper->num_nodes_per_elem + conv.get_node_map(k);
270 
271  // The entries in 'connect' are actually (1-based)
272  // indices into the node_num_map, so to get the right
273  // node ID we:
274  // 1.) Subtract 1 from connect[gi]
275  // 2.) Pass it through node_num_map to get the corresponding Exodus ID
276  // 3.) Subtract 1 from that, since libmesh node numbering is "zero"-based,
277  // even when the Exodus node numbering doesn't start with 1.
278  int libmesh_node_id = exio_helper->node_num_map[exio_helper->connect[gi] - 1] - 1;
279 
280  // Set the node pointer in the Elem
281  elem->set_node(k) = mesh.node_ptr(libmesh_node_id);
282  }
283  }
284 
285  // running sum of # of elements per block,
286  // (should equal total number of elements in the end)
287  nelem_last_block += exio_helper->num_elem_this_blk;
288  }
289 
290  // This assert isn't valid if the Exodus file's numbering doesn't
291  // start with 1! For example, if Exodus's elem_num_map is 21, 22,
292  // 23, 24, 25, 26, 27, 28, 29, 30, ... 84, then by the time you are
293  // done with the loop above, mesh.n_elem() will report 84 and
294  // nelem_last_block will be 64.
295  // libmesh_assert_equal_to (static_cast<unsigned>(nelem_last_block), mesh.n_elem());
296 
297  // Set the mesh dimension to the largest encountered for an element
298  for (unsigned char i=0; i!=4; ++i)
299  if (elems_of_dimension[i])
300  mesh.set_mesh_dimension(i);
301 
302  // Read in sideset information -- this is useful for applying boundary conditions
303  {
304  // Get basic information about all sidesets
305  exio_helper->read_sideset_info();
306  int offset=0;
307  for (int i=0; i<exio_helper->num_side_sets; i++)
308  {
309  // Compute new offset
310  offset += (i > 0 ? exio_helper->num_sides_per_set[i-1] : 0);
311  exio_helper->read_sideset (i, offset);
312 
313  std::string sideset_name = exio_helper->get_side_set_name(i);
314  if (!sideset_name.empty())
315  mesh.get_boundary_info().sideset_name
316  (cast_int<boundary_id_type>(exio_helper->get_side_set_id(i)))
317  = sideset_name;
318  }
319 
320  for (std::size_t e=0; e<exio_helper->elem_list.size(); e++)
321  {
322  // The numbers in the Exodus file sidesets should be thought
323  // of as (1-based) indices into the elem_num_map array. So,
324  // to get the right element ID we have to:
325  // 1.) Subtract 1 from elem_list[e] (to get a zero-based index)
326  // 2.) Pass it through elem_num_map (to get the corresponding Exodus ID)
327  // 3.) Subtract 1 from that, since libmesh is "zero"-based,
328  // even when the Exodus numbering doesn't start with 1.
329  dof_id_type libmesh_elem_id =
330  cast_int<dof_id_type>(exio_helper->elem_num_map[exio_helper->elem_list[e] - 1] - 1);
331 
332  // Set any relevant node/edge maps for this element
333  Elem & elem = mesh.elem_ref(libmesh_elem_id);
334 
335  const ExodusII_IO_Helper::Conversion conv = em.assign_conversion(elem.type());
336 
337  // Map the zero-based Exodus side numbering to the libmesh side numbering
338  unsigned int raw_side_index = exio_helper->side_list[e]-1;
339  unsigned int side_index_offset = conv.get_shellface_index_offset();
340 
341  if (raw_side_index < side_index_offset)
342  {
343  // We assume this is a "shell face"
344  int mapped_shellface = raw_side_index;
345 
346  // Check for errors
347  if (mapped_shellface == ExodusII_IO_Helper::Conversion::invalid_id)
348  libmesh_error_msg("Invalid 1-based side id: " \
349  << mapped_shellface \
350  << " detected for " \
351  << Utility::enum_to_string(elem.type()));
352 
353  // Add this (elem,shellface,id) triplet to the BoundaryInfo object.
354  mesh.get_boundary_info().add_shellface (libmesh_elem_id,
355  cast_int<unsigned short>(mapped_shellface),
356  cast_int<boundary_id_type>(exio_helper->id_list[e]));
357  }
358  else
359  {
360  unsigned int side_index = static_cast<unsigned int>(raw_side_index - side_index_offset);
361  int mapped_side = conv.get_side_map(side_index);
362 
363  // Check for errors
365  libmesh_error_msg("Invalid 1-based side id: " \
366  << side_index \
367  << " detected for " \
368  << Utility::enum_to_string(elem.type()));
369 
370  // Add this (elem,side,id) triplet to the BoundaryInfo object.
371  mesh.get_boundary_info().add_side (libmesh_elem_id,
372  cast_int<unsigned short>(mapped_side),
373  cast_int<boundary_id_type>(exio_helper->id_list[e]));
374  }
375  }
376  }
377 
378  // Read nodeset info
379  {
380  exio_helper->read_nodeset_info();
381 
382  for (int nodeset=0; nodeset<exio_helper->num_node_sets; nodeset++)
383  {
384  boundary_id_type nodeset_id =
385  cast_int<boundary_id_type>(exio_helper->nodeset_ids[nodeset]);
386 
387  std::string nodeset_name = exio_helper->get_node_set_name(nodeset);
388  if (!nodeset_name.empty())
389  mesh.get_boundary_info().nodeset_name(nodeset_id) = nodeset_name;
390 
391  exio_helper->read_nodeset(nodeset);
392 
393  for (std::size_t node=0; node<exio_helper->node_list.size(); node++)
394  {
395  // As before, the entries in 'node_list' are 1-based
396  // indices into the node_num_map array, so we have to map
397  // them. See comment above.
398  int libmesh_node_id = exio_helper->node_num_map[exio_helper->node_list[node] - 1] - 1;
399  mesh.get_boundary_info().add_node(cast_int<dof_id_type>(libmesh_node_id),
400  nodeset_id);
401  }
402  }
403  }
404 
405 #if LIBMESH_DIM < 3
406  if (mesh.mesh_dimension() > LIBMESH_DIM)
407  libmesh_error_msg("Cannot open dimension " \
408  << mesh.mesh_dimension() \
409  << " mesh file when configured without " \
410  << mesh.mesh_dimension() \
411  << "D support.");
412 #endif
413 }
std::vector< bool > elems_of_dimension
Definition: mesh_input.h:97
TestClass subdomain_id_type
Definition: id_types.h:43
int8_t boundary_id_type
Definition: id_types.h:51
std::string enum_to_string(const T e)
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=libmesh_nullptr)
Definition: elem.C:239
uint8_t dof_id_type
Definition: id_types.h:64
void libMesh::ExodusII_IO::read_elemental_variable ( std::string  elemental_var_name,
unsigned int  timestep,
std::map< unsigned int, Real > &  unique_id_to_value_map 
)

Given an elemental variable and a time step, returns a mapping from the elements (top parent) unique IDs to the value of the elemental variable at the corresponding time step index. Note that this function MUST only be called before renumbering! This function is essentially a wrapper for read_elemental_var_values from the exodus helper (which is not accessible outside this class).

Parameters
elemental_var_nameName of an elemental variable
timestepThe corresponding time step index
unique_id_to_value_mapThe map to be filled

Definition at line 552 of file exodusII_io.C.

References exio_helper, libMesh::MeshInput< MT >::mesh(), libMesh::Elem::top_parent(), and libMesh::DofObject::unique_id().

555 {
556  // Note that this function MUST be called before renumbering
557  std::map<dof_id_type, Real> elem_var_value_map;
558 
559  exio_helper->read_elemental_var_values(elemental_var_name, timestep, elem_var_value_map);
560  for (auto it = elem_var_value_map.begin(); it != elem_var_value_map.end(); ++it)
561  {
562  const Elem * elem = MeshInput<MeshBase>::mesh().query_elem_ptr(it->first);
563  unique_id_to_value_map.insert(std::make_pair(elem->top_parent()->unique_id(), it->second));
564  }
565 }
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
void libMesh::ExodusII_IO::read_global_variable ( std::vector< std::string >  global_var_names,
unsigned int  timestep,
std::vector< Real > &  global_values 
)

Given a vector of global variables and a time step, returns the values of the global variable at the corresponding time step index.

Parameters
global_var_namesVector of names of global variables
timestepThe corresponding time step index
global_valuesThe vector to be filled

Definition at line 567 of file exodusII_io.C.

References exio_helper, and libMesh::ExodusII_IO_Helper::GLOBAL.

570 {
571  unsigned int size = global_var_names.size();
572  if (size == 0)
573  libmesh_error_msg("ERROR, empty list of global variables to read from the Exodus file.");
574 
575  // read the values for all global variables
576  std::vector<Real> values_from_exodus;
577  exio_helper->read_var_names(ExodusII_IO_Helper::GLOBAL);
578  exio_helper->read_global_values(values_from_exodus, timestep);
579  std::vector<std::string> global_var_names_exodus = exio_helper->global_var_names;
580 
581  global_values.clear();
582  for (unsigned int i = 0; i < size; ++i)
583  {
584  // for each global variable in global_var_names, look the corresponding one in global_var_names_from_exodus
585  // and fill global_values accordingly
586  auto it = find(global_var_names_exodus.begin(), global_var_names_exodus.end(), global_var_names[i]);
587  if (it != global_var_names_exodus.end())
588  global_values.push_back(values_from_exodus[it - global_var_names_exodus.begin()]);
589  else
590  libmesh_error_msg("ERROR, Global variable " << global_var_names[i] << \
591  " not found in Exodus file.");
592  }
593 
594 }
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
void libMesh::ExodusII_IO::set_coordinate_offset ( Point  p)

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

Deprecated:
As requested by Roy in libmesh PR #90, this function was "deprecated on arrival". There is not really a suitable replacement for it in the works, however. The same effect could be achieved by calling MeshTools::Modification::translate() twice, but that approach seems inefficient in the case of very large problems with millions of nodes. That said, this should probably become a base class API so that it works for all the different IO subclasses.

Definition at line 441 of file exodusII_io.C.

References exio_helper.

Referenced by get_elem_var_names().

442 {
443  libmesh_warning("This method may be deprecated in the future");
444  exio_helper->set_coordinate_offset(p);
445 }
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
void libMesh::MeshInput< MeshBase >::set_n_partitions ( unsigned int  n_parts)
inlineprotectedinherited

Sets the number of partitions in the mesh. Typically this gets done by the partitioner, but some parallel file formats begin "pre-partitioned".

Definition at line 91 of file mesh_input.h.

References libMesh::MeshInput< MT >::mesh().

Referenced by libMesh::Nemesis_IO::read(), and libMesh::XdrIO::read_header().

91 { this->mesh().set_n_partitions() = n_parts; }
unsigned int & set_n_partitions()
Definition: mesh_base.h:1330
void libMesh::ExodusII_IO::set_output_variables ( const std::vector< std::string > &  output_variables,
bool  allow_empty = true 
)

Sets the list of variable names to be included in the output. This is optional. If this is never called then all variables will be present. If this is called and an empty vector is supplied no variables will be output. Setting the allow_empty = false will result in empty vectors supplied here to also be populated with all variables.

Definition at line 68 of file exodusII_io.C.

References _allow_empty_variables, and _output_variables.

70 {
71  _output_variables = output_variables;
72  _allow_empty_variables = allow_empty;
73 }
std::vector< std::string > _output_variables
Definition: exodusII_io.h:331
void libMesh::MeshInput< MeshBase >::skip_comment_lines ( std::istream &  in,
const char  comment_start 
)
protectedinherited

Reads input from in, skipping all the lines that start with the character comment_start.

Referenced by libMesh::TetGenIO::read(), and libMesh::UCDIO::read_implementation().

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

In the general case, meshes containing 2D elements can be manifolds living in 3D space, thus by default we write all meshes with the Exodus dimension set to LIBMESH_DIM = mesh.spatial_dimension().

In certain cases, however, the user may know his 2D mesh actually lives in the z=0 plane, and therefore wants to write a truly 2D Exodus mesh. In such a case, he should call this function with val=true.

Definition at line 427 of file exodusII_io.C.

References exio_helper.

Referenced by get_elem_var_names().

428 {
429  exio_helper->use_mesh_dimension_instead_of_spatial_dimension(val);
430 }
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
void libMesh::ExodusII_IO::verbose ( bool  set_verbosity)

Set the flag indicating if we should be verbose.

Definition at line 417 of file exodusII_io.C.

References _verbose, and exio_helper.

Referenced by get_elem_var_names().

418 {
419  _verbose = set_verbosity;
420 
421  // Set the verbose flag in the helper object as well.
422  exio_helper->verbose = _verbose;
423 }
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
void libMesh::ExodusII_IO::write ( const std::string &  fname)
virtual

This method implements writing a mesh to a specified file.

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 851 of file exodusII_io.C.

References _append, _verbose, exio_helper, libMesh::MeshBase::get_boundary_info(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::BoundaryInfo::n_edge_conds(), and libMesh::out.

Referenced by get_elem_var_names(), libMesh::ErrorVector::plot_error(), and libMesh::NameBasedIO::write().

852 {
853  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
854 
855  // We may need to gather a DistributedMesh to output it, making that
856  // const qualifier in our constructor a dirty lie
857  // The "true" specifies that we only need the mesh serialized to processor 0
858  MeshSerializer serialize(MeshInput<MeshBase>::mesh(), !MeshOutput<MeshBase>::_is_parallel_format, true);
859 
860  libmesh_assert( !exio_helper->opened_for_writing );
861 
862  // If the user has set the append flag here, it doesn't really make
863  // sense: the intent of this function is to write a Mesh with no
864  // data, while "appending" is really intended to add data to an
865  // existing file. If we're verbose, print a message to this effect.
866  if (_append && _verbose)
867  libMesh::out << "Warning: Appending in ExodusII_IO::write() does not make sense.\n"
868  << "Creating a new file instead!"
869  << std::endl;
870 
871  exio_helper->create(fname);
872  exio_helper->initialize(fname,mesh);
873  exio_helper->write_nodal_coordinates(mesh);
874  exio_helper->write_elements(mesh);
875  exio_helper->write_sidesets(mesh);
876  exio_helper->write_nodesets(mesh);
877 
878  if ((mesh.get_boundary_info().n_edge_conds() > 0) && _verbose)
879  {
880  libMesh::out << "Warning: Mesh contains edge boundary IDs, but these "
881  << "are not supported by the ExodusII format."
882  << std::endl;
883  }
884 }
const MT & mesh() const
Definition: mesh_output.h:216
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
OStreamProxy out(std::cout)
void libMesh::ExodusII_IO::write_as_dimension ( unsigned  dim)

Directly control 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 434 of file exodusII_io.C.

References exio_helper.

Referenced by get_elem_var_names().

435 {
436  exio_helper->write_as_dimension(dim);
437 }
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
void libMesh::ExodusII_IO::write_discontinuous_exodusII ( const std::string &  name,
const EquationSystems es,
const std::set< std::string > *  system_names = libmesh_nullptr 
)

Writes a exodusII file with discontinuous data

Definition at line 89 of file exodusII_io.C.

References libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::EquationSystems::build_variable_names(), libmesh_nullptr, and write_nodal_data_discontinuous().

Referenced by write_timestep_discontinuous().

92 {
93  std::vector<std::string> solution_names;
94  std::vector<Number> v;
95 
96  es.build_variable_names (solution_names, libmesh_nullptr, system_names);
97  es.build_discontinuous_solution_vector (v, system_names);
98 
99  this->write_nodal_data_discontinuous(name, v, solution_names);
100 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
const class libmesh_nullptr_t libmesh_nullptr
void write_nodal_data_discontinuous(const std::string &, const std::vector< Number > &, const std::vector< std::string > &)
Definition: exodusII_io.C:888
void libMesh::ExodusII_IO::write_element_data ( const EquationSystems es)

Write out element solution.

Definition at line 596 of file exodusII_io.C.

References _output_variables, _timestep, std::abs(), libMesh::EquationSystems::build_variable_names(), libMesh::CONSTANT, exio_helper, libMesh::EquationSystems::get_solution(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MONOMIAL, libMesh::ParallelObject::processor_id(), and value.

Referenced by get_elem_var_names(), and libMesh::ErrorVector::plot_error().

597 {
598  // Be sure the file has been opened for writing!
599  if (MeshOutput<MeshBase>::mesh().processor_id() == 0 && !exio_helper->opened_for_writing)
600  libmesh_error_msg("ERROR, ExodusII file must be initialized before outputting element variables.");
601 
602  // This function currently only works on serialized meshes. We rely
603  // on having a reference to a non-const MeshBase object from our
604  // MeshInput parent class to construct a MeshSerializer object,
605  // similar to what is done in ExodusII_IO::write(). Note that
606  // calling ExodusII_IO::write_timestep() followed by
607  // ExodusII_IO::write_element_data() when the underlying Mesh is a
608  // DistributedMesh will result in an unnecessary additional
609  // serialization/re-parallelization step.
610  // The "true" specifies that we only need the mesh serialized to processor 0
611  MeshSerializer serialize(MeshInput<MeshBase>::mesh(), !MeshOutput<MeshBase>::_is_parallel_format, true);
612 
613  // To be (possibly) filled with a filtered list of variable names to output.
614  std::vector<std::string> names;
615 
616  // If _output_variables is populated, only output the monomials which are
617  // also in the _output_variables vector.
618  if (_output_variables.size() > 0)
619  {
620  std::vector<std::string> monomials;
621  const FEType type(CONSTANT, MONOMIAL);
622 
623  // Create a list of monomial variable names
624  es.build_variable_names(monomials, &type);
625 
626  // Filter that list against the _output_variables list. Note: if names is still empty after
627  // all this filtering, all the monomial variables will be gathered
628  std::vector<std::string>::iterator it = monomials.begin();
629  for (; it!=monomials.end(); ++it)
630  if (std::find(_output_variables.begin(), _output_variables.end(), *it) != _output_variables.end())
631  names.push_back(*it);
632  }
633 
634  // If we pass in a list of names to "get_solution" it'll filter the variables coming back
635  std::vector<Number> soln;
636  es.get_solution(soln, names);
637 
638  if (soln.empty()) // If there is nothing to write just return
639  return;
640 
641  // The data must ultimately be written block by block. This means that this data
642  // must be sorted appropriately.
644  return;
645 
646  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
647 
648 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
649 
650  std::vector<std::string> complex_names = exio_helper->get_complex_names(names);
651 
652  exio_helper->initialize_element_variables(complex_names);
653 
654  unsigned int num_values = soln.size();
655  unsigned int num_vars = names.size();
656  unsigned int num_elems = num_values / num_vars;
657 
658  // This will contain the real and imaginary parts and the magnitude
659  // of the values in soln
660  std::vector<Real> complex_soln(3*num_values);
661 
662  for (unsigned i=0; i<num_vars; ++i)
663  {
664 
665  for (unsigned int j=0; j<num_elems; ++j)
666  {
667  Number value = soln[i*num_vars + j];
668  complex_soln[3*i*num_elems + j] = value.real();
669  }
670  for (unsigned int j=0; j<num_elems; ++j)
671  {
672  Number value = soln[i*num_vars + j];
673  complex_soln[3*i*num_elems + num_elems +j] = value.imag();
674  }
675  for (unsigned int j=0; j<num_elems; ++j)
676  {
677  Number value = soln[i*num_vars + j];
678  complex_soln[3*i*num_elems + 2*num_elems + j] = std::abs(value);
679  }
680  }
681 
682  exio_helper->write_element_values(mesh, complex_soln, _timestep);
683 
684 #else
685  exio_helper->initialize_element_variables(names);
686  exio_helper->write_element_values(mesh, soln, _timestep);
687 #endif
688 }
double abs(double a)
const MeshBase & mesh() const
std::vector< std::string > _output_variables
Definition: exodusII_io.h:331
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
static const bool value
Definition: xdr_io.C:108
processor_id_type processor_id() const
virtual void libMesh::MeshOutput< MeshBase >::write_equation_systems ( const std::string &  ,
const EquationSystems ,
const std::set< std::string > *  system_names = libmesh_nullptr 
)
virtualinherited

This method implements writing a mesh with data to a specified file where the data is taken from the EquationSystems object.

Reimplemented in libMesh::NameBasedIO.

Referenced by libMesh::Nemesis_IO::write_timestep(), and write_timestep().

void libMesh::ExodusII_IO::write_global_data ( const std::vector< Number > &  soln,
const std::vector< std::string > &  names 
)

Write out global variables.

Definition at line 781 of file exodusII_io.C.

References _timestep, std::abs(), exio_helper, libMesh::ParallelObject::processor_id(), and value.

Referenced by get_elem_var_names().

783 {
785  return;
786 
787  if (!exio_helper->opened_for_writing)
788  libmesh_error_msg("ERROR, ExodusII file must be initialized before outputting global variables.");
789 
790 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
791 
792  std::vector<std::string> complex_names = exio_helper->get_complex_names(names);
793 
794  exio_helper->initialize_global_variables(complex_names);
795 
796  unsigned int num_values = soln.size();
797  unsigned int num_vars = names.size();
798  unsigned int num_elems = num_values / num_vars;
799 
800  // This will contain the real and imaginary parts and the magnitude
801  // of the values in soln
802  std::vector<Real> complex_soln(3*num_values);
803 
804  for (unsigned i=0; i<num_vars; ++i)
805  {
806 
807  for (unsigned int j=0; j<num_elems; ++j)
808  {
809  Number value = soln[i*num_vars + j];
810  complex_soln[3*i*num_elems + j] = value.real();
811  }
812  for (unsigned int j=0; j<num_elems; ++j)
813  {
814  Number value = soln[i*num_vars + j];
815  complex_soln[3*i*num_elems + num_elems +j] = value.imag();
816  }
817  for (unsigned int j=0; j<num_elems; ++j)
818  {
819  Number value = soln[i*num_vars + j];
820  complex_soln[3*i*num_elems + 2*num_elems + j] = std::abs(value);
821  }
822  }
823 
824  exio_helper->write_global_values(complex_soln, _timestep);
825 
826 #else
827  exio_helper->initialize_global_variables(names);
828  exio_helper->write_global_values(soln, _timestep);
829 #endif
830 }
double abs(double a)
const MeshBase & mesh() const
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
static const bool value
Definition: xdr_io.C:108
processor_id_type processor_id() const
void libMesh::ExodusII_IO::write_information_records ( const std::vector< std::string > &  records)

Write out information records.

Definition at line 768 of file exodusII_io.C.

References exio_helper, and libMesh::ParallelObject::processor_id().

Referenced by get_elem_var_names().

769 {
771  return;
772 
773  if (!exio_helper->opened_for_writing)
774  libmesh_error_msg("ERROR, ExodusII file must be initialized before outputting information records.");
775 
776  exio_helper->write_information_records(records);
777 }
const MeshBase & mesh() const
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
processor_id_type processor_id() const
virtual void libMesh::MeshOutput< MeshBase >::write_nodal_data ( const std::string &  ,
const NumericVector< Number > &  ,
const std::vector< std::string > &   
)
virtualinherited

This method should be overridden by "parallel" output formats for writing nodal data. Instead of getting a localized copy of the nodal solution vector, it is passed a NumericVector of type=PARALLEL which is in node-major order i.e. (u0,v0,w0, u1,v1,w1, u2,v2,w2, u3,v3,w3, ...) and contains n_nodes*n_vars total entries. Then, it is up to the individual I/O class to extract the required solution values from this vector and write them in parallel.

If not implemented, localizes the parallel vector into a std::vector and calls the other version of this function.

Reimplemented in libMesh::Nemesis_IO.

void libMesh::ExodusII_IO::write_nodal_data ( const std::string &  fname,
const std::vector< Number > &  soln,
const std::vector< std::string > &  names 
)
virtual

Write out a nodal solution.

Reimplemented from libMesh::MeshOutput< MeshBase >.

Definition at line 692 of file exodusII_io.C.

References _allow_empty_variables, _output_variables, _timestep, std::abs(), exio_helper, libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::n_nodes(), libMesh::ParallelObject::processor_id(), and write_nodal_data_common().

Referenced by get_elem_var_names(), and libMesh::NameBasedIO::write_nodal_data().

695 {
696  LOG_SCOPE("write_nodal_data()", "ExodusII_IO");
697 
698  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
699 
700  int num_vars = cast_int<int>(names.size());
701  dof_id_type num_nodes = mesh.n_nodes();
702 
703  // The names of the variables to be output
704  std::vector<std::string> output_names;
705 
707  output_names = _output_variables;
708  else
709  output_names = names;
710 
711 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
712 
713  std::vector<std::string> complex_names = exio_helper->get_complex_names(names);
714 
715  // Call helper function for opening/initializing data, giving it the
716  // complex variable names
717  this->write_nodal_data_common(fname, complex_names, /*continuous=*/true);
718 #else
719  // Call helper function for opening/initializing data
720  this->write_nodal_data_common(fname, output_names, /*continuous=*/true);
721 #endif
722 
723  if (mesh.processor_id())
724  return;
725 
726  // This will count the number of variables actually output
727  for (int c=0; c<num_vars; c++)
728  {
729  std::stringstream name_to_find;
730 
731  std::vector<std::string>::iterator pos =
732  std::find(output_names.begin(), output_names.end(), names[c]);
733  if (pos == output_names.end())
734  continue;
735 
736  unsigned int variable_name_position =
737  cast_int<unsigned int>(pos - output_names.begin());
738 
739 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
740  std::vector<Real> real_parts(num_nodes);
741  std::vector<Real> imag_parts(num_nodes);
742  std::vector<Real> magnitudes(num_nodes);
743 
744  for (unsigned int i=0; i<num_nodes; ++i)
745  {
746  real_parts[i] = soln[i*num_vars + c].real();
747  imag_parts[i] = soln[i*num_vars + c].imag();
748  magnitudes[i] = std::abs(soln[i*num_vars + c]);
749  }
750  exio_helper->write_nodal_values(3*variable_name_position+1,real_parts,_timestep);
751  exio_helper->write_nodal_values(3*variable_name_position+2,imag_parts,_timestep);
752  exio_helper->write_nodal_values(3*variable_name_position+3,magnitudes,_timestep);
753 #else
754  std::vector<Number> cur_soln(num_nodes);
755 
756  // Copy out this variable's solution
757  for (dof_id_type i=0; i<num_nodes; i++)
758  cur_soln[i] = soln[i*num_vars + c];
759  exio_helper->write_nodal_values(variable_name_position+1,cur_soln,_timestep);
760 #endif
761 
762  }
763 }
double abs(double a)
const MT & mesh() const
Definition: mesh_output.h:216
std::vector< std::string > _output_variables
Definition: exodusII_io.h:331
void write_nodal_data_common(std::string fname, const std::vector< std::string > &names, bool continuous=true)
Definition: exodusII_io.C:946
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
uint8_t dof_id_type
Definition: id_types.h:64
void libMesh::ExodusII_IO::write_nodal_data_common ( std::string  fname,
const std::vector< std::string > &  names,
bool  continuous = true 
)
private

This function factors out a bunch of code which is common to the write_nodal_data() and write_nodal_data_discontinuous() functions

Definition at line 946 of file exodusII_io.C.

References _append, _verbose, exio_helper, libMesh::MeshBase::get_boundary_info(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::BoundaryInfo::n_edge_conds(), and libMesh::out.

Referenced by get_elem_var_names(), write_nodal_data(), and write_nodal_data_discontinuous().

949 {
950  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
951 
952  // This function can be called multiple times, we only want to open
953  // the ExodusII file the first time it's called.
954  if (!exio_helper->opened_for_writing)
955  {
956  // If we're appending, open() the file with read_only=false,
957  // otherwise create() it and write the contents of the mesh to
958  // it.
959  if (_append)
960  {
961  exio_helper->open(fname.c_str(), /*read_only=*/false);
962  // If we're appending, it's not valid to call exio_helper->initialize()
963  // or exio_helper->initialize_nodal_variables(), but we do need to set up
964  // certain aspects of the Helper object itself, such as the number of nodes
965  // and elements. We do that by reading the header...
966  exio_helper->read_header();
967 
968  // ...and reading the block info
969  exio_helper->read_block_info();
970  }
971  else
972  {
973  exio_helper->create(fname);
974 
975  exio_helper->initialize(fname, mesh, !continuous);
976  exio_helper->write_nodal_coordinates(mesh, !continuous);
977  exio_helper->write_elements(mesh, !continuous);
978 
979  exio_helper->write_sidesets(mesh);
980  exio_helper->write_nodesets(mesh);
981 
982  if ((mesh.get_boundary_info().n_edge_conds() > 0) && _verbose)
983  {
984  libMesh::out << "Warning: Mesh contains edge boundary IDs, but these "
985  << "are not supported by the ExodusII format."
986  << std::endl;
987  }
988 
989  exio_helper->initialize_nodal_variables(names);
990  }
991  }
992  else
993  {
994  // We are already open for writing, so check that the filename
995  // passed to this function matches the filename currently in use
996  // by the helper.
997  if (fname != exio_helper->current_filename)
998  libmesh_error_msg("Error! This ExodusII_IO object is already associated with file: " \
999  << exio_helper->current_filename \
1000  << ", cannot use it with requested file: " \
1001  << fname);
1002  }
1003 }
const MT & mesh() const
Definition: mesh_output.h:216
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
OStreamProxy out(std::cout)
void libMesh::ExodusII_IO::write_nodal_data_discontinuous ( const std::string &  fname,
const std::vector< Number > &  soln,
const std::vector< std::string > &  names 
)

Write out a discontinuous nodal solution.

Definition at line 888 of file exodusII_io.C.

References _timestep, std::abs(), libMesh::MeshBase::active_element_ptr_range(), exio_helper, libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::ParallelObject::processor_id(), and write_nodal_data_common().

Referenced by get_elem_var_names(), and write_discontinuous_exodusII().

891 {
892  LOG_SCOPE("write_nodal_data_discontinuous()", "ExodusII_IO");
893 
894  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
895 
896  int num_vars = cast_int<int>(names.size());
897  int num_nodes = 0;
898  for (const auto & elem : mesh.active_element_ptr_range())
899  num_nodes += elem->n_nodes();
900 
901 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
902 
903  std::vector<std::string> complex_names = exio_helper->get_complex_names(names);
904 
905  // Call helper function for opening/initializing data, giving it the
906  // complex variable names
907  this->write_nodal_data_common(fname, complex_names, /*continuous=*/false);
908 #else
909  // Call helper function for opening/initializing data
910  this->write_nodal_data_common(fname, names, /*continuous=*/false);
911 #endif
912 
913  if (mesh.processor_id())
914  return;
915 
916  for (int c=0; c<num_vars; c++)
917  {
918 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
919  std::vector<Real> real_parts(num_nodes);
920  std::vector<Real> imag_parts(num_nodes);
921  std::vector<Real> magnitudes(num_nodes);
922 
923  for (int i=0; i<num_nodes; ++i)
924  {
925  real_parts[i] = soln[i*num_vars + c].real();
926  imag_parts[i] = soln[i*num_vars + c].imag();
927  magnitudes[i] = std::abs(soln[i*num_vars + c]);
928  }
929  exio_helper->write_nodal_values(3*c+1,real_parts,_timestep);
930  exio_helper->write_nodal_values(3*c+2,imag_parts,_timestep);
931  exio_helper->write_nodal_values(3*c+3,magnitudes,_timestep);
932 #else
933  // Copy out this variable's solution
934  std::vector<Number> cur_soln(num_nodes);
935 
936  for (int i=0; i<num_nodes; i++)
937  cur_soln[i] = soln[i*num_vars + c];
938 
939  exio_helper->write_nodal_values(c+1,cur_soln,_timestep);
940 #endif
941  }
942 }
double abs(double a)
const MT & mesh() const
Definition: mesh_output.h:216
void write_nodal_data_common(std::string fname, const std::vector< std::string > &names, bool continuous=true)
Definition: exodusII_io.C:946
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
void libMesh::ExodusII_IO::write_timestep ( const std::string &  fname,
const EquationSystems es,
const int  timestep,
const Real  time,
const std::set< std::string > *  system_names = libmesh_nullptr 
)

Writes out the solution at a specific timestep.

Parameters
fnameName of the file to write to
esEquationSystems object which contains the solution vector.
timestepThe timestep to write out, should be 1 indexed.
timeThe current simulation time.
system_namesOptional list of systems to write solutions for.

Definition at line 834 of file exodusII_io.C.

References _timestep, exio_helper, libMesh::ParallelObject::processor_id(), and libMesh::MeshOutput< MeshBase >::write_equation_systems().

Referenced by get_elem_var_names().

839 {
840  _timestep = timestep;
841  write_equation_systems(fname,es,system_names);
842 
844  return;
845 
846  exio_helper->write_timestep(timestep, time);
847 }
const MeshBase & mesh() const
virtual void write_equation_systems(const std::string &, const EquationSystems &, const std::set< std::string > *system_names=libmesh_nullptr)
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
processor_id_type processor_id() const
void libMesh::ExodusII_IO::write_timestep_discontinuous ( const std::string &  fname,
const EquationSystems es,
const int  timestep,
const Real  time,
const std::set< std::string > *  system_names = libmesh_nullptr 
)

Writes a discontinuous solution at a specific timestep

Parameters
fnameName of the file to be written
esEquationSystems object which contains the solution vector
timestepThe timestep to write out. (should be 1 indexed)
timeThe current simulation time
system_namesOptional list of systems to write solutions for.

Definition at line 104 of file exodusII_io.C.

References _timestep, exio_helper, libMesh::ParallelObject::processor_id(), libMesh::Real, and write_discontinuous_exodusII().

109 {
110  _timestep = timestep;
111  write_discontinuous_exodusII(fname,es,system_names);
112 
114  return;
115 
116  exio_helper->write_timestep(timestep, time);
117 }
const MeshBase & mesh() const
std::unique_ptr< ExodusII_IO_Helper > exio_helper
Definition: exodusII_io.h:307
void write_discontinuous_exodusII(const std::string &name, const EquationSystems &es, const std::set< std::string > *system_names=libmesh_nullptr)
Definition: exodusII_io.C:89
processor_id_type processor_id() const

Member Data Documentation

bool libMesh::ExodusII_IO::_allow_empty_variables
private

If true, _output_variables is allowed to remain empty. If false, if _output_variables is empty it will be populated with a complete list of all variables By default, calling set_output_variables() sets this flag to true, but it provides an override.

Definition at line 346 of file exodusII_io.h.

Referenced by set_output_variables(), and write_nodal_data().

bool libMesh::ExodusII_IO::_append
private

Default false. If true, files will be opened with EX_WRITE rather than created from scratch when writing.

Definition at line 324 of file exodusII_io.h.

Referenced by append(), write(), and write_nodal_data_common().

const bool libMesh::MeshOutput< MeshBase >::_is_parallel_format
protectedinherited

Flag specifying whether this format is parallel-capable. If this is false (default) I/O is only permitted when the mesh has been serialized.

Definition at line 141 of file mesh_output.h.

Referenced by libMesh::FroIO::write(), libMesh::PostscriptIO::write(), and libMesh::EnsightIO::write().

std::vector<std::string> libMesh::ExodusII_IO::_output_variables
private

The names of the variables to be output. If this is empty then all variables are output.

Definition at line 331 of file exodusII_io.h.

Referenced by set_output_variables(), write_element_data(), and write_nodal_data().

const bool libMesh::MeshOutput< MeshBase >::_serial_only_needed_on_proc_0
protectedinherited

Flag specifying whether this format can be written by only serializing the mesh to processor zero

If this is false (default) the mesh will be serialized to all processors

Definition at line 150 of file mesh_output.h.

int libMesh::ExodusII_IO::_timestep
private
bool libMesh::ExodusII_IO::_verbose
private

should we be verbose?

Definition at line 318 of file exodusII_io.h.

Referenced by verbose(), write(), and write_nodal_data_common().


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