AugmentSparsityOnInterface Class Reference

#include <augment_sparsity_on_interface.h>

Inheritance diagram for AugmentSparsityOnInterface:

Public Types
typedef std::unordered_map< const Elem *, const CouplingMatrix * >	map_type
	What elements do we care about and what variables do we care about on each element? More...

Public Member Functions
	AugmentSparsityOnInterface (MeshBase &mesh, boundary_id_type crack_boundary_lower, boundary_id_type crack_boundary_upper)
	Constructor. More...
const ElementSideMap &	get_lower_to_upper () const
virtual void	operator() (const MeshBase::const_element_iterator &range_begin, const MeshBase::const_element_iterator &range_end, processor_id_type p, map_type &coupled_elements) override
	User-defined function to augment the sparsity pattern. More...
virtual void	mesh_reinit () override
	Rebuild the cached _lower_to_upper map whenever our Mesh has changed. More...
virtual void	redistribute () override
	Update the cached _lower_to_upper map whenever our Mesh has been redistributed. More...
virtual void	operator() (const MeshBase::const_element_iterator &range_begin, const MeshBase::const_element_iterator &range_end, processor_id_type p, map_type &coupled_elements)=0
	For the specified range of active elements, what other elements currently living (whether local or ghosted) on this processor need to be coupled/ghosted to accommodate them? Don't bother to return any results which already have processor_id p. More...
virtual void	dofmap_reinit ()
	For algebraic ghosting or coupling functors we also call dofmap_reinit() later, after dofs have been distributed on the new mesh but before the functors have been queried for send_list or sparsity pattern calculations. More...
virtual void	delete_remote_elements ()
	GhostingFunctor subclasses with relatively long-lasting caches may want to delete the no-longer-relevant parts of those caches after a redistribution is complete. More...

Static Public Member Functions
static std::string	get_info ()
	Gets a string containing the reference information. More...
static void	print_info (std::ostream &out=libMesh::out)
	Prints the reference information, by default to libMesh::out. More...
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects. More...
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info() More...
static void	disable_print_counter_info ()

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
	Data structure to log the information. More...

Protected Member Functions
void	increment_constructor_count (const std::string &name)
	Increments the construction counter. More...
void	increment_destructor_count (const std::string &name)
	Increments the destruction counter. More...

Static Protected Attributes
static Counts	_counts
	Actually holds the data. More...
static Threads::atomic< unsigned int >	_n_objects
	The number of objects. More...
static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting. More...
static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called. More...

Private Attributes
MeshBase &	_mesh
	The Mesh we're calculating on. More...
ElementSideMap	_lower_to_upper
	A map from (lower element ID, side ID) to matching upper element ID. More...
ElementMap	_upper_to_lower
	The inverse (ignoring sides) of the above map. More...
boundary_id_type	_crack_boundary_lower
	Boundary IDs for the lower and upper faces of the "crack" in the mesh. More...
boundary_id_type	_crack_boundary_upper
bool	_initialized
	Make sure we've been initialized before use. More...

Detailed Description

Definition at line 19 of file augment_sparsity_on_interface.h.

Member Typedef Documentation

Counts

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 117 of file reference_counter.h.

map_type

typedef std::unordered_map<const Elem*, const CouplingMatrix*> libMesh::GhostingFunctor::map_type

inherited

What elements do we care about and what variables do we care about on each element?

Definition at line 171 of file ghosting_functor.h.

Constructor & Destructor Documentation

AugmentSparsityOnInterface()

AugmentSparsityOnInterface::AugmentSparsityOnInterface	(	MeshBase &	mesh,
		boundary_id_type	crack_boundary_lower,
		boundary_id_type	crack_boundary_upper
	)

Constructor.

Definition at line 9 of file augment_sparsity_on_interface.C.

                                                                                              :
  _mesh(mesh),
  _crack_boundary_lower(crack_boundary_lower),
  _crack_boundary_upper(crack_boundary_upper),
  _initialized(false)
{
  this->mesh_reinit();
}

