The Nemesis_IO class implements reading parallel meshes in the Nemesis file format from Sandia National Labs. More...

#include <nemesis_io.h>

Inheritance diagram for libMesh::Nemesis_IO:

[legend]

Public Member Functions
	Nemesis_IO (MeshBase &mesh, bool single_precision=false)
	Constructor.

	Nemesis_IO (const MeshBase &mesh, bool single_precision=false)
	Constructor.

virtual	~Nemesis_IO ()
	Destructor.

virtual void	read (const std::string &base_filename) override
	Implements reading the mesh from several different files.

virtual void	write (const std::string &base_filename) override
	This method implements writing a mesh to a specified file.

void	write_timestep (const std::string &fname, const EquationSystems &es, const int timestep, const Real time)
	Write one timestep's worth of the solution.

void	set_output_variables (const std::vector< std::string > &output_variables, bool allow_empty=true)
	Specify the list of variables which should be included in the output (whitelist) If empty, then all variables will be present in the output.

virtual void	write_nodal_data (const std::string &fname, const std::vector< Number > &soln, const std::vector< std::string > &names) override
	Output a nodal solution from data in `soln`.

virtual void	write_nodal_data (const std::string &fname, const EquationSystems &es, const std::set< std::string > *system_names) override
	Output a nodal solution from EquationSystems current_local_solutions.

virtual void	write_nodal_data (const std::string &fname, const NumericVector< Number > &parallel_soln, const std::vector< std::string > &names) override
	Output a nodal solution in parallel, without localizing the soln vector.

void	write_element_data (const EquationSystems &es)
	Write out element solution in parallel, without localizing the solution vector.

void	verbose (bool set_verbosity)
	Set the flag indicating if we should be verbose.

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

void	write_global_data (const std::vector< Number > &, const std::vector< std::string > &)
	Write out global variables.

void	write_information_records (const std::vector< std::string > &)
	Write out information records.

void	append (bool val)
	If true, this flag will cause the Nemesis_IO object to attempt to open an existing file for writing, rather than creating a new file.

const std::vector< std::string > &	get_elem_var_names ()
	Return list of the elemental variable names.

const std::vector< std::string > &	get_nodal_var_names ()
	Return list of the nodal variable names.

const std::vector< std::string > &	get_global_var_names ()
	Return list of the global variable names.

const std::vector< Real > &	get_time_steps ()

int	get_num_time_steps ()

void	copy_nodal_solution (System &system, std::string system_var_name, std::string exodus_var_name, unsigned int timestep=1)
	If we read in a nodal solution while reading in a mesh, we can attempt to copy that nodal solution into an EquationSystems object.

void	copy_elemental_solution (System &system, std::string system_var_name, std::string exodus_var_name, unsigned int timestep=1)
	If we read in a elemental solution while reading in a mesh, we can attempt to copy that elemental solution into an EquationSystems object.

void	copy_scalar_solution (System &system, std::vector< std::string > system_var_names, std::vector< std::string > exodus_var_names, unsigned int timestep=1)
	Copy global variables into scalar variables of a System object.

void	read_global_variable (std::vector< std::string > global_var_names, unsigned int timestep, std::vector< Real > &global_values)
	Given a vector of global variables and a time step, returns the values of the global variable at the corresponding time step index.

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

Nemesis_IO_Helper &	get_nemio_helper ()
	Return a reference to the Nemesis_IO_Helper object.

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

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

void	prepare_to_write_nodal_data (const std::string &fname, const std::vector< std::string > &names)
	Helper function containing code shared between the two different versions of write_nodal_data which take std::vector and NumericVector, respectively.

Private Attributes
std::unique_ptr< Nemesis_IO_Helper >	nemhelper

int	_timestep
	Keeps track of the current timestep index being written.

bool	_verbose
	Controls whether extra debugging information is printed to the screen or not.

bool	_append
	Default false.

std::vector< std::string >	_output_variables
	The names of the variables to be output.

bool	_allow_empty_variables
	If true, _output_variables is allowed to remain empty.

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 Nemesis_IO class implements reading parallel meshes in the Nemesis file format from Sandia National Labs.

Nemesis files are essentially in the Exodus format plus some additional information. All the Nemesis files for a single mesh have the same basename, e.g. cylinder.e, followed by ".size.rank", where size is the total number of files the Mesh is split into and rank is the ID of the processor's elements that were written to the file.

Author: John Peterson

Date: 2008

Definition at line 51 of file nemesis_io.h.

Constructor & Destructor Documentation

◆ Nemesis_IO() [1/2]

libMesh::Nemesis_IO::Nemesis_IO	(	MeshBase &	mesh,
		bool	single_precision = `false`
	)

explicit

Constructor.

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

Definition at line 95 of file nemesis_io.C.

                                               :
  MeshInput<MeshBase> (mesh, /*is_parallel_format=*/true),
  MeshOutput<MeshBase> (mesh, /*is_parallel_format=*/true),
  ParallelObject (mesh),
#if defined(LIBMESH_HAVE_EXODUS_API) && defined(LIBMESH_HAVE_NEMESIS_API)
  nemhelper(std::make_unique<Nemesis_IO_Helper>(*this, false, single_precision)),
  _timestep(1),
#endif
  _verbose (false),
  _append(false),
  _allow_empty_variables(false)
{
  // if !LIBMESH_HAVE_EXODUS_API, we didn't use this
  libmesh_ignore(single_precision);
}

References libMesh::libmesh_ignore().

◆ Nemesis_IO() [2/2]

libMesh::Nemesis_IO::Nemesis_IO	(	const MeshBase &	mesh,
		bool	single_precision = `false`
	)

explicit

Constructor.

Takes a const reference to a mesh object. This constructor is acceptable to write meshes.

Definition at line 114 of file nemesis_io.C.

                                               :
  MeshInput<MeshBase> (),
  MeshOutput<MeshBase> (mesh, /*is_parallel_format=*/true),
  ParallelObject (mesh),
#if defined(LIBMESH_HAVE_EXODUS_API) && defined(LIBMESH_HAVE_NEMESIS_API)
  nemhelper(std::make_unique<Nemesis_IO_Helper>(*this, false, single_precision)),
  _timestep(1),
#endif
  _verbose (false),
  _append(false),
  _allow_empty_variables(false)
{
  // if !LIBMESH_HAVE_EXODUS_API, we didn't use this
  libmesh_ignore(single_precision);
}

References libMesh::libmesh_ignore().

◆ ~Nemesis_IO()

libMesh::Nemesis_IO::~Nemesis_IO ( )

virtualdefault

Destructor.

Member Function Documentation

◆ append()

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

If true, this flag will cause the Nemesis_IO object to attempt to open an existing file for writing, rather than creating a new file.

Obviously this will only work if the file already exists.

Definition at line 162 of file nemesis_io.C.

{
  _append = val;
}

References _append.

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

◆ assert_symmetric_cmaps()

void libMesh::Nemesis_IO::assert_symmetric_cmaps ( )

private

Definition at line 178 of file nemesis_io.C.

{
#ifndef NDEBUG
#if defined(LIBMESH_HAVE_EXODUS_API) && defined(LIBMESH_HAVE_NEMESIS_API)
  // We expect the communication maps to be symmetric - e.g. if processor i thinks it
  // communicates with processor j, then processor j should also be expecting to
  // communicate with i.  We can assert that here easily enough with an alltoall,
  // but let's only do it when not in optimized mode to limit unnecessary communication.
  {
    std::vector<unsigned char> pid_send_partner (this->n_processors(), 0);
 
    // strictly speaking, we should expect to communicate with ourself...
    pid_send_partner[this->processor_id()] = 1;
 
    // mark each processor id we reference with a node cmap
    for (unsigned int cmap=0; cmap<to_uint(nemhelper->num_node_cmaps); cmap++)
      {
        libmesh_assert_less (nemhelper->node_cmap_ids[cmap], this->n_processors());
 
        pid_send_partner[nemhelper->node_cmap_ids[cmap]] = 1;
      }
 
    // Copy the send pairing so we can catch the receive paring and
    // test for equality
    const std::vector<unsigned char> pid_recv_partner (pid_send_partner);
 
    this->comm().alltoall (pid_send_partner);
 
    libmesh_assert (pid_send_partner == pid_recv_partner);
  }
#endif
#endif
}

References libMesh::Parallel::Communicator::alltoall(), libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::ParallelObject::n_processors(), nemhelper, and libMesh::ParallelObject::processor_id().

Referenced by prepare_to_write_nodal_data(), read(), and write().

◆ comm()

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

inlineinherited

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

Definition at line 97 of file parallel_object.h.

98 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition parallel_object.h:120

References libMesh::ParallelObject::_communicator.

◆ copy_elemental_solution()

void libMesh::Nemesis_IO::copy_elemental_solution	(	System &	system,
		std::string	system_var_name,
		std::string	exodus_var_name,
		unsigned int	timestep = `1`
	)

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

Definition at line 1737 of file nemesis_io.C.

{
  parallel_object_only();
 
  const unsigned int var_num = system.variable_number(system_var_name);
  const auto & var_type = system.variable_type(var_num);
  libmesh_error_msg_if(!EquationSystems::is_elemental_data_fe_type(var_type) ||
                       FEInterface::field_type(var_type) == TYPE_VECTOR,
                       "Error! Trying to copy elemental solution into a variable that is not scalar elemental data.");
 
  const MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  // Map from element ID to elemental variable value.  We need to use
  // a map here rather than a vector (e.g. elem_var_values) since the
  // libmesh element numbering can contain "holes".  This is the case
  // if we are reading elemental var values from an adaptively refined
  // mesh that has not been sequentially renumbered.
  std::map<dof_id_type, Real> elem_var_value_map;
 
  libmesh_error_msg_if(!nemhelper->opened_for_reading,
                       "ERROR, Nemesis file must be opened for reading before copying an elemental solution!");
 
  nemhelper->read_elemental_var_values(exodus_var_name, timestep, elem_var_value_map);
 
  std::map<dof_id_type, Real>::iterator
    it = elem_var_value_map.begin(),
    end = elem_var_value_map.end();
 
  for (; it!=end; ++it)
    {
      const Elem * elem = mesh.query_elem_ptr(it->first);
 
      if (elem && elem->n_comp(system.number(), var_num) > 0)
        {
          dof_id_type dof_index = elem->dof_number(system.number(), var_num, 0);
          libmesh_assert(system.get_dof_map().local_index(dof_index));
          system.solution->set (dof_index, it->second);
        }
    }
 
  system.solution->close();
  system.update();
 
  parallel_object_only();
}

