Implements (adaptive) mesh refinement algorithms for a MeshBase. More...

#include <mesh_refinement.h>

Inheritance diagram for libMesh::MeshRefinement:

Classes
class	ElementFlagging
	Abstract base class to be used for user-specified element flagging. More...

Public Member Functions
	MeshRefinement (MeshBase &mesh)
	Constructor.

void	set_periodic_boundaries_ptr (PeriodicBoundaries *pb_ptr)
	Sets the `PeriodicBoundaries` pointer.

	~MeshRefinement ()
	Destructor.

void	clear ()
	Deletes all the data that are currently stored.

void	flag_elements_by_error_fraction (const ErrorVector &error_per_cell, const Real refine_fraction=0.3, const Real coarsen_fraction=0.0, const unsigned int max_level=libMesh::invalid_uint)
	Flags elements for coarsening and refinement based on the computed error passed in `error_per_cell`.

void	flag_elements_by_error_tolerance (const ErrorVector &error_per_cell)
	Flags elements for coarsening and refinement based on the computed error passed in `error_per_cell`.

bool	flag_elements_by_nelem_target (const ErrorVector &error_per_cell)
	Flags elements for coarsening and refinement based on the computed error passed in `error_per_cell`.

void	flag_elements_by_elem_fraction (const ErrorVector &error_per_cell, const Real refine_fraction=0.3, const Real coarsen_fraction=0.0, const unsigned int max_level=libMesh::invalid_uint)
	Flags elements for coarsening and refinement based on the computed error passed in `error_per_cell`.

void	flag_elements_by_mean_stddev (const ErrorVector &error_per_cell, const Real refine_fraction=1.0, const Real coarsen_fraction=0.0, const unsigned int max_level=libMesh::invalid_uint)
	Flags elements for coarsening and refinement based on the computed error passed in `error_per_cell`.

void	flag_elements_by (ElementFlagging &element_flagging)
	Flag elements based on a function object.

void	switch_h_to_p_refinement ()
	Takes a mesh whose elements are flagged for h refinement and coarsening, and switches those flags to request p refinement and coarsening instead.

void	add_p_to_h_refinement ()
	Takes a mesh whose elements are flagged for h refinement and coarsening, and adds flags to request p refinement and coarsening of the same elements.

bool	refine_and_coarsen_elements ()
	Refines and coarsens user-requested elements.

bool	coarsen_elements ()
	Only coarsens the user-requested elements.

bool	refine_elements ()
	Only refines the user-requested elements.

void	uniformly_refine (unsigned int n=1)
	Uniformly refines the mesh `n` times.

void	uniformly_coarsen (unsigned int n=1)
	Attempts to uniformly coarsen the mesh `n` times.

void	uniformly_p_refine (unsigned int n=1)
	Uniformly p refines the mesh `n` times.

void	uniformly_p_coarsen (unsigned int n=1)
	Attempts to uniformly p coarsen the mesh `n` times.

void	clean_refinement_flags ()
	Sets the refinement flag to `Elem::DO_NOTHING` for each element in the mesh.

bool	test_level_one (bool libmesh_assert_yes=false) const

bool	test_unflagged (bool libmesh_assert_yes=false) const

Node *	add_node (Elem &parent, unsigned int child, unsigned int node, processor_id_type proc_id)
	Add a node to the mesh.

Elem *	add_elem (Elem *elem)
	Adds the element `elem` to the mesh.

Elem *	add_elem (std::unique_ptr< Elem > elem)
	Same as the function above, but makes it clear that the MeshRefinement object (actually, its Mesh) takes ownership of the Elem which is passed in, so the user is not responsible for deleting it.

const MeshBase &	get_mesh () const

MeshBase &	get_mesh ()

bool &	coarsen_by_parents ()
	If `coarsen_by_parents` is true, complete groups of sibling elements (elements with the same parent) will be flagged for coarsening.

Real &	refine_fraction ()
	The `refine_fraction` sets either a desired target or a desired maximum number of elements to flag for refinement, depending on which flag_elements_by method is called.

Real &	coarsen_fraction ()
	The `coarsen_fraction` sets either a desired target or a desired maximum number of elements to flag for coarsening, depending on which flag_elements_by method is called.

unsigned int &	max_h_level ()
	The `max_h_level` is the greatest refinement level an element should reach.

Real &	coarsen_threshold ()
	The `coarsen_threshold` provides hysteresis in AMR/C strategies.

dof_id_type &	nelem_target ()
	If `nelem_target` is set to a nonzero value, methods like flag_elements_by_nelem_target() will attempt to keep the number of active elements in the mesh close to nelem_target.

Real &	absolute_global_tolerance ()
	If `absolute_global_tolerance` is set to a nonzero value, methods like flag_elements_by_global_tolerance() will attempt to reduce the global error of the mesh (defined as the square root of the sum of the squares of the errors on active elements) to below this tolerance.

unsigned char &	face_level_mismatch_limit ()
	If `face_level_mismatch_limit` is set to a nonzero value, then refinement and coarsening will produce meshes in which the refinement level of two face neighbors will not differ by more than that limit.

unsigned char &	edge_level_mismatch_limit ()
	If `edge_level_mismatch_limit` is set to a nonzero value, then refinement and coarsening will produce meshes in which the refinement level of two edge neighbors will not differ by more than that limit.

unsigned char &	node_level_mismatch_limit ()
	If `node_level_mismatch_limit` is set to a nonzero value, then refinement and coarsening will produce meshes in which the refinement level of two nodal neighbors will not differ by more than that limit.

signed char &	overrefined_boundary_limit ()
	If `overrefined_boundary_limit` is set to a nonnegative value, then refinement and coarsening will produce meshes in which the refinement level of a boundary element is no more than that many levels greater than the level of any of its interior neighbors.

signed char &	underrefined_boundary_limit ()
	If `underrefined_boundary_limit` is set to a nonnegative value, then refinement and coarsening will produce meshes in which the refinement level of an element is no more than that many levels greater than the level of any boundary elements on its sides.

bool &	allow_unrefined_patches ()
	This flag defaults to false in order to maintain the original behavior of the code, which was to always eliminate unrefined element patches.

bool	make_flags_parallel_consistent ()
	Copy refinement flags on ghost elements from their local processors.

bool &	enforce_mismatch_limit_prior_to_refinement ()
	Get/set the _enforce_mismatch_limit_prior_to_refinement flag.

bool	enforce_mismatch_limit_prior_to_refinement () const

void	enforce_mismatch_limit_prior_to_refinement (bool enforce)

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Protected Attributes
const Parallel::Communicator &	_communicator

Private Types
enum	NeighborType { POINT , EDGE }
	This helper function enforces the desired mismatch limits prior to refinement. More...

Private Member Functions
	MeshRefinement (const MeshRefinement &)

MeshRefinement &	operator= (const MeshRefinement &)

bool	_coarsen_elements ()
	Coarsens user-requested elements.

bool	_refine_elements ()
	Refines user-requested elements.

void	_smooth_flags (bool refining, bool coarsening)
	Smooths refinement flags according to current settings.

bool	limit_level_mismatch_at_node (const unsigned int max_mismatch)
	This algorithm restricts the maximum level mismatch at any node in the mesh.

bool	limit_level_mismatch_at_edge (const unsigned int max_mismatch)

bool	limit_overrefined_boundary (const signed char max_mismatch)

bool	limit_underrefined_boundary (const signed char max_mismatch)

bool	eliminate_unrefined_patches ()
	This algorithm selects an element for refinement if all of its neighbors are (or will be) refined.

void	create_parent_error_vector (const ErrorVector &error_per_cell, ErrorVector &error_per_parent, Real &parent_error_min, Real &parent_error_max)
	Calculates the error on all coarsenable parents.

void	update_nodes_map ()
	Updates the `_new_nodes_map`.

bool	make_coarsening_compatible ()
	Take user-specified coarsening flags and augment them so that level-one dependency is satisfied.

bool	make_refinement_compatible ()
	Take user-specified refinement flags and augment them so that level-one dependency is satisfied.

Elem *	topological_neighbor (Elem elem, const PointLocatorBase point_locator, const unsigned int side) const
	Local dispatch function for getting the correct topological neighbor from the Elem class.

bool	has_topological_neighbor (const Elem elem, const PointLocatorBase point_locator, const Elem *neighbor) const
	Local dispatch function for checking the correct has_neighbor function from the Elem class.

bool	enforce_mismatch_limit_prior_to_refinement (Elem *elem, NeighborType nt, unsigned max_mismatch)

Private Attributes
TopologyMap	_new_nodes_map
	Data structure that holds the new nodes information.

MeshBase &	_mesh
	Reference to the mesh.

bool	_use_member_parameters
	For backwards compatibility, we initialize this as false and then set it to true if the user uses any of the refinement parameter accessor functions.

bool	_coarsen_by_parents
	Refinement parameter values.

Real	_refine_fraction

Real	_coarsen_fraction

unsigned int	_max_h_level

Real	_coarsen_threshold

dof_id_type	_nelem_target

Real	_absolute_global_tolerance

unsigned char	_face_level_mismatch_limit

unsigned char	_edge_level_mismatch_limit

unsigned char	_node_level_mismatch_limit

signed char	_overrefined_boundary_limit

signed char	_underrefined_boundary_limit

bool	_allow_unrefined_patches

bool	_enforce_mismatch_limit_prior_to_refinement
	This option enforces the mismatch level prior to refinement by checking if refining any element marked for refinement would cause a mismatch greater than the limit.

PeriodicBoundaries *	_periodic_boundaries

Detailed Description

Implements (adaptive) mesh refinement algorithms for a MeshBase.

Note: Before using any of the algorithms in this class on a distributed mesh, the user needs to make sure that the mesh is prepared (MeshBase::prepare_for_use).

Author: Benjamin S. Kirk

Date: 2002-2007

Responsible for mesh refinement algorithms and data.

Definition at line 61 of file mesh_refinement.h.

Member Enumeration Documentation

◆ NeighborType

enum libMesh::MeshRefinement::NeighborType

private

This helper function enforces the desired mismatch limits prior to refinement.

It is called from the MeshRefinement::limit_level_mismatch_at_edge() and MeshRefinement::limit_level_mismatch_at_node() functions.

Returns: true if this enforcement caused the refinement flags for elem to change, false otherwise.

Enumerator
POINT
EDGE

Definition at line 867 of file mesh_refinement.h.

867{POINT, EDGE};

libMesh::MeshRefinement::POINT

@ POINT

Definition mesh_refinement.h:867

libMesh::MeshRefinement::EDGE

@ EDGE

Definition mesh_refinement.h:867

Constructor & Destructor Documentation

◆ MeshRefinement() [1/2]

libMesh::MeshRefinement::MeshRefinement ( MeshBase & mesh )

explicit

Constructor.

Definition at line 95 of file mesh_refinement.C.

                                            :
  ParallelObject(m),
  _mesh(m),
  _use_member_parameters(false),
  _coarsen_by_parents(false),
  _refine_fraction(0.3),
  _coarsen_fraction(0.0),
  _max_h_level(libMesh::invalid_uint),
  _coarsen_threshold(10),
  _nelem_target(0),
  _absolute_global_tolerance(0.0),
  _face_level_mismatch_limit(1),
  _edge_level_mismatch_limit(0),
  _node_level_mismatch_limit(0),
  _overrefined_boundary_limit(0),
  _underrefined_boundary_limit(0),
  _allow_unrefined_patches(false),
  _enforce_mismatch_limit_prior_to_refinement(false)
#ifdef LIBMESH_ENABLE_PERIODIC
  , _periodic_boundaries(nullptr)
#endif
{
}
 
 
 
#ifdef LIBMESH_ENABLE_PERIODIC
void MeshRefinement::set_periodic_boundaries_ptr(PeriodicBoundaries * pb_ptr)
{
  _periodic_boundaries = pb_ptr;
}

◆ MeshRefinement() [2/2]

libMesh::MeshRefinement::MeshRefinement ( const MeshRefinement & )

private

◆ ~MeshRefinement()

libMesh::MeshRefinement::~MeshRefinement ( )

default

Destructor.

Deletes all the elements that are currently stored.

Member Function Documentation

◆ _coarsen_elements()

bool libMesh::MeshRefinement::_coarsen_elements ( )

private

Coarsens user-requested elements.

Both coarsen_elements and refine_elements used to be in the public interface for the MeshRefinement object. Unfortunately, without proper preparation (make_refinement_compatible, make_coarsening_compatible) at least coarsen_elements() did not work alone. By making them private, we signal to the user that they are not part of the interface. It is possible that for a given set of refinement flags there is actually no change upon calling this member function.

Returns: true if the mesh actually changed (hence data needs to be projected) and false otherwise.

Definition at line 1371 of file mesh_refinement.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  LOG_SCOPE ("_coarsen_elements()", "MeshRefinement");
 
  // Flags indicating if this call actually changes the mesh
  bool mesh_changed = false;
  bool mesh_p_changed = false;
 
  // Clear the unused_elements data structure.
  // The elements have been packed since it was built,
  // so there are _no_ unused elements.  We cannot trust
  // any iterators currently in this data structure.
  // _unused_elements.clear();
 
  // Loop over the elements first to determine if the mesh will
  // undergo h-coarsening.  If it will, then we'll need to communicate
  // more ghosted elements.  We need to communicate them *before* we
  // do the coarsening; otherwise it is possible to coarsen away a
  // one-element-thick layer partition and leave the partitions on
  // either side unable to figure out how to talk to each other.
  for (auto & elem : _mesh.element_ptr_range())
    if (elem->refinement_flag() == Elem::COARSEN)
      {
        mesh_changed = true;
        break;
      }
 
  // If the mesh changed on any processor, it changed globally
  this->comm().max(mesh_changed);
 
  // And then we may need to widen the ghosting layers.
  if (mesh_changed)
    MeshCommunication().send_coarse_ghosts(_mesh);
 
  for (auto & elem : _mesh.element_ptr_range())
    {
      // Make sure we transfer the children's boundary id(s)
      // up to its parent when necessary before coarsening.
      _mesh.get_boundary_info().transfer_boundary_ids_from_children(elem);
 
      // active elements flagged for coarsening will
      // no longer be deleted until MeshRefinement::contract()
      if (elem->refinement_flag() == Elem::COARSEN)
        {
          // Huh?  no level-0 element should be active
          // and flagged for coarsening.
          libmesh_assert_not_equal_to (elem->level(), 0);
 
          // Remove this element from any neighbor
          // lists that point to it.
          elem->nullify_neighbors();
 
          // Remove any boundary information associated
          // with this element if we do not allow children to have boundary info.
          // Otherwise, we will do the removal in `transfer_boundary_ids_from_children`
          // to make sure we don't delete the information before it is transferred
          if (!_mesh.get_boundary_info().is_children_on_boundary_side())
            _mesh.get_boundary_info().remove (elem);
 
          // Add this iterator to the _unused_elements
          // data structure so we might fill it.
          // The _unused_elements optimization is currently off.
          // _unused_elements.push_back (it);
 
          // Don't delete the element until
          // MeshRefinement::contract()
          // _mesh.delete_elem(elem);
        }
 
      // inactive elements flagged for coarsening
      // will become active
      else if (elem->refinement_flag() == Elem::COARSEN_INACTIVE)
        {
          elem->coarsen();
          libmesh_assert (elem->active());
 
          // the mesh has certainly changed
          mesh_changed = true;
        }
      if (elem->p_refinement_flag() == Elem::COARSEN)
        {
          if (elem->p_level() > 0)
            {
              elem->set_p_refinement_flag(Elem::JUST_COARSENED);
              elem->set_p_level(elem->p_level() - 1);
              mesh_p_changed = true;
            }
          else
            {
              elem->set_p_refinement_flag(Elem::DO_NOTHING);
            }
        }
    }
 
  this->comm().max(mesh_p_changed);
 
  // And we may need to update DistributedMesh values reflecting the changes
  if (mesh_changed)
    _mesh.update_parallel_id_counts();
 
  // Node processor ids may need to change if an element of that id
  // was coarsened away
  if (mesh_changed && !_mesh.is_serial())
    {
      // Update the _new_nodes_map so that processors can
      // find requested nodes
      this->update_nodes_map ();
 
      MeshCommunication().make_nodes_parallel_consistent (_mesh);
 
      // Clear the _new_nodes_map
      this->clear();
 
#ifdef DEBUG
      MeshTools::libmesh_assert_valid_procids<Node>(_mesh);
#endif
    }
 
  // If p levels changed all we need to do is make sure that parent p
  // levels changed in sync
  if (mesh_p_changed && !_mesh.is_serial())
    {
      MeshCommunication().make_p_levels_parallel_consistent (_mesh);
    }
 
  return (mesh_changed || mesh_p_changed);
}

References libMesh::libmesh_assert(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), and libMesh::MeshCommunication::send_coarse_ghosts().

◆ _refine_elements()

bool libMesh::MeshRefinement::_refine_elements ( )

private

Refines user-requested elements.

It is possible that for a given set of refinement flags there is actually no change upon calling this member function.

Returns: true if the mesh actually changed (hence data needs to be projected) and false otherwise.

Definition at line 1504 of file mesh_refinement.C.