References mesh_reinit().

Member Function Documentation

delete_remote_elements()

virtual void libMesh::GhostingFunctor::delete_remote_elements ( )

inlinevirtualinherited

GhostingFunctor subclasses with relatively long-lasting caches may want to delete the no-longer-relevant parts of those caches after a redistribution is complete.

Reimplemented in libMesh::PointNeighborCoupling, and libMesh::DefaultCoupling.

Definition at line 221 of file ghosting_functor.h.

{};

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::LibMeshInit::LibMeshInit().

dofmap_reinit()

virtual void libMesh::GhostingFunctor::dofmap_reinit ( )

inlinevirtualinherited

For algebraic ghosting or coupling functors we also call dofmap_reinit() later, after dofs have been distributed on the new mesh but before the functors have been queried for send_list or sparsity pattern calculations.

Definition at line 202 of file ghosting_functor.h.

{};

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

Methods to enable/disable the reference counter output from print_info()

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

get_info()

std::string libMesh::ReferenceCounter::get_info ( )

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & pr : _counts)
    {
      const std::string name(pr.first);
      const unsigned int creations    = pr.second.first;
      const unsigned int destructions = pr.second.second;
 
      oss << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

get_lower_to_upper()

const ElementSideMap & AugmentSparsityOnInterface::get_lower_to_upper

(

)

const

Returns

a const reference to the lower-to-upper element ID map.

Definition at line 20 of file augment_sparsity_on_interface.C.

{
  libmesh_assert(this->_initialized);
  return _lower_to_upper;
}

References _initialized, _lower_to_upper, and libMesh::libmesh_assert().

Referenced by main().

increment_constructor_count()

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name )

inlineprotectedinherited

Increments the construction counter.

Should be called in the constructor of any derived class that will be reference counted.

Definition at line 181 of file reference_counter.h.

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int> & p = _counts[name];
 
  p.first++;
}

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

increment_destructor_count()

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name )

inlineprotectedinherited

Increments the destruction counter.

Should be called in the destructor of any derived class that will be reference counted.

Definition at line 194 of file reference_counter.h.

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int> & p = _counts[name];
 
  p.second++;
}

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

mesh_reinit()

void AugmentSparsityOnInterface::mesh_reinit ( )

overridevirtual

Rebuild the cached _lower_to_upper map whenever our Mesh has changed.

Reimplemented from libMesh::GhostingFunctor.

Definition at line 26 of file augment_sparsity_on_interface.C.