References libMesh::DofObject::dof_number(), libMesh::FEInterface::field_type(), libMesh::System::get_dof_map(), libMesh::EquationSystems::is_elemental_data_fe_type(), libMesh::libmesh_assert(), libMesh::DofMap::local_index(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshInput< MT >::mesh(), libMesh::DofObject::n_comp(), nemhelper, libMesh::System::number(), libMesh::MeshBase::query_elem_ptr(), libMesh::System::solution, libMesh::TYPE_VECTOR, libMesh::System::update(), libMesh::System::variable_number(), and libMesh::System::variable_type().

Referenced by MeshInputTest::testSingleElementImpl().

◆ copy_nodal_solution()

void libMesh::Nemesis_IO::copy_nodal_solution	(	System &	system,
		std::string	system_var_name,
		std::string	exodus_var_name,
		unsigned int	timestep = `1`
	)

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

Definition at line 1704 of file nemesis_io.C.

{
  libmesh_error_msg_if(!nemhelper->opened_for_reading,
                       "ERROR, Nemesis file must be opened for reading before copying a nodal solution!");
 
  nemhelper->read_nodal_var_values(exodus_var_name, timestep);
 
  const unsigned int var_num = system.variable_number(system_var_name);
 
  for (auto p : nemhelper->nodal_var_values)
    {
      dof_id_type i = p.first;
      const Node * node = MeshInput<MeshBase>::mesh().node_ptr(i);
 
      if (node && node->n_comp(system.number(), var_num) > 0)
        {
          dof_id_type dof_index = node->dof_number(system.number(), var_num, 0);
 
          // If the dof_index is local to this processor, set the value
          if (system.get_dof_map().local_index(dof_index))
            system.solution->set (dof_index, p.second);
        }
    }
 
  system.solution->close();
  system.update();
}

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

Referenced by WriteVecAndScalar::testWriteNemesis().

◆ copy_scalar_solution()

void libMesh::Nemesis_IO::copy_scalar_solution	(	System &	system,
		std::vector< std::string >	system_var_names,
		std::vector< std::string >	exodus_var_names,
		unsigned int	timestep = `1`
	)

Copy global variables into scalar variables of a System object.

Definition at line 1788 of file nemesis_io.C.

{
  libmesh_error_msg_if(!nemhelper->opened_for_reading,
                       "ERROR, Nemesis file must be opened for reading before copying a scalar solution!");
 
  libmesh_error_msg_if(system_var_names.size() != exodus_var_names.size(),
                       "ERROR, the number of system_var_names must match exodus_var_names.");
 
  std::vector<Real> values_from_exodus;
  read_global_variable(exodus_var_names, timestep, values_from_exodus);
 
  if (system.processor_id() == (system.n_processors()-1))
  {
    const DofMap & dof_map = system.get_dof_map();
 
    for (auto i : index_range(system_var_names))
    {
      const unsigned int var_num = system.variable_scalar_number(system_var_names[i], 0);
 
      std::vector<dof_id_type> SCALAR_dofs;
      dof_map.SCALAR_dof_indices(SCALAR_dofs, var_num);
 
      system.solution->set (SCALAR_dofs[0], values_from_exodus[i]);
    }
  }
 
  system.solution->close();
  system.update();
}

References libMesh::System::get_dof_map(), libMesh::index_range(), libMesh::ParallelObject::n_processors(), nemhelper, libMesh::ParallelObject::processor_id(), read_global_variable(), libMesh::DofMap::SCALAR_dof_indices(), libMesh::System::solution, libMesh::System::update(), and libMesh::System::variable_scalar_number().

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

176{ return false; }

◆ get_elem_var_names()

const std::vector< std::string > & libMesh::Nemesis_IO::get_elem_var_names ( )

Return list of the elemental variable names.

Definition at line 1670 of file nemesis_io.C.

{
  nemhelper->read_var_names(ExodusII_IO_Helper::ELEMENTAL);
  return nemhelper->elem_var_names;
}

References libMesh::ExodusII_IO_Helper::ELEMENTAL, and nemhelper.

◆ get_global_var_names()

const std::vector< std::string > & libMesh::Nemesis_IO::get_global_var_names ( )

Return list of the global variable names.

Definition at line 1676 of file nemesis_io.C.

{
  nemhelper->read_var_names(ExodusII_IO_Helper::GLOBAL);
  return nemhelper->global_var_names;
}

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

◆ get_nemio_helper()

Nemesis_IO_Helper & libMesh::Nemesis_IO::get_nemio_helper ( )

Return a reference to the Nemesis_IO_Helper object.

Definition at line 1852 of file nemesis_io.C.

{
  // Provide a warning when accessing the helper object
  // since it is a non-public API and is likely to see
  // future API changes
  libmesh_experimental();
 
  return *nemhelper;
}

References nemhelper.

◆ get_nodal_var_names()

const std::vector< std::string > & libMesh::Nemesis_IO::get_nodal_var_names ( )

Return list of the nodal variable names.

Definition at line 1664 of file nemesis_io.C.

{
  nemhelper->read_var_names(ExodusII_IO_Helper::NODAL);
  return nemhelper->nodal_var_names;
}

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

Referenced by WriteVecAndScalar::testWriteNemesis().

◆ get_num_time_steps()

int libMesh::Nemesis_IO::get_num_time_steps ( )

Returns: The number of timesteps currently stored in the Exodus file.

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

Definition at line 1694 of file nemesis_io.C.

{
  libmesh_error_msg_if(!nemhelper->opened_for_reading && !nemhelper->opened_for_writing,
                       "ERROR, ExodusII file must be opened for reading or writing before calling Nemesis_IO::get_num_time_steps()!");
 
  nemhelper->read_num_time_steps();
  return nemhelper->num_time_steps;
}

References nemhelper.

◆ get_time_steps()

const std::vector< Real > & libMesh::Nemesis_IO::get_time_steps ( )

Returns: An array containing the timesteps in the file.

Definition at line 1683 of file nemesis_io.C.

{
  libmesh_error_msg_if
    (!nemhelper->opened_for_reading,
     "ERROR, ExodusII file must be opened for reading before calling Nemesis_IO::get_time_steps()!");
 
  nemhelper->read_time_steps();
  return nemhelper->time_steps;
}

References nemhelper.

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

87{ return this->_is_parallel_format; }

libMesh::MeshInput< MeshBase >::_is_parallel_format

const bool _is_parallel_format

Flag specifying whether this format is parallel-capable.

Definition mesh_input.h:130

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

◆ prepare_to_write_nodal_data()

void libMesh::Nemesis_IO::prepare_to_write_nodal_data	(	const std::string &	fname,
		const std::vector< std::string > &	names
	)

private

Helper function containing code shared between the two different versions of write_nodal_data which take std::vector and NumericVector, respectively.

Definition at line 1318 of file nemesis_io.C.

{
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
  std::string nemesis_filename = nemhelper->construct_nemesis_filename(fname);
 
  if (!nemhelper->opened_for_writing)
    {
      // If we're appending, open() the file with read_only=false,
      // otherwise create() it and write the contents of the mesh to
      // it.
      if (_append)
        {
          nemhelper->open(nemesis_filename.c_str(), /*read_only=*/false);
          // After opening the file, read the header so that certain
          // fields, such as the number of nodes and the number of
          // elements, are correctly initialized for the subsequent
          // call to write the nodal solution.
          nemhelper->read_and_store_header_info();
 
          // ...and reading the block info
          nemhelper->read_block_info();
 
          // ...and rebuild the "exodus_node_num_to_libmesh" map
          nemhelper->compute_num_global_elem_blocks(mesh);
          nemhelper->build_element_and_node_maps(mesh);
        }
      else
        {
          nemhelper->create(nemesis_filename);
          nemhelper->initialize(nemesis_filename,mesh);
 
          // Make sure we're writing communication maps we can reuse
          // as expected when reading
          this->assert_symmetric_cmaps();
 
          nemhelper->write_nodal_coordinates(mesh);
          nemhelper->write_elements(mesh);
          nemhelper->write_nodesets(mesh);
          nemhelper->write_sidesets(mesh);
 
          if ((mesh.get_boundary_info().n_edge_conds() > 0) && _verbose)
            libmesh_warning("Warning: Mesh contains edge boundary IDs, but these "
                            "are not supported by the ExodusII format.");
        }
    }
 
  // Even if we were already open for writing, we might not have
  // initialized the nodal variable names yet. Even if we did, it
  // should not hurt to call this twice because the routine sets a
  // flag the first time it is called.
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
  std::vector<std::string> complex_names =
    nemhelper->get_complex_names(names, nemhelper->write_complex_abs);
  nemhelper->initialize_nodal_variables(complex_names);
#else
  nemhelper->initialize_nodal_variables(names);
#endif
}

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

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

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

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

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

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

◆ read()

void libMesh::Nemesis_IO::read ( const std::string & base_filename )

overridevirtual

Implements reading the mesh from several different files.

You provide the basename, then LibMesh appends the ".size.rank" depending on this->n_processors() and this->processor_id().

Implements libMesh::MeshInput< MeshBase >.

Definition at line 215 of file nemesis_io.C.

{
  LOG_SCOPE ("read()","Nemesis_IO");
 
  // This function must be run on all processors at once
  parallel_object_only();
 
  if (_verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] ";
      libMesh::out << "Reading Nemesis file on processor: " << this->processor_id() << std::endl;
    }
 
  // Construct the Nemesis filename based on the number of processors and the
  // current processor ID.
  std::string nemesis_filename = nemhelper->construct_nemesis_filename(base_filename);
 
  if (_verbose)
    libMesh::out << "Opening file: " << nemesis_filename << std::endl;
 
  // Open the Exodus file in EX_READ mode
  nemhelper->open(nemesis_filename.c_str(), /*read_only=*/true);
 
  // Get a reference to the mesh.  We need to be specific
  // since Nemesis_IO is multiply-inherited
  // MeshBase & mesh = this->mesh();
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  // We're reading a file on each processor, so our mesh is
  // partitioned into that many parts as it's created
  this->set_n_partitions(this->n_processors());
 
  // Local information: Read the following information from the standard Exodus header
  //  title[0]
  //  num_dim
  //  num_nodes
  //  num_elem
  //  num_elem_blk
  //  num_node_sets
  //  num_side_sets
  nemhelper->read_and_store_header_info();
  nemhelper->print_header();
 
  // Get global information: number of nodes, elems, blocks, nodesets and sidesets
  nemhelper->get_init_global();
 
  // Get "load balance" information.  This includes the number of internal & border
  // nodes and elements as well as the number of communication maps.
  nemhelper->get_loadbal_param();
 
  // Do some error checking
  libmesh_error_msg_if(nemhelper->num_external_nodes,
                       "ERROR: there should be no external nodes in an element-based partitioning!");
 
  libmesh_assert_equal_to (nemhelper->num_nodes,
                           (nemhelper->num_internal_nodes +
                            nemhelper->num_border_nodes));
 
  libmesh_assert_equal_to (nemhelper->num_elem,
                           (nemhelper->num_internal_elems +
                            nemhelper->num_border_elems));
 
  libmesh_assert_less_equal (nemhelper->num_nodes, nemhelper->num_nodes_global);
  libmesh_assert_less_equal (nemhelper->num_elem, nemhelper->num_elems_global);
 
  // Read nodes from the exodus file: this fills the nemhelper->x,y,z arrays.
  nemhelper->read_nodes();
 
  // Reads the nemhelper->node_num_map array, node_num_map[i] is the global node number for
  // local node number i.
  nemhelper->read_node_num_map();
 
  // The get_cmap_params() function reads in the:
  //  node_cmap_ids[],
  //  node_cmap_node_cnts[],
  //  elem_cmap_ids[],
  //  elem_cmap_elem_cnts[],
  nemhelper->get_cmap_params();
 
  // Read the IDs of the interior, boundary, and external nodes.  This function
  // fills the vectors:
  //  node_mapi[],
  //  node_mapb[],
  //  node_mape[]
  nemhelper->get_node_map();
 
  // Read each node communication map for this processor.  This function
  // fills the vectors of vectors named:
  //  node_cmap_node_ids[][]
  //  node_cmap_proc_ids[][]
  nemhelper->get_node_cmap();
 
  libmesh_assert_equal_to (to_uint(nemhelper->num_node_cmaps), nemhelper->node_cmap_node_cnts.size());
  libmesh_assert_equal_to (to_uint(nemhelper->num_node_cmaps), nemhelper->node_cmap_node_ids.size());
  libmesh_assert_equal_to (to_uint(nemhelper->num_node_cmaps), nemhelper->node_cmap_proc_ids.size());
 
  this->assert_symmetric_cmaps();
 
  // We now have enough information to infer node ownership.  We start by assuming
  // we own all the nodes on this processor.  We will then interrogate the
  // node cmaps and see if a lower-rank processor is associated with any of
  // our nodes.  If so, then that processor owns the node, not us...
  std::vector<processor_id_type> node_ownership (nemhelper->num_internal_nodes +
                                                 nemhelper->num_border_nodes,
                                                 this->processor_id());
 
  // a map from processor id to cmap number, to be used later
  std::map<unsigned int, unsigned int> pid_to_cmap_map;
 
  // For each node_cmap...
  for (unsigned int cmap=0; cmap<to_uint(nemhelper->num_node_cmaps); cmap++)
    {
      // Good time for error checking...
      libmesh_assert_equal_to (to_uint(nemhelper->node_cmap_node_cnts[cmap]),
                               nemhelper->node_cmap_node_ids[cmap].size());
 
      libmesh_assert_equal_to (to_uint(nemhelper->node_cmap_node_cnts[cmap]),
                               nemhelper->node_cmap_proc_ids[cmap].size());
 
      // In all the samples I have seen, node_cmap_ids[cmap] is the processor
      // rank of the remote processor...
      const processor_id_type adjcnt_pid_idx =
        cast_int<processor_id_type>(nemhelper->node_cmap_ids[cmap]);
 
      libmesh_assert_less (adjcnt_pid_idx, this->n_processors());
      libmesh_assert_not_equal_to (adjcnt_pid_idx, this->processor_id());
 
      // We only expect one cmap per adjacent processor
      libmesh_assert (!pid_to_cmap_map.count(adjcnt_pid_idx));
 
      pid_to_cmap_map[adjcnt_pid_idx] = cmap;
 
      // ...and each node in that cmap...
      for (unsigned int idx=0; idx<to_uint(nemhelper->node_cmap_node_cnts[cmap]); idx++)
        {
          //  Are the node_cmap_ids and node_cmap_proc_ids really redundant?
          libmesh_assert_equal_to
            (adjcnt_pid_idx,
             cast_int<processor_id_type>(nemhelper->node_cmap_proc_ids[cmap][idx]));
 
          // we are expecting the exodus node numbering to be 1-based...
          const unsigned int local_node_idx = nemhelper->node_cmap_node_ids[cmap][idx]-1;
 
          libmesh_assert_less (local_node_idx, node_ownership.size());
 
          // if the adjacent processor is lower rank than the current
          // owner for this node, then it will get the node...
          node_ownership[local_node_idx] =
            std::min(node_ownership[local_node_idx], adjcnt_pid_idx);
        }
    } // We now should have established proper node ownership.
 
  // now that ownership is established, we can figure out how many nodes we
  // will be responsible for numbering.
  unsigned int num_nodes_i_must_number = 0;
 
  for (const auto & pid : node_ownership)
    if (pid == this->processor_id())
      num_nodes_i_must_number++;
 
  // more error checking...
  libmesh_assert_greater_equal (num_nodes_i_must_number, nemhelper->num_internal_nodes);
  libmesh_assert (num_nodes_i_must_number <= to_uint(nemhelper->num_internal_nodes +
                                                     nemhelper->num_border_nodes));
  if (_verbose)
    libMesh::out << "[" << this->processor_id() << "] "
                 << "num_nodes_i_must_number="
                 << num_nodes_i_must_number
                 << std::endl;
 
  // The call to get_loadbal_param() gets 7 pieces of information.  We allgather
  // these now across all processors to determine some global numberings. We should
  // also gather the number of nodes each processor thinks it will number so that
  // we can (i) determine our offset, and (ii) do some error checking.
  std::vector<int> all_loadbal_data ( 8 );
  all_loadbal_data[0] = nemhelper->num_internal_nodes;
  all_loadbal_data[1] = nemhelper->num_border_nodes;
  all_loadbal_data[2] = nemhelper->num_external_nodes;
  all_loadbal_data[3] = nemhelper->num_internal_elems;
  all_loadbal_data[4] = nemhelper->num_border_elems;
  all_loadbal_data[5] = nemhelper->num_node_cmaps;
  all_loadbal_data[6] = nemhelper->num_elem_cmaps;
  all_loadbal_data[7] = num_nodes_i_must_number;
 
  this->comm().allgather (all_loadbal_data, /* identical_buffer_sizes = */ true);
 
  // OK, we are now in a position to request new global indices for all the nodes
  // we do not own
 
  // Let's get a unique message tag to use for send()/receive()
  Parallel::MessageTag nodes_tag = mesh.comm().get_unique_tag();
 
  std::vector<std::vector<int>>
    needed_node_idxs (nemhelper->num_node_cmaps); // the indices we will ask for
 
  std::vector<Parallel::Request>
    needed_nodes_requests (nemhelper->num_node_cmaps);
 
  for (unsigned int cmap=0; cmap<to_uint(nemhelper->num_node_cmaps); cmap++)
    {
      // We know we will need no more indices than there are nodes
      // in this cmap, but that number is an upper bound in general
      // since the neighboring processor associated with the cmap
      //  may not actually own it
      needed_node_idxs[cmap].reserve   (nemhelper->node_cmap_node_cnts[cmap]);
 
      const unsigned int adjcnt_pid_idx = nemhelper->node_cmap_ids[cmap];
 
      // ...and each node in that cmap...
      for (unsigned int idx=0; idx<to_uint(nemhelper->node_cmap_node_cnts[cmap]); idx++)
        {
          const unsigned int
            local_node_idx  = nemhelper->node_cmap_node_ids[cmap][idx]-1,
            owning_pid_idx  = node_ownership[local_node_idx];
 
          // add it to the request list for its owning processor.
          if (owning_pid_idx == adjcnt_pid_idx)
            {
              const unsigned int
                global_node_idx = nemhelper->node_num_map[local_node_idx]-1;
              needed_node_idxs[cmap].push_back(global_node_idx);
            }
        }
      // now post the send for this cmap
      this->comm().send (adjcnt_pid_idx,              // destination
                         needed_node_idxs[cmap],      // send buffer
                         needed_nodes_requests[cmap], // request
                         nodes_tag);
    } // all communication requests for getting updated global indices for border
      // nodes have been initiated
 
  // Figure out how many nodes each processor thinks it will number and make sure
  // that it adds up to the global number of nodes. Also, set up global node
  // index offsets for each processor.
  std::vector<unsigned int>
    all_num_nodes_i_must_number (this->n_processors());
 
  for (auto pid : make_range(this->n_processors()))
    all_num_nodes_i_must_number[pid] = all_loadbal_data[8*pid + 7];
 
  // The sum of all the entries in this vector should sum to the number of global nodes
  libmesh_assert (std::accumulate(all_num_nodes_i_must_number.begin(),
                                  all_num_nodes_i_must_number.end(),
                                  0) == nemhelper->num_nodes_global);
 
  unsigned int my_next_node = 0;
  for (auto pid : make_range(this->processor_id()))
    my_next_node += all_num_nodes_i_must_number[pid];
 
  const unsigned int my_node_offset = my_next_node;
 
  if (_verbose)
    libMesh::out << "[" << this->processor_id() << "] "
                 << "my_node_offset="
                 << my_node_offset
                 << std::endl;
 
  // Add internal nodes to the DistributedMesh, using the node ID offset we
  // computed and the current processor's ID.
  for (unsigned int i=0; i<to_uint(nemhelper->num_internal_nodes); ++i)
    {
      const unsigned int local_node_idx  = nemhelper->node_mapi[i]-1;
#ifndef NDEBUG
      const unsigned int owning_pid_idx  = node_ownership[local_node_idx];
#endif
 
      // an internal node we do not own? huh??
      libmesh_assert_equal_to (owning_pid_idx, this->processor_id());
      libmesh_assert_less (my_next_node, nemhelper->num_nodes_global);
 
      // "Catch" the node pointer after addition, make sure the
      // ID matches the requested value.
      Node * added_node =
        mesh.add_point (Point(nemhelper->x[local_node_idx],
                              nemhelper->y[local_node_idx],
                              nemhelper->z[local_node_idx]),
                        my_next_node,
                        this->processor_id());
 
      // Make sure the node we added has the ID we thought it would
      if (added_node->id() != my_next_node)
        {
          libMesh::err << "Error, node added with ID " << added_node->id()
                       << ", but we wanted ID " << my_next_node << std::endl;
        }
 
      // Set a unique_id ourselves since ReplicatedMesh can't handle
      // distributed unique_id generation.  Make sure it doesn't
      // overlap element unique_id() values either.
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      added_node->set_unique_id(added_node->id() + nemhelper->num_elems_global);
#endif
 
      // update the local->global index map, keeping it 1-based
      nemhelper->node_num_map[local_node_idx] = my_next_node++ + 1;
    }
 
  // Now, for the boundary nodes...  We may very well own some of them,
  // but there may be others for which we have requested the new global
  // id.  We expect to be asked for the ids of the ones we own, so
  // we need to create a map from the old global id to the new one
  // we are about to create.
  typedef std::vector<std::pair<unsigned int, unsigned int>> global_idx_mapping_type;
  global_idx_mapping_type old_global_to_new_global_map;
  old_global_to_new_global_map.reserve (num_nodes_i_must_number // total # i will have
                                        - (my_next_node         // amount i have thus far
                                           - my_node_offset));  // this should be exact!
  CompareGlobalIdxMappings global_idx_mapping_comp;
 
  for (unsigned int i=0; i<to_uint(nemhelper->num_border_nodes); ++i)
    {
      const unsigned int
        local_node_idx  = nemhelper->node_mapb[i]-1,
        owning_pid_idx  = node_ownership[local_node_idx];
 
      // if we own it...
      if (owning_pid_idx == this->processor_id())
        {
          const unsigned int
            global_node_idx = nemhelper->node_num_map[local_node_idx]-1;
 
          // we will number it, and create a mapping from its old global index to
          // the new global index, for lookup purposes when neighbors come calling
          old_global_to_new_global_map.emplace_back(global_node_idx, my_next_node);
 
          // "Catch" the node pointer after addition, make sure the
          // ID matches the requested value.
          Node * added_node =
            mesh.add_point (Point(nemhelper->x[local_node_idx],
                                  nemhelper->y[local_node_idx],
                                  nemhelper->z[local_node_idx]),
                            my_next_node,
                            this->processor_id());
 
          // Make sure the node we added has the ID we thought it would
          if (added_node->id() != my_next_node)
            {
              libMesh::err << "Error, node added with ID " << added_node->id()
                           << ", but we wanted ID " << my_next_node << std::endl;
            }
 
          // Set a unique_id ourselves since ReplicatedMesh can't handle
          // distributed unique_id generation.  Make sure it doesn't
          // overlap element unique_id() values either.
#ifdef LIBMESH_ENABLE_UNIQUE_ID
          added_node->set_unique_id(added_node->id() + nemhelper->num_elems_global);
#endif
 
          // update the local->global index map, keeping it 1-based
          nemhelper->node_num_map[local_node_idx] = my_next_node++ + 1;
        }
    }
  // That should cover numbering all the nodes which belong to us...
  libmesh_assert_equal_to (num_nodes_i_must_number, (my_next_node - my_node_offset));
 
  // Let's sort the mapping so we can efficiently answer requests
  std::sort (old_global_to_new_global_map.begin(),
             old_global_to_new_global_map.end(),
             global_idx_mapping_comp);
 
  // and it had better be unique...
  libmesh_assert (std::unique (old_global_to_new_global_map.begin(),
                               old_global_to_new_global_map.end(),
                               global_idx_mapping_equality) ==
                  old_global_to_new_global_map.end());
 
  // We can now catch incoming requests and process them. for efficiency
  // let's do whatever is available next
  std::map<unsigned int, std::vector<int>> requested_node_idxs; // the indices asked of us
 
  std::vector<Parallel::Request> requested_nodes_requests(nemhelper->num_node_cmaps);
 
  // We know we will receive the request from a given processor before
  // we receive its reply to our request. However, we may receive
  // a request and a response from one processor before getting
  // a request from another processor.  So what we are doing here
  // is processing whatever message comes next, while recognizing
  // we will receive a request from a processor before receiving
  // its reply
  std::vector<bool> processed_cmap (nemhelper->num_node_cmaps, false);
 
  for (unsigned int comm_step=0; comm_step<2*to_uint(nemhelper->num_node_cmaps); comm_step++)
    {
      // query the first message which is available
      const Parallel::Status
        status (this->comm().probe (Parallel::any_source,
                                    nodes_tag));
      const unsigned int
        requesting_pid_idx = status.source(),
        source_pid_idx     = status.source();
 
      // this had better be from a processor we are expecting...
      libmesh_assert (pid_to_cmap_map.count(requesting_pid_idx));
 
      // the local cmap which corresponds to the source processor
      const unsigned int cmap = pid_to_cmap_map[source_pid_idx];
 
      if (!processed_cmap[cmap])
        {
          processed_cmap[cmap] = true;
 
          // we should only get one request per paired processor
          libmesh_assert (!requested_node_idxs.count(requesting_pid_idx));
 
          // get a reference to the request buffer for this processor to
          // avoid repeated map lookups
          std::vector<int> & xfer_buf (requested_node_idxs[requesting_pid_idx]);
 
          // actually receive the message.
          this->comm().receive (requesting_pid_idx, xfer_buf, nodes_tag);
 
          // Fill the request
          for (auto i : index_range(xfer_buf))
            {
              // the requested old global node index, *now 0-based*
              const unsigned int old_global_node_idx = xfer_buf[i];
 
              // find the new global node index for the requested node -
              // note that requesting_pid_idx thinks we own this node,
              // so we better!
              const global_idx_mapping_type::const_iterator it =
                std::lower_bound (old_global_to_new_global_map.begin(),
                                  old_global_to_new_global_map.end(),
                                  old_global_node_idx,
                                  global_idx_mapping_comp);
 
              libmesh_assert (it != old_global_to_new_global_map.end());
              libmesh_assert_equal_to (it->first, old_global_node_idx);
              libmesh_assert_greater_equal (it->second, my_node_offset);
              libmesh_assert_less (it->second, my_next_node);
 
              // overwrite the requested old global node index with the new global index
              xfer_buf[i] = it->second;
            }
 
          // and send the new global indices back to the processor which asked for them
          this->comm().send (requesting_pid_idx,
                             xfer_buf,
                             requested_nodes_requests[cmap],
                             nodes_tag);
        } // done processing the request
 
      // this is the second time we have heard from this processor,
      // so it must be its reply to our request
      else
        {
          // a long time ago, we sent off our own requests.  now it is time to catch the
          // replies and get the new global node numbering.  note that for any reply
          // we receive, the corresponding nonblocking send from above *must* have been
          // completed, since the reply is in response to that request!!
 
          // if we have received a reply, our send *must* have completed
          // (note we never actually need to wait on the request)
          libmesh_assert (needed_nodes_requests[cmap].test());
          libmesh_assert_equal_to (to_uint(nemhelper->node_cmap_ids[cmap]), source_pid_idx);
 
          // now post the receive for this cmap
          this->comm().receive (source_pid_idx,
                                needed_node_idxs[cmap],
                                nodes_tag);
 
          libmesh_assert_less_equal (needed_node_idxs[cmap].size(),
                                     nemhelper->node_cmap_node_ids[cmap].size());
 
          for (std::size_t i=0, j=0, ncnis=nemhelper->node_cmap_node_ids[cmap].size(); i < ncnis; i++)
            {
              const unsigned int
                local_node_idx  = nemhelper->node_cmap_node_ids[cmap][i]-1,
                owning_pid_idx  = node_ownership[local_node_idx];
 
              // if this node is owned by source_pid_idx, its new global id
              // is in the buffer we just received
              if (owning_pid_idx == source_pid_idx)
                {
                  libmesh_assert_less (j, needed_node_idxs[cmap].size());
 
                  const unsigned int // now 0-based!
                    global_node_idx = needed_node_idxs[cmap][j++];
 
                  // "Catch" the node pointer after addition, make sure the
                  // ID matches the requested value.
                  Node * added_node =
                    mesh.add_point (Point(nemhelper->x[local_node_idx],
                                          nemhelper->y[local_node_idx],
                                          nemhelper->z[local_node_idx]),
                                    cast_int<dof_id_type>(global_node_idx),
                                    cast_int<processor_id_type>(source_pid_idx));
 
                  // Make sure the node we added has the ID we thought it would
                  if (added_node->id() != global_node_idx)
                    {
                      libMesh::err << "Error, node added with ID " << added_node->id()
                                   << ", but we wanted ID " << global_node_idx << std::endl;
                    }
 
                  // Set a unique_id ourselves since ReplicatedMesh can't handle
                  // distributed unique_id generation.  Make sure it doesn't
                  // overlap element unique_id() values either.
#ifdef LIBMESH_ENABLE_UNIQUE_ID
                  added_node->set_unique_id(added_node->id() + nemhelper->num_elems_global);
#endif
 
                  // update the local->global index map, keeping it 1-based
                  nemhelper->node_num_map[local_node_idx] = global_node_idx + 1;
 
                  // we are not really going to use my_next_node again, but we can
                  // keep incrementing it to track how many nodes we have added
                  // to the mesh
                  my_next_node++;
                }
            }
        }
    } // end of node index communication loop
 
  // we had better have added all the nodes we need to!
  libmesh_assert_equal_to ((my_next_node - my_node_offset), to_uint(nemhelper->num_nodes));
 
  // After all that, we should be done with all node-related arrays
  // *except* the node_num_map.
  // So let's clean up the arrays we are done with.
  {
    Utility::deallocate (nemhelper->node_mapi);
    Utility::deallocate (nemhelper->node_mapb);
    Utility::deallocate (nemhelper->node_mape);
    Utility::deallocate (nemhelper->node_cmap_ids);
    Utility::deallocate (nemhelper->node_cmap_node_cnts);
    Utility::deallocate (nemhelper->node_cmap_node_ids);
    Utility::deallocate (nemhelper->node_cmap_proc_ids);
    Utility::deallocate (nemhelper->x);
    Utility::deallocate (nemhelper->y);
    Utility::deallocate (nemhelper->z);
    Utility::deallocate (needed_node_idxs);
    Utility::deallocate (node_ownership);
  }
 
  Parallel::wait (needed_nodes_requests);
  Parallel::wait (requested_nodes_requests);
  requested_node_idxs.clear();
 
  // See what the node count is up to now.
  if (_verbose)
    {
      // Report the number of nodes which have been added locally
      libMesh::out << "[" << this->processor_id() << "] ";
      libMesh::out << "mesh.n_nodes()=" << mesh.n_nodes() << std::endl;
 
      // Reports the number of nodes that have been added in total.
      libMesh::out << "[" << this->processor_id() << "] ";
      libMesh::out << "mesh.parallel_n_nodes()=" << mesh.parallel_n_nodes() << std::endl;
    }
 
 
 
  // --------------------------------------------------------------------------------
  // --------------------------------------------------------------------------------
  // --------------------------------------------------------------------------------
 
 
  // We can now read in the elements...Exodus stores them in blocks in which all
  // elements have the same geometric type.  This code is adapted directly from exodusII_io.C
 
  // Assertion: The sum of the border and internal elements on all processors
  // should equal nemhelper->num_elems_global
#ifndef NDEBUG
  {
    int sum_internal_elems=0, sum_border_elems=0;
    for (unsigned int j=3,c=0; c<this->n_processors(); j+=8,++c)
      sum_internal_elems += all_loadbal_data[j];
 
    for (unsigned int j=4,c=0; c<this->n_processors(); j+=8,++c)
      sum_border_elems += all_loadbal_data[j];
 
    if (_verbose)
      {
        libMesh::out << "[" << this->processor_id() << "] ";
        libMesh::out << "sum_internal_elems=" << sum_internal_elems << std::endl;
 
        libMesh::out << "[" << this->processor_id() << "] ";
        libMesh::out << "sum_border_elems=" << sum_border_elems << std::endl;
      }
 
    libmesh_assert_equal_to (sum_internal_elems+sum_border_elems, nemhelper->num_elems_global);
  }
#endif
 
  // We need to set the mesh dimension, but the following...
  // mesh.set_mesh_dimension(static_cast<unsigned int>(nemhelper->num_dim));
 
  // ... is not sufficient since some codes report num_dim==3 for two dimensional
  // meshes living in 3D, even though all the elements are of 2D type.  Therefore,
  // we instead use the dimension of the highest element found for the Mesh dimension,
  // similar to what is done by the Exodus reader, except here it requires a
  // parallel communication.
  elems_of_dimension.resize(4, false); // will use 1-based
 
  // Fills in the:
  // global_elem_blk_ids[] and
  // global_elem_blk_cnts[] arrays.
  nemhelper->get_eb_info_global();
 
  //   // Fills in the vectors
  //   // elem_mapi[num_internal_elems]
  //   // elem_mapb[num_border_elems  ]
  //   // These tell which of the (locally-numbered) elements are internal and which are border elements.
  //   // In our test example these arrays are sorted (but non-contiguous), which makes it possible to
  //   // binary search for each element ID... however I don't think we need to distinguish between the
  //   // two types, since either can have nodes the boundary!
  //   nemhelper->get_elem_map();
 
  // Fills in the vectors of vectors:
  // elem_cmap_elem_ids[][]
  // elem_cmap_side_ids[][]
  // elem_cmap_proc_ids[][]
  // These arrays are of size num_elem_cmaps * elem_cmap_elem_cnts[i], i = 0..num_elem_cmaps
  nemhelper->get_elem_cmap();
 
  // Get information about the element blocks:
  // (read in the array nemhelper->block_ids[])
  nemhelper->read_block_info();
 
  // Reads the nemhelper->elem_num_map array.
  // elem_num_map[i] is the exodus element number for local element
  // number i, which makes elem_num_map[i]-1 the libMesh element
  // number.
  nemhelper->read_elem_num_map();
 
  std::size_t local_elem_num = 0;
 
  // Read in the element connectivity for each block by
  // looping over all the blocks.
  for (unsigned int i=0; i<to_uint(nemhelper->num_elem_blk); i++)
    {
      // Read the information for block i:  For nemhelper->block_ids[i], reads
      // elem_type
      // num_elem_this_blk
      // num_nodes_per_elem
      // num_attr
      // connect <-- the nodal connectivity array for each element in the block.
      nemhelper->read_elem_in_block(i);
 
      // Note that with parallel files it is possible we have no elements in
      // this block!
      if (!nemhelper->num_elem_this_blk) continue;
 
      // Set subdomain ID based on the block ID.
      subdomain_id_type subdomain_id =
        restrict_int<subdomain_id_type>(nemhelper->block_ids[i]);
 
      // Create a type string (this uses the null-terminated string ctor).
      const std::string type_str ( nemhelper->elem_type.data() );
 
      // Set any relevant node/edge maps for this element
      const auto & conv = nemhelper->get_conversion(type_str);
 
      if (_verbose)
        libMesh::out << "Reading a block of " << type_str << " elements." << std::endl;
 
      // Loop over all the elements in this block
      for (unsigned int j=0; j<to_uint(nemhelper->num_elem_this_blk); j++)
        {
          auto uelem = Elem::build (conv.libmesh_elem_type());
 
          // Assign subdomain and processor ID to the newly-created Elem.
          // Assigning the processor ID beforehand ensures that the Elem is
          // not added as an "unpartitioned" element.  Note that the element
          // numbering in Exodus is also 1-based.
          uelem->subdomain_id() = subdomain_id;
          uelem->processor_id() = this->processor_id();
          uelem->set_id()       = nemhelper->elem_num_map[local_elem_num++]-1;
 
          // Handle unique_id numbering, just in case we're using a
          // ReplicatedMesh that doesn't know how to handle it in
          // parallel.
#ifdef LIBMESH_ENABLE_UNIQUE_ID
          uelem->set_unique_id(uelem->id());
#endif
 
          // Mark that we have seen an element of the current element's
          // dimension.
          elems_of_dimension[uelem->dim()] = true;
 
          // Add the created Elem to the Mesh, catch the Elem
          // pointer that the Mesh throws back.
          Elem * elem = mesh.add_elem(std::move(uelem));
 
          // We are expecting the element "thrown back" by libmesh to have the ID we specified for it...
          // Check to see that really is the case.  Note that local_elem_num was post-incremented, so
          // subtract 1 when performing the check.
          libmesh_assert_equal_to(elem->id(),
                                  cast_int<dof_id_type>(nemhelper->elem_num_map[local_elem_num-1]-1));
 
          // Set all the nodes for this element
          if (_verbose)
            libMesh::out << "[" << this->processor_id() << "] "
                         << "Setting nodes for Elem " << elem->id() << std::endl;
 
          for (unsigned int k=0; k<to_uint(nemhelper->num_nodes_per_elem); k++)
            {
              const unsigned int
                gi              = (j*nemhelper->num_nodes_per_elem +       // index into connectivity array
                                   conv.get_node_map(k)),
                local_node_idx  = nemhelper->connect[gi]-1,                // local node index
                global_node_idx = nemhelper->node_num_map[local_node_idx]-1; // new global node index
 
              // Set node number
              elem->set_node(k, mesh.node_ptr(global_node_idx));
            }
        } // for (unsigned int j=0; j<nemhelper->num_elem_this_blk; j++)
    } // end for (unsigned int i=0; i<nemhelper->num_elem_blk; i++)
 
  for (const auto & [id, name] : nemhelper->id_to_block_names)
    if (name != "")
      mesh.set_subdomain_name(id, name);
 
  if (_verbose)
    {
      // Print local elems_of_dimension information
      for (auto i : IntRange<std::size_t>(1, elems_of_dimension.size()))
        libMesh::out << "[" << this->processor_id() << "] "
                     << "elems_of_dimension[" << i << "]=" << elems_of_dimension[i] << std::endl;
    }
 
  // Get the max dimension seen on the current processor
  unsigned char max_dim_seen = 0;
  for (auto i : IntRange<std::size_t>(1, elems_of_dimension.size()))
    if (elems_of_dimension[i])
      max_dim_seen = static_cast<unsigned char>(i);
 
  // Do a global max to determine the max dimension seen by all processors.
  // It should match -- I don't think we even support calculations on meshes
  // with elements of different dimension...
  this->comm().max(max_dim_seen);
 
  if (_verbose)
    {
      // Print the max element dimension from all processors
      libMesh::out << "[" << this->processor_id() << "] "
                   << "max_dim_seen=" << +max_dim_seen << std::endl;
    }
 
  // Set the mesh dimension to the largest encountered for an element
  mesh.set_mesh_dimension(max_dim_seen);
 
#if LIBMESH_DIM < 3
  libmesh_error_msg_if(mesh.mesh_dimension() > LIBMESH_DIM,
                       "Cannot open dimension "
                       << mesh.mesh_dimension()
                       << " mesh file when configured without "
                       << mesh.mesh_dimension()
                       << "D support." );
#endif
 
 
  // Global sideset information, they are distributed as well, not sure if they will require communication...?
  nemhelper->get_ss_param_global();
 
  if (_verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] "
                   << "Read global sideset parameter information." << std::endl;
 
      // These global values should be the same on all processors...
      libMesh::out << "[" << this->processor_id() << "] "
                   << "Number of global sideset IDs: " << nemhelper->global_sideset_ids.size() << std::endl;
    }
 
  // Read *local* sideset info the same way it is done in
  // exodusII_io_helper.  May be called any time after
  // nemhelper->read_and_store_header_info(); This sets num_side_sets and resizes
  // elem_list, side_list, and id_list to num_elem_all_sidesets.  Note
  // that there appears to be the same number of sidesets in each file
  // but they all have different numbers of entries (some are empty).
  // Note that the sum of "nemhelper->num_elem_all_sidesets" over all
  // processors should equal the sum of the entries in the "num_global_side_counts" array
  // filled up by nemhelper->get_ss_param_global()
  nemhelper->read_sideset_info();
 
  if (_verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] "
                   << "nemhelper->num_side_sets = " << nemhelper->num_side_sets << std::endl;
 
      libMesh::out << "[" << this->processor_id() << "] "
                   << "nemhelper->num_elem_all_sidesets = " << nemhelper->num_elem_all_sidesets << std::endl;
 
      if (nemhelper->num_side_sets > 0)
        {
          libMesh::out << "Sideset names are: ";
          for (const auto & [id, name] : nemhelper->id_to_ss_names)
            libMesh::out << "(" << id << "," << name << ") ";
          libMesh::out << std::endl;
        }
    }
 
