libMesh::CheckpointIO Class Reference

The CheckpointIO class can be used to write simplified restart files that can be used to restart simulations that have crashed. More...

#include <checkpoint_io.h>

Inheritance diagram for libMesh::CheckpointIO:

Public Types
typedef largest_id_type	xdr_id_type
typedef uint64_t	header_id_type

Public Member Functions
	CheckpointIO (MeshBase &, const bool=false)
	Constructor.
	CheckpointIO (const MeshBase &, const bool=false)
	Constructor.
virtual	~CheckpointIO ()
	Destructor.
virtual void	read (const std::string &input_name) override
	This method implements reading a mesh from a specified file.
virtual void	write (const std::string &name) override
	This method implements writing a mesh to a specified file.
bool	binary () const
	Get/Set the flag indicating if we should read/write binary.
bool &	binary ()
bool	parallel () const
	Get/Set the flag indicating if we should read/write binary.
bool &	parallel ()
const std::string &	version () const
	Get/Set the version string.
std::string &	version ()
bool	version_at_least_1_5 () const
bool	version_at_least_1_6 () const
bool	version_at_least_1_7 () const
const std::vector< processor_id_type > &	current_processor_ids () const
	Get/Set the processor id or processor ids to use.
std::vector< processor_id_type > &	current_processor_ids ()
const processor_id_type &	current_n_processors () const
	Get/Set the n_processors to use.
processor_id_type &	current_n_processors ()
template<typename file_id_type >
void	read_remote_elem (Xdr &io, bool libmesh_dbg_var(expect_all_remote))
bool	is_parallel_format () const
	Returns true iff this mesh file format and input class are parallelized, so that all processors can read their share of the data at once.
virtual void	write_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=nullptr)
	This method implements writing a mesh with data to a specified file where the data is taken from the EquationSystems object.
virtual void	write_discontinuous_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=nullptr)
	This method implements writing a mesh with discontinuous data to a specified file where the data is taken from the EquationSystems object.
virtual void	write_nodal_data (const std::string &, const std::vector< Number > &, const std::vector< std::string > &)
	This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are provided.
virtual void	write_nodal_data (const std::string &, const NumericVector< Number > &, const std::vector< std::string > &)
	This method may be overridden by "parallel" output formats for writing nodal data.
virtual void	write_nodal_data (const std::string &, const EquationSystems &, const std::set< std::string > *)
	This method should be overridden by "parallel" output formats for writing nodal data.
virtual void	write_nodal_data_discontinuous (const std::string &, const std::vector< Number > &, const std::vector< std::string > &)
	This method implements writing a mesh with discontinuous data to a specified file where the nodal data and variables names are provided.
unsigned int &	ascii_precision ()
	Return/set the precision to use when writing ASCII files.
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static void	cleanup (const std::string &input_name, processor_id_type n_procs)
	Used to remove a checkpoint directory and its corresponding files.

Protected Member Functions
MeshBase &	mesh ()
void	set_n_partitions (unsigned int n_parts)
	Sets the number of partitions in the mesh.
void	skip_comment_lines (std::istream &in, const char comment_start)
	Reads input from in, skipping all the lines that start with the character comment_start.
const MeshBase &	mesh () const
virtual bool	get_add_sides ()

Protected Attributes
std::vector< bool >	elems_of_dimension
	A vector of bools describing what dimension elements have been encountered when reading a mesh.
const bool	_is_parallel_format
	Flag specifying whether this format is parallel-capable.
const bool	_serial_only_needed_on_proc_0
	Flag specifying whether this format can be written by only serializing the mesh to processor zero.
const Parallel::Communicator &	_communicator

Private Member Functions
void	write_subdomain_names (Xdr &io) const
	Write subdomain name information.
void	write_connectivity (Xdr &io, const std::set< const Elem *, CompareElemIdsByLevel > &elements) const
	Write the connectivity for part of a mesh.
void	write_remote_elem (Xdr &io, const std::set< const Elem *, CompareElemIdsByLevel > &elements) const
	Write the remote_elem neighbor and child links for part of a mesh.
void	write_nodes (Xdr &io, const connected_node_set_type &nodeset) const
	Write the nodal locations for part of a mesh.
void	write_bcs (Xdr &io, const std::set< const Elem *, CompareElemIdsByLevel > &elements, const std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > > &bc_triples) const
	Write the side boundary conditions for part of a mesh.
void	write_nodesets (Xdr &io, const connected_node_set_type &nodeset, const std::vector< std::tuple< dof_id_type, boundary_id_type > > &bc_tuples) const
	Write the nodal boundary conditions for part of a mesh.
void	write_bc_names (Xdr &io, const BoundaryInfo &info, bool is_sideset) const
	Write boundary names information (sideset and nodeset)
void	write_disjoint_neighbor_boundary_pairs (Xdr &io) const
	Write disjoint neighbor boundary pairs.
template<typename file_id_type >
file_id_type	read_header (const std::string &name)
	Read header data on processor 0, then broadcast.
template<typename file_id_type >
void	read_subfile (Xdr &io, bool expect_all_remote)
	Read a non-header file.
template<typename file_id_type >
void	read_subdomain_names (Xdr &io)
	Read subdomain name information.
template<typename file_id_type >
void	read_connectivity (Xdr &io)
	Read the connectivity for a parallel, distributed mesh.
template<typename file_id_type >
void	read_remote_elem (Xdr &io, bool expect_all_remote)
	Read the remote_elem neighbor and child links for a parallel, distributed mesh.
template<typename file_id_type >
void	read_nodes (Xdr &io)
	Read the nodal locations for a parallel, distributed mesh.
template<typename file_id_type >
void	read_bcs (Xdr &io)
	Read the boundary conditions for a parallel, distributed mesh.
template<typename file_id_type >
void	read_nodesets (Xdr &io)
	Read the nodeset conditions for a parallel, distributed mesh.
template<typename file_id_type >
void	read_bc_names (Xdr &io, BoundaryInfo &info, bool is_sideset)
	Read boundary names information (sideset and nodeset)
template<typename file_id_type >
void	read_disjoint_neighbor_boundary_pairs (Xdr &io, std::vector< file_id_type > &pair_ids, std::vector< Real > &translations)
	Read disjoint neighbor boundary pairs: the two boundary ids of each pair, and the LIBMESH_DIM translation components of each pair.
template<typename file_id_type >
void	read_integers_names (Xdr &io, std::vector< std::string > &node_integer_names, std::vector< std::string > &elem_integer_names)
	Read extra integers names information.
unsigned int	n_active_levels_in (MeshBase::const_element_iterator begin, MeshBase::const_element_iterator end) const
processor_id_type	select_split_config (const std::string &input_name, header_id_type &data_size)

Private Attributes
bool	_binary
bool	_parallel
std::string	_version
std::vector< processor_id_type >	_my_processor_ids
processor_id_type	_my_n_processors
MeshBase *	_obj
	A pointer to a non-const object object.
const bool	_is_parallel_format
	Flag specifying whether this format is parallel-capable.
unsigned int	_ascii_precision
	Precision to use when writing ASCII files.

Detailed Description

The CheckpointIO class can be used to write simplified restart files that can be used to restart simulations that have crashed.

Author

Benjamin Kirk

John Peterson

Derek Gaston

Roy Stogner

Date

2017

Definition at line 61 of file checkpoint_io.h.

Member Typedef Documentation

header_id_type

typedef uint64_t libMesh::CheckpointIO::header_id_type

Definition at line 70 of file checkpoint_io.h.

xdr_id_type

typedef largest_id_type libMesh::CheckpointIO::xdr_id_type

Definition at line 67 of file checkpoint_io.h.

Constructor & Destructor Documentation

CheckpointIO() [1/2]

libMesh::CheckpointIO::CheckpointIO ( MeshBase &  mesh, const bool  binary_in = false  )

explicit

Constructor.

Takes a writable reference to a mesh object. This is the constructor required to read a mesh. The optional parameter binary can be used to switch between ASCII (false, the default) or binary (true) files.

Definition at line 196 of file checkpoint_io.C.

                                                                 :
  MeshInput<MeshBase> (mesh,/* is_parallel_format = */ true),
  MeshOutput<MeshBase>(mesh,/* is_parallel_format = */ true),
  ParallelObject      (mesh),
  _binary             (binary_in),
  _parallel           (false),
  _version            ("checkpoint-1.7"),
  _my_processor_ids   (1, processor_id()),
  _my_n_processors    (mesh.is_replicated() ? 1 : n_processors())
{
}

CheckpointIO() [2/2]

libMesh::CheckpointIO::CheckpointIO ( const MeshBase &  mesh, const bool  binary_in = false  )

explicit

Constructor.

Takes a reference to a constant mesh object. This constructor will only allow us to write the mesh. The optional parameter binary can be used to switch between ASCII (false, the default) or binary (true) files.

Definition at line 208 of file checkpoint_io.C.

                                                                       :
  MeshInput<MeshBase> (), // write-only
  MeshOutput<MeshBase>(mesh,/* is_parallel_format = */ true),
  ParallelObject      (mesh),
  _binary             (binary_in),
  _parallel           (false),
  _version            ("checkpoint-1.7"),
  _my_processor_ids   (1, processor_id()),
  _my_n_processors    (mesh.is_replicated() ? 1 : n_processors())
{
}

~CheckpointIO()

libMesh::CheckpointIO::~CheckpointIO ( )

virtualdefault

Destructor.

Member Function Documentation

ascii_precision()

unsigned int & libMesh::MeshOutput< MeshBase >::ascii_precision ( )

inlineinherited

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

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

Definition at line 160 of file mesh_output.h.

{
  return _ascii_precision;
}

binary() [1/2]

bool & libMesh::CheckpointIO::binary ( )

inline

Definition at line 147 of file checkpoint_io.h.

{ return _binary; }

References _binary.

binary() [2/2]

bool libMesh::CheckpointIO::binary ( ) const

inline

Get/Set the flag indicating if we should read/write binary.

Definition at line 146 of file checkpoint_io.h.

{ return _binary; }

References _binary.

Referenced by read(), read_header(), select_split_config(), CheckpointIOTest::testSplitter(), and write().

cleanup()

void libMesh::CheckpointIO::cleanup ( const std::string &  input_name, processor_id_type  n_procs  )

static

Used to remove a checkpoint directory and its corresponding files.

This effectively undoes all the work done be calls to write(...). For example, if a checkpoint configuration was written via:

unsigned int n_splits = 42;
std::unique_ptr<CheckpointIO> cp = split_mesh(my_mesh, n_splits);
// ...
cp->write("foo.cpr");

then you could remove all the corresponding created files/dirs by:

CheckpointIO::cleanup(my_mesh, n_splits);

Or for cases where the split configuration was determined automatically (e.g. via number of running procs with distributed/parallel mesh), then you could:

CheckpointIO::cleanup(your_mesh, your_mesh.comm().size());

Other remaining checkpoint split configurations for the mesh are left unmodified.

Definition at line 290 of file checkpoint_io.C.

{
  auto header = header_file(input_name, n_procs);
  auto ret = std::remove(header.c_str());
  if (ret != 0)
    libmesh_warning("Failed to clean up checkpoint header '" << header << "': " << std::strerror(ret));
 
  for (processor_id_type i = 0; i < n_procs; i++)
    {
      auto split = split_file(input_name, n_procs, i);
      ret = std::remove(split.c_str());
      if (ret != 0)
        libmesh_warning("Failed to clean up checkpoint split file '" << split << "': " << std::strerror(ret));
    }
 
  auto dir = split_dir(input_name, n_procs);
  ret = rmdir(dir.c_str());
  if (ret != 0)
    libmesh_warning("Failed to clean up checkpoint split dir '" << dir << "': " << std::strerror(ret));
 
  // We expect that this may fail if there are other split configurations still present in this
  // directory - so don't bother to check/warn for failure.
  rmdir(input_name.c_str());
}

