libMesh
Public Types | Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Static Protected Attributes | Private Attributes | List of all members
AugmentSparsityOnInterface Class Referenceabstract

#include <augment_sparsity_on_interface.h>

Inheritance diagram for AugmentSparsityOnInterface:
[legend]

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 ElementSideMapget_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) libmesh_override
 User-defined function to augment the sparsity pattern. More...
 
virtual void mesh_reinit () libmesh_override
 Rebuild the cached _lower_to_upper map whenever our Mesh has changed. More...
 
virtual void redistribute () libmesh_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

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.

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 140 of file ghosting_functor.h.

Constructor & Destructor Documentation

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.

References mesh_reinit().

11  :
12  _mesh(mesh),
13  _crack_boundary_lower(crack_boundary_lower),
14  _crack_boundary_upper(crack_boundary_upper),
15  _initialized(false)
16 {
17  this->mesh_reinit();
18 }
bool _initialized
Make sure we&#39;ve been initialized before use.
boundary_id_type _crack_boundary_lower
Boundary IDs for the lower and upper faces of the "crack" in the mesh.
virtual void mesh_reinit() libmesh_override
Rebuild the cached _lower_to_upper map whenever our Mesh has changed.
MeshBase & _mesh
The Mesh we&#39;re calculating on.

Member Function Documentation

virtual void libMesh::GhostingFunctor::delete_remote_elements ( )
virtualinherited

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 190 of file ghosting_functor.h.

Referenced by libMesh::MeshCommunication::delete_remote_elements().

190 {};
void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 107 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