#ifdef DEBUG
  {
    // In DEBUG mode, check that the global number of sidesets reported
    // in each nemesis file matches the sum of all local sideset counts
    // from each processor.  This requires a small communication, so only
    // do it in DEBUG mode.
    int sum_num_global_side_counts = std::accumulate(nemhelper->num_global_side_counts.begin(),
                                                     nemhelper->num_global_side_counts.end(),
                                                     0);
 
    // MPI sum up the local files contributions
    int sum_num_elem_all_sidesets = nemhelper->num_elem_all_sidesets;
    this->comm().sum(sum_num_elem_all_sidesets);
 
    libmesh_error_msg_if(sum_num_global_side_counts != sum_num_elem_all_sidesets,
                         "Error! global side count reported by Nemesis does not "
                         "match the side count reported by the individual files!");
  }
#endif
 
  // Note that exodus stores sidesets in separate vectors but we want to pack
  // them all into a single vector.  So when we call read_sideset(), we pass an offset
  // into the single vector of all IDs
  for (int offset=0, i=0; i<nemhelper->num_side_sets; i++)
    {
      offset += (i > 0 ? nemhelper->num_sides_per_set[i-1] : 0); // Compute new offset
      nemhelper->read_sideset (i, offset);
    }
 
  // Now that we have the lists of elements, sides, and IDs, we are ready to set them
  // in the BoundaryInfo object of our Mesh object.  This is slightly different in parallel...
  // For example, I think the IDs in each of the split Exodus files are numbered locally,
  // and we have to know the appropriate ID for this processor to be able to set the
  // entry in BoundaryInfo.  This id should be given by
  // elem_num_map[i]-1 for the local index i
 
  // Debugging:
  // Print entries of elem_list
  // libMesh::out << "[" << this->processor_id() << "] "
  //        << "elem_list = ";
  // for (const auto & id : nemhelper->elem_list)
  //   libMesh::out << id << ", ";
  // libMesh::out << std::endl;
 
  // Print entries of side_list
  // libMesh::out << "[" << this->processor_id() << "] "
  //        << "side_list = ";
  // for (const auto & id : nemhelper->side_list)
  //   libMesh::out << id << ", ";
  // libMesh::out << std::endl;
 
 
  // Loop over the entries of the elem_list, get their pointers from the
  // Mesh data structure, and assign the appropriate side to the BoundaryInfo object.
  for (auto e : index_range(nemhelper->elem_list))
    {
      // Exodus numbering is 1-based
      const std::size_t local_id = nemhelper->elem_list[e]-1;
      const dof_id_type elem_id = nemhelper->elem_num_map[local_id]-1;
 
      Elem * elem = mesh.elem_ptr(elem_id);
 
      // The side numberings in libmesh and exodus are not 1:1, so we need to map
      // whatever side number is stored in Exodus into a libmesh side number using
      // a conv object...
      const auto & conv = nemhelper->get_conversion(elem->type());
 
      // Finally, we are ready to add the element and its side to the BoundaryInfo object.
      // Call the version of add_side which takes a pointer, since we have already gone to
      // the trouble of getting said pointer...
      mesh.get_boundary_info().add_side(elem,
                                        cast_int<unsigned short>(conv.get_side_map(nemhelper->side_list[e]-1)), // Exodus numbering is 1-based
                                        cast_int<boundary_id_type>(nemhelper->id_list[e]));
    }
 
  for (const auto & [id, name] : nemhelper->id_to_ss_names)
    if (name != "")
      mesh.get_boundary_info().sideset_name(id) = name;
 
  // Debugging: make sure there are as many boundary conditions in the
  // boundary ID object as expected.  Note that, at this point, the
  // mesh still thinks it's serial, so n_boundary_conds() returns the
  // local number of boundary conditions (and is therefore cheap)
  // which should match nemhelper->elem_list.size().
  {
    std::size_t nbcs = mesh.get_boundary_info().n_boundary_conds();
    libmesh_error_msg_if(nbcs != nemhelper->elem_list.size(),
                         "[" << this->processor_id() << "] "
                         << "BoundaryInfo contains "
                         << nbcs
                         << " boundary conditions, while the Exodus file had "
                         << nemhelper->elem_list.size());
  }
 
  // Read global nodeset parameters?  We might be able to use this to verify
  // something about the local files, but I haven't figured out what yet...
  nemhelper->get_ns_param_global();
 
  // Read local nodeset info
  nemhelper->read_nodeset_info();
 
  if (_verbose)
    {
      libMesh::out << "[" << this->processor_id() << "] ";
      libMesh::out << "nemhelper->num_node_sets=" << nemhelper->num_node_sets << std::endl;
      if (nemhelper->num_node_sets > 0)
        {
          libMesh::out << "Nodeset names are: ";
          for (const auto & [id, name] : nemhelper->id_to_ns_names)
            libMesh::out << "(" << id << "," << name << ") ";
          libMesh::out << std::endl;
        }
    }
 
  //  // Debugging, what is currently in nemhelper->node_num_map anyway?
  //  libMesh::out << "[" << this->processor_id() << "] "
  //       << "nemhelper->node_num_map = ";
  //
  //  for (const auto & id : nemhelper->node_num_map)
  //    libMesh::out << id << ", ";
  //  libMesh::out << std::endl;
 
  // For each nodeset,
  for (int nodeset=0; nodeset<nemhelper->num_node_sets; nodeset++)
    {
      // Get the user-defined ID associated with the nodeset
      int nodeset_id = nemhelper->nodeset_ids[nodeset];
 
      if (_verbose)
        {
          libMesh::out << "[" << this->processor_id() << "] ";
          libMesh::out << "nemhelper->nodeset_ids[" << nodeset << "]=" << nodeset_id << std::endl;
        }
 
      // Read the nodeset from file, store them in a vector
      nemhelper->read_nodeset(nodeset);
 
      // Add nodes from the node_list to the BoundaryInfo object
      for (auto node : index_range(nemhelper->node_list))
        {
          // Don't run past the end of our node map!
          libmesh_error_msg_if(to_uint(nemhelper->node_list[node]-1) >= nemhelper->node_num_map.size(),
                               "Error, index is past the end of node_num_map array!");
 
          // We should be able to use the node_num_map data structure set up previously to determine
          // the proper global node index.
          unsigned global_node_id = nemhelper->node_num_map[ nemhelper->node_list[node]-1 /*Exodus is 1-based!*/ ]-1;
 
          if (_verbose)
            {
              libMesh::out << "[" << this->processor_id() << "] "
                           << "nodeset " << nodeset
                           << ", local node number: " << nemhelper->node_list[node]-1
                           << ", global node id: " << global_node_id
                           << std::endl;
            }
 
          // Add the node to the BoundaryInfo object with the proper nodeset_id
          mesh.get_boundary_info().add_node
            (cast_int<dof_id_type>(global_node_id),
             cast_int<boundary_id_type>(nodeset_id));
        }
    }
 
  for (const auto & [id, name] : nemhelper->id_to_ns_names)
    if (name != "")
      mesh.get_boundary_info().nodeset_name(id) = name;
 
  // See what the elem count is up to now.
  if (_verbose)
    {
      // Report the number of elements which have been added locally
      libMesh::out << "[" << this->processor_id() << "] ";
      libMesh::out << "mesh.n_elem()=" << mesh.n_elem() << std::endl;
 
      // Reports the number of elements that have been added in total.
      libMesh::out << "[" << this->processor_id() << "] ";
      libMesh::out << "mesh.parallel_n_elem()=" << mesh.parallel_n_elem() << std::endl;
    }
 
  // For DistributedMesh, it seems that _is_serial is true by default.  A hack to
  // make the Mesh think it's parallel might be to call:
  mesh.update_post_partitioning();
  MeshCommunication().make_node_unique_ids_parallel_consistent(mesh);
  mesh.delete_remote_elements();
 
  // If that didn't work, then we're actually reading into a
  // ReplicatedMesh, so we want to gather *all* elements
  if (mesh.is_serial())
    // Don't just use mesh.allgather(); that's a no-op, since
    // ReplicatedMesh didn't expect to be distributed in the first
    // place!
    MeshCommunication().allgather(mesh);
  else
    // Gather neighboring elements so that a distributed mesh has the
    // proper "ghost" neighbor information.
    MeshCommunication().gather_neighboring_elements(cast_ref<DistributedMesh &>(mesh));
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  // We've been setting unique_ids by hand; let's make sure that later
  // ones are consistent with them.
  mesh.set_next_unique_id(mesh.parallel_max_unique_id()+1);