{
  this->_initialized = true;
 
  // Loop over all elements (not just local elements) to make sure we find
  // "neighbor" elements on opposite sides of the crack.
 
  // Map from (elem, side) to centroid
  std::map<std::pair<const Elem *, unsigned char>, Point> lower_centroids;
  std::map<std::pair<const Elem *, unsigned char>, Point> upper_centroids;
 
  for (const auto & elem : _mesh.active_element_ptr_range())
    for (auto side : elem->side_index_range())
      if (elem->neighbor_ptr(side) == nullptr)
        {
          if (_mesh.get_boundary_info().has_boundary_id(elem, side, _crack_boundary_lower))
            {
              std::unique_ptr<const Elem> side_elem = elem->build_side_ptr(side);
 
              lower_centroids[std::make_pair(elem, side)] = side_elem->centroid();
            }
 
          if (_mesh.get_boundary_info().has_boundary_id(elem, side, _crack_boundary_upper))
            {
              std::unique_ptr<const Elem> side_elem = elem->build_side_ptr(side);
 
              upper_centroids[std::make_pair(elem, side)] = side_elem->centroid();
            }
        }
 
  // If we're doing a reinit on a distributed mesh then we may not see
  // all the centroids, or even a matching number of centroids.
  // std::size_t n_lower_centroids = lower_centroids.size();
  // std::size_t n_upper_centroids = upper_centroids.size();
  // libmesh_assert(n_lower_centroids == n_upper_centroids);
 
  // Clear _lower_to_upper. This map will be used for matrix assembly later on.
  _lower_to_upper.clear();
 
  // Clear _upper_to_lower. This map will be used for element ghosting
  // on distributed meshes, communication send_list construction in
  // parallel, and sparsity calculations
  _upper_to_lower.clear();
 
  // We do an N^2 search to find elements with matching centroids. This could be optimized,
  // e.g. by first sorting the centroids based on their (x,y,z) location.
  {
    std::map<std::pair<const Elem *, unsigned char>, Point>::iterator it     = lower_centroids.begin();
    std::map<std::pair<const Elem *, unsigned char>, Point>::iterator it_end = lower_centroids.end();
    for ( ; it != it_end; ++it)
      {
        Point lower_centroid = it->second;
 
        // find closest centroid in upper_centroids
        Real min_distance = std::numeric_limits<Real>::max();
 
        std::map<std::pair<const Elem *, unsigned char>, Point>::iterator inner_it     = upper_centroids.begin();
        std::map<std::pair<const Elem *, unsigned char>, Point>::iterator inner_it_end = upper_centroids.end();
 
        for ( ; inner_it != inner_it_end; ++inner_it)
          {
            Point upper_centroid = inner_it->second;
 
            Real distance = (upper_centroid - lower_centroid).norm();
            if (distance < min_distance)
              {
                min_distance = distance;
                _lower_to_upper[it->first] = inner_it->first.first;
              }
          }
 
        // For pairs with local elements, we should have found a
        // matching pair by now.
        const Elem * elem     = it->first.first;
        const Elem * neighbor = _lower_to_upper[it->first];
        if (min_distance < TOLERANCE)
          {
            // fill up the inverse map
            _upper_to_lower[neighbor] = elem;
          }
        else
          {
            libmesh_assert_not_equal_to(elem->processor_id(), _mesh.processor_id());
            // This must have a false positive; a remote element would
            // have been closer.
            _lower_to_upper.erase(it->first);
          }
      }
 
    // Let's make sure we didn't miss any upper elements either
#ifndef NDEBUG
    std::map<std::pair<const Elem *, unsigned char>, Point>::iterator inner_it     = upper_centroids.begin();
    std::map<std::pair<const Elem *, unsigned char>, Point>::iterator inner_it_end = upper_centroids.end();
 
    for ( ; inner_it != inner_it_end; ++inner_it)
      {
        const Elem * neighbor = inner_it->first.first;
        if (neighbor->processor_id() != _mesh.processor_id())
          continue;
        ElementMap::const_iterator utl_it =
          _upper_to_lower.find(neighbor);
        libmesh_assert(utl_it != _upper_to_lower.end());
      }
#endif
  }
}

