AugmentSparsityOnInterface Class Reference

#include <augment_sparsity_on_interface.h>

Inheritance diagram for AugmentSparsityOnInterface:

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

Public Member Functions
	AugmentSparsityOnInterface (MeshBase &mesh, boundary_id_type crack_boundary_lower, boundary_id_type crack_boundary_upper)
	Constructor.
virtual std::unique_ptr< GhostingFunctor >	clone () const override
	A clone() is needed because GhostingFunctor can not be shared between different meshes.
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.
virtual void	mesh_reinit () override
	Rebuild the cached _lower_to_upper map whenever our Mesh has changed.
virtual void	redistribute () override
	Update the cached _lower_to_upper map whenever our Mesh has been redistributed.
virtual void	set_mesh (const MeshBase *mesh)
	It should be called after cloning a ghosting functor.
virtual void	set_periodic_boundaries (const PeriodicBoundaries *)
const MeshBase *	get_mesh () const
	Return the mesh associated with ghosting functor.
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.
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.
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.

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

Public Attributes
return	nullptr { libmesh_deprecated()

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

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

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

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

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 119 of file reference_counter.h.

map_type

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

inherited

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

Definition at line 243 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 11 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

clone()

virtual std::unique_ptr< GhostingFunctor > AugmentSparsityOnInterface::clone ( ) const

inlineoverridevirtual

A clone() is needed because GhostingFunctor can not be shared between different meshes.

The operations in GhostingFunctor are mesh dependent.

Implements libMesh::GhostingFunctor.

Definition at line 60 of file augment_sparsity_on_interface.h.

  {
    return std::make_unique<AugmentSparsityOnInterface>
      (_mesh, _crack_boundary_lower, _crack_boundary_upper);
  }

References _crack_boundary_lower, _crack_boundary_upper, and _mesh.

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::DefaultCoupling, libMesh::GhostPointNeighbors, libMesh::NonManifoldGhostingFunctor, libMesh::OverlapCoupling, and libMesh::PointNeighborCoupling.

Definition at line 293 of file ghosting_functor.h.

{};

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

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 & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

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

get_mesh()

const MeshBase * libMesh::GhostingFunctor::get_mesh ( ) const

inlineinherited

Return the mesh associated with ghosting functor.

Definition at line 237 of file ghosting_functor.h.

{ libmesh_assert(_mesh); return _mesh; }

References libMesh::GhostingFunctor::_mesh, and libMesh::libmesh_assert().

increment_constructor_count()

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

increment_destructor_count()

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< T >::~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 28 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 vertex average
  std::map<std::pair<const Elem *, unsigned char>, Point> lower;
  std::map<std::pair<const Elem *, unsigned char>, Point> upper;
 
  // To avoid extraneous allocation when getting element side vertex averages
  std::unique_ptr<const Elem> side_elem;
 
  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))
            {
              elem->build_side_ptr(side_elem, side);
 
              lower[std::make_pair(elem, side)] = side_elem->vertex_average();
            }
 
          if (_mesh.get_boundary_info().has_boundary_id(elem, side, _crack_boundary_upper))
            {
              elem->build_side_ptr(side_elem, side);
 
              upper[std::make_pair(elem, side)] = side_elem->vertex_average();
            }
        }
 
  // If we're doing a reinit on a distributed mesh then we may not see
  // all the vertex averages, or even a matching number of vertex averages.
  // std::size_t n_lower = lower.size();
  // std::size_t n_upper = upper.size();
  // libmesh_assert(n_lower == n_upper);
 
  // 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 vertex averages. This could be optimized,
  // e.g. by first sorting the vertex averages based on their (x,y,z) location.
  {
    for (const auto & [lower_key, lower_val] : lower)
      {
        // find closest vertex average in upper
        Real min_distance = std::numeric_limits<Real>::max();
 
        for (const auto & [upper_key, upper_val] : upper)
          {
            Real distance = (upper_val - lower_val).norm();
            if (distance < min_distance)
              {
                min_distance = distance;
                _lower_to_upper[lower_key] = upper_key.first;
              }
          }
 
        // For pairs with local elements, we should have found a
        // matching pair by now.
        const Elem * elem     = lower_key.first;
        const Elem * neighbor = _lower_to_upper[lower_key];
        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(lower_key);
          }
      }
 
    // Let's make sure we didn't miss any upper elements either
#ifndef NDEBUG
    for (const auto & upper_pr : upper)
      {
        const Elem * neighbor = upper_pr.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, distance(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::has_boundary_id(), libMesh::libmesh_assert(), libMesh::DofObject::processor_id(), libMesh::ParallelObject::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 85 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

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

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 126 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.emplace(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.emplace(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.emplace(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::GhostPointNeighbors, libMesh::NonManifoldGhostingFunctor, libMesh::OverlapCoupling, libMesh::PointNeighborCoupling, libMesh::SiblingCoupling, OverlappingCouplingFunctor, and AugmentSparsityOnNodes.

print_info()

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

staticinherited

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

Definition at line 81 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().

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

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 89 of file augment_sparsity_on_interface.h.

  { this->mesh_reinit(); }

References mesh_reinit().

set_mesh()

virtual void libMesh::GhostingFunctor::set_mesh ( const MeshBase *  mesh )

inlinevirtualinherited

It should be called after cloning a ghosting functor.

Ghosting functor is mesh dependent

Definition at line 227 of file ghosting_functor.h.

{ _mesh = mesh; }

References libMesh::GhostingFunctor::_mesh, and mesh.

Referenced by libMesh::DofMap::add_algebraic_ghosting_functor(), and libMesh::DofMap::add_coupling_functor().

set_periodic_boundaries()

virtual void libMesh::GhostingFunctor::set_periodic_boundaries ( const PeriodicBoundaries *  )

inlinevirtualinherited

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

Definition at line 231 of file ghosting_functor.h.

{}

Member Data Documentation

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

_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 clone(), and 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 clone(), and 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 143 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 clone(), and mesh_reinit().

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 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 132 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), 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().

nullptr

return libMesh::GhostingFunctor::nullptr { libmesh_deprecated()

inherited

Definition at line 220 of file ghosting_functor.h.

---

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