#endif
}

Referenced by libMesh::NameBasedIO::read(), MeshInputTest::testNemesisReadImpl(), MeshInputTest::testSingleElementImpl(), and WriteVecAndScalar::testWriteNemesis().

◆ read_global_variable()

void libMesh::Nemesis_IO::read_global_variable	(	std::vector< std::string >	global_var_names,
		unsigned int	timestep,
		std::vector< Real > &	global_values
	)

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

Parameters

global_var_names	Vector of names of global variables
timestep	The corresponding time step index
global_values	The vector to be filled

Definition at line 1822 of file nemesis_io.C.

{
  std::size_t size = global_var_names.size();
  libmesh_error_msg_if(size == 0, "ERROR, empty list of global variables to read from the Nemesis file.");
 
  // read the values for all global variables
  std::vector<Real> values_from_exodus;
  nemhelper->read_var_names(ExodusII_IO_Helper::GLOBAL);
  nemhelper->read_global_values(values_from_exodus, timestep);
  std::vector<std::string> global_var_names_exodus = nemhelper->global_var_names;
 
  if (values_from_exodus.size() == 0)
    return;   // This will happen in parallel on procs that are not 0
 
  global_values.clear();
  for (std::size_t i = 0; i != size; ++i)
    {
      // for each global variable in global_var_names, look the corresponding one in global_var_names_from_exodus
      // and fill global_values accordingly
      auto it = find(global_var_names_exodus.begin(), global_var_names_exodus.end(), global_var_names[i]);
      if (it != global_var_names_exodus.end())
        global_values.push_back(values_from_exodus[it - global_var_names_exodus.begin()]);
      else
        libmesh_error_msg("ERROR, Global variable " << global_var_names[i] << \
                          " not found in Nemesis file.");
    }
}

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