{
  libmesh_assert(_mesh.is_prepared() || _mesh.is_replicated());
 
  // This function must be run on all processors at once
  parallel_object_only();
 
  // Update the _new_nodes_map so that elements can
  // find nodes to connect to.
  this->update_nodes_map ();
 
  LOG_SCOPE ("_refine_elements()", "MeshRefinement");
 
  // Iterate over the elements, counting the elements
  // flagged for h refinement.
  dof_id_type n_elems_flagged = 0;
 
  for (auto & elem : _mesh.element_ptr_range())
    if (elem->refinement_flag() == Elem::REFINE)
      n_elems_flagged++;
 
  // Construct a local vector of Elem * which have been
  // previously marked for refinement.  We reserve enough
  // space to allow for every element to be refined.
  std::vector<Elem *> local_copy_of_elements;
  local_copy_of_elements.reserve(n_elems_flagged);
 
  // If mesh p levels changed, we might need to synchronize parent p
  // levels on a distributed mesh.
  bool mesh_p_changed = false;
 
  // Iterate over the elements, looking for elements flagged for
  // refinement.
 
  // If we are on a ReplicatedMesh, then we just do the refinement in
  // the same order on every processor and everything stays in sync.
 
  // If we are on a DistributedMesh, that's impossible.
  //
  // If the mesh is distributed, we need to make sure that if we end
  // up as the owner of a new node, which might happen if that node is
  // attached to one of our own elements, then we have given it a
  // legitimate node id and our own processor id.  We generate
  // legitimate node ids and use our own processor id when we are
  // refining our own elements but not when we refine others'
  // elements.  Therefore we want to refine our own elements *first*,
  // thereby generating all nodes which might belong to us, and then
  // refine others' elements *after*, thereby generating nodes with
  // temporary ids which we know we will discard.
  //
  // Even if the DistributedMesh is serialized, we can't just treat it
  // like a ReplicatedMesh, because DistributedMesh doesn't *trust*
  // users to refine partitioned elements in a serialized way, so it
  // assigns temporary ids, so we need to synchronize ids afterward to
  // be safe anyway, so we might as well use the distributed mesh code
  // path.
  for (auto & elem : _mesh.is_replicated() ? _mesh.active_element_ptr_range() : _mesh.active_local_element_ptr_range())
    {
      if (elem->refinement_flag() == Elem::REFINE)
        local_copy_of_elements.push_back(elem);
      if (elem->p_refinement_flag() == Elem::REFINE &&
          elem->active())
        {
          elem->set_p_level(elem->p_level()+1);
          elem->set_p_refinement_flag(Elem::JUST_REFINED);
          mesh_p_changed = true;
        }
    }
 
  if (!_mesh.is_replicated())
    {
      for (auto & elem : as_range(_mesh.active_not_local_elements_begin(),
                                  _mesh.active_not_local_elements_end()))
        {
          if (elem->refinement_flag() == Elem::REFINE)
            local_copy_of_elements.push_back(elem);
          if (elem->p_refinement_flag() == Elem::REFINE &&
              elem->active())
            {
              elem->set_p_level(elem->p_level()+1);
              elem->set_p_refinement_flag(Elem::JUST_REFINED);
              mesh_p_changed = true;
            }
        }
    }
 
  // Now iterate over the local copies and refine each one.
  // This may resize the mesh's internal container and invalidate
  // any existing iterators.
  for (auto & elem : local_copy_of_elements)
    elem->refine(*this);
 
  // The mesh changed if there were elements h refined
  bool mesh_changed = !local_copy_of_elements.empty();
 
  // If the mesh changed on any processor, it changed globally
  this->comm().max(mesh_changed);
  this->comm().max(mesh_p_changed);
 
  // And we may need to update DistributedMesh values reflecting the changes
  if (mesh_changed)
    _mesh.update_parallel_id_counts();
 
  if (mesh_changed && !_mesh.is_replicated())
    {
      MeshCommunication().make_elems_parallel_consistent (_mesh);
      MeshCommunication().make_new_nodes_parallel_consistent (_mesh);
#ifdef DEBUG
      _mesh.libmesh_assert_valid_parallel_ids();
#endif
    }
 
  // If we're refining a ReplicatedMesh, then we haven't yet assigned
  // node processor ids.  But if we're refining a partitioned
  // ReplicatedMesh, then we *need* to assign node processor ids.
  if (mesh_changed && _mesh.is_replicated() &&
      (_mesh.unpartitioned_elements_begin() ==
       _mesh.unpartitioned_elements_end()))
    Partitioner::set_node_processor_ids(_mesh);
 
  if (mesh_p_changed && !_mesh.is_replicated())
    {
      MeshCommunication().make_p_levels_parallel_consistent (_mesh);
    }
 
  // Clear the _new_nodes_map and _unused_elements data structures.
  this->clear();
 
  return (mesh_changed || mesh_p_changed);
}

References libMesh::as_range(), libMesh::libmesh_assert(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), and libMesh::MeshCommunication::make_p_levels_parallel_consistent().

◆ _smooth_flags()

void libMesh::MeshRefinement::_smooth_flags	(	bool	refining,
		bool	coarsening
	)

private

Smooths refinement flags according to current settings.

It is possible that for a given set of refinement flags there is actually no change upon calling this member function.

Returns: true if the flags actually changed (hence data needs to be projected) and false otherwise.

Definition at line 1636 of file mesh_refinement.C.

{
  // Smoothing can break in weird ways on a mesh with broken topology
#ifdef DEBUG
  MeshTools::libmesh_assert_valid_neighbors(_mesh);
#endif
 
  // Repeat until flag changes match on every processor
  do
    {
      // Repeat until coarsening & refinement flags jive
      bool satisfied = false;
      do
        {
          // If we're refining or coarsening, hit the corresponding
          // face level test code.  Short-circuiting || is our friend
          const bool coarsening_satisfied =
            !coarsening ||
            this->make_coarsening_compatible();
 
          const bool refinement_satisfied =
            !refining ||
            this->make_refinement_compatible();
 
          bool smoothing_satisfied =
            !this->eliminate_unrefined_patches();// &&
 
          if (_edge_level_mismatch_limit)
            smoothing_satisfied = smoothing_satisfied &&
              !this->limit_level_mismatch_at_edge (_edge_level_mismatch_limit);
 
          if (_node_level_mismatch_limit)
            smoothing_satisfied = smoothing_satisfied &&
              !this->limit_level_mismatch_at_node (_node_level_mismatch_limit);
 
          if (_overrefined_boundary_limit>=0)
            smoothing_satisfied = smoothing_satisfied &&
              !this->limit_overrefined_boundary(_overrefined_boundary_limit);
 
          if (_underrefined_boundary_limit>=0)
            smoothing_satisfied = smoothing_satisfied &&
              !this->limit_underrefined_boundary(_underrefined_boundary_limit);
 
          satisfied = (coarsening_satisfied &&
                       refinement_satisfied &&
                       smoothing_satisfied);
 
          libmesh_assert(this->comm().verify(satisfied));
        }
      while (!satisfied);
    }
  while (!_mesh.is_serial() && !this->make_flags_parallel_consistent());
}

References libMesh::libmesh_assert().

◆ absolute_global_tolerance()

Real & libMesh::MeshRefinement::absolute_global_tolerance ( )

inline

If absolute_global_tolerance is set to a nonzero value, methods like flag_elements_by_global_tolerance() will attempt to reduce the global error of the mesh (defined as the square root of the sum of the squares of the errors on active elements) to below this tolerance.

absolute_global_tolerance is 0 by default.

Definition at line 918 of file mesh_refinement.h.

{
  _use_member_parameters = true;
  return _absolute_global_tolerance;
}

References _absolute_global_tolerance, and _use_member_parameters.

Referenced by main().

◆ add_elem() [1/2]

Elem * libMesh::MeshRefinement::add_elem ( Elem * elem )

Adds the element elem to the mesh.

Definition at line 208 of file mesh_refinement.C.

{
  libmesh_assert(elem);
  return _mesh.add_elem (elem);
}

References _mesh, libMesh::MeshBase::add_elem(), and libMesh::libmesh_assert().

Referenced by libMesh::Elem::refine().

◆ add_elem() [2/2]

Elem * libMesh::MeshRefinement::add_elem ( std::unique_ptr< Elem > elem )

Same as the function above, but makes it clear that the MeshRefinement object (actually, its Mesh) takes ownership of the Elem which is passed in, so the user is not responsible for deleting it.

The version of add_elem() taking a dumb pointer will eventually be deprecated in favor of this version.

Definition at line 214 of file mesh_refinement.C.

{
  libmesh_assert(elem);
  return _mesh.add_elem(std::move(elem));
}

References _mesh, libMesh::MeshBase::add_elem(), and libMesh::libmesh_assert().

◆ add_node()

Node * libMesh::MeshRefinement::add_node	(	Elem &	parent,
		unsigned int	child,
		unsigned int	node,
		processor_id_type	proc_id
	)

Add a node to the mesh.

The node should be node n of child c of parent Elem parent. The processor id proc_id is used if necessary to help determine numbering of newly created nodes, but newly created nodes are left unpartitioned until a node partitionining sweep is done later.

Returns: A pointer to a suitable existing or newly-created node.

Definition at line 141 of file mesh_refinement.C.

{
  LOG_SCOPE("add_node()", "MeshRefinement");
 
  unsigned int parent_n = parent.as_parent_node(child, node);
 
  if (parent_n != libMesh::invalid_uint)
    return parent.node_ptr(parent_n);
 
  const std::vector<std::pair<dof_id_type, dof_id_type>>
    bracketing_nodes = parent.bracketing_nodes(child, node);
 
  // If we're not a parent node, we *must* be bracketed by at least
  // one pair of parent nodes
  libmesh_assert(bracketing_nodes.size());
 
  // Return the node if it already exists.
  //
  // We'll leave the processor_id untouched in this case - if we're
  // repartitioning later or if this is a new unpartitioned node,
  // we'll update it then, and if not then we don't want to update it.
  if (const auto new_node_id = _new_nodes_map.find(bracketing_nodes);
      new_node_id != DofObject::invalid_id)
    return _mesh.node_ptr(new_node_id);
 
  // Otherwise we need to add a new node.
  //
  // Figure out where to add the point:
 
  Point p; // defaults to 0,0,0
 
  for (auto n : parent.node_index_range())
    {
      // The value from the embedding matrix
      const Real em_val = parent.embedding_matrix(child,node,n);
 
      if (em_val != 0.)
        {
          p.add_scaled (parent.point(n), em_val);
 
          // If we'd already found the node we shouldn't be here
          libmesh_assert_not_equal_to (em_val, 1);
        }
    }
 
  // Although we're leaving new nodes unpartitioned at first, with a
  // DistributedMesh we would need a default id based on the numbering
  // scheme for the requested processor_id.
  Node * new_node = _mesh.add_point (p, DofObject::invalid_id, proc_id);
 
  libmesh_assert(new_node);
 
  // But then we'll make sure this node is marked as unpartitioned.
  new_node->processor_id() = DofObject::invalid_processor_id;
 
  // Add the node to the map.
  _new_nodes_map.add_node(*new_node, bracketing_nodes);
 
  // Return the address of the new node
  return new_node;
}

References _mesh, _new_nodes_map, libMesh::TopologyMap::add_node(), libMesh::MeshBase::add_point(), libMesh::TypeVector< T >::add_scaled(), libMesh::Elem::as_parent_node(), libMesh::Elem::bracketing_nodes(), libMesh::Elem::embedding_matrix(), libMesh::TopologyMap::find(), libMesh::DofObject::invalid_id, libMesh::DofObject::invalid_processor_id, libMesh::invalid_uint, libMesh::libmesh_assert(), libMesh::Elem::node_index_range(), libMesh::MeshBase::node_ptr(), libMesh::Elem::node_ptr(), libMesh::Elem::point(), libMesh::DofObject::processor_id(), and libMesh::Real.

Referenced by libMesh::Elem::refine().

◆ add_p_to_h_refinement()

void libMesh::MeshRefinement::add_p_to_h_refinement ( )

Takes a mesh whose elements are flagged for h refinement and coarsening, and adds flags to request p refinement and coarsening of the same elements.

Definition at line 673 of file mesh_refinement_flagging.C.

{
  for (auto & elem : _mesh.element_ptr_range())
    elem->set_p_refinement_flag(elem->refinement_flag());
}

References _mesh.

Referenced by main().

◆ allow_unrefined_patches()

bool & libMesh::MeshRefinement::allow_unrefined_patches ( )

inline

This flag defaults to false in order to maintain the original behavior of the code, which was to always eliminate unrefined element patches.

If you set this flag to true, then the MeshRefinement::eliminate_unrefined_patches() function essentially does nothing, allowing such patches to persist. This may be particularly useful in e.g. 1D meshes where having unrefined patches does not introduce additional hanging nodes.

Definition at line 949 of file mesh_refinement.h.

{
  return _allow_unrefined_patches;
}

References _allow_unrefined_patches.

◆ clean_refinement_flags()

void libMesh::MeshRefinement::clean_refinement_flags ( )

Sets the refinement flag to Elem::DO_NOTHING for each element in the mesh.

Definition at line 681 of file mesh_refinement_flagging.C.

{
  // Possibly clean up the refinement flags from
  // a previous step
  for (auto & elem : _mesh.element_ptr_range())
    {
      if (elem->active())
        {
          elem->set_refinement_flag(Elem::DO_NOTHING);
          elem->set_p_refinement_flag(Elem::DO_NOTHING);
        }
      else
        {
          elem->set_refinement_flag(Elem::INACTIVE);
          elem->set_p_refinement_flag(Elem::INACTIVE);
        }
    }
}

References _mesh, libMesh::Elem::DO_NOTHING, and libMesh::Elem::INACTIVE.

Referenced by flag_elements_by_elem_fraction(), flag_elements_by_error_fraction(), flag_elements_by_nelem_target(), libMesh::EquationSystems::read(), and libMesh::EquationSystems::reinit_mesh().

◆ clear()

void libMesh::MeshRefinement::clear ( )

Deletes all the data that are currently stored.

Definition at line 134 of file mesh_refinement.C.

{
  _new_nodes_map.clear();
}

References _new_nodes_map, and libMesh::TopologyMap::clear().

◆ coarsen_by_parents()

bool & libMesh::MeshRefinement::coarsen_by_parents ( )

inline

If coarsen_by_parents is true, complete groups of sibling elements (elements with the same parent) will be flagged for coarsening.

This should make the coarsening more likely to occur as requested.

coarsen_by_parents is true by default.

Definition at line 882 of file mesh_refinement.h.

{
  _use_member_parameters = true;
  return _coarsen_by_parents;
}

References _coarsen_by_parents, and _use_member_parameters.

Referenced by main().

◆ coarsen_elements()

bool libMesh::MeshRefinement::coarsen_elements ( )

Only coarsens the user-requested elements.

Some elements will not be coarsened to satisfy the level one rule. It is possible that for a given set of refinement flags there is actually no change upon calling this member function.

Returns: true if the mesh actually changed (hence data needs to be projected) and false otherwise.

Note: This function used to take an argument, maintain_level_one, new code should use face_level_mismatch_limit() instead.; When we allow boundaries to be directly associated with child elements, i.e., _children_on_boundary = true. A child's boundary ID may be lost during coarsening if it differs from its siblings on that parent side.

Definition at line 620 of file mesh_refinement.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  // We can't yet turn a non-level-one mesh into a level-one mesh
  if (_face_level_mismatch_limit)
    libmesh_assert(test_level_one(true));
 
  // Possibly clean up the refinement flags from
  // a previous step
  Threads::parallel_for
    (_mesh.element_stored_range(),
     [](const ElemRange & range)
     {
       for (Elem * elem : range)
         {
           // Set refinement flag to INACTIVE if the
           // element isn't active
           if (!elem->active())
             {
               elem->set_refinement_flag(Elem::INACTIVE);
               elem->set_p_refinement_flag(Elem::INACTIVE);
             }
 
           // This might be left over from the last step
           if (elem->refinement_flag() == Elem::JUST_REFINED)
             elem->set_refinement_flag(Elem::DO_NOTHING);
         }
     });
 
  // Parallel consistency has to come first, or coarsening
  // along processor boundaries might occasionally be falsely
  // prevented
  bool flags_were_consistent = this->make_flags_parallel_consistent();
 
  // In theory, we should be able to remove the above call, which can
  // be expensive and should be unnecessary.  In practice, doing
  // consistent flagging in parallel is hard, it's impossible to
  // verify at the library level if it's being done by user code, and
  // we don't want to abort large parallel runs in opt mode... but we
  // do want to warn that they should be fixed.
  libmesh_assert(flags_were_consistent);
 
  if (!flags_were_consistent)
    libmesh_warning("Warning: Refinement flags were not consistent between processors! "
                    "Correcting and continuing.\n");
 
  // Smooth coarsening flags
  _smooth_flags(false, true);
 
  // Coarsen the flagged elements.
  const bool mesh_changed =
    this->_coarsen_elements ();
 
  if (_face_level_mismatch_limit)
    libmesh_assert(test_level_one(true));
  libmesh_assert(this->make_coarsening_compatible());
  // FIXME: This won't pass unless we add a redundant find_neighbors()
  // call or replace find_neighbors() with on-the-fly neighbor updating
  // libmesh_assert(!this->eliminate_unrefined_patches());
 
  // We can't contract the mesh ourselves anymore - a System might
  // need to restrict old coefficient vectors first
  // _mesh.contract();
 
  // Finally, the new mesh may need to be prepared for use
  if (mesh_changed)
    _mesh.prepare_for_use ();
 
  return mesh_changed;
}

References libMesh::libmesh_assert().

Referenced by libMesh::EquationSystems::reinit_solutions(), and BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen().

◆ coarsen_fraction()

Real & libMesh::MeshRefinement::coarsen_fraction ( )

inline

The coarsen_fraction sets either a desired target or a desired maximum number of elements to flag for coarsening, depending on which flag_elements_by method is called.

coarsen_fraction must be in \( [0,1] \), and is 0 by default.

Definition at line 894 of file mesh_refinement.h.

{
  _use_member_parameters = true;
  return _coarsen_fraction;
}

References _coarsen_fraction, and _use_member_parameters.

Referenced by assemble_and_solve(), and main().

◆ coarsen_threshold()

Real & libMesh::MeshRefinement::coarsen_threshold ( )

inline

The coarsen_threshold provides hysteresis in AMR/C strategies.

Refinement of elements with error estimate E will be done even at the expense of coarsening elements whose children's accumulated error does not exceed coarsen_threshold * E.

coarsen_threshold must be in \( [0,1] \), and is 0.1 by default.

Definition at line 906 of file mesh_refinement.h.

{
  _use_member_parameters = true;
  return _coarsen_threshold;
}

References _coarsen_threshold, and _use_member_parameters.

Referenced by main().

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

◆ create_parent_error_vector()

void libMesh::MeshRefinement::create_parent_error_vector	(	const ErrorVector &	error_per_cell,
		ErrorVector &	error_per_parent,
		Real &	parent_error_min,
		Real &	parent_error_max
	)

private

Calculates the error on all coarsenable parents.

error_per_parent[parent_id] stores this error if parent_id corresponds to a coarsenable parent, and stores -1 otherwise.

Definition at line 221 of file mesh_refinement.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  // Make sure the input error vector is valid
#ifdef DEBUG
  for (const auto & val : error_per_cell)
    {
      libmesh_assert_greater_equal (val, 0);
      // isnan() isn't standard C++ yet
#ifdef isnan
      libmesh_assert(!isnan(val));
#endif
    }
 
  // Use a reference to std::vector to avoid confusing
  // this->comm().verify
  std::vector<ErrorVectorReal> & epc = error_per_parent;
  libmesh_assert(this->comm().verify(epc));