References _crack_boundary_lower, _crack_boundary_upper, _initialized, _lower_to_upper, _mesh, _upper_to_lower, libMesh::MeshBase::active_element_ptr_range(), distance(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::has_boundary_id(), libMesh::libmesh_assert(), std::norm(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Real, and libMesh::TOLERANCE.

Referenced by AugmentSparsityOnInterface(), and redistribute().

n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )

inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 83 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

operator()() [1/2]

void AugmentSparsityOnInterface::operator() ( const MeshBase::const_element_iterator &  range_begin, const MeshBase::const_element_iterator &  range_end, processor_id_type  p, map_type &  coupled_elements  )

overridevirtual

User-defined function to augment the sparsity pattern.

Definition at line 134 of file augment_sparsity_on_interface.C.

{
  libmesh_assert(this->_initialized);
 
  const CouplingMatrix * const null_mat = nullptr;
 
  for (const auto & elem : as_range(range_begin, range_end))
    {
      if (elem->processor_id() != p)
        coupled_elements.insert (std::make_pair(elem, null_mat));
 
      for (auto side : elem->side_index_range())
        if (elem->neighbor_ptr(side) == nullptr)
          {
            ElementSideMap::const_iterator ltu_it =
              _lower_to_upper.find(std::make_pair(elem, side));
            if (ltu_it != _lower_to_upper.end())
              {
                const Elem * neighbor = ltu_it->second;
                if (neighbor->processor_id() != p)
                  coupled_elements.insert (std::make_pair(neighbor, null_mat));
              }
          }
 
      ElementMap::const_iterator utl_it =
        _upper_to_lower.find(elem);
      if (utl_it != _upper_to_lower.end())
        {
          const Elem * neighbor = utl_it->second;
          if (neighbor->processor_id() != p)
            coupled_elements.insert (std::make_pair(neighbor, null_mat));
        }
 
    }
}

References libMesh::as_range(), libMesh::libmesh_assert(), and libMesh::DofObject::processor_id().

operator()() [2/2]

virtual void libMesh::GhostingFunctor::operator() ( const MeshBase::const_element_iterator &  range_begin, const MeshBase::const_element_iterator &  range_end, processor_id_type  p, map_type &  coupled_elements  )

pure virtualinherited

For the specified range of active elements, what other elements currently living (whether local or ghosted) on this processor need to be coupled/ghosted to accommodate them? Don't bother to return any results which already have processor_id p.

This API is new, and we should replace "ignoring those on processor p" with "ignoring those which match a predicate functor" eventually.

Implemented in libMesh::DefaultCoupling, libMesh::PointNeighborCoupling, AugmentSparsityOnNodes, libMesh::SiblingCoupling, and libMesh::GhostPointNeighbors.

print_info()

void libMesh::ReferenceCounter::print_info ( std::ostream &  out = libMesh::out )

staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 87 of file reference_counter.C.

{
  if (_enable_print_counter)
    out_stream << ReferenceCounter::get_info();
}

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

redistribute()

virtual void AugmentSparsityOnInterface::redistribute ( )

inlineoverridevirtual

Update the cached _lower_to_upper map whenever our Mesh has been redistributed.

We'll be lazy and just recalculate from scratch.

Reimplemented from libMesh::GhostingFunctor.

Definition at line 82 of file augment_sparsity_on_interface.h.

  { this->mesh_reinit(); }

References mesh_reinit().

Member Data Documentation

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

_crack_boundary_lower

boundary_id_type AugmentSparsityOnInterface::_crack_boundary_lower

private

Boundary IDs for the lower and upper faces of the "crack" in the mesh.

Definition at line 43 of file augment_sparsity_on_interface.h.

Referenced by mesh_reinit().

_crack_boundary_upper

boundary_id_type AugmentSparsityOnInterface::_crack_boundary_upper

private

Definition at line 43 of file augment_sparsity_on_interface.h.

Referenced by mesh_reinit().

_enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 141 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

_initialized

bool AugmentSparsityOnInterface::_initialized

private

Make sure we've been initialized before use.

Definition at line 48 of file augment_sparsity_on_interface.h.

Referenced by get_lower_to_upper(), and mesh_reinit().

_lower_to_upper

ElementSideMap AugmentSparsityOnInterface::_lower_to_upper

private

A map from (lower element ID, side ID) to matching upper element ID.

Here "lower" and "upper" refer to the lower and upper (wrt +z direction) sides of the crack in our mesh.

Definition at line 33 of file augment_sparsity_on_interface.h.

Referenced by get_lower_to_upper(), and mesh_reinit().

_mesh

MeshBase& AugmentSparsityOnInterface::_mesh

private

The Mesh we're calculating on.

Definition at line 26 of file augment_sparsity_on_interface.h.

Referenced by mesh_reinit().

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 of file reference_counter.h.

_n_objects

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects

staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 130 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

_upper_to_lower

ElementMap AugmentSparsityOnInterface::_upper_to_lower

private

The inverse (ignoring sides) of the above map.

Definition at line 38 of file augment_sparsity_on_interface.h.

Referenced by mesh_reinit().

---

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

• examples/miscellaneous/miscellaneous_ex9/augment_sparsity_on_interface.h
• examples/miscellaneous/miscellaneous_ex9/augment_sparsity_on_interface.C