libMesh::Patch Class Reference

#include <patch.h>

Inheritance diagram for libMesh::Patch:

Public Types
typedef void(Patch::*	PMF) ()

Public Member Functions
	Patch (const processor_id_type my_procid=static_cast< processor_id_type >(-1))
	~Patch ()
void	add_face_neighbors ()
void	add_local_face_neighbors ()
void	add_semilocal_face_neighbors ()
void	add_point_neighbors ()
void	add_local_point_neighbors ()
void	add_semilocal_point_neighbors ()
void	build_around_element (const Elem *elem, const unsigned int target_patch_size=10, PMF patchtype=&Patch::add_local_face_neighbors)

Protected Member Functions
void	find_face_neighbors (std::set< const Elem *> &neighbor_set)
void	find_point_neighbors (std::set< const Elem *> &neighbor_set)

Protected Attributes
const processor_id_type	_my_procid

Detailed Description

This class implements useful utility functions for a patch of elements

Author

Varis Carey

Benjamin S. Kirk

Date

2004

Author

Roy H. Stogner

Date

2007

Definition at line 47 of file patch.h.

Member Typedef Documentation

PMF

typedef void(Patch::* libMesh::Patch::PMF) ()

Pointer to Member Function typedef

Definition at line 104 of file patch.h.

Constructor & Destructor Documentation

Patch()

libMesh::Patch::Patch ( const processor_id_type  my_procid = static_cast<processor_id_type>(-1) )

inline

Constructor. Requires the processor ID to be interpreted as "local".

Definition at line 54 of file patch.h.

                                                                                :
    _my_procid(my_procid)
  {}

~Patch()

libMesh::Patch::~Patch ( )

inline

Destructor.

Definition at line 61 of file patch.h.

{}

Member Function Documentation

add_face_neighbors()

void libMesh::Patch::add_face_neighbors

(

)

This function finds all elements which touch the current patch at a face, and adds them to the patch.

Definition at line 64 of file patch.C.

References find_face_neighbors().

{
  std::set<const Elem *> new_neighbors;

  this->find_face_neighbors(new_neighbors);

  this->insert(new_neighbors.begin(), new_neighbors.end());
}

add_local_face_neighbors()

void libMesh::Patch::add_local_face_neighbors

(

)

This function finds all elements on the current processor which touch the current patch at a face, and adds them to the patch.

Definition at line 75 of file patch.C.

References _my_procid, and find_face_neighbors().

Referenced by build_around_element().

{
  std::set<const Elem *> new_neighbors;

  this->find_face_neighbors(new_neighbors);

  // if neighbor belongs to this processor then add it to the patch
  for (const auto & neighbor : new_neighbors)
    if (neighbor->processor_id() == _my_procid)
      this->insert (neighbor);
}

add_local_point_neighbors()

void libMesh::Patch::add_local_point_neighbors

(

)

This function finds all elements on the current processor which touch the current patch at any point, and adds them to the patch.

Definition at line 129 of file patch.C.

References _my_procid, and find_point_neighbors().

Referenced by build_around_element().

{
  std::set<const Elem *> new_neighbors;

  this->find_point_neighbors(new_neighbors);

  // if neighbor belongs to this processor then add it to the patch
  for (const auto & neighbor : new_neighbors)
    if (neighbor->processor_id() == _my_procid)
      this->insert (neighbor);
}

add_point_neighbors()

void libMesh::Patch::add_point_neighbors

(

)

This function finds all elements which touch the current patch at any point, and adds them to the patch.

Definition at line 118 of file patch.C.

References find_point_neighbors().

{
  std::set<const Elem *> new_neighbors;

  this->find_point_neighbors(new_neighbors);

  this->insert(new_neighbors.begin(), new_neighbors.end());
}

add_semilocal_face_neighbors()

void libMesh::Patch::add_semilocal_face_neighbors

(

)

This function finds all elements which touch the current patch at a face and which touch one of our processor's elements at any point, and it adds them to the patch.

Definition at line 89 of file patch.C.

References _my_procid, and find_face_neighbors().

{
  std::set<const Elem *> new_neighbors;

  this->find_face_neighbors(new_neighbors);

  for (const auto & neighbor : new_neighbors)
    if (neighbor->is_semilocal(_my_procid))
      this->insert (neighbor);
}

add_semilocal_point_neighbors()

void libMesh::Patch::add_semilocal_point_neighbors

(

)

This function finds all elements which touch the current patch at any point and which touch one of our processor's elements at any point, and it adds them to the patch.

Definition at line 143 of file patch.C.

References _my_procid, and find_point_neighbors().