#endif // #ifdef DEBUG
 
  // error values on uncoarsenable elements will be left at -1
  error_per_parent.clear();
  error_per_parent.resize(error_per_cell.size(), 0.0);
 
  {
    // Find which elements are uncoarsenable
    for (auto & elem : _mesh.active_local_element_ptr_range())
      {
        Elem * parent = elem->parent();
 
        // Active elements are uncoarsenable
        error_per_parent[elem->id()] = -1.0;
 
        // Grandparents and up are uncoarsenable
        while (parent)
          {
            parent = parent->parent();
            if (parent)
              {
                const dof_id_type parentid  = parent->id();
                libmesh_assert_less (parentid, error_per_parent.size());
                error_per_parent[parentid] = -1.0;
              }
          }
      }
 
    // Sync between processors.
    // Use a reference to std::vector to avoid confusing
    // this->comm().min
    std::vector<ErrorVectorReal> & epp = error_per_parent;
    this->comm().min(epp);
  }
 
  // The parent's error is defined as the square root of the
  // sum of the children's errors squared, so errors that are
  // Hilbert norms remain Hilbert norms.
  //
  // Because the children may be on different processors, we
  // calculate local contributions to the parents' errors squared
  // first, then sum across processors and take the square roots
  // second.
  Threads::parallel_for
    (_mesh.active_local_element_stored_range(),
     [&error_per_cell, &error_per_parent](const ConstElemRange & range)
     {
       for (const Elem * elem : range)
         {
           const Elem * parent = elem->parent();
 
           // Calculate each contribution to parent cells
           if (parent)
             {
               const dof_id_type parentid  = parent->id();
               libmesh_assert_less (parentid, error_per_parent.size());
 
               // If the parent has grandchildren we won't be able to
               // coarsen it, so forget it.  Otherwise, add this child's
               // contribution to the sum of the squared child errors
               if (error_per_parent[parentid] != -1.0)
                 error_per_parent[parentid] += (error_per_cell[elem->id()] *
                                                error_per_cell[elem->id()]);
             }
         }
     });
 
  // Sum the vector across all processors
  this->comm().sum(static_cast<std::vector<ErrorVectorReal> &>(error_per_parent));
 
  // Calculate the min and max as we loop
  parent_error_min = std::numeric_limits<double>::max();
  parent_error_max = 0.;
 
  for (auto i : index_range(error_per_parent))
    {
      // If this element isn't a coarsenable parent with error, we
      // have nothing to do.  Just flag it as -1 and move on
      // Note that this->comm().sum might have left uncoarsenable
      // elements with error_per_parent=-n_proc, so reset it to
      // error_per_parent=-1
      if (error_per_parent[i] < 0.)
        {
          error_per_parent[i] = -1.;
          continue;
        }
 
      // The error estimator might have already given us an
      // estimate on the coarsenable parent elements; if so then
      // we want to retain that estimate
      if (error_per_cell[i])
        {
          error_per_parent[i] = error_per_cell[i];
          continue;
        }
      // if not, then e_parent = sqrt(sum(e_child^2))
      else
        error_per_parent[i] = std::sqrt(error_per_parent[i]);
 
      parent_error_min = std::min (parent_error_min,
                                   error_per_parent[i]);
      parent_error_max = std::max (parent_error_max,
                                   error_per_parent[i]);
    }
}

References _mesh, libMesh::MeshBase::active_local_element_stored_range(), libMesh::ParallelObject::comm(), libMesh::DofObject::id(), libMesh::isnan(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::min(), libMesh::Threads::parallel_for(), and libMesh::Elem::parent().

Referenced by flag_elements_by_elem_fraction(), flag_elements_by_error_fraction(), flag_elements_by_error_tolerance(), and flag_elements_by_nelem_target().

◆ edge_level_mismatch_limit()

unsigned char & libMesh::MeshRefinement::edge_level_mismatch_limit ( )

inline

If edge_level_mismatch_limit is set to a nonzero value, then refinement and coarsening will produce meshes in which the refinement level of two edge neighbors will not differ by more than that limit.

If edge_level_mismatch_limit is 0, then level differences will be unlimited.

edge_level_mismatch_limit is 0 by default.

Definition at line 929 of file mesh_refinement.h.

{
  return _edge_level_mismatch_limit;
}

References _edge_level_mismatch_limit.

◆ eliminate_unrefined_patches()

bool libMesh::MeshRefinement::eliminate_unrefined_patches ( )

private

This algorithm selects an element for refinement if all of its neighbors are (or will be) refined.

This algorithm will transform this mesh:

* o---o---o---o---o---o---o
* |   |   |   |   |   |   |
* |   |   |   |   |   |   |
* o---o---o---o---o---o---o
* |   |   |   |   |   |   |
* |   |   |   |   |   |   |
* o---o---o---o---o---o---o
* |   |   |       |   |   |
* |   |   |       |   |   |
* o---o---o       o---o---o
* |   |   |       |   |   |
* |   |   |       |   |   |
* o---o---o---o---o---o---o
* |   |   |   |   |   |   |
* |   |   |   |   |   |   |
* o---o---o---o---o---o---o
* |   |   |   |   |   |   |
* |   |   |   |   |   |   |
* o---o---o---o---o---o---o
*

into this:

* o---o---o---o---o---o---o
* |   |   |   |   |   |   |
* |   |   |   |   |   |   |
* o---o---o---o---o---o---o
* |   |   |   |   |   |   |
* |   |   |   |   |   |   |
* o---o---o---o---o---o---o
* |   |   |   :   |   |   |
* |   |   |   :   |   |   |
* o---o---o...o...o---o---o
* |   |   |   :   |   |   |
* |   |   |   :   |   |   |
* o---o---o---o---o---o---o
* |   |   |   |   |   |   |
* |   |   |   |   |   |   |
* o---o---o---o---o---o---o
* |   |   |   |   |   |   |
* |   |   |   |   |   |   |
* o---o---o---o---o---o---o
*

by refining the indicated element. If the _allow_unrefined_patches flag (default false) is set to true, then this function simpy returns false (indicating that no changes were made).

Definition at line 367 of file mesh_refinement_smoothing.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  bool flags_changed = false;
 
  // Quick return: if unrefined patches are allowed, then we are not
  // going to do anything here and can simply return that the flags
  // haven't changed.
  if (_allow_unrefined_patches)
    return flags_changed;
 
  // Note: we *cannot* use a reference to the real pointer here, since
  // the pointer may be reseated below and we don't want to reseat
  // pointers held by the Mesh.
  for (Elem * elem : _mesh.active_element_ptr_range())
    {
      // First, see if there's any possibility we might have to flag
      // this element for h and p refinement - do we have any visible
      // neighbors?  Next we'll check to see if any of those neighbors
      // are as coarse or coarser than us.
      bool h_flag_me = false,
           p_flag_me = false;
      for (auto neighbor : elem->neighbor_ptr_range())
        {
          // Quit if the element is not a local boundary
          if (neighbor != nullptr && neighbor != remote_elem)
            {
              h_flag_me = true;
              p_flag_me = true;
              break;
            }
        }
 
      // Skip the element if it is already fully flagged for refinement
      if (elem->p_refinement_flag() == Elem::REFINE)
        p_flag_me = false;
      if (elem->refinement_flag() == Elem::REFINE)
        {
          h_flag_me = false;
          if (!p_flag_me)
            continue;
        }
      // Test the parent if that is already flagged for coarsening
      else if (elem->refinement_flag() == Elem::COARSEN)
        {
          libmesh_assert(elem->parent());
          elem = elem->parent();
          // FIXME - this doesn't seem right - RHS
          if (elem->refinement_flag() != Elem::COARSEN_INACTIVE)
            continue;
          p_flag_me = false;
        }
 
      const unsigned int my_level = elem->level();
      int my_p_adjustment = 0;
      if (elem->p_refinement_flag() == Elem::REFINE)
        my_p_adjustment = 1;
      else if (elem->p_refinement_flag() == Elem::COARSEN)
        {
          libmesh_assert_greater (elem->p_level(), 0);
          my_p_adjustment = -1;
        }
      const unsigned int my_new_p_level =
        cast_int<unsigned int>(int(elem->p_level()) +
                               my_p_adjustment);
 
      // Check all the element neighbors
      for (auto neighbor : elem->neighbor_ptr_range())
        {
          // Quit if the element is on a local boundary
          if (neighbor == nullptr || neighbor == remote_elem)
            {
              h_flag_me = false;
              p_flag_me = false;
              break;
            }
          // if the neighbor will be equally or less refined than
          // we are, then we will not become an unrefined island.
          // So if we are still considering h refinement:
          if (h_flag_me &&
              // If our neighbor is already at a lower level,
              // it can't end up at a higher level even if it
              // is flagged for refinement once
              ((neighbor->level() < my_level) ||
               // If our neighbor is at the same level but isn't
               // flagged for refinement, it won't end up at a
               // higher level
               ((neighbor->active()) &&
                (neighbor->refinement_flag() != Elem::REFINE)) ||
               // If our neighbor is currently more refined but is
               // a parent flagged for coarsening, it will end up
               // at the same level.
               (neighbor->refinement_flag() == Elem::COARSEN_INACTIVE)))
            {
              // We've proven we won't become an unrefined island,
              // so don't h refine to avoid that.
              h_flag_me = false;
 
              // If we've also proven we don't need to p refine,
              // we don't need to check more neighbors
              if (!p_flag_me)
                break;
            }
          if (p_flag_me)
            {
              // if active neighbors will have a p level
              // equal to or lower than ours, then we do not need to p
              // refine ourselves.
              if (neighbor->active())
                {
                  int p_adjustment = 0;
                  if (neighbor->p_refinement_flag() == Elem::REFINE)
                    p_adjustment = 1;
                  else if (neighbor->p_refinement_flag() == Elem::COARSEN)
                    {
                      libmesh_assert_greater (neighbor->p_level(), 0);
                      p_adjustment = -1;
                    }
                  if (my_new_p_level >=
                      cast_int<unsigned int>(int(neighbor->p_level())
                                             + p_adjustment))
                    {
                      p_flag_me = false;
                      if (!h_flag_me)
                        break;
                    }
                }
              // If we have inactive neighbors, we need to
              // test all their active descendants which neighbor us
              else if (neighbor->ancestor())
                {
                  if (neighbor->min_new_p_level_by_neighbor(elem,
                                                            my_new_p_level + 2) <= my_new_p_level)
                    {
                      p_flag_me = false;
                      if (!h_flag_me)
                        break;
                    }
                }
            }
        }
 
      if (h_flag_me)
        {
          // Parents that would create islands should no longer
          // coarsen
          if (elem->refinement_flag() == Elem::COARSEN_INACTIVE)
            {
              for (auto & child : elem->child_ref_range())
                {
                  libmesh_assert_equal_to (child.refinement_flag(),
                                           Elem::COARSEN);
                  child.set_refinement_flag(Elem::DO_NOTHING);
                }
              elem->set_refinement_flag(Elem::INACTIVE);
            }
          else
            elem->set_refinement_flag(Elem::REFINE);
          flags_changed = true;
        }
      if (p_flag_me)
        {
          if (elem->p_refinement_flag() == Elem::COARSEN)
            elem->set_p_refinement_flag(Elem::DO_NOTHING);
          else
            elem->set_p_refinement_flag(Elem::REFINE);
          flags_changed = true;
        }
    }
 
  // If flags changed on any processor then they changed globally
  this->comm().max(flags_changed);
 
  return flags_changed;
}

References _allow_unrefined_patches, _mesh, libMesh::Elem::COARSEN, libMesh::Elem::COARSEN_INACTIVE, libMesh::ParallelObject::comm(), libMesh::Elem::DO_NOTHING, libMesh::Elem::INACTIVE, libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::Elem::REFINE, and libMesh::remote_elem.

◆ enforce_mismatch_limit_prior_to_refinement() [1/4]

bool & libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement ( )

inline

Get/set the _enforce_mismatch_limit_prior_to_refinement flag.

The default value for this flag is false.

Definition at line 954 of file mesh_refinement.h.

{
  return _enforce_mismatch_limit_prior_to_refinement;
}

References _enforce_mismatch_limit_prior_to_refinement.

Referenced by limit_level_mismatch_at_edge(), and limit_level_mismatch_at_node().

◆ enforce_mismatch_limit_prior_to_refinement() [2/4]

bool libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement ( ) const

inline

Definition at line 960 of file mesh_refinement.h.

{
  return _enforce_mismatch_limit_prior_to_refinement;
}

References _enforce_mismatch_limit_prior_to_refinement.

◆ enforce_mismatch_limit_prior_to_refinement() [3/4]

void libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement ( bool enforce )

inline

Definition at line 966 of file mesh_refinement.h.

{
  _enforce_mismatch_limit_prior_to_refinement = enforce;
}

References _enforce_mismatch_limit_prior_to_refinement.

◆ enforce_mismatch_limit_prior_to_refinement() [4/4]

bool libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement	(	Elem *	elem,
		NeighborType	nt,
		unsigned	max_mismatch
	)

private

Definition at line 547 of file mesh_refinement_smoothing.C.

{
  // Eventual return value
  bool flags_changed = false;
 
  // If we are enforcing the limit prior to refinement then we
  // need to remove flags from any elements marked for refinement that
  // would cause a mismatch
  if (_enforce_mismatch_limit_prior_to_refinement
      && elem->refinement_flag() == Elem::REFINE)
    {
      // get all the relevant neighbors since we may have to refine
      // elements off edges or corners as well
      std::set<const Elem *> neighbor_set;
 
      if (nt == POINT)
        elem->find_point_neighbors(neighbor_set);
      else if (nt == EDGE)
        elem->find_edge_neighbors(neighbor_set);
      else
        libmesh_error_msg("Unrecognized NeighborType: " << nt);
 
      // Loop over the neighbors of element e
      for (const auto & neighbor : neighbor_set)
        {
          if ((elem->level() + 1 - max_mismatch) > neighbor->level())
            {
              elem->set_refinement_flag(Elem::DO_NOTHING);
              flags_changed = true;
            }
          if ((elem->p_level() + 1 - max_mismatch) > neighbor->p_level())
            {
              elem->set_p_refinement_flag(Elem::DO_NOTHING);
              flags_changed = true;
            }
        } // loop over edge/point neighbors
    } // if _enforce_mismatch_limit_prior_to_refinement
 
  return flags_changed;
}

References _enforce_mismatch_limit_prior_to_refinement, libMesh::Elem::DO_NOTHING, EDGE, libMesh::Elem::find_edge_neighbors(), libMesh::Elem::find_point_neighbors(), libMesh::Elem::level(), libMesh::Elem::p_level(), POINT, libMesh::Elem::REFINE, libMesh::Elem::refinement_flag(), libMesh::Elem::set_p_refinement_flag(), and libMesh::Elem::set_refinement_flag().

◆ face_level_mismatch_limit()

unsigned char & libMesh::MeshRefinement::face_level_mismatch_limit ( )

inline

If face_level_mismatch_limit is set to a nonzero value, then refinement and coarsening will produce meshes in which the refinement level of two face neighbors will not differ by more than that limit.

If face_level_mismatch_limit is 0, then level differences will be unlimited.

face_level_mismatch_limit is 1 by default. Currently the only supported options are 0 and 1.

Definition at line 924 of file mesh_refinement.h.

{
  return _face_level_mismatch_limit;
}

References _face_level_mismatch_limit.

Referenced by libMesh::EquationSystems::reinit_solutions().

◆ flag_elements_by()

void libMesh::MeshRefinement::flag_elements_by ( ElementFlagging & element_flagging )

Flag elements based on a function object.

The class ElementFlagging defines a mechanism for implementing refinement strategies.

Definition at line 647 of file mesh_refinement_flagging.C.

{
  element_flagging.flag_elements();
}

References libMesh::MeshRefinement::ElementFlagging::flag_elements().

◆ flag_elements_by_elem_fraction()

void libMesh::MeshRefinement::flag_elements_by_elem_fraction	(	const ErrorVector &	error_per_cell,
		const Real	refine_fraction = `0.3`,
		const Real	coarsen_fraction = `0.0`,
		const unsigned int	max_level = `libMesh::invalid_uint`
	)

Flags elements for coarsening and refinement based on the computed error passed in error_per_cell.

This method picks the top refine_fraction * n_elem elements for refinement and the bottom coarsen_fraction * n_elem elements for coarsening. The two fractions refine_fraction and coarsen_fraction must be in \( [0,1] \).

All the function arguments except error_per_cell have been deprecated, and will be removed in future libMesh releases - to control these parameters, set the corresponding member variables.

Definition at line 445 of file mesh_refinement_flagging.C.