108 {
109  _enable_print_counter = false;
110  return;
111 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
virtual void libMesh::GhostingFunctor::dofmap_reinit ( )
virtualinherited

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 171 of file ghosting_functor.h.

Referenced by libMesh::DofMap::distribute_dofs().

171 {};
void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 101 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

102 {
103  _enable_print_counter = true;
104  return;
105 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
std::string libMesh::ReferenceCounter::get_info ( )
staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (Counts::iterator it = _counts.begin();
59  it != _counts.end(); ++it)
60  {
61  const std::string name(it->first);
62  const unsigned int creations = it->second.first;
63  const unsigned int destructions = it->second.second;
64 
65  oss << "| " << name << " reference count information:\n"
66  << "| Creations: " << creations << '\n'
67  << "| Destructions: " << destructions << '\n';
68  }
69 
70  oss << " ---------------------------------------------------------------------------- \n";
71 
72  return oss.str();
73 
74 #else
75 
76  return "";
77 
78 #endif
79 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:39
static Counts _counts
Actually holds the data.
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.

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

Referenced by main().

21 {
23  return _lower_to_upper;
24 }
bool _initialized
Make sure we&#39;ve been initialized before use.
libmesh_assert(j)
ElementSideMap _lower_to_upper
A map from (lower element ID, side ID) to matching upper element ID.
void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name)
protectedinherited

Increments the construction counter.

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

Definition at line 185 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

186 {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189 
190  p.first++;
191 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:39
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:29
static Counts _counts
Actually holds the data.
void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name)
protectedinherited

Increments the destruction counter.

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

Definition at line 198 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

199 {
200  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
201  std::pair<unsigned int, unsigned int> & p = _counts[name];
202 
203  p.second++;
204 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:39
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:29
static Counts _counts
Actually holds the data.
void AugmentSparsityOnInterface::mesh_reinit ( )
virtual

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.

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(), libmesh_nullptr, std::max(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Real, side, and libMesh::TOLERANCE.

Referenced by AugmentSparsityOnInterface(), and redistribute().

27 {
28  this->_initialized = true;
29 
30  // Loop over all elements (not just local elements) to make sure we find
31  // "neighbor" elements on opposite sides of the crack.
32 
33  // Map from (elem, side) to centroid
34  std::map<std::pair<const Elem *, unsigned char>, Point> lower_centroids;
35  std::map<std::pair<const Elem *, unsigned char>, Point> upper_centroids;
36 
37  for (const auto & elem : _mesh.active_element_ptr_range())
38  for (auto side : elem->side_index_range())
39  if (elem->neighbor_ptr(side) == libmesh_nullptr)
40  {
42  {
43  UniquePtr<const Elem> side_elem = elem->build_side_ptr(side);
44 
45  lower_centroids[std::make_pair(elem, side)] = side_elem->centroid();
46  }
47 
49  {
50  UniquePtr<const Elem> side_elem = elem->build_side_ptr(side);
51 
52  upper_centroids[std::make_pair(elem, side)] = side_elem->centroid();
53  }
54  }
55 
56  // If we're doing a reinit on a distributed mesh then we may not see
57  // all the centroids, or even a matching number of centroids.
58  // std::size_t n_lower_centroids = lower_centroids.size();
59  // std::size_t n_upper_centroids = upper_centroids.size();
60  // libmesh_assert(n_lower_centroids == n_upper_centroids);
61 
62  // Clear _lower_to_upper. This map will be used for matrix assembly later on.
63  _lower_to_upper.clear();
64 
65  // Clear _upper_to_lower. This map will be used for element ghosting
66  // on distributed meshes, communication send_list construction in
67  // parallel, and sparsity calculations
68  _upper_to_lower.clear();
69 
70  // We do an N^2 search to find elements with matching centroids. This could be optimized,
71  // e.g. by first sorting the centroids based on their (x,y,z) location.
72  {
73  std::map<std::pair<const Elem *, unsigned char>, Point>::iterator it = lower_centroids.begin();
74  std::map<std::pair<const Elem *, unsigned char>, Point>::iterator it_end = lower_centroids.end();
75  for ( ; it != it_end; ++it)
76  {
77  Point lower_centroid = it->second;
78 
79  // find closest centroid in upper_centroids
80  Real min_distance = std::numeric_limits<Real>::max();
81 
82  std::map<std::pair<const Elem *, unsigned char>, Point>::iterator inner_it = upper_centroids.begin();
83  std::map<std::pair<const Elem *, unsigned char>, Point>::iterator inner_it_end = upper_centroids.end();
84 
85  for ( ; inner_it != inner_it_end; ++inner_it)
86  {
87  Point upper_centroid = inner_it->second;
88 
89  Real distance = (upper_centroid - lower_centroid).norm();
90  if (distance < min_distance)
91  {
92  min_distance = distance;
93  _lower_to_upper[it->first] = inner_it->first.first;
94  }
95  }
96 
97  // For pairs with local elements, we should have found a
98  // matching pair by now.
99  const Elem * elem = it->first.first;
100  const Elem * neighbor = _lower_to_upper[it->first];
101  if (min_distance < TOLERANCE)
102  {
103  // fill up the inverse map
104  _upper_to_lower[neighbor] = elem;
105  }
106  else
107  {
108  libmesh_assert_not_equal_to(elem->processor_id(), _mesh.processor_id());
109  // This must have a false positive; a remote element would
110  // have been closer.
111  _lower_to_upper.erase(it->first);
112  }
113  }
114 
115  // Let's make sure we didn't miss any upper elements either
116 #ifndef NDEBUG
117  std::map<std::pair<const Elem *, unsigned char>, Point>::iterator inner_it = upper_centroids.begin();
118  std::map<std::pair<const Elem *, unsigned char>, Point>::iterator inner_it_end = upper_centroids.end();
119 
120  for ( ; inner_it != inner_it_end; ++inner_it)
121  {
122  const Elem * neighbor = inner_it->first.first;
123  if (neighbor->processor_id() != _mesh.processor_id())
124  continue;
125  ElementMap::const_iterator utl_it =
126  _upper_to_lower.find(neighbor);
127  libmesh_assert(utl_it != _upper_to_lower.end());
128  }
129 #endif
130  }
131 }
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition: mesh_base.h:117
unsigned short int side
Definition: xdr_io.C:49
This is the base class from which all geometric element types are derived.
Definition: elem.h:89
const class libmesh_nullptr_t libmesh_nullptr
bool _initialized
Make sure we&#39;ve been initialized before use.
static const Real TOLERANCE
virtual SimpleRange< element_iterator > active_element_ptr_range()=0
long double max(long double a, double b)
Real distance(const Point &p)
libmesh_assert(j)
std::unique_ptr< T > UniquePtr
Definition: auto_ptr.h:46
boundary_id_type _crack_boundary_lower
Boundary IDs for the lower and upper faces of the "crack" in the mesh.
ElementMap _upper_to_lower
The inverse (ignoring sides) of the above map.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
bool has_boundary_id(const Node *const node, const boundary_id_type id) const
ElementSideMap _lower_to_upper
A map from (lower element ID, side ID) to matching upper element ID.
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition: point.h:38
MeshBase & _mesh
The Mesh we&#39;re calculating on.
processor_id_type processor_id() const
processor_id_type processor_id() const
Definition: dof_object.h:694
static unsigned int libMesh::ReferenceCounter::n_objects ( )
staticinherited
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 
)
virtual

User-defined function to augment the sparsity pattern.

Definition at line 134 of file augment_sparsity_on_interface.C.

References _initialized, _lower_to_upper, _upper_to_lower, libMesh::libmesh_assert(), libmesh_nullptr, libMesh::Elem::neighbor_ptr(), libMesh::DofObject::processor_id(), side, and libMesh::Elem::side_index_range().

138 {
140 
141  const CouplingMatrix * const null_mat = libmesh_nullptr;
142 
143  for (MeshBase::const_element_iterator elem_it = range_begin;
144  elem_it != range_end; ++elem_it)
145  {
146  const Elem * const elem = *elem_it;
147 
148  if (elem->processor_id() != p)
149  coupled_elements.insert (std::make_pair(elem, null_mat));
150 
151  for (auto side : elem->side_index_range())
152  if (elem->neighbor_ptr(side) == libmesh_nullptr)
153  {
154  ElementSideMap::const_iterator ltu_it =
155  _lower_to_upper.find(std::make_pair(elem, side));
156  if (ltu_it != _lower_to_upper.end())
157  {
158  const Elem * neighbor = ltu_it->second;
159  if (neighbor->processor_id() != p)
160  coupled_elements.insert (std::make_pair(neighbor, null_mat));
161  }
162  }
163 
164  ElementMap::const_iterator utl_it =
165  _upper_to_lower.find(elem);
166  if (utl_it != _upper_to_lower.end())
167  {
168  const Elem * neighbor = utl_it->second;
169  if (neighbor->processor_id() != p)
170  coupled_elements.insert (std::make_pair(neighbor, null_mat));
171  }
172 
173  }
174 }
The definition of the const_element_iterator struct.
Definition: mesh_base.h:1494
IntRange< unsigned short > side_index_range() const
Definition: elem.h:2083
unsigned short int side
Definition: xdr_io.C:49
This is the base class from which all geometric element types are derived.
Definition: elem.h:89
const class libmesh_nullptr_t libmesh_nullptr
bool _initialized
Make sure we&#39;ve been initialized before use.
libmesh_assert(j)
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:1967
ElementMap _upper_to_lower
The inverse (ignoring sides) of the above map.
ElementSideMap _lower_to_upper
A map from (lower element ID, side ID) to matching upper element ID.
processor_id_type processor_id() const
Definition: dof_object.h:694
This class defines a coupling matrix.
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, libMesh::SiblingCoupling, and libMesh::GhostPointNeighbors.

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

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

Definition at line 88 of file reference_counter.C.

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

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

89 {
91  out_stream << ReferenceCounter::get_info();
92 }
static std::string get_info()
Gets a string containing the reference information.
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
virtual void AugmentSparsityOnInterface::redistribute ( )
virtual

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.

References mesh_reinit().

83  { this->mesh_reinit(); }
virtual void mesh_reinit() libmesh_override
Rebuild the cached _lower_to_upper map whenever our Mesh has changed.

Member Data Documentation

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited
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().

boundary_id_type AugmentSparsityOnInterface::_crack_boundary_upper
private

Definition at line 43 of file augment_sparsity_on_interface.h.

Referenced by mesh_reinit().

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

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(), mesh_reinit(), and operator()().

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(), mesh_reinit(), and operator()().

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

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.

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(), and libMesh::ReferenceCounter::~ReferenceCounter().

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(), and operator()().


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