Referenced by copy_scalar_solution().

◆ set_hdf5_writing()

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

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

If HDF5 is unavailable, this setting does nothing.

Definition at line 1862 of file nemesis_io.C.

{
    nemhelper->set_hdf5_writing(write_hdf5);
}

References nemhelper.

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

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

mesh

MeshBase & mesh

Definition mesh_communication.C:1460

◆ set_output_variables()

void libMesh::Nemesis_IO::set_output_variables	(	const std::vector< std::string > &	output_variables,
		bool	allow_empty = `true`
	)

Specify the list of variables which should be included in the output (whitelist) If empty, then all variables will be present in the output.

This interface is copied from ExodusII_IO since it was found to be useful there, but perhaps eventually these implementations could somehow be combined.

Definition at line 169 of file nemesis_io.C.

{
  _output_variables = output_variables;
  _allow_empty_variables = allow_empty;
}

References _allow_empty_variables, and _output_variables.

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

◆ verbose()

void libMesh::Nemesis_IO::verbose ( bool set_verbosity )

Set the flag indicating if we should be verbose.

Definition at line 139 of file nemesis_io.C.

{
  _verbose = set_verbosity;
 
#if defined(LIBMESH_HAVE_EXODUS_API) && defined(LIBMESH_HAVE_NEMESIS_API)
  // Set the verbose flag in the helper object
  // as well.
  nemhelper->verbose = _verbose;
#endif
}