{
  parallel_object_only();
 
  // Verify that our error vector is consistent, using std::vector to
  // avoid confusing this->comm().verify
  libmesh_assert(this->comm().verify(dynamic_cast<const std::vector<ErrorVectorReal> &>(error_per_cell)));
 
  // The function arguments are currently just there for
  // backwards_compatibility
  if (!_use_member_parameters)
    {
      // If the user used non-default parameters, lets warn
      // that they're deprecated
      if (refine_frac != 0.3 ||
          coarsen_frac != 0.0 ||
          max_l != libMesh::invalid_uint)
        libmesh_deprecated();
 
      _refine_fraction = refine_frac;
      _coarsen_fraction = coarsen_frac;
      _max_h_level = max_l;
    }
 
  // Check for valid fractions..
  // The fraction values must be in [0,1]
  libmesh_assert_greater_equal (_refine_fraction, 0);
  libmesh_assert_less_equal (_refine_fraction, 1);
  libmesh_assert_greater_equal (_coarsen_fraction, 0);
  libmesh_assert_less_equal (_coarsen_fraction, 1);
 
  // The number of active elements in the mesh
  const dof_id_type n_active_elem  = _mesh.n_active_elem();
 
  // The number of elements to flag for coarsening
  const dof_id_type n_elem_coarsen =
    static_cast<dof_id_type>(_coarsen_fraction * n_active_elem);
 
  // The number of elements to flag for refinement
  const dof_id_type n_elem_refine =
    static_cast<dof_id_type>(_refine_fraction  * n_active_elem);
 
 
 
  // Clean up the refinement flags.  These could be left
  // over from previous refinement steps.
  this->clean_refinement_flags();
 
 
  // This vector stores the error and element number for all the
  // active elements.  It will be sorted and the top & bottom
  // elements will then be flagged for coarsening & refinement
  std::vector<ErrorVectorReal> sorted_error;
 
  sorted_error.reserve (n_active_elem);
 
  // Loop over the active elements and create the entry
  // in the sorted_error vector
  for (auto & elem : _mesh.active_local_element_ptr_range())
    sorted_error.push_back (error_per_cell[elem->id()]);
 
  this->comm().allgather(sorted_error);
 
  // Now sort the sorted_error vector
  std::sort (sorted_error.begin(), sorted_error.end());
 
  // If we're coarsening by parents:
  // Create a sorted error vector with coarsenable parent elements
  // only, sorted by lowest errors first
  ErrorVector error_per_parent, sorted_parent_error;
  if (_coarsen_by_parents)
    {
      Real parent_error_min, parent_error_max;
 
      create_parent_error_vector(error_per_cell,
                                 error_per_parent,
                                 parent_error_min,
                                 parent_error_max);
 
      sorted_parent_error = error_per_parent;
      std::sort (sorted_parent_error.begin(), sorted_parent_error.end());
 
      // All the other error values will be 0., so get rid of them.
      sorted_parent_error.erase (std::remove(sorted_parent_error.begin(),
                                             sorted_parent_error.end(), 0.),
                                 sorted_parent_error.end());
    }
 
 
  ErrorVectorReal top_error= 0., bottom_error = 0.;
 
  // Get the maximum error value corresponding to the
  // bottom n_elem_coarsen elements
  if (_coarsen_by_parents && n_elem_coarsen)
    {
      const unsigned int dim = _mesh.mesh_dimension();
      unsigned int twotodim = 1;
      for (unsigned int i=0; i!=dim; ++i)
        twotodim *= 2;
 
      dof_id_type n_parent_coarsen = n_elem_coarsen / (twotodim - 1);
 
      if (n_parent_coarsen)
        bottom_error = sorted_parent_error[n_parent_coarsen - 1];
    }
  else if (n_elem_coarsen)
    {
      bottom_error = sorted_error[n_elem_coarsen - 1];
    }
 
  if (n_elem_refine)
    top_error = sorted_error[sorted_error.size() - n_elem_refine];
 
  // Finally, let's do the element flagging
  for (auto & elem : _mesh.active_element_ptr_range())
    {
      Elem * parent = elem->parent();
 
      if (_coarsen_by_parents && parent && n_elem_coarsen &&
          error_per_parent[parent->id()] <= bottom_error)
        elem->set_refinement_flag(Elem::COARSEN);
 
      if (!_coarsen_by_parents && n_elem_coarsen &&
          error_per_cell[elem->id()] <= bottom_error)
        elem->set_refinement_flag(Elem::COARSEN);
 
      if (n_elem_refine &&
          elem->level() < _max_h_level &&
          error_per_cell[elem->id()] >= top_error)
        elem->set_refinement_flag(Elem::REFINE);
    }
}