Referenced by CheckpointIOTest::testC0PolygonCheckpoint(), CheckpointIOTest::testC0PolyhedronCheckpoint(), CheckpointIOTest::testDisjointNeighborPairsCheckpoint(), and CheckpointIOTest::testMissingSplitError().

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.

  { return _communicator; }

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::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), 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::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::RBEIMEvaluation::add_interpolation_data(), libMesh::CondensedEigenSystem::add_matrices(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::AdvectionSystem::assemble_claw_rhs(), 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::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::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::BoundaryInfo::build_side_list_from_node_list(), libMesh::MeshBase::cache_elem_data(), centroid_l2_error(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::MeshTetInterface::check_hull_integrity(), MeshInputTest::checkHexPrismPolyhedron(), libMesh::MeshBase::complete_preparation(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), 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::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::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), PetscSolverConfiguration::configure_solver(), 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::CondensedEigenSystem::copy_super_to_sub(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshBase::count_constraint_rows(), 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< T >::create_submatrix_nosort(), create_wrapped_function(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::MeshBase::detect_interior_parents(), libMesh::RBEIMEvaluation::distribute_bfs(), 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::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::SmoothnessEstimator::estimate_smoothness(), 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::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), 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(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::MeshTetInterface::improve_hull_integrity(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::StaticCondensation::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::LocationMap< T >::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), ElasticitySystem::init_data(), libMesh::AdvectionSystem::init_data(), libMesh::ClawSystem::init_data(), libMesh::PetscDMWrapper::init_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::Modification::interpolate_surface(), 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_constraint_rows(), 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_snes_postcheck(), 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::MeshCommunication::make_elems_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::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::MeshTools::n_connected_components(), libMesh::DofMap::n_constrained_dofs(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), 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::PetscVector< T >::operator=(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::ReplicatedMesh::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(), MeshGenerationTest::polyhedronTetNeighbor(), LaplaceSystem::postprocess(), PoissonSystem::postprocess(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), FEMParameters::read(), libMesh::EquationSystems::read(), read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::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::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::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(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), MeshFunctionTest::read_variable_info_from_output_data(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::BoundaryInfo::remove_edge_id(), libMesh::BoundaryInfo::remove_node_id(), libMesh::BoundaryInfo::remove_shellface_id(), libMesh::BoundaryInfo::remove_side_id(), 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(), 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::VariationalMeshSmoother::smooth(), libMesh::NoxNonlinearSolver< Number >::solve(), libMesh::ClawSystem::solve_conservation_law(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::MeshBase::sync_subdomain_name_map(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), MeshGenerationTest::testBuildCube(), BoundaryInfoTest::testBuildSideListFromNodeListThinMesh(), CheckpointIOTest::testC0PolygonCheckpoint(), VolumeTest::testC0PolygonMethods(), CheckpointIOTest::testC0PolyhedronCheckpoint(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), SystemsTest::testProjectScalarCoarsening(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testSelectiveRenumber(), BoundaryMeshSubdomainTest::testSingleSubdomain(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), update_current_local_solution(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::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::RBConstruction::write_riesz_representors_to_files(), libMesh::TransientRBConstruction::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().

current_n_processors() [1/2]

processor_id_type & libMesh::CheckpointIO::current_n_processors ( )

inline

Definition at line 210 of file checkpoint_io.h.

{ return _my_n_processors; }

References _my_n_processors.

current_n_processors() [2/2]

const processor_id_type & libMesh::CheckpointIO::current_n_processors ( ) const

inline

Get/Set the n_processors to use.

The default n_processors to use is the n_processors() of the mesh.

This is used for m->n parallel checkpoint file writing: You can force CheckpointIO to view the world as if it contains this number of processors by setting it here

Definition at line 209 of file checkpoint_io.h.

{ return _my_n_processors; }

References _my_n_processors.

Referenced by CheckpointIOTest::testMissingSplitError(), and CheckpointIOTest::testSplitter().

current_processor_ids() [1/2]

std::vector< processor_id_type > & libMesh::CheckpointIO::current_processor_ids ( )

inline

Definition at line 197 of file checkpoint_io.h.

{ return _my_processor_ids; }

References _my_processor_ids.

current_processor_ids() [2/2]

const std::vector< processor_id_type > & libMesh::CheckpointIO::current_processor_ids ( ) const

inline

Get/Set the processor id or processor ids to use.

The default processor_id to use is the processor_id() of the mesh.

This is used for m->n parallel checkpoint file writing: You can force CheckpointIO to write out different partitions of a mesh by setting which partitions to write from each processor here.

Definition at line 196 of file checkpoint_io.h.

{ return _my_processor_ids; }

References _my_processor_ids.

Referenced by CheckpointIOTest::testMissingSplitError(), and CheckpointIOTest::testSplitter().

get_add_sides()

virtual bool libMesh::MeshOutput< MeshBase >::get_add_sides ( )

inlineprotectedvirtualinherited

Returns

Whether or not added sides are expected to be output, to plot SIDE_DISCONTINUOUS data. Subclasses should override this if they are capable of plotting such data.

Reimplemented in libMesh::ExodusII_IO.

Definition at line 176 of file mesh_output.h.

{ return false; }

is_parallel_format()

bool libMesh::MeshInput< MeshBase >::is_parallel_format ( ) const

inlineinherited

Returns true iff this mesh file format and input class are parallelized, so that all processors can read their share of the data at once.

Definition at line 87 of file mesh_input.h.

{ return this->_is_parallel_format; }

mesh() [1/2]

MeshBase & libMesh::MeshInput< MeshBase >::mesh ( )

inlineprotectedinherited

Returns

The object as a writable reference.

Definition at line 94 of file mesh_input.h.

{
  libmesh_error_msg_if(_obj == nullptr, "ERROR: _obj should not be nullptr!");
  return *_obj;
}

mesh() [2/2]

const MeshBase & libMesh::MeshOutput< MeshBase >::mesh ( ) const

inlineprotectedinherited

Returns

The object as a read-only reference.

Definition at line 168 of file mesh_output.h.

{
  libmesh_assert(_obj);
  return *_obj;
}

n_active_levels_in()

unsigned int libMesh::CheckpointIO::n_active_levels_in ( MeshBase::const_element_iterator  begin, MeshBase::const_element_iterator  end  ) const

private

Returns

The number of levels of refinement in the active mesh on this processor.

Note

This includes all elements on this processor even those not owned by this processor! Implemented by looping over all the active elements and finding the maximum level.

Definition at line 1787 of file checkpoint_io.C.

{
  unsigned int max_level = 0;
 
  for (const auto & elem : as_range(begin, end))
    max_level = std::max(elem->level(), max_level);
 
  return max_level + 1;
}

References libMesh::as_range().

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 103 of file parallel_object.h.

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

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

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::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), ExodusC0PolyhedronTest::assert_distributed_if_parallel(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::Partitioner::build_graph(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::NumericVector< T >::is_effectively_ghosted(), libMesh::NumericVector< T >::is_effectively_serial(), 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::MeshBase::n_active_elem_on_proc(), libMesh::DofMap::n_dofs_per_processor(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::Nemesis_IO::read(), read(), libMesh::NameBasedIO::read(), read_connectivity(), libMesh::XdrIO::read_header(), 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_ids(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DistributedMesh::set_next_unique_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), ExodusC0PolyhedronTest::test_write_and_read_mixed_hex_tet_block_names_impl(), CheckpointIOTest::testDisjointNeighborPairsCheckpoint(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::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().

parallel() [1/2]

bool & libMesh::CheckpointIO::parallel ( )

inline

Definition at line 153 of file checkpoint_io.h.

{ return _parallel; }

References _parallel.

parallel() [2/2]

bool libMesh::CheckpointIO::parallel ( ) const

inline

Get/Set the flag indicating if we should read/write binary.

Definition at line 152 of file checkpoint_io.h.

{ return _parallel; }

References _parallel.

Referenced by CheckpointIOTest::testMissingSplitError(), CheckpointIOTest::testSplitter(), and write().

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.

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

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::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::MeshFunction::check_found_elem(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), 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::RBConstruction::compute_max_error_bound(), 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::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::MeshBase::count_constraint_rows(), libMesh::ExodusII_IO_Helper::create(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), 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::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::MeshBase::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), 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::MeshTools::Modification::interpolate_surface(), libMesh::SparsityPattern::Build::join(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::TransientRBEvaluation::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(), main(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMapBase::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::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), 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::XdrIO::read(), libMesh::Nemesis_IO::read(), read(), libMesh::NameBasedIO::read(), libMesh::EquationSystems::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::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(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), select_split_config(), libMesh::DistributedMesh::set_next_ids(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DistributedMesh::set_next_unique_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolyhedronTest::test_write_and_read_mixed_hex_tet_block_names_impl(), ExodusC0PolygonTest::test_write_and_read_pentagon(), MeshInputTest::testAbaqusRead(), MeshInputTest::testBadGmsh(), BoundaryInfoTest::testBoundaryIDs(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusCopyHighOrderElementSolution(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), DofMapTest::testGhostConstraintSendList(), MeshInputTest::testGmshBCIDOverlap(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), BoundaryInfoTest::testInternalBoundary(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), BoundaryMeshSubdomainTest::testSingleSubdomain(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), write(), libMesh::EquationSystems::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_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::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::UCDIO::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(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_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(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

read()

void libMesh::CheckpointIO::read ( const std::string &  input_name )

overridevirtual

This method implements reading a mesh from a specified file.

If the mesh has been split for running on several processors, input_name should simply be the name of the mesh split directory without the "-split[n]" suffix. The number of splits will be determined automatically by the number of processes being used for the mesh at the time of reading.

Implements libMesh::MeshInput< MeshBase >.

Definition at line 939 of file checkpoint_io.C.

{
  LOG_SCOPE("read()","CheckpointIO");
 
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  libmesh_assert(!mesh.n_elem());
 
  header_id_type data_size;
  processor_id_type input_n_procs = select_split_config(input_name, data_size);
  auto header_name = header_file(input_name, input_n_procs);
  bool input_parallel = input_n_procs > 0;
 
  // If this is a serial read then we're going to only read the mesh
  // on processor 0, then broadcast it
  if ((input_parallel && !mesh.is_replicated()) || mesh.processor_id() == 0)
    {
      // If we're trying to read a parallel checkpoint file on a
      // replicated mesh, we'll read every file on processor 0 so we
      // can broadcast it later.  If we're on a distributed mesh then
      // we'll read every id to it's own processor and we'll "wrap
      // around" with any ids that exceed our processor count.
      const processor_id_type begin_proc_id =
        (input_parallel && !mesh.is_replicated()) ?
        mesh.processor_id() : 0;
      const processor_id_type stride =
        (input_parallel && !mesh.is_replicated()) ?
        mesh.n_processors() : 1;
 
      for (processor_id_type proc_id = begin_proc_id; proc_id < input_n_procs;
           proc_id = cast_int<processor_id_type>(proc_id + stride))
        {
          auto file_name = split_file(input_name, input_n_procs, proc_id);
 
          {
            std::ifstream in (file_name.c_str());
 
            libmesh_error_msg_if(!in.good(), "ERROR: cannot locate specified file:\n\t" << file_name);
          }
 
          // Do we expect all our files' remote_elem entries to really
          // be remote?  Only if we're not reading multiple input
          // files on the same processor.
          const bool expect_all_remote =
            (input_n_procs <= mesh.n_processors() &&
             !mesh.is_replicated());
 
          Xdr io (file_name, this->binary() ? DECODE : READ);
 
          switch (data_size) {
          case 2:
            this->read_subfile<uint16_t>(io, expect_all_remote);
            break;
          case 4:
            this->read_subfile<uint32_t>(io, expect_all_remote);
            break;
          case 8:
            this->read_subfile<uint64_t>(io, expect_all_remote);
            break;
          default:
            libmesh_error();
          }
 
          io.close();
        }
    }
 
  // If the mesh was only read on processor 0 then we need to broadcast it
  if (mesh.is_replicated())
    MeshCommunication().broadcast(mesh);
  // If the mesh is really distributed then we need to make sure it
  // knows that
  else if (mesh.n_processors() > 1)
    mesh.set_distributed();
 
  // If the mesh isn't getting even critical partitioning then we
  // should update cached data from the partitioning we just read in
  if (mesh.skip_partitioning())
    {
      mesh.recalculate_n_partitions();
      mesh.update_post_partitioning();
    }
}

References binary(), libMesh::MeshCommunication::broadcast(), libMesh::Xdr::close(), libMesh::DECODE, libMesh::MeshBase::is_replicated(), libMesh::libmesh_assert(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshBase::n_elem(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::READ, libMesh::MeshBase::recalculate_n_partitions(), select_split_config(), libMesh::MeshBase::set_distributed(), libMesh::MeshBase::skip_partitioning(), and libMesh::MeshBase::update_post_partitioning().

Referenced by libMesh::NameBasedIO::read(), CheckpointIOTest::testC0PolygonCheckpoint(), CheckpointIOTest::testC0PolyhedronCheckpoint(), CheckpointIOTest::testDisjointNeighborPairsCheckpoint(), CheckpointIOTest::testMissingSplitError(), and CheckpointIOTest::testSplitter().

read_bc_names()

template<typename file_id_type >

void libMesh::CheckpointIO::read_bc_names ( Xdr &  io, BoundaryInfo &  info, bool  is_sideset  )

private

Read boundary names information (sideset and nodeset)

Definition at line 1720 of file checkpoint_io.C.

{
  std::map<boundary_id_type, std::string> & boundary_map = is_sideset ?
    info.set_sideset_name_map() : info.set_nodeset_name_map();
 
  std::vector<file_id_type> boundary_ids;
  std::vector<std::string>  boundary_names;
 
  file_id_type n_boundary_names = 0;
 
  if (is_sideset)
    io.data(n_boundary_names, "# sideset id to name map");
  else
    io.data(n_boundary_names, "# nodeset id to name map");
 
  if (n_boundary_names)
    {
      io.data(boundary_ids);
      io.data(boundary_names);
    }
 
  // Add them back into the map
  for (auto i : index_range(boundary_ids))
    boundary_map[cast_int<boundary_id_type>(boundary_ids[i])] =
      boundary_names[i];
}

References libMesh::Xdr::data(), and libMesh::index_range().

read_bcs()

template<typename file_id_type >

void libMesh::CheckpointIO::read_bcs ( Xdr &  io )

private

Read the boundary conditions for a parallel, distributed mesh.

Definition at line 1672 of file checkpoint_io.C.

{
  // convenient reference to our mesh
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  // and our boundary info object
  BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
  std::vector<file_id_type> element_id_list;
  std::vector<uint16_t> side_list;
  std::vector<file_id_type> bc_id_list;
 
  io.data(element_id_list, "# element ids for bcs");
  io.data(side_list, "# sides of elements for bcs");
  io.data(bc_id_list, "# bc ids");
 
  for (auto i : index_range(element_id_list))
    boundary_info.add_side
      (cast_int<dof_id_type>(element_id_list[i]), side_list[i],
       cast_int<boundary_id_type>(bc_id_list[i]));
}

References libMesh::BoundaryInfo::add_side(), libMesh::Xdr::data(), libMesh::MeshBase::get_boundary_info(), libMesh::index_range(), libMesh::MeshInput< MT >::mesh(), and libMesh::MeshInput< MeshBase >::mesh().

read_connectivity()

template<typename file_id_type >

void libMesh::CheckpointIO::read_connectivity ( Xdr &  io )

private

Read the connectivity for a parallel, distributed mesh.

Definition at line 1298 of file checkpoint_io.C.

{
  // convenient reference to our mesh
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  const bool read_extra_integers = this->version_at_least_1_5();
  const bool read_runtime_topology = this->version_at_least_1_6();
 
  const unsigned int n_extra_integers =
    read_extra_integers ? mesh.n_elem_integers() : 0;
 
  file_id_type n_elems_here;
  io.data(n_elems_here);
 
  // Keep track of the highest dimensional element we've added to the mesh
  unsigned int highest_elem_dim = mesh.mesh_dimension();
 
  // RHS: Originally we used invalid_processor_id as a "no parent" tag
  // number, because I'm an idiot.  Let's try to support broken files
  // as much as possible.
  bool file_is_broken = false;
 
  for (unsigned int i=0; i<n_elems_here; i++)
    {
      // id type pid subdomain_id parent_id
      std::vector<file_id_type> elem_data(6 + n_extra_integers);
      io.data_stream
        (elem_data.data(), cast_int<unsigned int>(elem_data.size()),
         cast_int<unsigned int>(elem_data.size()));
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      file_id_type unique_id = 0;
      io.data(unique_id, "# unique id");
#endif
 
#ifdef LIBMESH_ENABLE_AMR
      uint16_t p_level = 0;
      io.data(p_level, "# p_level");
 
      uint16_t rflag, pflag;
      io.data(rflag, "# rflag");
      io.data(pflag, "# pflag");
#endif
 
      const ElemType elem_type =
        static_cast<ElemType>(elem_data[1]);
      const bool is_c0polygon = (elem_type == C0POLYGON);
      const bool is_c0polyhedron = (elem_type == C0POLYHEDRON);
 
      unsigned int n_nodes = Elem::type_to_n_nodes_map[elem_data[1]];
      // Runtime-topology types have no fixed node count in this map.
      const bool has_runtime_topology = (n_nodes == invalid_uint);
      std::vector<std::vector<unsigned int>> nodes_on_sides;
 
      if (has_runtime_topology)
        {
          libmesh_error_msg_if
            (!read_runtime_topology,
             "Checkpoint format 1.6 or newer is required to read " <<
             Utility::enum_to_string(elem_type) << " elements.");
 
          std::vector<file_id_type> runtime_topology;
          io.data(runtime_topology, "# runtime topology");
          libmesh_error_msg_if(runtime_topology.size() < 2,
                               "Invalid runtime element topology.");
 
          std::size_t topology_index = 0;
          n_nodes =
            cast_int<unsigned int>(runtime_topology[topology_index++]);
          const unsigned int n_sides =
            cast_int<unsigned int>(runtime_topology[topology_index++]);
          nodes_on_sides.resize(n_sides);
 
          for (auto s : index_range(nodes_on_sides))
            {
              libmesh_error_msg_if
                (topology_index == runtime_topology.size(),
                 "Incomplete runtime element checkpoint topology.");
 
              const unsigned int n_side_nodes =
                cast_int<unsigned int>(runtime_topology[topology_index++]);
              libmesh_error_msg_if
                (n_side_nodes > runtime_topology.size() - topology_index,
                 "Invalid runtime element side checkpoint topology.");
 
              auto & side_nodes = nodes_on_sides[s];
              side_nodes.resize(n_side_nodes);
              for (auto n : index_range(side_nodes))
                {
                  const unsigned int local_node =
                    cast_int<unsigned int>(runtime_topology[topology_index++]);
                  libmesh_error_msg_if
                    (local_node >= n_nodes,
                     "Runtime element side checkpoint topology references "
                     "an invalid local node.");
                  side_nodes[n] = local_node;
                }
            }
 
          libmesh_error_msg_if
            (topology_index != runtime_topology.size(),
             "Extra data in runtime element checkpoint topology.");
 
          if (is_c0polygon)
            {
              libmesh_error_msg_if
                (n_nodes < 3 || n_sides != n_nodes,
                 "Invalid C0POLYGON checkpoint topology.");
              for (const auto & side_nodes : nodes_on_sides)
                libmesh_error_msg_if
                  (side_nodes.size() != 2,
                   "Invalid C0POLYGON side checkpoint topology.");
            }
          else if (is_c0polyhedron)
            {
              libmesh_error_msg_if(n_sides < 4,
                                   "Invalid C0POLYHEDRON checkpoint topology.");
              for (const auto & side_nodes : nodes_on_sides)
                libmesh_error_msg_if
                  (side_nodes.size() < 3,
                   "Invalid C0POLYHEDRON side checkpoint topology.");
            }
        }
 
      // Snag the node ids this element was connected to
      std::vector<file_id_type> conn_data(n_nodes);
      io.data_stream
        (conn_data.data(), cast_int<unsigned int>(conn_data.size()),
         cast_int<unsigned int>(conn_data.size()));
 
      const dof_id_type id                 =
        cast_int<dof_id_type>      (elem_data[0]);
      const processor_id_type proc_id      =
        cast_int<processor_id_type>
        (elem_data[2] % mesh.n_processors());
      const subdomain_id_type subdomain_id =
        restrict_int<subdomain_id_type>(elem_data[3]);
 
      // Old broken files used processsor_id_type(-1)...
      // But we *know* our first element will be level 0
      if (i == 0 && elem_data[4] == 65535)
        file_is_broken = true;
 
      // On a broken file we can't tell whether a parent of 65535 is a
      // null parent or an actual parent of 65535.  Assuming the
      // former will cause less breakage.
      Elem * parent =
        (elem_data[4] == static_cast<largest_id_type>(-1) ||
         (file_is_broken && elem_data[4] == 65535)) ?
        nullptr : mesh.elem_ptr(cast_int<dof_id_type>(elem_data[4]));
 
      const unsigned short int child_num   =
        (elem_data[5] == static_cast<largest_id_type>(-1) ||
         (file_is_broken && elem_data[5] == 65535)) ?
        static_cast<unsigned short>(-1) :
        cast_int<unsigned short>(elem_data[5]);
 
      if (!parent)
        libmesh_assert_equal_to
          (child_num, static_cast<unsigned short>(-1));
 
      Elem * old_elem = mesh.query_elem_ptr(id);
 
      // If we already have this element (e.g. from another file,
      // when reading multiple distributed CheckpointIO files into
      // a ReplicatedMesh) then we don't want to add it again
      // (because ReplicatedMesh can't handle that) but we do want
      // to assert consistency between what we're reading and what
      // we have.
      if (old_elem)
        {
          libmesh_assert_equal_to(elem_type, old_elem->type());
          libmesh_assert_equal_to(proc_id, old_elem->processor_id());
          libmesh_assert_equal_to(subdomain_id, old_elem->subdomain_id());
          if (parent)
            libmesh_assert_equal_to(parent, old_elem->parent());
          else
            libmesh_assert(!old_elem->parent());
 
          libmesh_assert_equal_to(n_extra_integers, old_elem->n_extra_integers());
#ifndef NDEBUG
          for (unsigned int ei=0; ei != n_extra_integers; ++ei)
            {
              const dof_id_type extra_int = cast_int<dof_id_type>(elem_data[6+ei]);
              libmesh_assert_equal_to(extra_int, old_elem->get_extra_integer(ei));
            }
#endif
 
          libmesh_assert_equal_to(old_elem->n_nodes(), conn_data.size());
 
          for (unsigned int n=0,
               n_conn = cast_int<unsigned int>(conn_data.size());
               n != n_conn; n++)
            libmesh_assert_equal_to
              (old_elem->node_id(n),
               cast_int<dof_id_type>(conn_data[n]));
 
          if (has_runtime_topology)
            {
              libmesh_assert_equal_to(old_elem->n_sides(),
                                      nodes_on_sides.size());
#ifndef NDEBUG
              for (auto s : index_range(nodes_on_sides))
                libmesh_assert(old_elem->nodes_on_side(s) ==
                               nodes_on_sides[s]);
#endif
            }
        }
      else
        {
          // Create the element
          std::unique_ptr<Elem> elem;
          std::unique_ptr<Node> generated_mid_elem_node;
 
          if (is_c0polygon)
            elem = std::make_unique<C0Polygon>(n_nodes, parent);
          else if (is_c0polyhedron)
            {
              std::vector<std::shared_ptr<Polygon>> sides(nodes_on_sides.size());
              for (auto s : index_range(nodes_on_sides))
                {
                  const auto & side_node_indices = nodes_on_sides[s];
                  auto side =
                    std::make_shared<C0Polygon>
                      (cast_int<unsigned int>(side_node_indices.size()));
                  for (auto n : index_range(side_node_indices))
                    side->set_node
                      (n, mesh.node_ptr(cast_int<dof_id_type>
                       (conn_data[side_node_indices[n]])));
                  sides[s] = std::move(side);
                }
 
              elem = std::make_unique<C0Polyhedron>
                (sides, generated_mid_elem_node, parent);
 
              libmesh_error_msg_if
                (elem->n_nodes() != conn_data.size(),
                 "C0POLYHEDRON checkpoint topology is incompatible with "
                 "this libMesh configuration.");
 
              for (auto n : make_range(elem->n_vertices()))
                libmesh_error_msg_if
                  (elem->node_id(n) !=
                   cast_int<dof_id_type>(conn_data[n]),
                   "C0POLYHEDRON checkpoint topology has inconsistent "
                   "local node ordering.");
            }
          else
            elem = Elem::build(elem_type, parent);
 
          if (has_runtime_topology)
            {
              libmesh_error_msg_if
                (!elem->runtime_topology() ||
                 elem->n_nodes() != conn_data.size() ||
                 elem->n_sides() != nodes_on_sides.size(),
                 Utility::enum_to_string(elem_type) <<
                 " checkpoint topology is incompatible with this "
                 "libMesh configuration.");
 
              for (auto s : index_range(nodes_on_sides))
                libmesh_error_msg_if
                  (elem->nodes_on_side(s) != nodes_on_sides[s],
                   Utility::enum_to_string(elem_type) <<
                   " checkpoint topology has inconsistent side ordering.");
            }
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
          elem->set_unique_id(unique_id);
#endif
 
          if (elem->dim() > highest_elem_dim)
            highest_elem_dim = elem->dim();
 
          elem->set_id()       = id;
          elem->processor_id() = proc_id;
          elem->subdomain_id() = subdomain_id;
 
#ifdef LIBMESH_ENABLE_AMR
          elem->hack_p_level(p_level);
 
          elem->set_refinement_flag  (cast_int<Elem::RefinementState>(rflag));
          elem->set_p_refinement_flag(cast_int<Elem::RefinementState>(pflag));
 
          // Set parent connections
          if (parent)
            {
              // We must specify a child_num, because we will have
              // skipped adding any preceding remote_elem children
              parent->add_child(elem.get(), child_num);
            }
#else
          libmesh_ignore(child_num);
#endif
 
          libmesh_assert(elem->n_nodes() == conn_data.size());
 
          // Connect all the nodes to this element
          for (unsigned int n=0,
               n_conn = cast_int<unsigned int>(conn_data.size());
               n != n_conn; n++)
            elem->set_node(n,
              mesh.node_ptr(cast_int<dof_id_type>(conn_data[n])));
 
          Elem * added_elem = mesh.add_elem(std::move(elem));
 
          libmesh_assert_equal_to(n_extra_integers, added_elem->n_extra_integers());
          for (unsigned int ei=0; ei != n_extra_integers; ++ei)
            {
              const dof_id_type extra_int = cast_int<dof_id_type>(elem_data[6+ei]);
              added_elem->set_extra_integer(ei, extra_int);
            }
        }
    }
 
  mesh.set_mesh_dimension(cast_int<unsigned char>(highest_elem_dim));
}

References libMesh::Elem::add_child(), libMesh::MeshBase::add_elem(), libMesh::Elem::build(), libMesh::C0POLYGON, libMesh::C0POLYHEDRON, libMesh::Xdr::data(), libMesh::Xdr::data_stream(), libMesh::MeshBase::elem_ptr(), libMesh::Utility::enum_to_string(), libMesh::DofObject::get_extra_integer(), libMesh::index_range(), libMesh::invalid_uint, libMesh::libmesh_assert(), libMesh::libmesh_ignore(), libMesh::make_range(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_elem_integers(), libMesh::DofObject::n_extra_integers(), libMesh::Elem::n_nodes(), n_nodes, libMesh::ParallelObject::n_processors(), libMesh::Elem::n_sides(), libMesh::Elem::node_id(), libMesh::MeshBase::node_ptr(), libMesh::Elem::nodes_on_side(), libMesh::Elem::parent(), libMesh::DofObject::processor_id(), libMesh::MeshBase::query_elem_ptr(), libMesh::DofObject::set_extra_integer(), libMesh::MeshBase::set_mesh_dimension(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), libMesh::Elem::type_to_n_nodes_map, version_at_least_1_5(), and version_at_least_1_6().

read_disjoint_neighbor_boundary_pairs()

template<typename file_id_type >

void libMesh::CheckpointIO::read_disjoint_neighbor_boundary_pairs ( Xdr &  io, std::vector< file_id_type > &  pair_ids, std::vector< Real > &  translations  )

private

Read disjoint neighbor boundary pairs: the two boundary ids of each pair, and the LIBMESH_DIM translation components of each pair.

Definition at line 1749 of file checkpoint_io.C.

{
  file_id_type n_pairs = 0;
  io.data(n_pairs, "# disjoint neighbor boundary pairs");
  if (n_pairs)
    {
      io.data(pair_ids);
      libmesh_error_msg_if(pair_ids.size() != 2 * n_pairs,
                           "Expected " << 2 * n_pairs << " disjoint neighbor boundary ids, found "
                           << pair_ids.size());
 
      translations.resize(LIBMESH_DIM * n_pairs);
      io.data_stream(translations.data(),
                     cast_int<unsigned int>(translations.size()),
                     LIBMESH_DIM);
    }
}

References libMesh::Xdr::data(), and libMesh::Xdr::data_stream().

read_header()

template<typename file_id_type >

file_id_type libMesh::CheckpointIO::read_header ( const std::string &  name )

private

Read header data on processor 0, then broadcast.

Returns the number of processors for which parallel non-header files have been written, or 0 if files were written in serial.

Definition at line 1026 of file checkpoint_io.C.

{
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  // Hack for codes which don't look at all elem dimensions
  uint16_t mesh_dimension;
 
  // Will this be a parallel input file?  With how many processors?  Stay tuned!
  uint16_t input_parallel;
  file_id_type input_n_procs;
 
  std::string input_version;
  std::vector<std::string> node_integer_names, elem_integer_names;
  std::vector<file_id_type> disjoint_pair_ids;
  std::vector<Real> disjoint_translations;
 
  // We'll write a header file from processor 0 and broadcast.
  if (this->processor_id() == 0)
    {
      Xdr io (name, this->binary() ? DECODE : READ);
 
      // read the version
      io.data(input_version);
 
      // read the data type, don't care about it this time
      header_id_type data_size;
      io.data (data_size);
 
      // read the dimension
      io.data (mesh_dimension);
 
      // Read whether or not this is a parallel file
      io.data(input_parallel);
 
      // With how many processors?
      if (input_parallel)
        io.data(input_n_procs);
 
      // read subdomain names
      this->read_subdomain_names<file_id_type>(io);
 
      // read boundary names
      BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
      this->read_bc_names<file_id_type>(io, boundary_info, true);  // sideset names
      this->read_bc_names<file_id_type>(io, boundary_info, false); // nodeset names
 
      // read extra integer names?
      std::swap(input_version, this->version());
      const bool read_extra_integers = this->version_at_least_1_5();
      std::swap(input_version, this->version());
 
      if (read_extra_integers)
        this->read_integers_names<file_id_type>
          (io, node_integer_names, elem_integer_names);
 
      std::swap(input_version, this->version());
      const bool read_disjoint_pairs = this->version_at_least_1_7();
      std::swap(input_version, this->version());
 
      if (read_disjoint_pairs)
        this->read_disjoint_neighbor_boundary_pairs<file_id_type>
          (io, disjoint_pair_ids, disjoint_translations);
    }
 
  // broadcast data from processor 0, set values everywhere
  this->comm().broadcast(input_version);
  this->version() = input_version;
 
  this->comm().broadcast(mesh_dimension);
  mesh.set_mesh_dimension(cast_int<unsigned char>(mesh_dimension));
 
  this->comm().broadcast(input_parallel);
 
  if (input_parallel)
    this->comm().broadcast(input_n_procs);
  else
    input_n_procs = 1;
 
  std::map<subdomain_id_type, std::string> & subdomain_map =
    mesh.set_subdomain_name_map();
  this->comm().broadcast(subdomain_map);
 
  BoundaryInfo & boundary_info = mesh.get_boundary_info();
  this->comm().broadcast(boundary_info.set_sideset_name_map());
  this->comm().broadcast(boundary_info.set_nodeset_name_map());
 
  this->comm().broadcast(node_integer_names);
  this->comm().broadcast(elem_integer_names);
 
  for (auto & int_name : node_integer_names)
    mesh.add_node_integer(int_name);
 
  for (auto & int_name : elem_integer_names)
    mesh.add_elem_integer(int_name);
 
  this->comm().broadcast(disjoint_pair_ids);
  this->comm().broadcast(disjoint_translations);
 
#ifdef LIBMESH_ENABLE_PERIODIC
  // The file is the complete record of the pairs, so it replaces any
  // pairs left on a reused mesh rather than merging with them
  if (this->version_at_least_1_7())
    if (PeriodicBoundaries * db = mesh.get_disjoint_neighbor_boundary_pairs())
      db->clear();
 
  for (auto i : make_range(disjoint_pair_ids.size() / 2))
    {
      RealVectorValue translation;
      for (auto d : make_range(LIBMESH_DIM))
        translation(d) = disjoint_translations[LIBMESH_DIM * i + d];
      mesh.add_disjoint_neighbor_boundary_pairs
        (cast_int<boundary_id_type>(disjoint_pair_ids[2 * i]),
         cast_int<boundary_id_type>(disjoint_pair_ids[2 * i + 1]),
         translation);
    }
#else
  libmesh_error_msg_if(!disjoint_pair_ids.empty(),
                       "Reading disjoint neighbor boundary pairs requires --enable-periodic");
#endif
 
  return input_parallel ? input_n_procs : 0;
}

References libMesh::MeshBase::add_disjoint_neighbor_boundary_pairs(), libMesh::MeshBase::add_elem_integer(), libMesh::MeshBase::add_node_integer(), binary(), libMesh::Parallel::Communicator::broadcast(), libMesh::ParallelObject::comm(), libMesh::Xdr::data(), libMesh::DECODE, libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::get_disjoint_neighbor_boundary_pairs(), libMesh::make_range(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshInput< MT >::mesh(), libMesh::ParallelObject::processor_id(), libMesh::READ, libMesh::MeshBase::set_mesh_dimension(), libMesh::BoundaryInfo::set_nodeset_name_map(), libMesh::BoundaryInfo::set_sideset_name_map(), libMesh::MeshBase::set_subdomain_name_map(), version(), version_at_least_1_5(), and version_at_least_1_7().

read_integers_names()

template<typename file_id_type >

void libMesh::CheckpointIO::read_integers_names ( Xdr &  io, std::vector< std::string > &  node_integer_names, std::vector< std::string > &  elem_integer_names  )

private

Read extra integers names information.

Definition at line 1773 of file checkpoint_io.C.

{
  file_id_type n_node_integers, n_elem_integers;
 
  io.data(n_node_integers, "# n_extra_integers per node");
  io.data(node_integer_names);
  io.data(n_elem_integers, "# n_extra_integers per elem");
  io.data(elem_integer_names);
}

References libMesh::Xdr::data().

read_nodes()

template<typename file_id_type >

void libMesh::CheckpointIO::read_nodes ( Xdr &  io )

private

Read the nodal locations for a parallel, distributed mesh.

Definition at line 1204 of file checkpoint_io.C.

{
  // convenient reference to our mesh
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  file_id_type n_nodes_here;
  io.data(n_nodes_here, "# n_nodes on proc");
 
  const bool read_extra_integers = this->version_at_least_1_5();
 
  const unsigned int n_extra_integers =
    read_extra_integers ? mesh.n_node_integers() : 0;
 
  // Will hold the node id and pid and extra integers
  std::vector<file_id_type> id_pid(2 + n_extra_integers);
 
  // For the coordinates
  std::vector<Real> coords(LIBMESH_DIM);
 
  for (unsigned int i=0; i<n_nodes_here; i++)
    {
      io.data_stream(id_pid.data(), 2 + n_extra_integers, 2 + n_extra_integers);
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      file_id_type unique_id = 0;
      io.data(unique_id, "# unique id");
#endif
 
      io.data_stream(coords.data(), LIBMESH_DIM, LIBMESH_DIM);
 
      Point p;
      p(0) = coords[0];
 
#if LIBMESH_DIM > 1
      p(1) = coords[1];
#endif
 
#if LIBMESH_DIM > 2
      p(2) = coords[2];
#endif
 
      const dof_id_type id = cast_int<dof_id_type>(id_pid[0]);
 
      // "Wrap around" if we see more processors than we're using.
      processor_id_type pid =
        cast_int<processor_id_type>(id_pid[1] % mesh.n_processors());
 
      // If we already have this node (e.g. from another file, when
      // reading multiple distributed CheckpointIO files into a
      // ReplicatedMesh) then we don't want to add it again (because
      // ReplicatedMesh can't handle that) but we do want to assert
      // consistency between what we're reading and what we have.
      const Node * old_node = mesh.query_node_ptr(id);
 
      if (old_node)
        {
          libmesh_assert_equal_to(pid, old_node->processor_id());
 
          libmesh_assert_equal_to(n_extra_integers, old_node->n_extra_integers());
#ifndef NDEBUG
          for (unsigned int ei=0; ei != n_extra_integers; ++ei)
            {
              const dof_id_type extra_int = cast_int<dof_id_type>(id_pid[2+ei]);
              libmesh_assert_equal_to(extra_int, old_node->get_extra_integer(ei));
            }
#endif
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
          libmesh_assert_equal_to(unique_id, old_node->unique_id());
#endif
        }
      else
        {
          Node * node =
            mesh.add_point(p, id, pid);
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
          node->set_unique_id(unique_id);
#endif
 
          libmesh_assert_equal_to(n_extra_integers, node->n_extra_integers());
 
          for (unsigned int ei=0; ei != n_extra_integers; ++ei)
            {
              const dof_id_type extra_int = cast_int<dof_id_type>(id_pid[2+ei]);
              node->set_extra_integer(ei, extra_int);
            }
        }
    }
}

References libMesh::MeshBase::add_point(), libMesh::Xdr::data(), libMesh::Xdr::data_stream(), libMesh::DofObject::get_extra_integer(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::DofObject::n_extra_integers(), libMesh::MeshBase::n_node_integers(), libMesh::ParallelObject::n_processors(), libMesh::DofObject::processor_id(), libMesh::MeshBase::query_node_ptr(), libMesh::DofObject::set_extra_integer(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::unique_id(), and version_at_least_1_5().

read_nodesets()

template<typename file_id_type >

void libMesh::CheckpointIO::read_nodesets ( Xdr &  io )

private

Read the nodeset conditions for a parallel, distributed mesh.

Definition at line 1697 of file checkpoint_io.C.

{
  // convenient reference to our mesh
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  // and our boundary info object
  BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
  std::vector<file_id_type> node_id_list;
  std::vector<file_id_type> bc_id_list;
 
  io.data(node_id_list, "# node id list");
  io.data(bc_id_list, "# nodeset bc id list");
 
  for (auto i : index_range(node_id_list))
    boundary_info.add_node
      (cast_int<dof_id_type>(node_id_list[i]),
       cast_int<boundary_id_type>(bc_id_list[i]));
}

References libMesh::BoundaryInfo::add_node(), libMesh::Xdr::data(), libMesh::MeshBase::get_boundary_info(), libMesh::index_range(), libMesh::MeshInput< MT >::mesh(), and libMesh::MeshInput< MeshBase >::mesh().

read_remote_elem() [1/2]

template<typename file_id_type >

void libMesh::CheckpointIO::read_remote_elem ( Xdr &  io, bool  expect_all_remote  )

private

Read the remote_elem neighbor and child links for a parallel, distributed mesh.

If we expect all these remote_elem links to truly be remote, because we aren't doing an N -> M restart with M < N, then we set expect_all_remote to true and test more assertions.

read_remote_elem() [2/2]

template<typename file_id_type >

void libMesh::CheckpointIO::read_remote_elem	(	Xdr &	io,
		bool	libmesh_dbg_varexpect_all_remote
	)

Definition at line 1618 of file checkpoint_io.C.

{
  // convenient reference to our mesh
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  // Find the remote_elem neighbor links
  std::vector<file_id_type> elem_ids;
  std::vector<uint16_t> elem_sides;
 
  io.data(elem_ids, "# remote neighbor elem_ids");
  io.data(elem_sides, "# remote neighbor elem_sides");
 
  libmesh_assert_equal_to(elem_ids.size(), elem_sides.size());
 
  for (auto i : index_range(elem_ids))
    {
      Elem & elem = mesh.elem_ref(cast_int<dof_id_type>(elem_ids[i]));
      if (!elem.neighbor_ptr(elem_sides[i]))
        elem.set_neighbor(elem_sides[i],
                          const_cast<RemoteElem *>(remote_elem));
      else
        libmesh_assert(!expect_all_remote);
    }
 
  // Find the remote_elem children links
  std::vector<file_id_type> parent_ids;
  std::vector<uint16_t> child_numbers;
 
  io.data(parent_ids, "# remote child parent_ids");
  io.data(child_numbers, "# remote child_numbers");
 
#ifdef LIBMESH_ENABLE_AMR
  for (auto i : index_range(parent_ids))
    {
      Elem & elem = mesh.elem_ref(cast_int<dof_id_type>(parent_ids[i]));
 
      // We'd like to assert that no child pointer already exists to
      // be overwritten by remote_elem, but Elem doesn't actually have
      // an API that will return a child pointer without asserting
      // that it isn't nullptr.
      const Elem * child = elem.raw_child_ptr(child_numbers[i]);
 
      if (!child)
        elem.add_child(const_cast<RemoteElem *>(remote_elem),
                       child_numbers[i]);
      else
        libmesh_assert(!expect_all_remote);
    }
#endif
}

References libMesh::Elem::add_child(), libMesh::Xdr::data(), libMesh::MeshBase::elem_ref(), libMesh::index_range(), libMesh::libmesh_assert(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::raw_child_ptr(), libMesh::remote_elem, and libMesh::Elem::set_neighbor().

read_subdomain_names()

template<typename file_id_type >

void libMesh::CheckpointIO::read_subdomain_names ( Xdr &  io )

private

Read subdomain name information.

Definition at line 1174 of file checkpoint_io.C.

{
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  std::map<subdomain_id_type, std::string> & subdomain_map =
    mesh.set_subdomain_name_map();
 
  std::vector<file_id_type> subdomain_ids;
  subdomain_ids.reserve(subdomain_map.size());
 
  std::vector<std::string>  subdomain_names;
  subdomain_names.reserve(subdomain_map.size());
 
  file_id_type n_subdomain_names = 0;
  io.data(n_subdomain_names, "# subdomain id to name map");
 
  if (n_subdomain_names)
    {
      io.data(subdomain_ids);
      io.data(subdomain_names);
 
      for (auto i : index_range(subdomain_ids))
        subdomain_map[cast_int<subdomain_id_type>(subdomain_ids[i])] =
          subdomain_names[i];
    }
}

References libMesh::Xdr::data(), libMesh::index_range(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshInput< MeshBase >::mesh(), and libMesh::MeshBase::set_subdomain_name_map().

read_subfile()

template<typename file_id_type >

void libMesh::CheckpointIO::read_subfile ( Xdr &  io, bool  expect_all_remote  )

private

Read a non-header file.

Definition at line 1153 of file checkpoint_io.C.

{
  // read the nodal locations
  this->read_nodes<file_id_type> (io);
 
  // read connectivity
  this->read_connectivity<file_id_type> (io);
 
  // read remote_elem connectivity
  this->read_remote_elem<file_id_type> (io, expect_all_remote);
 
  // read the boundary conditions
  this->read_bcs<file_id_type> (io);
 
  // read the nodesets
  this->read_nodesets<file_id_type> (io);
}

select_split_config()

processor_id_type libMesh::CheckpointIO::select_split_config ( const std::string &  input_name, header_id_type &  data_size  )

private

Definition at line 222 of file checkpoint_io.C.

{
  std::string header_name;
 
  // We'll read a header file from processor 0 and broadcast.
  if (this->processor_id() == 0)
    {
      header_name = header_file(input_name, _my_n_processors);
 
      {
        // look for header+splits with nprocs equal to _my_n_processors
        std::ifstream in (header_name.c_str());
        if (!in.good())
          {
            // otherwise fall back to a serial/single-split mesh
            auto orig_header_name = header_name;
            header_name = header_file(input_name, 1);
            std::ifstream in2 (header_name.c_str());
            const auto splits = existing_splits(input_name);
            libmesh_error_msg_if(!in2.good(),
                                 "ERROR: Neither one of the following files can be located:\n\t'"
                                 << orig_header_name << "' nor\n\t'" << input_name << "'\n"
                                 << "If you are running a parallel job, double check that you've "
                                 << "created a split for " << _my_n_processors << " ranks.\n"
                                 << "Note: One of paths above may refer to a valid directory on your "
                                 << "system, however we are attempting to read a valid header file.\n"
                                 << (splits.empty()
                                         ? "No processor-count splits were found in '" + input_name + "'."
                                         : "Splits that do exist in '" + input_name +
                                               "': " + splits + "."));
          }
      }
 
      Xdr io (header_name, this->binary() ? DECODE : READ);
 
      // read the version, but don't care about it
      std::string input_version;
      io.data(input_version);
 
      // read the data type
      io.data (data_size);
    }
 
  this->comm().broadcast(data_size);
  this->comm().broadcast(header_name);
 
  // How many per-processor files are here?
  largest_id_type input_n_procs;
 
  switch (data_size) {
  case 2:
    input_n_procs = this->read_header<uint16_t>(header_name);
    break;
  case 4:
    input_n_procs = this->read_header<uint32_t>(header_name);
    break;
  case 8:
    input_n_procs = this->read_header<uint64_t>(header_name);
    break;
  default:
    libmesh_error();
  }
 
  if (!input_n_procs)
    input_n_procs = 1;
  return cast_int<processor_id_type>(input_n_procs);
}

References _my_n_processors, binary(), libMesh::Parallel::Communicator::broadcast(), libMesh::ParallelObject::comm(), libMesh::Xdr::data(), libMesh::DECODE, libMesh::ParallelObject::processor_id(), and libMesh::READ.

Referenced by read().

set_n_partitions()

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 101 of file mesh_input.h.

{ this->mesh().set_n_partitions() = n_parts; }

skip_comment_lines()

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.

Definition at line 113 of file mesh_input.h.

{
  char c, line[256];
 
  while (in.get(c), c==comment_start)
    in.getline (line, 255);
 
  // put back first character of
  // first non-comment line
  in.putback (c);
}

version() [1/2]

std::string & libMesh::CheckpointIO::version ( )

inline

Definition at line 159 of file checkpoint_io.h.

{ return _version; }

References _version.

version() [2/2]

const std::string & libMesh::CheckpointIO::version ( ) const

inline

Get/Set the version string.

Definition at line 158 of file checkpoint_io.h.

{ return _version; }

References _version.

Referenced by read_header(), version_at_least_1_5(), version_at_least_1_6(), and version_at_least_1_7().

version_at_least_1_5()

bool libMesh::CheckpointIO::version_at_least_1_5

(

)

const

Returns

true if the current file has an XDR/XDA version that matches or exceeds 1.5

As of this version we encode any extra integer data that has been attached to a mesh.

Definition at line 316 of file checkpoint_io.C.

{
  return
    (this->version().find("1.5") != std::string::npos) ||
    (this->version().find("1.6") != std::string::npos) ||
    (this->version().find("1.7") != std::string::npos);
}

References version().

Referenced by read_connectivity(), read_header(), read_nodes(), write(), write_connectivity(), and write_nodes().

version_at_least_1_6()

bool libMesh::CheckpointIO::version_at_least_1_6

(

)

const

Returns

true if the current file has an XDR/XDA version that matches or exceeds 1.6

As of this version we encode runtime element topology.

Definition at line 325 of file checkpoint_io.C.

{
  return
    (this->version().find("1.6") != std::string::npos) ||
    (this->version().find("1.7") != std::string::npos);
}

References version().

Referenced by read_connectivity(), and write_connectivity().

version_at_least_1_7()

bool libMesh::CheckpointIO::version_at_least_1_7

(

)

const

Returns

true if the current file has an XDR/XDA version that matches or exceeds 1.7

As of this version we encode disjoint neighbor boundary pairs.

Definition at line 333 of file checkpoint_io.C.

{
  return (this->version().find("1.7") != std::string::npos);
}

References version().

Referenced by read_header(), and write().

write()

void libMesh::CheckpointIO::write ( const std::string &  name )

overridevirtual

This method implements writing a mesh to a specified file.

If the mesh has been split for running on several processors, this will create a subdirectory named "[name]-split[n]" where name is the given name argument and n is the number of processors the mesh is split for running on. For example:

unsigned int n_splits = 42;
std::unique_ptr<CheckpointIO> cp = split_mesh(my_mesh, n_splits);
// ...
cp->write("foo.cpr");

would create a directory named "foo.cpr-split42".

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 339 of file checkpoint_io.C.

{
  LOG_SCOPE("write()", "CheckpointIO");
 
  // convenient reference to our mesh
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
  // FIXME: For backwards compatibility, we'll assume for now that we
  // only want to write distributed meshes in parallel.  Later we can
  // do a gather_to_zero() and support that case too.
  _parallel = _parallel || !mesh.is_serial();
 
  processor_id_type use_n_procs = 1;
  if (_parallel)
    use_n_procs = _my_n_processors;
 
  std::string header_file_name = header_file(name, use_n_procs);
  make_dir(name, use_n_procs);
 
  // We'll write a header file from processor 0 to make it easier to do unambiguous
  // restarts later:
  if (this->processor_id() == 0)
    {
      Xdr io (header_file_name, this->binary() ? ENCODE : WRITE);
 
      // write the version
      io.data(_version, "# version");
 
      // write what kind of data type we're using
      header_id_type data_size = sizeof(largest_id_type);
      io.data(data_size, "# integer size");
 
      // Write out the max mesh dimension for backwards compatibility
      // with code that sets it independently of element dimensions
      {
        uint16_t mesh_dimension = cast_int<uint16_t>(mesh.mesh_dimension());
        io.data(mesh_dimension, "# dimensions");
      }
 
      // Write out whether or not this is serial output
      {
        uint16_t parallel = _parallel;
        io.data(parallel, "# parallel");
      }
 
      // If we're writing out a parallel mesh then we need to write the number of processors
      // so we can check it upon reading the file
      if (_parallel)
        {
          largest_id_type n_procs = _my_n_processors;
          io.data(n_procs, "# n_procs");
        }
 
      // write subdomain names
      this->write_subdomain_names(io);
 
      // write boundary id names
      const BoundaryInfo & boundary_info = mesh.get_boundary_info();
      write_bc_names(io, boundary_info, true);  // sideset names
      write_bc_names(io, boundary_info, false); // nodeset names
 
      // write extra integer names
      const bool write_extra_integers = this->version_at_least_1_5();
 
      if (write_extra_integers)
        {
          largest_id_type n_node_integers = mesh.n_node_integers();
          io.data(n_node_integers, "# n_extra_integers per node");
 
          std::vector<std::string> node_integer_names;
          for (unsigned int i=0; i != n_node_integers; ++i)
            node_integer_names.push_back(mesh.get_node_integer_name(i));
 
          io.data(node_integer_names);
 
          largest_id_type n_elem_integers = mesh.n_elem_integers();
          io.data(n_elem_integers, "# n_extra_integers per elem");
 
          std::vector<std::string> elem_integer_names;
          for (unsigned int i=0; i != n_elem_integers; ++i)
            elem_integer_names.push_back(mesh.get_elem_integer_name(i));
 
          io.data(elem_integer_names);
        }
 
      if (this->version_at_least_1_7())
        this->write_disjoint_neighbor_boundary_pairs(io);
    }
 
  // If this is a serial mesh written to a serial file then we're only
  // going to write local data from processor 0.  If this is a mesh being
  // written in parallel then we're going to write from every
  // processor.
  std::vector<processor_id_type> ids_to_write;
 
  // We're going to sort elements by pid in one pass, to avoid sending
  // predicated iterators through the whole mesh N_p times.
  //
  // The data type here needs to be a non-const-pointer to whatever
  // our element_iterator is a const-pointer to, for compatibility
  // later.
  typedef std::remove_const<MeshBase::const_element_iterator::value_type>::type nc_v_t;
  std::unordered_map<processor_id_type, std::vector<nc_v_t>> elements_on_pid;
 
  if (_parallel)
    {
      ids_to_write = _my_processor_ids;
      for (processor_id_type p : ids_to_write)
        elements_on_pid[p].clear();
      auto eop_end = elements_on_pid.end();
      for (auto & elem : mesh.element_ptr_range())
        {
          const processor_id_type p = elem->processor_id();
          if (auto eop_it = elements_on_pid.find(p);
              eop_it != eop_end)
            eop_it->second.push_back(elem);
        }
    }
  else if (mesh.is_serial())
    {
      if (mesh.processor_id() == 0)
        {
          // placeholder
          ids_to_write.push_back(0);
        }
    }
  else
    {
      libmesh_error_msg("Cannot write serial checkpoint from distributed mesh");
    }
 
  // Call build_side_list() and build_node_list() just *once* to avoid
  // redundant expensive sorts during mesh splitting.
  const BoundaryInfo & boundary_info = mesh.get_boundary_info();
  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>>
    bc_triples = boundary_info.build_side_list();
  std::vector<std::tuple<dof_id_type, boundary_id_type>>
    bc_tuples = boundary_info.build_node_list();
 
  for (const auto & my_pid : ids_to_write)
    {
      auto file_name = split_file(name, use_n_procs, my_pid);
      Xdr io (file_name, this->binary() ? ENCODE : WRITE);
 
      std::set<const Elem *, CompareElemIdsByLevel> elements;
 
      // For serial files or for already-distributed meshs, we write
      // everything we can see.
      if (!_parallel || !mesh.is_serial())
        elements.insert(mesh.elements_begin(), mesh.elements_end());
      // For parallel files written from serial meshes we write what
      // we'd be required to keep if we were to be deleting remote
      // elements.  This allows us to write proper parallel files even
      // from a ReplicateMesh.
      //
      // WARNING: If we have a DistributedMesh which used
      // "add_extra_ghost_elem" rather than ghosting functors to
      // preserve elements and which is *also* currently serialized
      // then we're not preserving those elements here.  As a quick
      // workaround user code should delete_remote_elements() before
      // writing the checkpoint; as a long term workaround user code
      // should use ghosting functors instead of extra_ghost_elem
      // lists.
      else
        {
          for (processor_id_type p : {my_pid, DofObject::invalid_processor_id})
            {
              if (const auto elements_vec_it = elements_on_pid.find(p);
                  elements_vec_it != elements_on_pid.end())
                {
                  auto & p_elements = elements_vec_it->second;
 
                  // Be compatible with both deprecated and
                  // corrected MeshBase iterator types
                  typedef MeshBase::const_element_iterator::value_type v_t;
 
                  v_t * elempp = p_elements.data();
                  v_t * elemend = elempp + p_elements.size();
 
                  const MeshBase::const_element_iterator
                    pid_elements_begin = MeshBase::const_element_iterator
                      (elempp, elemend, Predicates::NotNull<v_t *>()),
                    pid_elements_end = MeshBase::const_element_iterator
                      (elemend, elemend, Predicates::NotNull<v_t *>()),
                    active_pid_elements_begin = MeshBase::const_element_iterator
                      (elempp, elemend, Predicates::Active<v_t *>()),
                    active_pid_elements_end = MeshBase::const_element_iterator
                      (elemend, elemend, Predicates::Active<v_t *>());
 
                  query_ghosting_functors
                    (mesh, p, active_pid_elements_begin,
                     active_pid_elements_end, elements);
                  connect_children(mesh, pid_elements_begin,
                                   pid_elements_end, elements);
                }
            }
        }
 
      connected_node_set_type connected_nodes;
      connect_element_dependencies(mesh, elements, connected_nodes);
 
      // write the nodal locations
      this->write_nodes (io, connected_nodes);
 
      // write connectivity
      this->write_connectivity (io, elements);
 
      // write remote_elem connectivity
      this->write_remote_elem (io, elements);
 
      // write the boundary condition information
      this->write_bcs (io, elements, bc_triples);
 
      // write the nodeset information
      this->write_nodesets (io, connected_nodes, bc_tuples);
 
      // close it up
      io.close();
    }
 
  // this->comm().barrier();
}

References _my_n_processors, _my_processor_ids, _parallel, _version, binary(), libMesh::BoundaryInfo::build_node_list(), libMesh::BoundaryInfo::build_side_list(), libMesh::Xdr::close(), libMesh::connect_children(), libMesh::connect_element_dependencies(), libMesh::Xdr::data(), libMesh::ENCODE, libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::get_elem_integer_name(), libMesh::MeshBase::get_node_integer_name(), libMesh::DofObject::invalid_processor_id, libMesh::MeshBase::is_serial(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_elem_integers(), libMesh::MeshBase::n_node_integers(), parallel(), libMesh::ParallelObject::processor_id(), libMesh::query_ghosting_functors(), version_at_least_1_5(), version_at_least_1_7(), libMesh::WRITE, write_bc_names(), write_bcs(), write_connectivity(), write_disjoint_neighbor_boundary_pairs(), write_nodes(), write_nodesets(), write_remote_elem(), and write_subdomain_names().

Referenced by CheckpointIOTest::testC0PolygonCheckpoint(), CheckpointIOTest::testC0PolyhedronCheckpoint(), CheckpointIOTest::testDisjointNeighborPairsCheckpoint(), CheckpointIOTest::testMissingSplitError(), CheckpointIOTest::testSplitter(), and libMesh::NameBasedIO::write().

write_bc_names()

void libMesh::CheckpointIO::write_bc_names ( Xdr &  io, const BoundaryInfo &  info, bool  is_sideset  ) const

private

Write boundary names information (sideset and nodeset)

Definition at line 862 of file checkpoint_io.C.

{
  const std::map<boundary_id_type, std::string> & boundary_map = is_sideset ?
    info.get_sideset_name_map() : info.get_nodeset_name_map();
 
  std::vector<largest_id_type> boundary_ids;   boundary_ids.reserve(boundary_map.size());
  std::vector<std::string>  boundary_names; boundary_names.reserve(boundary_map.size());
 
  // We need to loop over the map and make sure that there aren't any invalid entries.  Since we
  // return writable references in boundary_info, it's possible for the user to leave some entity names
  // blank.  We can't write those to the XDA file.
  largest_id_type n_boundary_names = 0;
  for (const auto & [id, name] : boundary_map)
    if (!name.empty())
      {
        n_boundary_names++;
        boundary_ids.push_back(id);
        boundary_names.push_back(name);
      }
 
  if (is_sideset)
    io.data(n_boundary_names, "# sideset id to name map");
  else
    io.data(n_boundary_names, "# nodeset id to name map");
  // Write out the ids and names in two vectors
  if (n_boundary_names)
    {
      io.data(boundary_ids);
      io.data(boundary_names);
    }
}

References libMesh::Xdr::data().

Referenced by write().

write_bcs()

void libMesh::CheckpointIO::write_bcs ( Xdr &  io, const std::set< const Elem *, CompareElemIdsByLevel > &  elements, const std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > > &  bc_triples  ) const

private

Write the side boundary conditions for part of a mesh.

Definition at line 794 of file checkpoint_io.C.

{
  libmesh_assert (io.writing());
 
  // Build a list of (elem, side, bc) tuples.
  std::size_t bc_size = bc_triples.size();
 
  std::vector<largest_id_type> element_id_list;
  std::vector<uint16_t> side_list;
  std::vector<largest_id_type> bc_id_list;
 
  element_id_list.reserve(bc_size);
  side_list.reserve(bc_size);
  bc_id_list.reserve(bc_size);
 
  std::unordered_set<dof_id_type> elems;
  for (auto & e : elements)
    elems.insert(e->id());
 
  for (const auto & t : bc_triples)
    if (elems.count(std::get<0>(t)))
      {
        element_id_list.push_back(std::get<0>(t));
        side_list.push_back(std::get<1>(t));
        bc_id_list.push_back(std::get<2>(t));
      }
 
 
  io.data(element_id_list, "# element ids for bcs");
  io.data(side_list, "# sides of elements for bcs");
  io.data(bc_id_list, "# bc ids");
}

References libMesh::Xdr::data(), libMesh::libmesh_assert(), and libMesh::Xdr::writing().

Referenced by write().

write_connectivity()

void libMesh::CheckpointIO::write_connectivity ( Xdr &  io, const std::set< const Elem *, CompareElemIdsByLevel > &  elements  ) const

private

Write the connectivity for part of a mesh.

Definition at line 646 of file checkpoint_io.C.

{
  libmesh_assert (io.writing());
 
  const bool write_extra_integers = this->version_at_least_1_5();
  const bool write_runtime_topology = this->version_at_least_1_6();
  const unsigned int n_extra_integers =
    write_extra_integers ? MeshOutput<MeshBase>::mesh().n_elem_integers() : 0;
 
  // Put these out here to reduce memory churn
  // id type pid subdomain_id parent_id extra_integer_0 ...
  std::vector<largest_id_type> elem_data(6 + n_extra_integers);
  std::vector<largest_id_type> conn_data;
  std::vector<largest_id_type> runtime_topology;
 
  largest_id_type n_elems_here = elements.size();
 
  io.data(n_elems_here, "# number of elements");
 
  for (const auto & elem : elements)
    {
      unsigned int n_nodes = elem->n_nodes();
 
      elem_data[0] = elem->id();
      elem_data[1] = elem->type();
      elem_data[2] = elem->processor_id();
      elem_data[3] = elem->subdomain_id();
 
#ifdef LIBMESH_ENABLE_AMR
      if (elem->parent() != nullptr)
        {
          elem_data[4] = elem->parent()->id();
          elem_data[5] = elem->parent()->which_child_am_i(elem);
        }
      else
#endif
        {
          elem_data[4] = static_cast<largest_id_type>(-1);
          elem_data[5] = static_cast<largest_id_type>(-1);
        }
 
      for (unsigned int i=0; i != n_extra_integers; ++i)
        elem_data[6+i] = elem->get_extra_integer(i);
 
      conn_data.resize(n_nodes);
 
      for (unsigned int i=0; i<n_nodes; i++)
        conn_data[i] = elem->node_id(i);
 
      io.data_stream(elem_data.data(),
                     cast_int<unsigned int>(elem_data.size()),
                     cast_int<unsigned int>(elem_data.size()));
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      largest_id_type unique_id = elem->unique_id();
 
      io.data(unique_id, "# unique id");
#endif
 
#ifdef LIBMESH_ENABLE_AMR
      uint16_t p_level = cast_int<uint16_t>(elem->p_level());
      io.data(p_level, "# p_level");
 
      uint16_t rflag = elem->refinement_flag();
      io.data(rflag, "# rflag");
 
      uint16_t pflag = elem->p_refinement_flag();
      io.data(pflag, "# pflag");
#endif
 
      if (elem->runtime_topology())
        {
          libmesh_error_msg_if
            (!write_runtime_topology,
             "Checkpoint format 1.6 or newer is required to write " <<
             Utility::enum_to_string(elem->type()) << " elements.");
 
          runtime_topology.clear();
          runtime_topology.push_back(n_nodes);
          runtime_topology.push_back(elem->n_sides());
          for (auto s : elem->side_index_range())
            {
              const auto side_nodes = elem->nodes_on_side(s);
              runtime_topology.push_back(side_nodes.size());
              for (const auto n : side_nodes)
                runtime_topology.push_back(n);
            }
 
          io.data(runtime_topology, "# runtime topology");
        }
 
      io.data_stream(conn_data.data(),
                     cast_int<unsigned int>(conn_data.size()),
                     cast_int<unsigned int>(conn_data.size()));
    }
}

References libMesh::Xdr::data(), libMesh::Xdr::data_stream(), libMesh::Utility::enum_to_string(), libMesh::libmesh_assert(), libMesh::MeshOutput< MT >::mesh(), n_nodes, version_at_least_1_5(), version_at_least_1_6(), and libMesh::Xdr::writing().

Referenced by write().

write_discontinuous_equation_systems()

void libMesh::MeshOutput< MeshBase >::write_discontinuous_equation_systems ( const std::string &  fname, const EquationSystems &  es, const std::set< std::string > *  system_names = nullptr  )

virtualinherited

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

Definition at line 101 of file mesh_output.C.

{
  LOG_SCOPE("write_discontinuous_equation_systems()", "MeshOutput");
 
  // We may need to gather and/or renumber a DistributedMesh to output
  // it, making that const qualifier in our constructor a dirty lie
  MT & my_mesh = const_cast<MT &>(*_obj);
 
  // If we're asked to write data that's associated with a different
  // mesh, output files full of garbage are the result.
  libmesh_assert_equal_to(&es.get_mesh(), _obj);
 
  // A non-renumbered mesh may not have a contiguous numbering, and
  // that needs to be fixed before we can build a solution vector.
  if (my_mesh.max_elem_id() != my_mesh.n_elem() ||
      my_mesh.max_node_id() != my_mesh.n_nodes())
    {
      // If we were allowed to renumber then we should have already
      // been properly renumbered...
      libmesh_assert(!my_mesh.allow_renumbering());
 
      libmesh_do_once(libMesh::out <<
                      "Warning:  This MeshOutput subclass only supports meshes which are contiguously renumbered!"
                      << std::endl;);
 
      my_mesh.allow_renumbering(true);
 
      my_mesh.renumber_nodes_and_elements();
 
      // Not sure what good going back to false will do here, the
      // renumbering horses have already left the barn...
      my_mesh.allow_renumbering(false);
    }
 
  MeshSerializer serialize(const_cast<MT &>(*_obj), !_is_parallel_format, _serial_only_needed_on_proc_0);
 
  // Build the list of variable names that will be written.
  std::vector<std::string> names;
  es.build_variable_names  (names, nullptr, system_names);
 
  if (!_is_parallel_format)
    {
      // Build the nodal solution values & get the variable
      // names from the EquationSystems object
      std::vector<Number> soln;
      es.build_discontinuous_solution_vector (soln, system_names,
                                              nullptr, false, /* defaults */
                                              this->get_add_sides());
 
      this->write_nodal_data_discontinuous (fname, soln, names);
    }
  else // _is_parallel_format
    {
      libmesh_not_implemented();
    }
}

write_disjoint_neighbor_boundary_pairs()

void libMesh::CheckpointIO::write_disjoint_neighbor_boundary_pairs ( Xdr &  io ) const

private

Write disjoint neighbor boundary pairs.

Definition at line 894 of file checkpoint_io.C.

{
  std::vector<largest_id_type> pair_ids;
  std::vector<Real> translations;
 
#ifdef LIBMESH_ENABLE_PERIODIC
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
  // MeshBase stores each pair once per direction; write each pair once,
  // from its smaller boundary id, and re-register both directions on read.
  if (const PeriodicBoundaries * db = mesh.get_disjoint_neighbor_boundary_pairs())
    for (const auto & [id, pb] : *db)
      {
        if (id > pb->pairedboundary)
          continue;
 
        // MeshBase only registers translations, which we can recover
        // as the image of the origin.
        libmesh_error_msg_if(!dynamic_cast<const PeriodicBoundary *>(pb.get()) ||
                             pb->has_transformation_matrix(),
                             "CheckpointIO can only write translational disjoint neighbor "
                             "boundary pairs");
 
        pair_ids.push_back(id);
        pair_ids.push_back(pb->pairedboundary);
 
        const Point translation = pb->get_corresponding_pos(Point(0));
        for (auto d : make_range(LIBMESH_DIM))
          translations.push_back(translation(d));
      }
#endif
 
  largest_id_type n_pairs = pair_ids.size() / 2;
  io.data(n_pairs, "# disjoint neighbor boundary pairs");
  if (n_pairs)
    {
      io.data(pair_ids);
      // data_stream, unlike the generic vector path, handles extended
      // precision Real
      io.data_stream(translations.data(),
                     cast_int<unsigned int>(translations.size()),
                     LIBMESH_DIM);
    }
}

References libMesh::Xdr::data(), libMesh::Xdr::data_stream(), libMesh::MeshBase::get_disjoint_neighbor_boundary_pairs(), libMesh::PeriodicBoundaryBase::has_transformation_matrix(), libMesh::make_range(), libMesh::MeshInput< MeshBase >::mesh(), and libMesh::MeshOutput< MT >::mesh().

Referenced by write().

write_equation_systems()

void libMesh::MeshOutput< MeshBase >::write_equation_systems ( const std::string &  fname, const EquationSystems &  es, const std::set< std::string > *  system_names = 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, and libMesh::ExodusII_IO.

Definition at line 92 of file mesh_output.C.

{
  LOG_SCOPE("write_equation_systems()", "MeshOutput");
 
  // We may need to gather and/or renumber a DistributedMesh to output
  // it, making that const qualifier in our constructor a dirty lie
  MT & my_mesh = const_cast<MT &>(*_obj);
 
  // If we're asked to write data that's associated with a different
  // mesh, output files full of garbage are the result.
  libmesh_assert_equal_to(&es.get_mesh(), _obj);
 
  // A non-parallel format, non-renumbered mesh may not have a contiguous
  // numbering, and that needs to be fixed before we can build a solution vector.
  if (!_is_parallel_format &&
      (my_mesh.max_elem_id() != my_mesh.n_elem() ||
       my_mesh.max_node_id() != my_mesh.n_nodes()))
    {
      // If we were allowed to renumber then we should have already
      // been properly renumbered...
      libmesh_assert(!my_mesh.allow_renumbering());
 
      libmesh_do_once(libMesh::out <<
                      "Warning:  This MeshOutput subclass only supports meshes which are contiguously renumbered!"
                      << std::endl;);
 
      my_mesh.allow_renumbering(true);
 
      my_mesh.renumber_nodes_and_elements();
 
      // Not sure what good going back to false will do here, the
      // renumbering horses have already left the barn...
      my_mesh.allow_renumbering(false);
    }
 
  if (!_is_parallel_format)
    {
      MeshSerializer serialize(const_cast<MT &>(*_obj), !_is_parallel_format, _serial_only_needed_on_proc_0);
 
      // Build the list of variable names that will be written.
      std::vector<std::string> names;
      es.build_variable_names  (names, nullptr, system_names);
 
      // Build the nodal solution values & get the variable
      // names from the EquationSystems object
      std::vector<Number> soln;
      es.build_solution_vector (soln, system_names,
                                this->get_add_sides());
 
      this->write_nodal_data (fname, soln, names);
    }
  else // _is_parallel_format
    this->write_nodal_data (fname, es, system_names);
}

write_nodal_data() [1/3]

void libMesh::MeshOutput< MeshBase >::write_nodal_data ( const std::string &  fname, const EquationSystems &  es, const std::set< std::string > *  system_names  )

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 directly uses EquationSystems current_local_solution vectors to look up nodal values.

If not implemented, reorders the solutions into a nodal-only NumericVector and calls the above version of this function.

Reimplemented in libMesh::Nemesis_IO.

Definition at line 149 of file mesh_output.C.

{
  std::vector<std::string> names;
  es.build_variable_names  (names, nullptr, system_names);
 
  std::unique_ptr<NumericVector<Number>> parallel_soln =
    es.build_parallel_solution_vector(system_names);
 
  this->write_nodal_data (fname, *parallel_soln, names);
}

write_nodal_data() [2/3]

void libMesh::MeshOutput< MeshBase >::write_nodal_data ( const std::string &  fname, const NumericVector< Number > &  parallel_soln, const std::vector< std::string > &  names  )

virtualinherited

This method may 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.

Definition at line 136 of file mesh_output.C.

{
  // This is the fallback implementation for parallel I/O formats that
  // do not yet implement proper writing in parallel, and instead rely
  // on the full solution vector being available on all processors.
  std::vector<Number> soln;
  parallel_soln.localize(soln);
  this->write_nodal_data(fname, soln, names);
}

write_nodal_data() [3/3]

virtual void libMesh::MeshOutput< MeshBase >::write_nodal_data ( const std::string &  , const std::vector< Number > &  , const std::vector< std::string > &    )

inlinevirtualinherited

This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are provided.

Reimplemented in libMesh::ExodusII_IO, libMesh::GmshIO, libMesh::GMVIO, libMesh::GnuPlotIO, libMesh::MEDITIO, libMesh::NameBasedIO, libMesh::TecplotIO, libMesh::VTKIO, libMesh::Nemesis_IO, and libMesh::UCDIO.

Definition at line 109 of file mesh_output.h.

  { libmesh_not_implemented(); }

write_nodal_data_discontinuous()

virtual void libMesh::MeshOutput< MeshBase >::write_nodal_data_discontinuous ( const std::string &  , const std::vector< Number > &  , const std::vector< std::string > &    )

inlinevirtualinherited

This method implements writing a mesh with discontinuous data to a specified file where the nodal data and variables names are provided.

Reimplemented in libMesh::ExodusII_IO.

Definition at line 118 of file mesh_output.h.

  { libmesh_not_implemented(); }

write_nodes()

void libMesh::CheckpointIO::write_nodes ( Xdr &  io, const connected_node_set_type &  nodeset  ) const

private

Write the nodal locations for part of a mesh.

Definition at line 596 of file checkpoint_io.C.

{
  largest_id_type n_nodes_here = nodeset.size();
 
  io.data(n_nodes_here, "# n_nodes on proc");
 
  const bool write_extra_integers = this->version_at_least_1_5();
  const unsigned int n_extra_integers =
    write_extra_integers ? MeshOutput<MeshBase>::mesh().n_node_integers() : 0;
 
  // Will hold the node id and pid and extra integers
  std::vector<largest_id_type> id_pid(2 + n_extra_integers);
 
  // For the coordinates
  std::vector<Real> coords(LIBMESH_DIM);
 
  for (const auto & node : nodeset)
    {
      id_pid[0] = node->id();
      id_pid[1] = node->processor_id();
 
      libmesh_assert_equal_to(n_extra_integers, node->n_extra_integers());
      for (unsigned int i=0; i != n_extra_integers; ++i)
        id_pid[2+i] = node->get_extra_integer(i);
 
      io.data_stream(id_pid.data(), 2 + n_extra_integers, 2 + n_extra_integers);
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      largest_id_type unique_id = node->unique_id();
 
      io.data(unique_id, "# unique id");
#endif
 
      coords[0] = (*node)(0);
 
#if LIBMESH_DIM > 1
      coords[1] = (*node)(1);
#endif
 
#if LIBMESH_DIM > 2
      coords[2] = (*node)(2);
#endif
 
      io.data_stream(coords.data(), LIBMESH_DIM, 3);
    }
}

References libMesh::Xdr::data(), libMesh::Xdr::data_stream(), libMesh::MeshOutput< MT >::mesh(), and version_at_least_1_5().

Referenced by write().

write_nodesets()

void libMesh::CheckpointIO::write_nodesets ( Xdr &  io, const connected_node_set_type &  nodeset, const std::vector< std::tuple< dof_id_type, boundary_id_type > > &  bc_tuples  ) const

private

Write the nodal boundary conditions for part of a mesh.

Definition at line 831 of file checkpoint_io.C.

{
  libmesh_assert (io.writing());
 
  // convenient reference to our mesh
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
  // Build a list of (node, bc) tuples
  std::size_t nodeset_size = bc_tuples.size();
 
  std::vector<largest_id_type> node_id_list;
  std::vector<largest_id_type> bc_id_list;
 
  node_id_list.reserve(nodeset_size);
  bc_id_list.reserve(nodeset_size);
 
  for (const auto & t : bc_tuples)
    if (nodeset.count(mesh.node_ptr(std::get<0>(t))))
      {
        node_id_list.push_back(std::get<0>(t));
        bc_id_list.push_back(std::get<1>(t));
      }
 
  io.data(node_id_list, "# node id list");
  io.data(bc_id_list, "# nodeset bc id list");
}

References libMesh::Xdr::data(), libMesh::libmesh_assert(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::node_ptr(), and libMesh::Xdr::writing().

Referenced by write().

write_remote_elem()

void libMesh::CheckpointIO::write_remote_elem ( Xdr &  io, const std::set< const Elem *, CompareElemIdsByLevel > &  elements  ) const

private

Write the remote_elem neighbor and child links for part of a mesh.

Definition at line 745 of file checkpoint_io.C.

{
  libmesh_assert (io.writing());
 
  // Find the remote_elem neighbor and child links
  std::vector<largest_id_type> elem_ids, parent_ids;
  std::vector<uint16_t> elem_sides, child_numbers;
 
  for (const auto & elem : elements)
    {
      for (auto n : elem->side_index_range())
        {
          const Elem * neigh = elem->neighbor_ptr(n);
          if (neigh == remote_elem ||
              (neigh && !elements.count(neigh)))
            {
              elem_ids.push_back(elem->id());
              elem_sides.push_back(n);
            }
        }
 
#ifdef LIBMESH_ENABLE_AMR
      if (elem->has_children())
        {
          for (unsigned short c = 0,
               nc = cast_int<unsigned short>(elem->n_children());
               c != nc; ++c)
            {
              const Elem * child = elem->child_ptr(c);
              if (child == remote_elem ||
                  (child && !elements.count(child)))
                {
                  parent_ids.push_back(elem->id());
                  child_numbers.push_back(c);
                }
            }
        }
#endif
    }
 
  io.data(elem_ids, "# remote neighbor elem_ids");
  io.data(elem_sides, "# remote neighbor elem_sides");
  io.data(parent_ids, "# remote child parent_ids");
  io.data(child_numbers, "# remote child_numbers");
}

References libMesh::Elem::child_ptr(), libMesh::Xdr::data(), libMesh::libmesh_assert(), libMesh::Elem::neighbor_ptr(), libMesh::remote_elem, and libMesh::Xdr::writing().

Referenced by write().

write_subdomain_names()

void libMesh::CheckpointIO::write_subdomain_names ( Xdr &  io ) const

private

Write subdomain name information.

Definition at line 562 of file checkpoint_io.C.

{
  {
    const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
    const std::map<subdomain_id_type, std::string> & subdomain_map = mesh.get_subdomain_name_map();
 
    std::vector<largest_id_type> subdomain_ids;   subdomain_ids.reserve(subdomain_map.size());
    std::vector<std::string>  subdomain_names; subdomain_names.reserve(subdomain_map.size());
 
    // We need to loop over the map and make sure that there aren't any invalid entries.  Since we
    // return writable references in mesh_base, it's possible for the user to leave some entity names
    // blank.  We can't write those to the XDA file.
    largest_id_type n_subdomain_names = 0;
    for (const auto & [id, name] : subdomain_map)
      if (!name.empty())
        {
          n_subdomain_names++;
          subdomain_ids.push_back(id);
          subdomain_names.push_back(name);
        }
 
    io.data(n_subdomain_names, "# subdomain id to name map");
    // Write out the ids and names in two vectors
    if (n_subdomain_names)
      {
        io.data(subdomain_ids);
        io.data(subdomain_names);
      }
  }
}

References libMesh::Xdr::data(), libMesh::MeshBase::get_subdomain_name_map(), libMesh::MeshInput< MeshBase >::mesh(), and libMesh::MeshOutput< MT >::mesh().

Referenced by write().

Member Data Documentation

_ascii_precision

unsigned int libMesh::MeshOutput< MeshBase >::_ascii_precision

privateinherited

Precision to use when writing ASCII files.

Definition at line 207 of file mesh_output.h.

_binary

bool libMesh::CheckpointIO::_binary

private

Definition at line 360 of file checkpoint_io.h.

Referenced by binary(), and binary().

_communicator

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

protectedinherited

Definition at line 120 of file parallel_object.h.

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

_is_parallel_format [1/2]

const bool libMesh::MeshInput< MeshBase >::_is_parallel_format

privateinherited

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 130 of file mesh_input.h.

_is_parallel_format [2/2]

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 184 of file mesh_output.h.

_my_n_processors

processor_id_type libMesh::CheckpointIO::_my_n_processors

private

Definition at line 368 of file checkpoint_io.h.

Referenced by current_n_processors(), current_n_processors(), select_split_config(), and write().

_my_processor_ids

std::vector<processor_id_type> libMesh::CheckpointIO::_my_processor_ids

private

Definition at line 365 of file checkpoint_io.h.

Referenced by current_processor_ids(), current_processor_ids(), and write().

_obj

MeshBase * libMesh::MeshInput< MeshBase >::_obj

privateinherited

A pointer to a non-const object object.

This allows us to read the object from file.

Definition at line 123 of file mesh_input.h.

_parallel

bool libMesh::CheckpointIO::_parallel

private

Definition at line 361 of file checkpoint_io.h.

Referenced by parallel(), parallel(), and write().

_serial_only_needed_on_proc_0

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 193 of file mesh_output.h.

_version

std::string libMesh::CheckpointIO::_version

private

Definition at line 362 of file checkpoint_io.h.

Referenced by version(), version(), and write().

elems_of_dimension

std::vector<bool> libMesh::MeshInput< MeshBase >::elems_of_dimension

protectedinherited

A vector of bools describing what dimension elements have been encountered when reading a mesh.

Definition at line 107 of file mesh_input.h.

---

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

• include/mesh/checkpoint_io.h
• src/mesh/checkpoint_io.C