References _verbose, and nemhelper.

◆ write()

void libMesh::Nemesis_IO::write ( const std::string & base_filename )

overridevirtual

This method implements writing a mesh to a specified file.

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 1229 of file nemesis_io.C.

{
  // Get a constant reference to the mesh for writing
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
  // Create the filename for this processor given the base_filename passed in.
  std::string nemesis_filename = nemhelper->construct_nemesis_filename(base_filename);
 
  // If the user has set the append flag here, it doesn't really make
  // sense: the intent of this function is to write a Mesh with no
  // data, while "appending" is really intended to add data to an
  // existing file.  If we're verbose, print a message to this effect.
  if (_append && _verbose)
    libmesh_warning("Warning: Appending in Nemesis_IO::write() does not make sense.\n"
                    "Creating a new file instead!");
 
  nemhelper->create(nemesis_filename);
 
  // Initialize data structures and write some global Nemesis-specific data, such as
  // communication maps, to file.
  nemhelper->initialize(nemesis_filename,mesh);
 
  // Make sure we're writing communication maps we can reuse as
  // expected when reading
  this->assert_symmetric_cmaps();
 
  // Call the Nemesis-specialized version of write_nodal_coordinates() to write
  // the nodal coordinates.
  nemhelper->write_nodal_coordinates(mesh);
 
  // Call the Nemesis-specialized version of write_elements() to write
  // the elements.  Note: Must write a zero if a given global block ID has no
  // elements...
  nemhelper->write_elements(mesh);
 
  // Call our specialized function to write the nodesets
  nemhelper->write_nodesets(mesh);
 
  // Call our specialized write_sidesets() function to write the sidesets to file
  nemhelper->write_sidesets(mesh);
 
  // Not sure if this is really necessary, but go ahead and flush the file
  // once we have written all this stuff.
  nemhelper->update();
 
  if ((mesh.get_boundary_info().n_edge_conds() > 0) && _verbose)
    libmesh_warning("Warning: Mesh contains edge boundary IDs, but these "
                    "are not supported by the Nemesis format.");
}

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

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