References _coarsen_by_parents, _coarsen_fraction, _max_h_level, _mesh, _refine_fraction, _use_member_parameters, libMesh::Parallel::Communicator::allgather(), clean_refinement_flags(), libMesh::Elem::COARSEN, libMesh::ParallelObject::comm(), create_parent_error_vector(), dim, libMesh::ErrorVectorReal, libMesh::DofObject::id(), libMesh::invalid_uint, libMesh::libmesh_assert(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_active_elem(), libMesh::Elem::parent(), libMesh::Real, libMesh::Elem::REFINE, and libMesh::Elem::set_refinement_flag().

Referenced by main().

◆ flag_elements_by_error_fraction()

void libMesh::MeshRefinement::flag_elements_by_error_fraction	(	const ErrorVector &	error_per_cell,
		const Real	refine_fraction = `0.3`,
		const Real	coarsen_fraction = `0.0`,
		const unsigned int	max_level = `libMesh::invalid_uint`
	)

Flags elements for coarsening and refinement based on the computed error passed in error_per_cell.

The two fractions refine_fraction and coarsen_fraction must be in \( [0,1] \).

All the function arguments except error_per_cell have been deprecated, and will be removed in future libMesh releases - to control these parameters, set the corresponding member variables.

Definition at line 44 of file mesh_refinement_flagging.C.

{
  parallel_object_only();
 
  // Verify that our error vector is consistent, using std::vector to
  // avoid confusing this->comm().verify
  libmesh_assert(this->comm().verify(dynamic_cast<const std::vector<ErrorVectorReal> &>(error_per_cell)));
 
  // The function arguments are currently just there for
  // backwards_compatibility
  if (!_use_member_parameters)
    {
      // If the user used non-default parameters, lets warn
      // that they're deprecated
      if (refine_frac != 0.3 ||
          coarsen_frac != 0.0 ||
          max_l != libMesh::invalid_uint)
        libmesh_deprecated();
 
      _refine_fraction = refine_frac;
      _coarsen_fraction = coarsen_frac;
      _max_h_level = max_l;
    }
 
  // Check for valid fractions..
  // The fraction values must be in [0,1]
  libmesh_assert_greater_equal (_refine_fraction, 0);
  libmesh_assert_less_equal (_refine_fraction, 1);
  libmesh_assert_greater_equal (_coarsen_fraction, 0);
  libmesh_assert_less_equal (_coarsen_fraction, 1);
 
  // Clean up the refinement flags.  These could be left
  // over from previous refinement steps.
  this->clean_refinement_flags();
 
  // We're getting the minimum and maximum error values
  // for the ACTIVE elements
  Real error_min = 1.e30;
  Real error_max = 0.;
 
  // And, if necessary, for their parents
  Real parent_error_min = 1.e30;
  Real parent_error_max = 0.;
 
  // Prepare another error vector if we need to sum parent errors
  ErrorVector error_per_parent;
  if (_coarsen_by_parents)
    {
      create_parent_error_vector(error_per_cell,
                                 error_per_parent,
                                 parent_error_min,
                                 parent_error_max);
    }
 
  // We need to loop over all active elements to find the minimum
  for (auto & elem : _mesh.active_local_element_ptr_range())
    {
      const dof_id_type id  = elem->id();
      libmesh_assert_less (id, error_per_cell.size());
 
      error_max = std::max (error_max, error_per_cell[id]);
      error_min = std::min (error_min, error_per_cell[id]);
    }
  this->comm().max(error_max);
  this->comm().min(error_min);
 
  // Compute the cutoff values for coarsening and refinement
  const Real error_delta = (error_max - error_min);
  const Real parent_error_delta = parent_error_max - parent_error_min;
 
  const Real refine_cutoff  = (1.- _refine_fraction)*error_max;
  const Real coarsen_cutoff = _coarsen_fraction*error_delta + error_min;
  const Real parent_cutoff = _coarsen_fraction*parent_error_delta + error_min;
 
  //   // Print information about the error
  //   libMesh::out << " Error Information:"                     << std::endl
  //     << " ------------------"                     << std::endl
  //     << "   min:              " << error_min      << std::endl
  //     << "   max:              " << error_max      << std::endl
  //     << "   delta:            " << error_delta    << std::endl
  //     << "     refine_cutoff:  " << refine_cutoff  << std::endl
  //     << "     coarsen_cutoff: " << coarsen_cutoff << std::endl;
 
 
 
  // Loop over the elements and flag them for coarsening or
  // refinement based on the element error
  for (auto & elem : _mesh.active_element_ptr_range())
    {
      const dof_id_type id = elem->id();
 
      libmesh_assert_less (id, error_per_cell.size());
 
      const ErrorVectorReal elem_error = error_per_cell[id];
 
      if (_coarsen_by_parents)
        {
          Elem * parent           = elem->parent();
          if (parent)
            {
              const dof_id_type parentid  = parent->id();
              if (error_per_parent[parentid] >= 0. &&
                  error_per_parent[parentid] <= parent_cutoff)
                elem->set_refinement_flag(Elem::COARSEN);
            }
        }
      // Flag the element for coarsening if its error
      // is <= coarsen_fraction*delta + error_min
      else if (elem_error <= coarsen_cutoff)
        {
          elem->set_refinement_flag(Elem::COARSEN);
        }
 
      // Flag the element for refinement if its error
      // is >= refinement_cutoff.
      if (elem_error >= refine_cutoff)
        if (elem->level() < _max_h_level)
          elem->set_refinement_flag(Elem::REFINE);
    }
}

References _coarsen_by_parents, _coarsen_fraction, _max_h_level, _mesh, _refine_fraction, _use_member_parameters, clean_refinement_flags(), libMesh::Elem::COARSEN, libMesh::ParallelObject::comm(), create_parent_error_vector(), libMesh::ErrorVectorReal, libMesh::DofObject::id(), libMesh::invalid_uint, libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::Parallel::Communicator::min(), libMesh::Elem::parent(), libMesh::Real, and libMesh::Elem::REFINE.

Referenced by assemble_and_solve(), and main().

◆ flag_elements_by_error_tolerance()

void libMesh::MeshRefinement::flag_elements_by_error_tolerance ( const ErrorVector & error_per_cell )

Flags elements for coarsening and refinement based on the computed error passed in error_per_cell.

This method refines the worst elements with errors greater than absolute_global_tolerance / n_active_elem, flagging at most refine_fraction * n_active_elem It coarsens elements with errors less than coarsen_threshold * global_tolerance / n_active_elem, flagging at most coarsen_fraction * n_active_elem

The three fractions refine_fraction coarsen_fraction and coarsen_threshold should be in \( [0,1] \).

Definition at line 170 of file mesh_refinement_flagging.C.

{
  parallel_object_only();
 
  // Verify that our error vector is consistent, using std::vector to
  // avoid confusing this->comm().verify
  libmesh_assert(this->comm().verify(dynamic_cast<const std::vector<ErrorVectorReal> &>(error_per_cell_in)));
 
  libmesh_assert_greater (_coarsen_threshold, 0);
 
  // Check for valid fractions..
  // The fraction values must be in [0,1]
  libmesh_assert_greater_equal (_refine_fraction, 0);
  libmesh_assert_less_equal (_refine_fraction, 1);
  libmesh_assert_greater_equal (_coarsen_fraction, 0);
  libmesh_assert_less_equal (_coarsen_fraction, 1);
 
  // How much error per cell will we tolerate?
  const Real local_refinement_tolerance =
    _absolute_global_tolerance / std::sqrt(static_cast<Real>(_mesh.n_active_elem()));
  const Real local_coarsening_tolerance =
    local_refinement_tolerance * _coarsen_threshold;
 
  // Prepare another error vector if we need to sum parent errors
  ErrorVector error_per_parent;
  if (_coarsen_by_parents)
    {
      Real parent_error_min, parent_error_max;
 
      create_parent_error_vector(error_per_cell_in,
                                 error_per_parent,
                                 parent_error_min,
                                 parent_error_max);
    }
 
  for (auto & elem : _mesh.active_element_ptr_range())
    {
      Elem * parent = elem->parent();
      const dof_id_type elem_number    = elem->id();
      const ErrorVectorReal elem_error = error_per_cell_in[elem_number];
 
      if (elem_error > local_refinement_tolerance &&
          elem->level() < _max_h_level)
        elem->set_refinement_flag(Elem::REFINE);
 
      if (!_coarsen_by_parents && elem_error <
          local_coarsening_tolerance)
        elem->set_refinement_flag(Elem::COARSEN);
 
      if (_coarsen_by_parents && parent)
        {
          ErrorVectorReal parent_error = error_per_parent[parent->id()];
          if (parent_error >= 0.)
            {
              const Real parent_coarsening_tolerance =
                std::sqrt(parent->n_children() *
                          local_coarsening_tolerance *
                          local_coarsening_tolerance);
              if (parent_error < parent_coarsening_tolerance)
                elem->set_refinement_flag(Elem::COARSEN);
            }
        }
    }
}

References _absolute_global_tolerance, _coarsen_by_parents, _coarsen_fraction, _coarsen_threshold, _max_h_level, _mesh, _refine_fraction, libMesh::Elem::COARSEN, libMesh::ParallelObject::comm(), create_parent_error_vector(), libMesh::ErrorVectorReal, libMesh::DofObject::id(), libMesh::libmesh_assert(), libMesh::MeshBase::n_active_elem(), libMesh::Elem::n_children(), libMesh::Elem::parent(), libMesh::Real, and libMesh::Elem::REFINE.

Referenced by main().

◆ flag_elements_by_mean_stddev()

void libMesh::MeshRefinement::flag_elements_by_mean_stddev	(	const ErrorVector &	error_per_cell,
		const Real	refine_fraction = `1.0`,
		const Real	coarsen_fraction = `0.0`,
		const unsigned int	max_level = `libMesh::invalid_uint`
	)

Flags elements for coarsening and refinement based on the computed error passed in error_per_cell.

This method picks the top refine_fraction * stddev + mean elements for refinement and the bottom mean - coarsen_fraction * stddev elements for coarsening. The two fractions refine_fraction and coarsen_fraction must be in \( [0,1] \).

All the function arguments except error_per_cell have been deprecated, and will be removed in future libMesh releases - to control these parameters, set the corresponding member variables.

Definition at line 583 of file mesh_refinement_flagging.C.

{
  // Verify that our error vector is consistent, using std::vector to
  // avoid confusing this->comm().verify
  libmesh_assert(this->comm().verify(dynamic_cast<const std::vector<ErrorVectorReal> &>(error_per_cell)));
 
  // The function arguments are currently just there for
  // backwards_compatibility
  if (!_use_member_parameters)
    {
      // If the user used non-default parameters, lets warn
      // that they're deprecated
      if (refine_frac != 0.3 ||
          coarsen_frac != 0.0 ||
          max_l != libMesh::invalid_uint)
        libmesh_deprecated();
 
      _refine_fraction = refine_frac;
      _coarsen_fraction = coarsen_frac;
      _max_h_level = max_l;
    }
 
  // Get the mean value from the error vector
  const Real mean = error_per_cell.mean();
 
  // Get the standard deviation.  This equals the
  // square-root of the variance
  const Real stddev = std::sqrt (error_per_cell.variance());
 
  // Check for valid fractions
  libmesh_assert_greater_equal (_refine_fraction, 0);
  libmesh_assert_less_equal (_refine_fraction, 1);
  libmesh_assert_greater_equal (_coarsen_fraction, 0);
  libmesh_assert_less_equal (_coarsen_fraction, 1);
 
  // The refine and coarsen cutoff
  const Real refine_cutoff  =  mean + _refine_fraction  * stddev;
  const Real coarsen_cutoff =  std::max(mean - _coarsen_fraction * stddev, 0.);
 
  // Loop over the elements and flag them for coarsening or
  // refinement based on the element error
  for (auto & elem : _mesh.active_element_ptr_range())
    {
      const dof_id_type id  = elem->id();
 
      libmesh_assert_less (id, error_per_cell.size());
 
      const ErrorVectorReal elem_error = error_per_cell[id];
 
      // Possibly flag the element for coarsening ...
      if (elem_error <= coarsen_cutoff)
        elem->set_refinement_flag(Elem::COARSEN);
 
      // ... or refinement
      if ((elem_error >= refine_cutoff) && (elem->level() < _max_h_level))
        elem->set_refinement_flag(Elem::REFINE);
    }
}

References _coarsen_fraction, _max_h_level, _mesh, _refine_fraction, _use_member_parameters, libMesh::Elem::COARSEN, libMesh::ParallelObject::comm(), libMesh::ErrorVectorReal, libMesh::invalid_uint, libMesh::libmesh_assert(), libMesh::ErrorVector::mean(), libMesh::Real, libMesh::Elem::REFINE, and libMesh::ErrorVector::variance().

◆ flag_elements_by_nelem_target()

bool libMesh::MeshRefinement::flag_elements_by_nelem_target ( const ErrorVector & error_per_cell )

Flags elements for coarsening and refinement based on the computed error passed in error_per_cell.

This method attempts to produce a mesh with slightly more than nelem_target active elements, trading element refinement for element coarsening when their error ratios exceed coarsen_threshold. It flags no more than refine_fraction * n_elem elements for refinement and flags no more than coarsen_fraction * n_elem elements for coarsening.

Returns: true if it has done all the AMR/C it can do in a single step, or false if further adaptive steps may be required to produce a mesh with a narrow error distribution and the right number of elements.

Definition at line 237 of file mesh_refinement_flagging.C.

{
  parallel_object_only();
 
  // Verify that our error vector is consistent, using std::vector to
  // avoid confusing this->comm().verify
  libmesh_assert(this->comm().verify(dynamic_cast<const std::vector<ErrorVectorReal> &>(error_per_cell)));
 
  // Check for valid fractions..
  // The fraction values must be in [0,1]
  libmesh_assert_greater_equal (_refine_fraction, 0);
  libmesh_assert_less_equal (_refine_fraction, 1);
  libmesh_assert_greater_equal (_coarsen_fraction, 0);
  libmesh_assert_less_equal (_coarsen_fraction, 1);
 
  // This function is currently only coded to work when coarsening by
  // parents - it's too hard to guess how many coarsenings will be
  // performed otherwise.
  libmesh_assert (_coarsen_by_parents);
 
  // The number of active elements in the mesh - hopefully less than
  // 2 billion on 32 bit machines
  const dof_id_type n_active_elem  = _mesh.n_active_elem();
 
  // The maximum number of active elements to flag for coarsening
  const dof_id_type max_elem_coarsen =
    static_cast<dof_id_type>(_coarsen_fraction * n_active_elem) + 1;
 
  // The maximum number of elements to flag for refinement
  const dof_id_type max_elem_refine  =
    static_cast<dof_id_type>(_refine_fraction  * n_active_elem) + 1;
 
  // Clean up the refinement flags.  These could be left
  // over from previous refinement steps.
  this->clean_refinement_flags();
 
  // The target number of elements to add or remove
  const std::ptrdiff_t n_elem_new =
    std::ptrdiff_t(_nelem_target) - std::ptrdiff_t(n_active_elem);
 
  // Create an vector with active element errors and ids,
  // sorted by highest errors first
  const dof_id_type max_elem_id = _mesh.max_elem_id();
  std::vector<std::pair<ErrorVectorReal, dof_id_type>> sorted_error;
 
  sorted_error.reserve (n_active_elem);
 
  // On a DistributedMesh, we need to communicate to know which remote ids
  // correspond to active elements.
  {
    std::vector<bool> is_active(max_elem_id, false);
 
    for (auto & elem : _mesh.active_local_element_ptr_range())
      {
        const dof_id_type eid = elem->id();
        is_active[eid] = true;
        libmesh_assert_less (eid, error_per_cell.size());
        sorted_error.emplace_back(error_per_cell[eid], eid);
      }
 
    this->comm().max(is_active);
 
    this->comm().allgather(sorted_error);
  }
 
  // Default sort works since pairs are sorted lexicographically
  std::sort (sorted_error.begin(), sorted_error.end());
  std::reverse (sorted_error.begin(), sorted_error.end());
 
  // Create a sorted error vector with coarsenable parent elements
  // only, sorted by lowest errors first
  ErrorVector error_per_parent;
  std::vector<std::pair<ErrorVectorReal, dof_id_type>> sorted_parent_error;
  Real parent_error_min, parent_error_max;
 
  create_parent_error_vector(error_per_cell,
                             error_per_parent,
                             parent_error_min,
                             parent_error_max);
 
  // create_parent_error_vector sets values for non-parents and
  // non-coarsenable parents to -1.  Get rid of them.
  for (auto i : index_range(error_per_parent))
    if (error_per_parent[i] != -1)
      sorted_parent_error.emplace_back(error_per_parent[i], i);
 
  std::sort (sorted_parent_error.begin(), sorted_parent_error.end());
 
  // Keep track of how many elements we plan to coarsen & refine
  dof_id_type coarsen_count = 0;
  dof_id_type refine_count = 0;
 
  const unsigned int dim = _mesh.mesh_dimension();
  unsigned int twotodim = 1;
  for (unsigned int i=0; i!=dim; ++i)
    twotodim *= 2;
 
  // First, let's try to get our element count to target_nelem
  if (n_elem_new >= 0)
    {
      // Every element refinement creates at least
      // 2^dim-1 new elements
      refine_count =
        std::min(cast_int<dof_id_type>(n_elem_new / (twotodim-1)),
                 max_elem_refine);
    }
  else
    {
      // Every successful element coarsening is likely to destroy
      // 2^dim-1 net elements.
      coarsen_count =
        std::min(cast_int<dof_id_type>(-n_elem_new / (twotodim-1)),
                 max_elem_coarsen);
    }
 
  // Next, let's see if we can trade any refinement for coarsening
  while (coarsen_count < max_elem_coarsen &&
         refine_count < max_elem_refine &&
         coarsen_count < sorted_parent_error.size() &&
         refine_count < sorted_error.size() &&
         sorted_error[refine_count].first >
         sorted_parent_error[coarsen_count].first * _coarsen_threshold)
    {
      coarsen_count++;
      refine_count++;
    }
 
  // On a DistributedMesh, we need to communicate to know which remote ids
  // correspond to refinable elements
  dof_id_type successful_refine_count = 0;
  {
    std::vector<bool> is_refinable(max_elem_id, false);
 
    for (const auto & pr : sorted_error)
      {
        dof_id_type eid = pr.second;
        Elem * elem = _mesh.query_elem_ptr(eid);
        if (elem && elem->level() < _max_h_level)
          is_refinable[eid] = true;
      }
    this->comm().max(is_refinable);
 
    if (refine_count > max_elem_refine)
      refine_count = max_elem_refine;
    for (const auto & pr : sorted_error)
      {
        if (successful_refine_count >= refine_count)
          break;
 
        dof_id_type eid = pr.second;
        Elem * elem = _mesh.query_elem_ptr(eid);
        if (is_refinable[eid])
          {
            if (elem)
              elem->set_refinement_flag(Elem::REFINE);
            successful_refine_count++;
          }
      }
  }
 
  // If we couldn't refine enough elements, don't coarsen too many
  // either
  if (coarsen_count < (refine_count - successful_refine_count))
    coarsen_count = 0;
  else
    coarsen_count -= (refine_count - successful_refine_count);
 
  if (coarsen_count > max_elem_coarsen)
    coarsen_count = max_elem_coarsen;
 
  dof_id_type successful_coarsen_count = 0;
  if (coarsen_count)
    {
      for (const auto & pr : sorted_parent_error)
        {
          if (successful_coarsen_count >= coarsen_count * twotodim)
            break;
 
          dof_id_type parent_id = pr.second;
          Elem * parent = _mesh.query_elem_ptr(parent_id);
 
          // On a DistributedMesh we skip remote elements
          if (!parent)
            continue;
 
          libmesh_assert(parent->has_children());
          for (auto & elem : parent->child_ref_range())
            {
              if (&elem != remote_elem)
                {
                  libmesh_assert(elem.active());
                  elem.set_refinement_flag(Elem::COARSEN);
                  successful_coarsen_count++;
                }
            }
        }
    }
 
  // Return true if we've done all the AMR/C we can
  if (!successful_coarsen_count &&
      !successful_refine_count)
    return true;
  // And false if there may still be more to do.
  return false;
}

References _coarsen_by_parents, _coarsen_fraction, _coarsen_threshold, _max_h_level, _mesh, _nelem_target, _refine_fraction, libMesh::Parallel::Communicator::allgather(), libMesh::Elem::child_ref_range(), clean_refinement_flags(), libMesh::Elem::COARSEN, libMesh::ParallelObject::comm(), create_parent_error_vector(), dim, libMesh::Elem::has_children(), libMesh::index_range(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_elem_id(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_active_elem(), libMesh::MeshBase::query_elem_ptr(), libMesh::Real, libMesh::Elem::REFINE, libMesh::remote_elem, and libMesh::Elem::set_refinement_flag().

Referenced by main().

◆ get_mesh() [1/2]

MeshBase & libMesh::MeshRefinement::get_mesh ( )

inline

Returns: A writable reference to the MeshBase object associated with this object.

Definition at line 346 of file mesh_refinement.h.

346{ return _mesh; }

References _mesh.

◆ get_mesh() [2/2]

const MeshBase & libMesh::MeshRefinement::get_mesh ( ) const

inline

Returns: A constant reference to the MeshBase object associated with this object.

Definition at line 340 of file mesh_refinement.h.

340{ return _mesh; }

References _mesh.

◆ has_topological_neighbor()

bool libMesh::MeshRefinement::has_topological_neighbor	(	const Elem *	elem,
		const PointLocatorBase *	point_locator,
		const Elem *	neighbor
	)		const

private

Local dispatch function for checking the correct has_neighbor function from the Elem class.

Definition at line 1849 of file mesh_refinement.C.

{
#ifdef LIBMESH_ENABLE_PERIODIC
  if (_periodic_boundaries && !_periodic_boundaries->empty())
    {
      libmesh_assert(point_locator);
      return elem->has_topological_neighbor(neighbor, _mesh, *point_locator, _periodic_boundaries);
    }
#endif
  return elem->has_neighbor(neighbor);
}

References libMesh::Elem::has_neighbor(), libMesh::Elem::has_topological_neighbor(), and libMesh::libmesh_assert().

◆ limit_level_mismatch_at_edge()

bool libMesh::MeshRefinement::limit_level_mismatch_at_edge ( const unsigned int max_mismatch )

private

Definition at line 126 of file mesh_refinement_smoothing.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  bool flags_changed = false;
 
 
  // Maps holding the maximum element level that touches an edge
  std::map<std::pair<unsigned int, unsigned int>, unsigned char>
    max_level_at_edge;
  std::map<std::pair<unsigned int, unsigned int>, unsigned char>
    max_p_level_at_edge;
 
  std::unique_ptr<const Elem> edge, pedge;
  // Loop over all the active elements & fill the maps
  for (auto & elem : _mesh.active_element_ptr_range())
    {
      const unsigned char elem_level =
        cast_int<unsigned char>(elem->level() +
                                ((elem->refinement_flag() == Elem::REFINE) ? 1 : 0));
      const unsigned char elem_p_level =
        cast_int<unsigned char>(elem->p_level() +
                                ((elem->p_refinement_flag() == Elem::REFINE) ? 1 : 0));
 
      // Set the max_level at each edge
      for (auto n : elem->edge_index_range())
        {
          elem->build_edge_ptr(edge, n);
          dof_id_type childnode0 = edge->node_id(0);
          dof_id_type childnode1 = edge->node_id(1);
          if (childnode1 < childnode0)
            std::swap(childnode0, childnode1);
 
          for (const Elem * p = elem; p != nullptr; p = p->parent())
            {
              p->build_edge_ptr(pedge, n);
              dof_id_type node0 = pedge->node_id(0);
              dof_id_type node1 = pedge->node_id(1);
 
              if (node1 < node0)
                std::swap(node0, node1);
 
              // If elem does not share this edge with its ancestor
              // p, refinement levels of elements sharing p's edge
              // are not restricted by refinement levels of elem.
              // Furthermore, elem will not share this edge with any
              // of p's ancestors, so we can safely break out of the
              // for loop early.
              if (node0 != childnode0 && node1 != childnode1)
                break;
 
              childnode0 = node0;
              childnode1 = node1;
 
              std::pair<unsigned int, unsigned int> edge_key =
                std::make_pair(node0, node1);
 
              // Try emplacing (edge_key, elem_level) into max_level_at_edge map.
              // If emplacing fails, it means the edge_key already existed, so
              // we need to take the max of the previous and current values.
              if (auto [it, emplaced] = max_level_at_edge.emplace(edge_key, elem_level);
                  !emplaced)
                it->second = std::max(it->second, elem_level);
 
              // Same thing for p_level
              if (auto [it, emplaced] = max_p_level_at_edge.emplace(edge_key, elem_p_level);
                  !emplaced)
                it->second = std::max(it->second, elem_p_level);
            }
        }
    }
 
 
  // Now loop over the active elements and flag the elements
  // who violate the requested level mismatch
  for (auto & elem : _mesh.active_element_ptr_range())
    {
      const unsigned int elem_level = elem->level();
      const unsigned int elem_p_level = elem->p_level();
 
      // Skip the element if it is already fully flagged
      if (elem->refinement_flag() == Elem::REFINE &&
          elem->p_refinement_flag() == Elem::REFINE
          && !_enforce_mismatch_limit_prior_to_refinement)
        continue;
 
      // Loop over the nodes, check for possible mismatch
      for (auto n : elem->edge_index_range())
        {
          elem->build_edge_ptr(edge, n);
          dof_id_type node0 = edge->node_id(0);
          dof_id_type node1 = edge->node_id(1);
          if (node1 < node0)
            std::swap(node0, node1);
 
          std::pair<dof_id_type, dof_id_type> edge_key =
            std::make_pair(node0, node1);
 
          // Flag the element for refinement if it violates
          // the requested level mismatch
          if ((elem_level + max_mismatch) < max_level_at_edge[edge_key]
              && elem->refinement_flag() != Elem::REFINE)
            {
              elem->set_refinement_flag (Elem::REFINE);
              flags_changed = true;
            }
 
          if ((elem_p_level + max_mismatch) < max_p_level_at_edge[edge_key]
              && elem->p_refinement_flag() != Elem::REFINE)
            {
              elem->set_p_refinement_flag (Elem::REFINE);
              flags_changed = true;
            }
 
          // Possibly enforce limit mismatch prior to refinement
          flags_changed |= this->enforce_mismatch_limit_prior_to_refinement(elem, EDGE, max_mismatch);
        } // loop over edges
    } // loop over active elements
 
  // If flags changed on any processor then they changed globally
  this->comm().max(flags_changed);
 
  return flags_changed;
}

References _enforce_mismatch_limit_prior_to_refinement, _mesh, libMesh::ParallelObject::comm(), EDGE, enforce_mismatch_limit_prior_to_refinement(), libMesh::Parallel::Communicator::max(), libMesh::Elem::parent(), and libMesh::Elem::REFINE.

◆ limit_level_mismatch_at_node()

bool libMesh::MeshRefinement::limit_level_mismatch_at_node ( const unsigned int max_mismatch )

private

This algorithm restricts the maximum level mismatch at any node in the mesh.

Calling this with max_mismatch equal to 1 would transform this mesh:

* o---o---o---o---o-------o-------o
* |   |   |   |   |       |       |
* |   |   |   |   |       |       |
* o---o---o---o---o       |       |
* |   |   |   |   |       |       |
* |   |   |   |   |       |       |
* o---o---o---o---o-------o-------o
* |   |   |   |   |       |       |
* |   |   |   |   |       |       |
* o---o---o---o---o       |       |
* |   |   |   |   |       |       |
* |   |   |   |   |       |       |
* o---o---o---o---o-------o-------o
* |       |       |               |
* |       |       |               |
* |       |       |               |
* |       |       |               |
* |       |       |               |
* o-------o-------o               |
* |       |       |               |
* |       |       |               |
* |       |       |               |
* |       |       |               |
* |       |       |               |
* o-------o-------o---------------o
*

into this:

* o---o---o---o---o-------o-------o
* |   |   |   |   |       |       |
* |   |   |   |   |       |       |
* o---o---o---o---o       |       |
* |   |   |   |   |       |       |
* |   |   |   |   |       |       |
* o---o---o---o---o-------o-------o
* |   |   |   |   |       |       |
* |   |   |   |   |       |       |
* o---o---o---o---o       |       |
* |   |   |   |   |       |       |
* |   |   |   |   |       |       |
* o---o---o---o---o-------o-------o
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* o-------o-------o.......o.......o
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* o-------o-------o-------o-------o
*

by refining the indicated element

Definition at line 39 of file mesh_refinement_smoothing.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  bool flags_changed = false;
 
 
  // Vector holding the maximum element level that touches a node.
  std::vector<unsigned char> max_level_at_node (_mesh.n_nodes(), 0);
  std::vector<unsigned char> max_p_level_at_node (_mesh.n_nodes(), 0);
 
  // Loop over all the active elements & fill the vector
  for (auto & elem : _mesh.active_element_ptr_range())
    {
      const unsigned char elem_level =
        cast_int<unsigned char>(elem->level() +
                                ((elem->refinement_flag() == Elem::REFINE) ? 1 : 0));
      const unsigned char elem_p_level =
        cast_int<unsigned char>(elem->p_level() +
                                ((elem->p_refinement_flag() == Elem::REFINE) ? 1 : 0));
 
      // Set the max_level at each node
      for (const Node & node : elem->node_ref_range())
        {
          const dof_id_type node_number = node.id();
 
          libmesh_assert_less (node_number, max_level_at_node.size());
 
          max_level_at_node[node_number] =
            std::max (max_level_at_node[node_number], elem_level);
          max_p_level_at_node[node_number] =
            std::max (max_p_level_at_node[node_number], elem_p_level);
        }
    }
 
 
  // Now loop over the active elements and flag the elements
  // who violate the requested level mismatch. Alternatively, if
  // _enforce_mismatch_limit_prior_to_refinement is true, swap refinement flags
  // accordingly.
  for (auto & elem : _mesh.active_element_ptr_range())
    {
      const unsigned int elem_level = elem->level();
      const unsigned int elem_p_level = elem->p_level();
 
      // Skip the element if it is already fully flagged
      // unless we are enforcing mismatch prior to refinement and may need to
      // remove the refinement flag(s)
      if (elem->refinement_flag() == Elem::REFINE &&
          elem->p_refinement_flag() == Elem::REFINE
          && !_enforce_mismatch_limit_prior_to_refinement)
        continue;
 
      // Loop over the nodes, check for possible mismatch
      for (const Node & node : elem->node_ref_range())
        {
          const dof_id_type node_number = node.id();
 
          // Flag the element for refinement if it violates
          // the requested level mismatch
          if ((elem_level + max_mismatch) < max_level_at_node[node_number]
              && elem->refinement_flag() != Elem::REFINE)
            {
              elem->set_refinement_flag (Elem::REFINE);
              flags_changed = true;
            }
          if ((elem_p_level + max_mismatch) < max_p_level_at_node[node_number]
              && elem->p_refinement_flag() != Elem::REFINE)
            {
              elem->set_p_refinement_flag (Elem::REFINE);
              flags_changed = true;
            }
 
          // Possibly enforce limit mismatch prior to refinement
          flags_changed |= this->enforce_mismatch_limit_prior_to_refinement(elem, POINT, max_mismatch);
        }
    }
 
  // If flags changed on any processor then they changed globally
  this->comm().max(flags_changed);
 
  return flags_changed;
}

References _enforce_mismatch_limit_prior_to_refinement, _mesh, libMesh::ParallelObject::comm(), enforce_mismatch_limit_prior_to_refinement(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::n_nodes(), POINT, and libMesh::Elem::REFINE.

◆ limit_overrefined_boundary()

bool libMesh::MeshRefinement::limit_overrefined_boundary ( const signed char max_mismatch )

private

Definition at line 254 of file mesh_refinement_smoothing.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  bool flags_changed = false;
 
  // Loop over all the active elements & look for mismatches to fix.
  for (auto & elem : _mesh.active_element_ptr_range())
    {
      // If we don't have an interior_parent then there's nothing to
      // be mismatched with.
      if ((elem->dim() >= LIBMESH_DIM) ||
          !elem->interior_parent())
        continue;
 
      const unsigned char elem_level =
        cast_int<unsigned char>(elem->level() +
                                ((elem->refinement_flag() == Elem::REFINE) ? 1 : 0));
      const unsigned char elem_p_level =
        cast_int<unsigned char>(elem->p_level() +
                                ((elem->p_refinement_flag() == Elem::REFINE) ? 1 : 0));
 
      // get all relevant interior elements
      std::set<Elem *> neighbor_set;
      elem->find_interior_neighbors(neighbor_set);
 
      for (auto & neighbor : neighbor_set)
        if (max_mismatch >= 0)
          {
            if ((elem_level > neighbor->level() + max_mismatch) &&
                (neighbor->refinement_flag() != Elem::REFINE))
              {
                neighbor->set_refinement_flag(Elem::REFINE);
                flags_changed = true;
              }
 
            if ((elem_p_level > neighbor->p_level() + max_mismatch) &&
                (neighbor->p_refinement_flag() != Elem::REFINE))
              {
                neighbor->set_p_refinement_flag(Elem::REFINE);
                flags_changed = true;
              }
          }
    }
 
  // If flags changed on any processor then they changed globally
  this->comm().max(flags_changed);
 
  return flags_changed;
}

References _mesh, libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::max(), and libMesh::Elem::REFINE.

◆ limit_underrefined_boundary()

bool libMesh::MeshRefinement::limit_underrefined_boundary ( const signed char max_mismatch )

private

Definition at line 308 of file mesh_refinement_smoothing.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  bool flags_changed = false;
 
  // Loop over all the active elements & look for mismatches to fix.
  for (auto & elem : _mesh.active_element_ptr_range())
    {
      // If we don't have an interior_parent then there's nothing to
      // be mismatched with.
      if ((elem->dim() >= LIBMESH_DIM) ||
          !elem->interior_parent())
        continue;
 
      // get all relevant interior elements
      std::set<const Elem *> neighbor_set;
      elem->find_interior_neighbors(neighbor_set);
 
      for (const Elem * neighbor : neighbor_set)
        {
          const unsigned char neighbor_level =
            cast_int<unsigned char>(neighbor->level() +
                                    ((neighbor->refinement_flag() == Elem::REFINE) ? 1 : 0));
 
          const unsigned char neighbor_p_level =
            cast_int<unsigned char>(neighbor->p_level() +
                                    ((neighbor->p_refinement_flag() == Elem::REFINE) ? 1 : 0));
 
          if (max_mismatch >= 0)
            {
              if ((neighbor_level >
                   elem->level() + max_mismatch) &&
                  (elem->refinement_flag() != Elem::REFINE))
                {
                  elem->set_refinement_flag(Elem::REFINE);
                  flags_changed = true;
                }
 
              if ((neighbor_p_level >
                   elem->p_level() + max_mismatch) &&
                  (elem->p_refinement_flag() != Elem::REFINE))
                {
                  elem->set_p_refinement_flag(Elem::REFINE);
                  flags_changed = true;
                }
            }
        } // loop over interior neighbors
    }
 
  // If flags changed on any processor then they changed globally
  this->comm().max(flags_changed);
 
  return flags_changed;
}

