Temporarily serialize a DistributedMesh for non-distributed-mesh capable code paths. More...

#include <mesh_serializer.h>

Public Member Functions
	MeshSerializer (MeshBase &mesh, bool need_serial=true, bool serial_only_needed_on_proc_0=false)

	~MeshSerializer ()

Private Attributes
MeshBase &	_mesh

bool	reparallelize

bool	resume_allow_remote_element_removal

Detailed Description

Temporarily serialize a DistributedMesh for non-distributed-mesh capable code paths.

A distributed mesh is allgathered by the MeshSerializer constructor if need_serial is true, in which case remote elements are deleted again by the destructor.

Serialization to processor 0 alone (e.g. for serial output from that processor) can be selected in the constructor.

If allow_remote_element_removal() is set to true, that will also be temporarily disabled by the serializer, to be reenabled after serializer destruction if so; this allows prepare_for_use() to be called safely from within serialized code.

If a mesh is explicitly distributed by a delete_remote_elements() call within serialized code, or if allow_remote_element_removal() is explicitly set to true within serialized code, the behavior is undefined.

Author: Roy Stogner

Date: 2011-2022

Temporarily serializes a DistributedMesh for output.

Definition at line 55 of file mesh_serializer.h.

Constructor & Destructor Documentation

◆ MeshSerializer()

libMesh::MeshSerializer::MeshSerializer	(	MeshBase &	mesh,
		bool	need_serial = `true`,
		bool	serial_only_needed_on_proc_0 = `false`
	)

Definition at line 27 of file mesh_serializer.C.

                                                                                                   :
  _mesh(mesh),
  reparallelize(false),
  resume_allow_remote_element_removal(false)
{
  libmesh_parallel_only(mesh.comm());
  if (need_serial && !_mesh.is_serial() && !serial_only_needed_on_proc_0) {
    reparallelize = true;
    _mesh.allgather();
  }
  else if (need_serial && !_mesh.is_serial() && serial_only_needed_on_proc_0) {
    // Note: NOT reparallelizing on purpose.
    // Just waste a bit of space on processor 0 to speed things up
    _mesh.gather_to_zero();
  }
 
  if (_mesh.allow_remote_element_removal())
    {
      resume_allow_remote_element_removal = true;
      _mesh.allow_remote_element_removal(false);
    }
}

References _mesh, libMesh::MeshBase::allgather(), libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshBase::gather_to_zero(), libMesh::MeshBase::is_serial(), mesh, reparallelize, and resume_allow_remote_element_removal.

◆ ~MeshSerializer()

libMesh::MeshSerializer::~MeshSerializer ( )

Definition at line 52 of file mesh_serializer.C.

{
  if (reparallelize)
    _mesh.delete_remote_elements();
 
  if (resume_allow_remote_element_removal)
    _mesh.allow_remote_element_removal(true);
}