{
  std::set<const Elem *> new_neighbors;

  this->find_point_neighbors(new_neighbors);

  for (const auto & neighbor : new_neighbors)
    if (neighbor->is_semilocal(_my_procid))
      this->insert (neighbor);
}

build_around_element()

void libMesh::Patch::build_around_element	(	const Elem *	elem,
		const unsigned int	target_patch_size = 10,
		PMF	patchtype = &Patch::add_local_face_neighbors
	)

Erases any elements in the current patch, then builds a new patch containing element elem by repeated addition of neighbors on the current processor. This procedure is repeated until the number of elements meets or exceeds target_patch_size, or until the patch has no more local neighbors.

Definition at line 156 of file patch.C.

References _my_procid, libMesh::Elem::active(), add_local_face_neighbors(), add_local_point_neighbors(), libMesh::err, and libMesh::DofObject::processor_id().

Referenced by libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), and libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()().

{

  // Make sure we are building a patch for an active element.
  libmesh_assert(e0);
  libmesh_assert (e0->active());
  // Make sure we are either starting with a local element or
  // requesting a nonlocal patch
  libmesh_assert ((patchtype != &Patch::add_local_face_neighbors &&
                   patchtype != &Patch::add_local_point_neighbors) ||
                  e0->processor_id() == _my_procid);

  // First clear the current set, then add the element of interest.
  this->clear();
  this->insert (e0);

  // Repeatedly add the neighbors of the elements in the patch until
  // the target patch size is met
  while (this->size() < target_patch_size)
    {
      // It is possible that the target patch size is larger than the number
      // of elements that can be added to the patch.  Since we don't
      // have access to the Mesh object here, the only way we can
      // detect this case is by detecting a "stagnant patch," i.e. a
      // patch whose size does not increase after adding face neighbors
      const std::size_t old_patch_size = this->size();

      // We profile the patch-extending functions separately
      (this->*patchtype)();

      // Check for a "stagnant" patch
      if (this->size() == old_patch_size)
        {
          libmesh_do_once(libMesh::err <<
                          "WARNING: stagnant patch of " << this->size() << " elements."
                          << std::endl <<
                          "Does the target patch size exceed the number of local elements?"
                          << std::endl;
                          libmesh_here(););
          break;
        }
    } // end while loop


  // make sure all the elements in the patch are active and local
  // if we are in debug mode
#ifdef DEBUG
    for (const auto & elem : *this)
      {
        libmesh_assert (elem->active());
        if ((patchtype == &Patch::add_local_face_neighbors ||
             patchtype == &Patch::add_local_point_neighbors))
          libmesh_assert_equal_to (elem->processor_id(), _my_procid);
      }
#endif

}

find_face_neighbors()

void libMesh::Patch::find_face_neighbors ( std::set< const Elem *> &  neighbor_set )

protected

This function finds all elements which touch the current patch at a face

Definition at line 37 of file patch.C.

Referenced by add_face_neighbors(), add_local_face_neighbors(), and add_semilocal_face_neighbors().

{
  // Loop over all the elements in the patch
  for (const auto & elem : *this)
      for (auto neighbor : elem->neighbor_ptr_range())
        if (neighbor != nullptr)        // we have a neighbor on this side
          {
#ifdef LIBMESH_ENABLE_AMR
            if (!neighbor->active())          // the neighbor is *not* active,
              {                               // so add *all* neighboring
                                              // active children to the patch
                std::vector<const Elem *> active_neighbor_children;

                neighbor->active_family_tree_by_neighbor
                  (active_neighbor_children, elem);

                for (const auto & child : active_neighbor_children)
                  new_neighbors.insert(child);
              }
            else
#endif // #ifdef LIBMESH_ENABLE_AMR
              new_neighbors.insert (neighbor); // add active neighbors
          }
}

find_point_neighbors()

void libMesh::Patch::find_point_neighbors ( std::set< const Elem *> &  neighbor_set )

protected

This function finds all elements which touch the current patch at any point

Definition at line 102 of file patch.C.

Referenced by add_local_point_neighbors(), add_point_neighbors(), and add_semilocal_point_neighbors().

{
  // Loop over all the elements in the patch
  for (const auto & elem : *this)
    {
      std::set<const Elem *> elem_point_neighbors;

      elem->find_point_neighbors(elem_point_neighbors);

      new_neighbors.insert(elem_point_neighbors.begin(),
                           elem_point_neighbors.end());
    }
}

Member Data Documentation

_my_procid

const processor_id_type libMesh::Patch::_my_procid

protected

Definition at line 131 of file patch.h.

Referenced by add_local_face_neighbors(), add_local_point_neighbors(), add_semilocal_face_neighbors(), add_semilocal_point_neighbors(), and build_around_element().

---

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

• patch.h
• patch.C