References _mesh, libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::max(), and libMesh::Elem::REFINE.

◆ make_coarsening_compatible()

bool libMesh::MeshRefinement::make_coarsening_compatible ( )

private

Take user-specified coarsening flags and augment them so that level-one dependency is satisfied.

This function used to take an argument, maintain_level_one - new code should use face_level_mismatch_limit() instead.

Definition at line 815 of file mesh_refinement.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  // We may need a PointLocator for topological_neighbor() tests
  // later, which we need to make sure gets constructed on all
  // processors at once.
  std::unique_ptr<PointLocatorBase> point_locator;
 
#ifdef LIBMESH_ENABLE_PERIODIC
  bool has_periodic_boundaries =
    _periodic_boundaries && !_periodic_boundaries->empty();
  libmesh_assert(this->comm().verify(has_periodic_boundaries));
 
  if (has_periodic_boundaries)
    point_locator = _mesh.sub_point_locator();
#endif
 
  LOG_SCOPE ("make_coarsening_compatible()", "MeshRefinement");
 
  // Unless we encounter a specific situation level-one
  // will be satisfied after executing this loop just once
  bool level_one_satisfied = true;
 
 
  // Unless we encounter a specific situation we will be compatible
  // with any selected refinement flags
  bool compatible_with_refinement = true;
 
 
  // find the maximum h and p levels in the mesh
  unsigned int max_level = 0;
  unsigned int max_p_level = 0;
 
  {
    // First we look at all the active level-0 elements.  Since it doesn't make
    // sense to coarsen them we must un-set their coarsen flags if
    // they are set.
    for (auto & elem : _mesh.active_element_ptr_range())
      {
        max_level = std::max(max_level, elem->level());
        max_p_level =
          std::max(max_p_level,
                   static_cast<unsigned int>(elem->p_level()));
 
        if ((elem->level() == 0) &&
            (elem->refinement_flag() == Elem::COARSEN))
          elem->set_refinement_flag(Elem::DO_NOTHING);
 
        if ((elem->p_level() == 0) &&
            (elem->p_refinement_flag() == Elem::COARSEN))
          elem->set_p_refinement_flag(Elem::DO_NOTHING);
      }
  }
 
  // Even if there are no refined elements on this processor then
  // there may still be work for us to do on e.g. ancestor elements.
  // At the very least we need to be in the loop if a distributed mesh
  // needs to synchronize data.
#if 0
  if (max_level == 0 && max_p_level == 0)
    {
      // But we still have to check with other processors
      this->comm().min(compatible_with_refinement);
 
      return compatible_with_refinement;
    }
#endif
 
  // Loop over all the active elements.  If an element is marked
  // for coarsening we better check its neighbors.  If ANY of these neighbors
  // are marked for refinement AND are at the same level then there is a
  // conflict.  By convention refinement wins, so we un-mark the element for
  // coarsening.  Level-one would be violated in this case so we need to re-run
  // the loop.
  if (_face_level_mismatch_limit)
    {
 
    repeat:
      level_one_satisfied = true;
 
      do
        {
          level_one_satisfied = true;
 
          for (auto & elem : _mesh.active_element_ptr_range())
            {
              bool my_flag_changed = false;
 
              if (elem->refinement_flag() == Elem::COARSEN) // If the element is active and
                // the coarsen flag is set
                {
                  const unsigned int my_level = elem->level();
 
                  for (auto n : elem->side_index_range())
                    {
                      const Elem * neighbor =
                        topological_neighbor(elem, point_locator.get(), n);
 
                      if (neighbor != nullptr &&      // I have a
                          neighbor != remote_elem) // neighbor here
                        {
                          if (neighbor->active()) // and it is active
                            {
                              if ((neighbor->level() == my_level) &&
                                  (neighbor->refinement_flag() == Elem::REFINE)) // the neighbor is at my level
                                // and wants to be refined
                                {
                                  elem->set_refinement_flag(Elem::DO_NOTHING);
                                  my_flag_changed = true;
                                  break;
                                }
                            }
                          else // I have a neighbor and it is not active. That means it has children.
                            {  // While it _may_ be possible to coarsen us if all the children of
                              // that element want to be coarsened, it is impossible to know at this
                              // stage.  Forget about it for the moment...  This can be handled in
                              // two steps.
                              elem->set_refinement_flag(Elem::DO_NOTHING);
                              my_flag_changed = true;
                              break;
                            }
                        }
                    }
                }
              if (elem->p_refinement_flag() == Elem::COARSEN) // If
                // the element is active and the order reduction flag is set
                {
                  const unsigned int my_p_level = elem->p_level();
 
                  for (auto n : elem->side_index_range())
                    {
                      const Elem * neighbor =
                        topological_neighbor(elem, point_locator.get(), n);
 
                      if (neighbor != nullptr &&      // I have a
                          neighbor != remote_elem) // neighbor here
                        {
                          if (neighbor->active()) // and it is active
                            {
                              if ((neighbor->p_level() > my_p_level &&
                                   neighbor->p_refinement_flag() != Elem::COARSEN)
                                  || (neighbor->p_level() == my_p_level &&
                                      neighbor->p_refinement_flag() == Elem::REFINE))
                                {
                                  elem->set_p_refinement_flag(Elem::DO_NOTHING);
                                  my_flag_changed = true;
                                  break;
                                }
                            }
                          else // I have a neighbor and it is not active.
                            {  // We need to find which of its children
                              // have me as a neighbor, and maintain
                              // level one p compatibility with them.
                              // Because we currently have level one h
                              // compatibility, we don't need to check
                              // grandchildren
 
                              libmesh_assert(neighbor->has_children());
                              for (auto & subneighbor : neighbor->child_ref_range())
                                if (&subneighbor != remote_elem &&
                                    subneighbor.active() &&
                                    has_topological_neighbor(&subneighbor, point_locator.get(), elem))
                                  if ((subneighbor.p_level() > my_p_level &&
                                       subneighbor.p_refinement_flag() != Elem::COARSEN)
                                      || (subneighbor.p_level() == my_p_level &&
                                          subneighbor.p_refinement_flag() == Elem::REFINE))
                                    {
                                      elem->set_p_refinement_flag(Elem::DO_NOTHING);
                                      my_flag_changed = true;
                                      break;
                                    }
                              if (my_flag_changed)
                                break;
                            }
                        }
                    }
                }
 
              // If the current element's flag changed, we hadn't
              // satisfied the level one rule.
              if (my_flag_changed)
                level_one_satisfied = false;
 
              // Additionally, if it has non-local neighbors, and
              // we're not in serial, then we'll eventually have to
              // return compatible_with_refinement = false, because
              // our change has to propagate to neighboring
              // processors.
              if (my_flag_changed && !_mesh.is_serial())
                for (auto n : elem->side_index_range())
                  {
                    Elem * neigh =
                      topological_neighbor(elem, point_locator.get(), n);
 
                    if (!neigh)
                      continue;
                    if (neigh == remote_elem ||
                        neigh->processor_id() !=
                        this->processor_id())
                      {
                        compatible_with_refinement = false;
                        break;
                      }
                    // FIXME - for non-level one meshes we should
                    // test all descendants
                    if (neigh->has_children())
                      for (auto & child : neigh->child_ref_range())
                        if (&child == remote_elem ||
                            child.processor_id() !=
                            this->processor_id())
                          {
                            compatible_with_refinement = false;
                            break;
                          }
                  }
            }
        }
      while (!level_one_satisfied);
 
    } // end if (_face_level_mismatch_limit)
 
 
  // Next we look at all of the ancestor cells.
  // If there is a parent cell with all of its children
  // wanting to be unrefined then the element is a candidate
  // for unrefinement.  If all the children don't
  // all want to be unrefined then ALL of them need to have their
  // unrefinement flags cleared.
  for (int level = max_level; level >= 0; level--)
    for (auto & elem : as_range(_mesh.level_elements_begin(level), _mesh.level_elements_end(level)))
      if (elem->ancestor())
        {
          // right now the element hasn't been disqualified
          // as a candidate for unrefinement
          bool is_a_candidate = true;
          bool found_remote_child = false;
 
          for (auto & child : elem->child_ref_range())
            {
              if (&child == remote_elem)
                found_remote_child = true;
              else if ((child.refinement_flag() != Elem::COARSEN) ||
                       !child.active() )
                is_a_candidate = false;
            }
 
          if (!is_a_candidate && !found_remote_child)
            {
              elem->set_refinement_flag(Elem::INACTIVE);
 
              for (auto & child : elem->child_ref_range())
                {
                  if (&child == remote_elem)
                    continue;
                  if (child.refinement_flag() == Elem::COARSEN)
                    {
                      level_one_satisfied = false;
                      child.set_refinement_flag(Elem::DO_NOTHING);
                    }
                }
            }
        }
 
  if (!level_one_satisfied && _face_level_mismatch_limit) goto repeat;
 
 
  // If all the children of a parent are set to be coarsened
  // then flag the parent so that they can kill their kids.
 
  // On a distributed mesh, we won't always be able to determine this
  // on parent elements with remote children, even if we own the
  // parent, without communication.
  //
  // We'll first communicate *to* parents' owners when we determine
  // they cannot be coarsened, then we'll sync the final refinement
  // flag *from* the parents.
 
  // uncoarsenable_parents[p] live on processor id p
  const processor_id_type n_proc     = _mesh.n_processors();
  const processor_id_type my_proc_id = _mesh.processor_id();
  const bool distributed_mesh = !_mesh.is_replicated();
 
  std::vector<std::vector<dof_id_type>>
    uncoarsenable_parents(n_proc);
 
  for (auto & elem : as_range(_mesh.ancestor_elements_begin(), _mesh.ancestor_elements_end()))
    {
      // Presume all the children are flagged for coarsening and
      // then look for a contradiction
      bool all_children_flagged_for_coarsening = true;
 
      for (auto & child : elem->child_ref_range())
        {
          if (&child != remote_elem &&
              child.refinement_flag() != Elem::COARSEN)
            {
              all_children_flagged_for_coarsening = false;
              if (!distributed_mesh)
                break;
              if (child.processor_id() != elem->processor_id())
                {
                  uncoarsenable_parents[elem->processor_id()].push_back(elem->id());
                  break;
                }
            }
        }
 
      if (all_children_flagged_for_coarsening)
        elem->set_refinement_flag(Elem::COARSEN_INACTIVE);
      else
        elem->set_refinement_flag(Elem::INACTIVE);
    }
 
  // If we have a distributed mesh, we might need to sync up
  // INACTIVE vs. COARSEN_INACTIVE flags.
  if (distributed_mesh)
    {
      // We'd better still be in sync here
      parallel_object_only();
 
      Parallel::MessageTag
        uncoarsenable_tag = this->comm().get_unique_tag();
      std::vector<Parallel::Request> uncoarsenable_push_requests(n_proc-1);
 
      for (processor_id_type p = 0; p != n_proc; ++p)
        {
          if (p == my_proc_id)
            continue;
 
          Parallel::Request &request =
            uncoarsenable_push_requests[p - (p > my_proc_id)];
 
          _mesh.comm().send
            (p, uncoarsenable_parents[p], request, uncoarsenable_tag);
        }
 
      for (processor_id_type p = 1; p != n_proc; ++p)
        {
          std::vector<dof_id_type> my_uncoarsenable_parents;
          _mesh.comm().receive
            (Parallel::any_source, my_uncoarsenable_parents,
             uncoarsenable_tag);
 
          for (const auto & id : my_uncoarsenable_parents)
            {
              Elem & elem = _mesh.elem_ref(id);
              libmesh_assert(elem.refinement_flag() == Elem::INACTIVE ||
                             elem.refinement_flag() == Elem::COARSEN_INACTIVE);
              elem.set_refinement_flag(Elem::INACTIVE);
            }
        }
 
      Parallel::wait(uncoarsenable_push_requests);
 
      SyncRefinementFlags hsync(_mesh, &Elem::refinement_flag,
                                &Elem::set_refinement_flag);
      sync_dofobject_data_by_id
        (this->comm(), _mesh.not_local_elements_begin(),
         _mesh.not_local_elements_end(),
         // We'd like a smaller sync, but this leads to bugs?
         // SyncCoarsenInactive(),
         hsync);
    }
 
  // If one processor finds an incompatibility, we're globally
  // incompatible
  this->comm().min(compatible_with_refinement);
 
  return compatible_with_refinement;
}

References libMesh::Elem::active(), libMesh::as_range(), libMesh::Elem::child_ref_range(), libMesh::Elem::has_children(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::DofObject::processor_id(), libMesh::Elem::refinement_flag(), libMesh::remote_elem, and libMesh::Elem::set_refinement_flag().

◆ make_flags_parallel_consistent()

bool libMesh::MeshRefinement::make_flags_parallel_consistent ( )

Copy refinement flags on ghost elements from their local processors.

Returns: true if any flags changed.

Definition at line 787 of file mesh_refinement.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  LOG_SCOPE ("make_flags_parallel_consistent()", "MeshRefinement");
 
  SyncRefinementFlags hsync(_mesh, &Elem::refinement_flag,
                            &Elem::set_refinement_flag);
  Parallel::sync_dofobject_data_by_id
    (this->comm(), _mesh.elements_begin(), _mesh.elements_end(), hsync);
 
  SyncRefinementFlags psync(_mesh, &Elem::p_refinement_flag,
                            &Elem::set_p_refinement_flag);
  Parallel::sync_dofobject_data_by_id
    (this->comm(), _mesh.elements_begin(), _mesh.elements_end(), psync);
 
  // If we weren't consistent in both h and p on every processor then
  // we weren't globally consistent
  bool parallel_consistent = hsync.parallel_consistent &&
    psync.parallel_consistent;
  this->comm().min(parallel_consistent);
 
  return parallel_consistent;
}

References libMesh::SyncRefinementFlags::parallel_consistent.

Referenced by libMesh::HPCoarsenTest::select_refinement().

◆ make_refinement_compatible()

bool libMesh::MeshRefinement::make_refinement_compatible ( )

private

Take user-specified refinement flags and augment them so that level-one dependency is satisfied.

This function used to take an argument, maintain_level_one - new code should use face_level_mismatch_limit() instead.

Definition at line 1195 of file mesh_refinement.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  // We may need a PointLocator for topological_neighbor() tests
  // later, which we need to make sure gets constructed on all
  // processors at once.
  std::unique_ptr<PointLocatorBase> point_locator;
 
#ifdef LIBMESH_ENABLE_PERIODIC
  bool has_periodic_boundaries =
    _periodic_boundaries && !_periodic_boundaries->empty();
  libmesh_assert(this->comm().verify(has_periodic_boundaries));
 
  if (has_periodic_boundaries)
    point_locator = _mesh.sub_point_locator();