◆ write_complex_magnitude()

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

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

By default this flag is set to true.

Definition at line 152 of file nemesis_io.C.

{
#if defined(LIBMESH_HAVE_EXODUS_API) && defined(LIBMESH_HAVE_NEMESIS_API)
  nemhelper->write_complex_abs = val;
#endif
  libmesh_ignore(val);
}

References libMesh::libmesh_ignore(), and nemhelper.

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

void libMesh::Nemesis_IO::write_element_data ( const EquationSystems & es )

Write out element solution in parallel, without localizing the solution vector.

Note: Unlike write_nodal_data(), this function is not virtual and it does not override anything from the base class. This design is similar to the function by the same name in ExodusII_IO.

Definition at line 1467 of file nemesis_io.C.

{
  libmesh_error_msg_if(!nemhelper->opened_for_writing,
                       "ERROR, Nemesis file must be initialized before outputting elemental variables.");
 
  // To be (possibly) filled with a filtered list of variable names to output.
  std::vector<std::string> names;
 
  // If _output_variables is populated, find_elemental_data_variable_numbers()
  // will filter this list to the variables that can be written as elemental data.
  if (_output_variables.size())
    names.assign(_output_variables.begin(), _output_variables.end());
 
  // The 'names' vector will here be updated with the variable's names
  // that are actually eligible to write
  std::vector<std::pair<unsigned int, unsigned int>> var_nums =
    es.find_elemental_data_variable_numbers(names);
 
  // find_variable_numbers() can return an empty vector, in which case there are no elemental data
  // variables to write, and we can just return.
  if (var_nums.empty())
    {
      if (_verbose)
        libMesh::out << "No elemental data variables to be written." << std::endl;
      return;
    }
 
  // Store the list of subdomains on which each variable *that we are
  // going to plot* is active. Note: if any of these sets is _empty_,
  // the variable in question is active on _all_ subdomains.
  std::vector<std::set<subdomain_id_type>> vars_active_subdomains;
  es.get_vars_active_subdomains(names, vars_active_subdomains);
 
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
  std::vector<std::string> complex_names =
    nemhelper->get_complex_names(names, nemhelper->write_complex_abs);
 
  std::vector<std::set<subdomain_id_type>>
    complex_vars_active_subdomains =
    nemhelper->get_complex_vars_active_subdomains(vars_active_subdomains,
                                                  nemhelper->write_complex_abs);
  nemhelper->initialize_element_variables(complex_names, complex_vars_active_subdomains);
 
  // Call (non-virtual) function to write the elemental data in
  // parallel.  This function is named similarly to the corresponding
  // function in the Exodus helper, but it has a different calling
  // sequence and is not virtual or an override.
  nemhelper->write_element_values(mesh,
                                  es,
                                  var_nums,
                                  _timestep,
                                  complex_vars_active_subdomains);
 
#else
  // Call the Nemesis version of initialize_element_variables().
  //
  // The Exodus helper version of this function writes an incorrect
  // truth table in parallel that somehow does not account for the
  // case where a subdomain does not appear on one or more of the
  // processors. So, we override that function's behavior in the
  // Nemesis helper.
  nemhelper->initialize_element_variables(names, vars_active_subdomains);
 
  // Call (non-virtual) function to write the elemental data in
  // parallel.  This function is named similarly to the corresponding
  // function in the Exodus helper, but it has a different calling
  // sequence and is not virtual or an override.
  nemhelper->write_element_values(mesh,
                                  es,
                                  var_nums,
                                  _timestep,
                                  vars_active_subdomains);
#endif
}