#endif
 
  LOG_SCOPE ("make_refinement_compatible()", "MeshRefinement");
 
  // Unless we encounter a specific situation we will be compatible
  // with any selected coarsening flags
  bool compatible_with_coarsening = true;
 
  // This loop enforces the level-1 rule.  We should only
  // execute it if the user indeed wants level-1 satisfied!
  if (_face_level_mismatch_limit)
    {
      // Unless we encounter a specific situation level-one
      // will be satisfied after executing this loop just once
      bool level_one_satisfied = true;
 
      do
        {
          level_one_satisfied = true;
 
          for (auto & elem : _mesh.active_element_ptr_range())
            {
              const unsigned short n_sides = elem->n_sides();
 
              if (elem->refinement_flag() == Elem::REFINE)  // If the element is active and the
                // h refinement flag is set
                {
                  const unsigned int my_level = elem->level();
 
                  for (unsigned short side = 0; side != n_sides;
                       ++side)
                    {
                      Elem * neighbor =
                        topological_neighbor(elem, point_locator.get(), side);
 
                      if (neighbor != nullptr        && // I have a
                          neighbor != remote_elem && // neighbor here
                          neighbor->active()) // and it is active
                        {
                          // Case 1:  The neighbor is at the same level I am.
                          //        1a: The neighbor will be refined       -> NO PROBLEM
                          //        1b: The neighbor won't be refined      -> NO PROBLEM
                          //        1c: The neighbor wants to be coarsened -> PROBLEM
                          if (neighbor->level() == my_level)
                            {
                              if (neighbor->refinement_flag() == Elem::COARSEN)
                                {
                                  neighbor->set_refinement_flag(Elem::DO_NOTHING);
                                  if (neighbor->parent())
                                    neighbor->parent()->set_refinement_flag(Elem::INACTIVE);
                                  compatible_with_coarsening = false;
                                  level_one_satisfied = false;
                                }
                            }
 
 
                          // Case 2: The neighbor is one level lower than I am.
                          //         The neighbor thus MUST be refined to satisfy
                          //         the level-one rule, regardless of whether it
                          //         was originally flagged for refinement. If it
                          //         wasn't flagged already we need to repeat
                          //         this process.
                          else if ((neighbor->level()+1) == my_level)
                            {
                              if (neighbor->refinement_flag() != Elem::REFINE)
                                {
                                  neighbor->set_refinement_flag(Elem::REFINE);
                                  if (neighbor->parent())
                                    neighbor->parent()->set_refinement_flag(Elem::INACTIVE);
                                  compatible_with_coarsening = false;
                                  level_one_satisfied = false;
                                }
                            }
#ifdef DEBUG
                          // Note that the only other possibility is that the
                          // neighbor is already refined, in which case it isn't
                          // active and we should never get here.
                          else
                            libmesh_error_msg("ERROR: Neighbor level must be equal or 1 higher than mine.");
#endif
                        }
                    }
                }
              if (elem->p_refinement_flag() == Elem::REFINE)  // If the element is active and the
                // p refinement flag is set
                {
                  const unsigned int my_p_level = elem->p_level();
 
                  for (unsigned int side=0; side != n_sides; side++)
                    {
                      Elem * neighbor =
                        topological_neighbor(elem, point_locator.get(), side);
 
                      if (neighbor != nullptr &&      // I have a
                          neighbor != remote_elem) // neighbor here
                        {
                          if (neighbor->active()) // and it is active
                            {
                              if (neighbor->p_level() < my_p_level &&
                                  neighbor->p_refinement_flag() != Elem::REFINE)
                                {
                                  neighbor->set_p_refinement_flag(Elem::REFINE);
                                  level_one_satisfied = false;
                                  compatible_with_coarsening = false;
                                }
                              if (neighbor->p_level() == my_p_level &&
                                  neighbor->p_refinement_flag() == Elem::COARSEN)
                                {
                                  neighbor->set_p_refinement_flag(Elem::DO_NOTHING);
                                  level_one_satisfied = false;
                                  compatible_with_coarsening = false;
                                }
                            }
                          else // I have an inactive neighbor
                            {
                              libmesh_assert(neighbor->has_children());
                              for (auto & subneighbor : neighbor->child_ref_range())
                                if (&subneighbor != remote_elem && subneighbor.active() &&
                                    has_topological_neighbor(&subneighbor, point_locator.get(), elem))
                                  {
                                    if (subneighbor.p_level() < my_p_level &&
                                        subneighbor.p_refinement_flag() != Elem::REFINE)
                                      {
                                        // We should already be level one
                                        // compatible
                                        libmesh_assert_greater (subneighbor.p_level() + 2u,
                                                                my_p_level);
                                        subneighbor.set_p_refinement_flag(Elem::REFINE);
                                        level_one_satisfied = false;
                                        compatible_with_coarsening = false;
                                      }
                                    if (subneighbor.p_level() == my_p_level &&
                                        subneighbor.p_refinement_flag() == Elem::COARSEN)
                                      {
                                        subneighbor.set_p_refinement_flag(Elem::DO_NOTHING);
                                        level_one_satisfied = false;
                                        compatible_with_coarsening = false;
                                      }
                                  }
                            }
                        }
                    }
                }
            }
        }
 
      while (!level_one_satisfied);
    } // end if (_face_level_mismatch_limit)
 
  // If we're not compatible on one processor, we're globally not
  // compatible
  this->comm().min(compatible_with_coarsening);
 
  return compatible_with_coarsening;
}

References libMesh::Elem::active(), libMesh::Elem::child_ref_range(), libMesh::Elem::has_children(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::parent(), libMesh::Elem::refinement_flag(), libMesh::remote_elem, libMesh::Elem::set_p_refinement_flag(), and libMesh::Elem::set_refinement_flag().

◆ max_h_level()

unsigned int & libMesh::MeshRefinement::max_h_level ( )

inline

The max_h_level is the greatest refinement level an element should reach.

max_h_level is unlimited (libMesh::invalid_uint) by default

Definition at line 900 of file mesh_refinement.h.

{
  _use_member_parameters = true;
  return _max_h_level;
}

References _max_h_level, and _use_member_parameters.

Referenced by assemble_and_solve(), and main().

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

◆ nelem_target()

dof_id_type & libMesh::MeshRefinement::nelem_target ( )

inline

If nelem_target is set to a nonzero value, methods like flag_elements_by_nelem_target() will attempt to keep the number of active elements in the mesh close to nelem_target.

nelem_target is 0 by default.

Definition at line 912 of file mesh_refinement.h.

{
  _use_member_parameters = true;
  return _nelem_target;
}

References _nelem_target, and _use_member_parameters.

Referenced by main().

◆ node_level_mismatch_limit()

unsigned char & libMesh::MeshRefinement::node_level_mismatch_limit ( )

inline

If node_level_mismatch_limit is set to a nonzero value, then refinement and coarsening will produce meshes in which the refinement level of two nodal neighbors will not differ by more than that limit.

If node_level_mismatch_limit is 0, then level differences will be unlimited.

node_level_mismatch_limit is 0 by default.

Definition at line 934 of file mesh_refinement.h.

{
  return _node_level_mismatch_limit;
}

References _node_level_mismatch_limit.

◆ operator=()

MeshRefinement & libMesh::MeshRefinement::operator= ( const MeshRefinement & )

private

◆ overrefined_boundary_limit()

signed char & libMesh::MeshRefinement::overrefined_boundary_limit ( )

inline

If overrefined_boundary_limit is set to a nonnegative value, then refinement and coarsening will produce meshes in which the refinement level of a boundary element is no more than that many levels greater than the level of any of its interior neighbors.

This may be counter-intuitive in the 1D-embedded-in-3D case: an edge has more interior neighbors than a face containing that edge.

If overrefined_boundary_limit is negative, then level differences will be unlimited.

overrefined_boundary_limit is 0 by default. This implies that adaptive coarsening can only be done on an interior element if any boundary elements on its sides are simultaneously coarsened.

Definition at line 939 of file mesh_refinement.h.

{
  return _overrefined_boundary_limit;
}

References _overrefined_boundary_limit.

Referenced by libMesh::EquationSystems::reinit_solutions().

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

◆ refine_and_coarsen_elements()

bool libMesh::MeshRefinement::refine_and_coarsen_elements ( )

Refines and coarsens user-requested elements.

Will also refine/coarsen additional elements to satisfy level-one rule. It is possible that for a given set of refinement flags there is actually no change upon calling this member function.

Returns: true if the mesh actually changed (hence data needs to be projected) and false otherwise.

Note: This function used to take an argument, maintain_level_one. New code should use face_level_mismatch_limit() instead.

Definition at line 482 of file mesh_refinement.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  // We can't yet turn a non-level-one mesh into a level-one mesh
  if (_face_level_mismatch_limit)
    libmesh_assert(test_level_one(true));
 
  // Possibly clean up the refinement flags from
  // a previous step.  While we're at it, see if this method should be
  // a no-op.
  std::atomic<bool> elements_flagged{false};
 
  Threads::parallel_for
    (_mesh.element_stored_range(),
     [&elements_flagged](const ElemRange & range)
     {
       for (Elem * elem : range)
         {
           // This might be left over from the last step
           const Elem::RefinementState flag = elem->refinement_flag();
 
           // Set refinement flag to INACTIVE if the
           // element isn't active
           if (!elem->active())
             {
               elem->set_refinement_flag(Elem::INACTIVE);
               elem->set_p_refinement_flag(Elem::INACTIVE);
             }
           else if (flag == Elem::JUST_REFINED)
             elem->set_refinement_flag(Elem::DO_NOTHING);
           else if (!elements_flagged)
             {
               if (flag == Elem::REFINE || flag == Elem::COARSEN)
                 elements_flagged = true;
               else
                 {
                   const Elem::RefinementState pflag =
                     elem->p_refinement_flag();
                   if (pflag == Elem::REFINE || pflag == Elem::COARSEN)
                     elements_flagged = true;
                 }
             }
         }
     });
 
  // Did *any* processor find elements flagged for AMR/C?
  bool any_elements_flagged = elements_flagged;
  _mesh.comm().max(any_elements_flagged);
 
  // If we have nothing to do, let's not bother verifying that nothing
  // is compatible with nothing.
  if (!any_elements_flagged)
    return false;
 
  // Parallel consistency has to come first, or coarsening
  // along processor boundaries might occasionally be falsely
  // prevented
#ifdef DEBUG
  bool flags_were_consistent = this->make_flags_parallel_consistent();
 
  libmesh_assert (flags_were_consistent);
#endif
 
  // Smooth refinement and coarsening flags
  _smooth_flags(true, true);
 
  // First coarsen the flagged elements.
  const bool coarsening_changed_mesh =
    this->_coarsen_elements ();
 
  // First coarsen the flagged elements.
  // FIXME: test_level_one now tests consistency across periodic
  // boundaries, which requires a point_locator, which just got
  // invalidated by _coarsen_elements() and hasn't yet been cleared by
  // prepare_for_use().
 
  //  libmesh_assert(this->make_coarsening_compatible());
  //  libmesh_assert(this->make_refinement_compatible());
 
  // FIXME: This won't pass unless we add a redundant find_neighbors()
  // call or replace find_neighbors() with on-the-fly neighbor updating
  // libmesh_assert(!this->eliminate_unrefined_patches());
 
  // We can't contract the mesh ourselves anymore - a System might
  // need to restrict old coefficient vectors first
  // _mesh.contract();
 
  // First coarsen the flagged elements.
  // Now refine the flagged elements.  This will
  // take up some space, maybe more than what was freed.
  const bool refining_changed_mesh =
    this->_refine_elements();
 
  // First coarsen the flagged elements.
  // Finally, the new mesh needs to be prepared for use
  if (coarsening_changed_mesh || refining_changed_mesh)
    {
#ifdef DEBUG
      _mesh.libmesh_assert_valid_parallel_ids();
#endif
 
      _mesh.prepare_for_use ();
 
      if (_face_level_mismatch_limit)
        libmesh_assert(test_level_one(true));
      libmesh_assert(test_unflagged(true));
      libmesh_assert(this->make_coarsening_compatible());
      libmesh_assert(this->make_refinement_compatible());
      // FIXME: This won't pass unless we add a redundant find_neighbors()
      // call or replace find_neighbors() with on-the-fly neighbor updating
      // libmesh_assert(!this->eliminate_unrefined_patches());
 
      return true;
    }
  else
    {
      if (_face_level_mismatch_limit)
        libmesh_assert(test_level_one(true));
      libmesh_assert(test_unflagged(true));
      libmesh_assert(this->make_coarsening_compatible());
      libmesh_assert(this->make_refinement_compatible());
    }
 
  // Otherwise there was no change in the mesh,
  // let the user know.  Also, there is no need
  // to prepare the mesh for use since it did not change.
  return false;
 
}

References libMesh::libmesh_assert().

Referenced by assemble_and_solve(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), and main().

◆ refine_elements()

bool libMesh::MeshRefinement::refine_elements ( )

Only refines the user-requested elements.

It is possible that for a given set of refinement flags there is actually no change upon calling this member function.

Returns: true if the mesh actually changed (hence data needs to be projected) and false otherwise.

Note: This function used to take an argument, maintain_level_one, new code should use face_level_mismatch_limit() instead.

Definition at line 699 of file mesh_refinement.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  // Prevent refinement when the mesh has disjoint neighbor boundary pairs.
  //
  // Disjoint neighbor boundary interfaces violate the topological continuity
  // assumed by the refinement algorithm. Refinement on such meshes can
  // produce invalid neighbor relationships (for example reverse indices
  // equal to invalid_uint), which may trigger assertions like
  // `rev < neigh->n_neighbors()` or corrupt neighbor data.
  //
  // For safety, refinement is disabled while disjoint neighbor boundary pairs are
  // present.
  if (_mesh.get_disjoint_neighbor_boundary_pairs())
    {
      libmesh_not_implemented_msg(
        "Mesh refinement is not yet implemented for meshes with disjoint neighbor boundary interfaces.\n");
    }
 
  if (_face_level_mismatch_limit)
    libmesh_assert(test_level_one(true));
 
  // Possibly clean up the refinement flags from
  // a previous step
  Threads::parallel_for
    (_mesh.element_stored_range(),
     [](const ElemRange & range)
     {
       for (Elem * elem : range)
         {
           // Set refinement flag to INACTIVE if the
           // element isn't active
           if (!elem->active())
             {
               elem->set_refinement_flag(Elem::INACTIVE);
               elem->set_p_refinement_flag(Elem::INACTIVE);
             }
 
           // This might be left over from the last step
           if (elem->refinement_flag() == Elem::JUST_REFINED)
             elem->set_refinement_flag(Elem::DO_NOTHING);
         }
     });
 
  // Parallel consistency has to come first, or coarsening
  // along processor boundaries might occasionally be falsely
  // prevented
  bool flags_were_consistent = this->make_flags_parallel_consistent();
 
  // In theory, we should be able to remove the above call, which can
  // be expensive and should be unnecessary.  In practice, doing
  // consistent flagging in parallel is hard, it's impossible to
  // verify at the library level if it's being done by user code, and
  // we don't want to abort large parallel runs in opt mode... but we
  // do want to warn that they should be fixed.
  libmesh_assert(flags_were_consistent);
 
  if (!flags_were_consistent)
    libmesh_warning("Warning: Refinement flags were not consistent between processors! "
                    "Correcting and continuing.\n");
 
  // Smooth refinement flags
  _smooth_flags(true, false);
 
  // Now refine the flagged elements.  This will
  // take up some space, maybe more than what was freed.
  const bool mesh_changed =
    this->_refine_elements();
 
  if (_face_level_mismatch_limit)
    libmesh_assert(test_level_one(true));
  libmesh_assert(this->make_refinement_compatible());
 
  // FIXME: This won't pass unless we add a redundant find_neighbors()
  // call or replace find_neighbors() with on-the-fly neighbor updating
  // libmesh_assert(!this->eliminate_unrefined_patches());
 
  // Finally, the new mesh needs to be prepared for use
  if (mesh_changed)
    _mesh.prepare_for_use ();
 
  return mesh_changed;
}

References libMesh::libmesh_assert().

Referenced by DisjointNeighborTest::build_split_mesh_with_interface(), main(), libMesh::EquationSystems::reinit_solutions(), BoundaryInfoTest::testBoundaryOnChildrenBoundaryIDs(), BoundaryInfoTest::testBoundaryOnChildrenBoundarySides(), BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), SystemsTest::testProjectScalarCoarsening(), InfFERadialTest::testRefinement(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), and EquationSystemsTest::testSelectivePRefine().

◆ refine_fraction()

Real & libMesh::MeshRefinement::refine_fraction ( )

inline

The refine_fraction sets either a desired target or a desired maximum number of elements to flag for refinement, depending on which flag_elements_by method is called.

refine_fraction must be in \( [0,1] \), and is 0.3 by default.

Definition at line 888 of file mesh_refinement.h.

{
  _use_member_parameters = true;
  return _refine_fraction;
}

References _refine_fraction, and _use_member_parameters.

Referenced by assemble_and_solve(), and main().

◆ set_periodic_boundaries_ptr()

void libMesh::MeshRefinement::set_periodic_boundaries_ptr ( PeriodicBoundaries * pb_ptr )

Sets the PeriodicBoundaries pointer.

Referenced by main().

◆ switch_h_to_p_refinement()

void libMesh::MeshRefinement::switch_h_to_p_refinement ( )

Takes a mesh whose elements are flagged for h refinement and coarsening, and switches those flags to request p refinement and coarsening instead.

Definition at line 654 of file mesh_refinement_flagging.C.

{
  for (auto & elem : _mesh.element_ptr_range())
    {
      if (elem->active())
        {
          elem->set_p_refinement_flag(elem->refinement_flag());
          elem->set_refinement_flag(Elem::DO_NOTHING);
        }
      else
        {
          elem->set_p_refinement_flag(elem->refinement_flag());
          elem->set_refinement_flag(Elem::INACTIVE);
        }
    }
}

References _mesh, libMesh::Elem::DO_NOTHING, and libMesh::Elem::INACTIVE.

Referenced by main(), and EquationSystemsTest::testSelectivePRefine().

◆ test_level_one()

bool libMesh::MeshRefinement::test_level_one ( bool libmesh_assert_yes = false ) const

Returns: true if the mesh satisfies the level one restriction, and false otherwise.

Aborts the program if libmesh_assert_yes is true and the mesh does not satisfy the level one restriction.

Definition at line 359 of file mesh_refinement.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  // We may need a PointLocator for topological_neighbor() tests
  // later, which we need to make sure gets constructed on all
  // processors at once.
  std::unique_ptr<PointLocatorBase> point_locator;
 
#ifdef LIBMESH_ENABLE_PERIODIC
  bool has_periodic_boundaries =
    _periodic_boundaries && !_periodic_boundaries->empty();
  libmesh_assert(this->comm().verify(has_periodic_boundaries));
 
  if (has_periodic_boundaries)
    point_locator = _mesh.sub_point_locator();
#endif
 
  bool failure = false;
 
#ifndef NDEBUG
  Elem * failed_elem = nullptr;
  Elem * failed_neighbor = nullptr;
#endif // !NDEBUG
 
  for (auto & elem : _mesh.active_local_element_ptr_range())
    for (auto n : elem->side_index_range())
      {
        Elem * neighbor =
          topological_neighbor(elem, point_locator.get(), n);
 
        if (!neighbor || !neighbor->active() ||
            neighbor == remote_elem)
          continue;
 
        if ((neighbor->level() + 1 < elem->level()) ||
            (neighbor->p_level() + 1 < elem->p_level()) ||
            (neighbor->p_level() > elem->p_level() + 1))
          {
            failure = true;
#ifndef NDEBUG
            failed_elem = elem;
            failed_neighbor = neighbor;
#endif // !NDEBUG
            break;
          }
      }
 
  // If any processor failed, we failed globally
  this->comm().max(failure);
 
  if (failure)
    {
      // We didn't pass the level one test, so libmesh_assert that
      // we're allowed not to
#ifndef NDEBUG
      if (libmesh_assert_pass)
        {
          libMesh::out << "MeshRefinement Level one failure, element: "
                       << *failed_elem
                       << std::endl;
          libMesh::out << "MeshRefinement Level one failure, neighbor: "
                       << *failed_neighbor
                       << std::endl;
        }
#endif // !NDEBUG
      libmesh_assert(!libmesh_assert_pass);
      return false;
    }
  return true;
}

References libMesh::Elem::active(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::out, libMesh::Elem::p_level(), and libMesh::remote_elem.

◆ test_unflagged()

bool libMesh::MeshRefinement::test_unflagged ( bool libmesh_assert_yes = false ) const

Returns: true if the mesh has no elements flagged to be coarsened or refined, and false otherwise.

Aborts the program if libmesh_assert_yes is true and the mesh has flagged elements.

Definition at line 434 of file mesh_refinement.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  bool found_flag = false;
 
#ifndef NDEBUG
  Elem * failed_elem = nullptr;
#endif
 
  // Search for local flags
  for (auto & elem : _mesh.active_local_element_ptr_range())
    if (elem->refinement_flag() == Elem::REFINE ||
        elem->refinement_flag() == Elem::COARSEN ||
        elem->p_refinement_flag() == Elem::REFINE ||
        elem->p_refinement_flag() == Elem::COARSEN)
      {
        found_flag = true;
#ifndef NDEBUG
        failed_elem = elem;
#endif
        break;
      }
 
  // If we found a flag on any processor, it counts
  this->comm().max(found_flag);
 
  if (found_flag)
    {
#ifndef NDEBUG
      if (libmesh_assert_pass)
        {
          libMesh::out <<
            "MeshRefinement test_unflagged failure, element: " <<
            *failed_elem << std::endl;
        }
#endif
      // We didn't pass the "elements are unflagged" test,
      // so libmesh_assert that we're allowed not to
      libmesh_assert(!libmesh_assert_pass);
      return false;
    }
  return true;
}

References libMesh::libmesh_assert(), and libMesh::out.

◆ topological_neighbor()

Elem * libMesh::MeshRefinement::topological_neighbor	(	Elem *	elem,
		const PointLocatorBase *	point_locator,
		const unsigned int	side
	)		const

private

Local dispatch function for getting the correct topological neighbor from the Elem class.

Definition at line 1833 of file mesh_refinement.C.

{
#ifdef LIBMESH_ENABLE_PERIODIC
  if (_periodic_boundaries && !_periodic_boundaries->empty())
    {
      libmesh_assert(point_locator);
      return elem->topological_neighbor(side, _mesh, *point_locator, _periodic_boundaries);
    }
#endif
  return elem->neighbor_ptr(side);
}

References libMesh::libmesh_assert(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::topological_neighbor().

◆ underrefined_boundary_limit()

signed char & libMesh::MeshRefinement::underrefined_boundary_limit ( )

inline

If underrefined_boundary_limit is set to a nonnegative value, then refinement and coarsening will produce meshes in which the refinement level of an element is no more than that many levels greater than the level of any boundary elements on its sides.

If underrefined_boundary_limit is negative, then level differences will be unlimited.

underrefined_boundary_limit is 0 by default. This implies that adaptive coarsening can only be done on a boundary element if any interior elements it is on the side of are simultaneously coarsened.

Definition at line 944 of file mesh_refinement.h.

{
  return _underrefined_boundary_limit;
}

References _underrefined_boundary_limit.

Referenced by libMesh::EquationSystems::reinit_solutions().

◆ uniformly_coarsen()

void libMesh::MeshRefinement::uniformly_coarsen ( unsigned int n = 1 )

Attempts to uniformly coarsen the mesh n times.

Definition at line 1745 of file mesh_refinement.C.

{
  // Coarsen n times
  for (unsigned int rstep=0; rstep<n; rstep++)
    {
      // Clean up the refinement flags
      this->clean_refinement_flags();
 
      // Flag all the active elements for coarsening.
      for (auto & elem : _mesh.active_element_ptr_range())
        {
          elem->set_refinement_flag(Elem::COARSEN);
          if (elem->parent())
            elem->parent()->set_refinement_flag(Elem::COARSEN_INACTIVE);
        }
 
      // On a distributed mesh, we may have parent elements with
      // remote active children.  To keep flags consistent, we'll need
      // a communication step.
      if (!_mesh.is_replicated())
        {
          const processor_id_type n_proc = _mesh.n_processors();
          const processor_id_type my_proc_id = _mesh.processor_id();
 
          std::vector<std::vector<dof_id_type>>
            parents_to_coarsen(n_proc);
 
          for (const auto & elem : as_range(_mesh.ancestor_elements_begin(), _mesh.ancestor_elements_end()))
            if (elem->processor_id() != my_proc_id &&
                elem->refinement_flag() == Elem::COARSEN_INACTIVE)
              parents_to_coarsen[elem->processor_id()].push_back(elem->id());
 
          Parallel::MessageTag
            coarsen_tag = this->comm().get_unique_tag();
          std::vector<Parallel::Request> coarsen_push_requests(n_proc-1);
 
          for (processor_id_type p = 0; p != n_proc; ++p)
            {
              if (p == my_proc_id)
                continue;
 
              Parallel::Request &request =
                coarsen_push_requests[p - (p > my_proc_id)];
 
              _mesh.comm().send
                (p, parents_to_coarsen[p], request, coarsen_tag);
            }
 
          for (processor_id_type p = 1; p != n_proc; ++p)
            {
              std::vector<dof_id_type> my_parents_to_coarsen;
              _mesh.comm().receive
                (Parallel::any_source, my_parents_to_coarsen,
                 coarsen_tag);
 
              for (const auto & id : my_parents_to_coarsen)
                {
                  Elem & elem = _mesh.elem_ref(id);
                  libmesh_assert(elem.refinement_flag() == Elem::INACTIVE ||
                                 elem.refinement_flag() == Elem::COARSEN_INACTIVE);
                  elem.set_refinement_flag(Elem::COARSEN_INACTIVE);
                }
            }
 
          Parallel::wait(coarsen_push_requests);
 
          SyncRefinementFlags hsync(_mesh, &Elem::refinement_flag,
                                    &Elem::set_refinement_flag);
          sync_dofobject_data_by_id
            (this->comm(), _mesh.not_local_elements_begin(),
             _mesh.not_local_elements_end(),
             // We'd like a smaller sync, but this leads to bugs?
             // SyncCoarsenInactive(),
             hsync);
        }
 
      // Coarsen all the elements we just flagged.
      this->_coarsen_elements();
    }
 
 
  // Finally, the new mesh probably needs to be prepared for use
  if (n > 0)
    _mesh.prepare_for_use ();
}

References libMesh::as_range(), libMesh::libmesh_assert(), libMesh::Elem::refinement_flag(), and libMesh::Elem::set_refinement_flag().

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), and libMesh::PetscDMWrapper::init_petscdm().

◆ uniformly_p_coarsen()

void libMesh::MeshRefinement::uniformly_p_coarsen ( unsigned int n = 1 )

Attempts to uniformly p coarsen the mesh n times.

Definition at line 1705 of file mesh_refinement.C.

{
  // Coarsen p times
  for (unsigned int rstep=0; rstep<n; rstep++)
    for (auto & elem : _mesh.active_element_ptr_range())
      if (elem->p_level() > 0)
        {
          // P coarsen all the active elements
          elem->set_p_level(elem->p_level()-1);
          elem->set_p_refinement_flag(Elem::JUST_COARSENED);
        }
}

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), and libMesh::AdjointRefinementEstimator::estimate_error().

◆ uniformly_p_refine()

void libMesh::MeshRefinement::uniformly_p_refine ( unsigned int n = 1 )

Uniformly p refines the mesh n times.

Definition at line 1691 of file mesh_refinement.C.

{
  // Refine n times
  for (unsigned int rstep=0; rstep<n; rstep++)
    for (auto & elem : _mesh.active_element_ptr_range())
      {
        // P refine all the active elements
        elem->set_p_level(elem->p_level()+1);
        elem->set_p_refinement_flag(Elem::JUST_REFINED);
      }
}

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), and main().

◆ uniformly_refine()

void libMesh::MeshRefinement::uniformly_refine ( unsigned int n = 1 )

Uniformly refines the mesh n times.

Definition at line 1720 of file mesh_refinement.C.

{
  // Refine n times
  // FIXME - this won't work if n>1 and the mesh
  // has already been attached to an equation system
  for (unsigned int rstep=0; rstep<n; rstep++)
    {
      // Clean up the refinement flags
      this->clean_refinement_flags();
 
      // Flag all the active elements for refinement.
      for (auto & elem : _mesh.active_element_ptr_range())
        elem->set_refinement_flag(Elem::REFINE);
 
      // Refine all the elements we just flagged.
      this->_refine_elements();
    }
 
  // Finally, the new mesh probably needs to be prepared for use
  if (n > 0)
    _mesh.prepare_for_use ();
}

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), OverlappingTestBase::build_quad_mesh(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::PetscDMWrapper::init_petscdm(), main(), OverlappingFunctorTest::run_coupling_functor_test(), OverlappingFunctorTest::run_partitioner_test(), BoundaryRefinedMeshTest::setUp(), BoundaryOfRefinedMeshTest::setUp(), MixedDimensionRefinedMeshTest::setUp(), SlitMeshRefinedMeshTest::setUp(), SlitMeshRefinedSystemTest::setUp(), ExtraIntegersTest::test_helper(), ElemTest< elem_type >::test_n_refinements(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

◆ update_nodes_map()

void libMesh::MeshRefinement::update_nodes_map ( )

private

Updates the _new_nodes_map.

Definition at line 352 of file mesh_refinement.C.

{
  this->_new_nodes_map.init(_mesh);
}

Member Data Documentation

◆ _absolute_global_tolerance

Real libMesh::MeshRefinement::_absolute_global_tolerance

private

Definition at line 777 of file mesh_refinement.h.

Referenced by absolute_global_tolerance(), and flag_elements_by_error_tolerance().

◆ _allow_unrefined_patches

bool libMesh::MeshRefinement::_allow_unrefined_patches

private

Definition at line 786 of file mesh_refinement.h.

Referenced by allow_unrefined_patches(), and eliminate_unrefined_patches().

◆ _coarsen_by_parents

bool libMesh::MeshRefinement::_coarsen_by_parents

private

Refinement parameter values.

Definition at line 765 of file mesh_refinement.h.

Referenced by coarsen_by_parents(), flag_elements_by_elem_fraction(), flag_elements_by_error_fraction(), flag_elements_by_error_tolerance(), and flag_elements_by_nelem_target().

◆ _coarsen_fraction

Real libMesh::MeshRefinement::_coarsen_fraction

private

Definition at line 769 of file mesh_refinement.h.

Referenced by coarsen_fraction(), flag_elements_by_elem_fraction(), flag_elements_by_error_fraction(), flag_elements_by_error_tolerance(), flag_elements_by_mean_stddev(), and flag_elements_by_nelem_target().

◆ _coarsen_threshold

Real libMesh::MeshRefinement::_coarsen_threshold

private

Definition at line 773 of file mesh_refinement.h.

Referenced by coarsen_threshold(), flag_elements_by_error_tolerance(), and flag_elements_by_nelem_target().

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

◆ _edge_level_mismatch_limit

unsigned char libMesh::MeshRefinement::_edge_level_mismatch_limit

private

Definition at line 780 of file mesh_refinement.h.

Referenced by edge_level_mismatch_limit().

◆ _enforce_mismatch_limit_prior_to_refinement

bool libMesh::MeshRefinement::_enforce_mismatch_limit_prior_to_refinement

private

This option enforces the mismatch level prior to refinement by checking if refining any element marked for refinement would cause a mismatch greater than the limit.

Applies to all mismatch methods.

Calling this with node_level_mismatch_limit() = 1 would transform this mesh:

* o-------o-------o-------o-------o
* |       |       |       |       |
* |       |       |       |       |
* |       |       |       |       |
* |       |       |       |       |
* |       |       |       |       |
* o-------o---o---o-------o-------o
* |       |   :   |       |       |
* |       |   :   |       |       |
* |       o...o...o       |       |
* |       |   :   |       |       |
* |       |   :   |       |       |
* o-------o---o---o-------o-------o
* |       |       |               |
* |       |       |               |
* |       |       |               |
* |       |       |               |
* |       |       |               |
* o-------o-------o               |
* |       |       |               |
* |       |       |               |
* |       |       |               |
* |       |       |               |
* |       |       |               |
* o-------o-------o---------------o
*

into this:

* o-------o-------o-------o-------o
* |       |       |       |       |
* |       |       |       |       |
* |       |       |       |       |
* |       |       |       |       |
* |       |       |       |       |
* o-------o-------o-------o-------o
* |       |       |       |       |
* |       |       |       |       |
* |       |       |       |       |
* |       |       |       |       |
* |       |       |       |       |
* o-------o-------o-------o-------o
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* o-------o-------o.......o.......o
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* |       |       |       :       |
* o-------o-------o-------o-------o
*

by moving the refinement flag to the indicated element.

Default value is false.

Definition at line 856 of file mesh_refinement.h.

Referenced by enforce_mismatch_limit_prior_to_refinement(), enforce_mismatch_limit_prior_to_refinement(), enforce_mismatch_limit_prior_to_refinement(), enforce_mismatch_limit_prior_to_refinement(), limit_level_mismatch_at_edge(), and limit_level_mismatch_at_node().

◆ _face_level_mismatch_limit

unsigned char libMesh::MeshRefinement::_face_level_mismatch_limit

private

Definition at line 779 of file mesh_refinement.h.

Referenced by face_level_mismatch_limit().

◆ _max_h_level

unsigned int libMesh::MeshRefinement::_max_h_level

private

Definition at line 771 of file mesh_refinement.h.

Referenced by flag_elements_by_elem_fraction(), flag_elements_by_error_fraction(), flag_elements_by_error_tolerance(), flag_elements_by_mean_stddev(), flag_elements_by_nelem_target(), and max_h_level().

◆ _mesh

MeshBase& libMesh::MeshRefinement::_mesh

private

◆ _nelem_target

dof_id_type libMesh::MeshRefinement::_nelem_target

private

Definition at line 775 of file mesh_refinement.h.

Referenced by flag_elements_by_nelem_target(), and nelem_target().

◆ _new_nodes_map

TopologyMap libMesh::MeshRefinement::_new_nodes_map

private

Data structure that holds the new nodes information.

Definition at line 747 of file mesh_refinement.h.

Referenced by add_node(), and clear().

◆ _node_level_mismatch_limit

unsigned char libMesh::MeshRefinement::_node_level_mismatch_limit

private

Definition at line 781 of file mesh_refinement.h.

Referenced by node_level_mismatch_limit().

◆ _overrefined_boundary_limit

signed char libMesh::MeshRefinement::_overrefined_boundary_limit

private

Definition at line 783 of file mesh_refinement.h.

Referenced by overrefined_boundary_limit().

◆ _periodic_boundaries

PeriodicBoundaries* libMesh::MeshRefinement::_periodic_boundaries

private

Definition at line 873 of file mesh_refinement.h.

◆ _refine_fraction

Real libMesh::MeshRefinement::_refine_fraction

private

Definition at line 767 of file mesh_refinement.h.

Referenced by flag_elements_by_elem_fraction(), flag_elements_by_error_fraction(), flag_elements_by_error_tolerance(), flag_elements_by_mean_stddev(), flag_elements_by_nelem_target(), and refine_fraction().

◆ _underrefined_boundary_limit

signed char libMesh::MeshRefinement::_underrefined_boundary_limit

private

Definition at line 784 of file mesh_refinement.h.

Referenced by underrefined_boundary_limit().

◆ _use_member_parameters

bool libMesh::MeshRefinement::_use_member_parameters

private

For backwards compatibility, we initialize this as false and then set it to true if the user uses any of the refinement parameter accessor functions.

Definition at line 759 of file mesh_refinement.h.

Referenced by absolute_global_tolerance(), coarsen_by_parents(), coarsen_fraction(), coarsen_threshold(), flag_elements_by_elem_fraction(), flag_elements_by_error_fraction(), flag_elements_by_mean_stddev(), max_h_level(), nelem_target(), and refine_fraction().

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

Classes

Public Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ NeighborType

Constructor & Destructor Documentation

◆ MeshRefinement() [1/2]

◆ MeshRefinement() [2/2]

◆ ~MeshRefinement()

Member Function Documentation

◆ _coarsen_elements()

◆ _refine_elements()

◆ _smooth_flags()

◆ absolute_global_tolerance()

◆ add_elem() [1/2]

◆ add_elem() [2/2]

◆ add_node()

◆ add_p_to_h_refinement()

◆ allow_unrefined_patches()

◆ clean_refinement_flags()

◆ clear()

◆ coarsen_by_parents()

◆ coarsen_elements()

◆ coarsen_fraction()

◆ coarsen_threshold()

◆ comm()

◆ create_parent_error_vector()

◆ edge_level_mismatch_limit()

◆ eliminate_unrefined_patches()

◆ enforce_mismatch_limit_prior_to_refinement() [1/4]

◆ enforce_mismatch_limit_prior_to_refinement() [2/4]

◆ enforce_mismatch_limit_prior_to_refinement() [3/4]

◆ enforce_mismatch_limit_prior_to_refinement() [4/4]

◆ face_level_mismatch_limit()

◆ flag_elements_by()

◆ flag_elements_by_elem_fraction()

◆ flag_elements_by_error_fraction()

◆ flag_elements_by_error_tolerance()

◆ flag_elements_by_mean_stddev()

◆ flag_elements_by_nelem_target()

◆ get_mesh() [1/2]

◆ get_mesh() [2/2]

◆ has_topological_neighbor()

◆ limit_level_mismatch_at_edge()

◆ limit_level_mismatch_at_node()

◆ limit_overrefined_boundary()

◆ limit_underrefined_boundary()

◆ make_coarsening_compatible()

◆ make_flags_parallel_consistent()

◆ make_refinement_compatible()

◆ max_h_level()

◆ n_processors()

◆ nelem_target()

◆ node_level_mismatch_limit()

◆ operator=()

◆ overrefined_boundary_limit()

◆ processor_id()

◆ refine_and_coarsen_elements()

◆ refine_elements()

◆ refine_fraction()

◆ set_periodic_boundaries_ptr()

◆ switch_h_to_p_refinement()

◆ test_level_one()

◆ test_unflagged()

◆ topological_neighbor()

◆ underrefined_boundary_limit()

◆ uniformly_coarsen()

◆ uniformly_p_coarsen()

◆ uniformly_p_refine()

◆ uniformly_refine()

◆ update_nodes_map()

Member Data Documentation

◆ _absolute_global_tolerance

◆ _allow_unrefined_patches

◆ _coarsen_by_parents

◆ _coarsen_fraction