References _output_variables, _timestep, _verbose, libMesh::EquationSystems::find_elemental_data_variable_numbers(), libMesh::EquationSystems::get_vars_active_subdomains(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), nemhelper, and libMesh::out.

Referenced by libMesh::ErrorVector::plot_error(), and MeshInputTest::testSingleElementImpl().

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

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

Write out global variables.

Definition at line 1584 of file nemesis_io.C.

{
  libmesh_error_msg_if(!nemhelper->opened_for_writing,
                       "ERROR, Nemesis file must be initialized before outputting global variables.");
 
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
 
  std::vector<std::string> complex_names =
    nemhelper->get_complex_names(names, nemhelper->write_complex_abs);
 
  nemhelper->initialize_global_variables(complex_names);
 
  unsigned int num_values = soln.size();
  unsigned int num_vars = names.size();
  unsigned int num_elems = num_values / num_vars;
 
  // This will contain the real and imaginary parts and the magnitude
  // of the values in soln
  int nco = nemhelper->write_complex_abs ? 3 : 2;
  std::vector<Real> complex_soln(nco * num_values);
 
  for (unsigned i=0; i<num_vars; ++i)
    {
      for (unsigned int j=0; j<num_elems; ++j)
        {
          Number value = soln[i*num_vars + j];
          complex_soln[nco*i*num_elems + j] = value.real();
        }
      for (unsigned int j=0; j<num_elems; ++j)
        {
          Number value = soln[i*num_vars + j];
          complex_soln[nco*i*num_elems + num_elems + j] = value.imag();
        }
      if (nemhelper->write_complex_abs)
        {
          for (unsigned int j=0; j<num_elems; ++j)
            {
              Number value = soln[i*num_vars + j];
              complex_soln[3*i*num_elems + 2*num_elems + j] = std::abs(value);
            }
        }
    }
 
  nemhelper->write_global_values(complex_soln, _timestep);
 
#else
 
  // Call the Exodus writer implementation
  nemhelper->initialize_global_variables( names );
  nemhelper->write_global_values( soln, _timestep);
 
#endif
 
}

References _timestep, nemhelper, and value.

◆ write_information_records()

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

Write out information records.

Definition at line 1654 of file nemesis_io.C.

{
  libmesh_error_msg_if(!nemhelper->opened_for_writing,
                       "ERROR, Nemesis file must be initialized before outputting information records.");
 
  // Call the Exodus writer implementation
  nemhelper->write_information_records( records );
}

References nemhelper.

◆ write_nodal_data() [1/3]

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

overridevirtual

Output a nodal solution from EquationSystems current_local_solutions.

Reimplemented from libMesh::MeshOutput< MeshBase >.

Definition at line 1418 of file nemesis_io.C.

{
  LOG_SCOPE("write_nodal_data(parallel)", "Nemesis_IO");
 
  // Only prepare and write nodal variables that are also in
  // _output_variables, unless _output_variables is empty. This is the
  // same logic that is in ExodusII_IO::write_nodal_data().
  std::vector<std::string> output_names;
 
  if (_allow_empty_variables || !_output_variables.empty())
    output_names = _output_variables;
  else
    es.build_variable_names  (output_names, nullptr, system_names);
 
  this->prepare_to_write_nodal_data(base_filename, output_names);
 
  std::vector<std::pair<unsigned int, unsigned int>> var_nums;
  // If we pass in an empty vector below, it will return all of the
  // var nums in es, which we don't want.
  if (!output_names.empty())
    var_nums = es.find_variable_numbers(output_names);
 
  nemhelper->write_nodal_solution(es, var_nums, _timestep, output_names);
}

References _allow_empty_variables, _output_variables, _timestep, libMesh::EquationSystems::build_variable_names(), libMesh::EquationSystems::find_variable_numbers(), nemhelper, and prepare_to_write_nodal_data().

◆ write_nodal_data() [2/3]

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

overridevirtual

Output a nodal solution in parallel, without localizing the soln vector.

Reimplemented from libMesh::MeshOutput< MeshBase >.

Definition at line 1393 of file nemesis_io.C.

{
  LOG_SCOPE("write_nodal_data(parallel)", "Nemesis_IO");
 
  // Only prepare and write nodal variables that are also in
  // _output_variables, unless _output_variables is empty. This is the
  // same logic that is in ExodusII_IO::write_nodal_data().
  std::vector<std::string> output_names;
 
  if (_allow_empty_variables || !_output_variables.empty())
    output_names = _output_variables;
  else
    output_names = names;
 
  this->prepare_to_write_nodal_data(base_filename, output_names);
 
  // Call the new version of write_nodal_solution() that takes a
  // NumericVector directly without localizing.
  nemhelper->write_nodal_solution(parallel_soln, names, _timestep, output_names);
}

References _allow_empty_variables, _output_variables, _timestep, nemhelper, and prepare_to_write_nodal_data().

◆ write_nodal_data() [3/3]

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

overridevirtual

Output a nodal solution from data in soln.

Reimplemented from libMesh::MeshOutput< MeshBase >.

Definition at line 1557 of file nemesis_io.C.

{
  LOG_SCOPE("write_nodal_data(serialized)", "Nemesis_IO");
 
  this->prepare_to_write_nodal_data(base_filename, names);
 
  nemhelper->write_nodal_solution(soln, names, _timestep);
}

References _timestep, nemhelper, and prepare_to_write_nodal_data().

Referenced by libMesh::NameBasedIO::write_nodal_data().

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

121 { libmesh_not_implemented(); }

◆ write_timestep()

void libMesh::Nemesis_IO::write_timestep	(	const std::string &	fname,
		const EquationSystems &	es,
		const int	timestep,
		const Real	time
	)

Write one timestep's worth of the solution.

Definition at line 1291 of file nemesis_io.C.

{
  _timestep=timestep;
  write_equation_systems(fname,es);
 
  nemhelper->write_timestep(timestep, time);
}

References _timestep, nemhelper, and libMesh::MeshOutput< MeshBase >::write_equation_systems().

Member Data Documentation

◆ _allow_empty_variables

bool libMesh::Nemesis_IO::_allow_empty_variables

private

If true, _output_variables is allowed to remain empty.

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

Definition at line 302 of file nemesis_io.h.

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

◆ _append

bool libMesh::Nemesis_IO::_append

private

Default false.

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

Definition at line 281 of file nemesis_io.h.

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

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

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

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

◆ _output_variables

std::vector<std::string> libMesh::Nemesis_IO::_output_variables

private

The names of the variables to be output.

If this is empty then all variables are output.

Definition at line 295 of file nemesis_io.h.

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

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

◆ _timestep

int libMesh::Nemesis_IO::_timestep

private

Keeps track of the current timestep index being written.

Used when calling write_nodal_data() and other functions.

Definition at line 269 of file nemesis_io.h.

Referenced by write_element_data(), write_global_data(), write_nodal_data(), write_nodal_data(), write_nodal_data(), and write_timestep().

◆ _verbose

bool libMesh::Nemesis_IO::_verbose

private

Controls whether extra debugging information is printed to the screen or not.

Definition at line 275 of file nemesis_io.h.

Referenced by prepare_to_write_nodal_data(), read(), verbose(), write(), and write_element_data().

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

◆ nemhelper

std::unique_ptr<Nemesis_IO_Helper> libMesh::Nemesis_IO::nemhelper

private

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

include/mesh/nemesis_io.h
src/mesh/nemesis_io.C

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Nemesis_IO() [1/2]

◆ Nemesis_IO() [2/2]

◆ ~Nemesis_IO()

Member Function Documentation

◆ append()

◆ ascii_precision()

◆ assert_symmetric_cmaps()

◆ comm()

◆ copy_elemental_solution()

◆ copy_nodal_solution()

◆ copy_scalar_solution()

◆ get_add_sides()

◆ get_elem_var_names()

◆ get_global_var_names()

◆ get_nemio_helper()

◆ get_nodal_var_names()

◆ get_num_time_steps()

◆ get_time_steps()

◆ is_parallel_format()

◆ mesh() [1/2]

◆ mesh() [2/2]

◆ n_processors()

◆ prepare_to_write_nodal_data()

◆ processor_id()

◆ read()

◆ read_global_variable()

◆ set_hdf5_writing()

◆ set_n_partitions()

◆ set_output_variables()

◆ skip_comment_lines()

◆ verbose()

◆ write()

◆ write_complex_magnitude()

◆ write_discontinuous_equation_systems()

◆ write_element_data()

◆ write_equation_systems()

◆ write_global_data()

◆ write_information_records()

◆ write_nodal_data() [1/3]

◆ write_nodal_data() [2/3]

◆ write_nodal_data() [3/3]

◆ write_nodal_data_discontinuous()

◆ write_timestep()

Member Data Documentation

◆ _allow_empty_variables

◆ _append

◆ _ascii_precision

◆ _communicator

◆ _is_parallel_format [1/2]

◆ _is_parallel_format [2/2]

◆ _obj

◆ _output_variables

◆ _serial_only_needed_on_proc_0

◆ _timestep

◆ _verbose

◆ elems_of_dimension

◆ nemhelper