libMesh::PointNeighborCoupling Class Reference

#include <point_neighbor_coupling.h>

Inheritance diagram for libMesh::PointNeighborCoupling:

Public Types

typedef LIBMESH_BEST_UNORDERED_MAP< const Elem *, const CouplingMatrix * > map_type
 

Public Member Functions

 PointNeighborCoupling ()
 
void set_dof_coupling (const CouplingMatrix *dof_coupling)
 
unsigned int n_levels ()
 
void set_n_levels (unsigned int n_levels)
 
void set_periodic_boundaries (const PeriodicBoundaries *periodic_bcs)
 
void set_mesh (const MeshBase *mesh)
 
virtual void mesh_reinit () libmesh_override
 
virtual void redistribute () libmesh_override
 
virtual void delete_remote_elements () libmesh_override
 
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
 
virtual void dofmap_reinit ()
 

Static Public Member Functions

static std::string get_info ()
 
static void print_info (std::ostream &out=libMesh::out)
 
static unsigned int n_objects ()
 
static void enable_print_counter_info ()
 
static void disable_print_counter_info ()
 

Protected Types

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

Protected Member Functions

void increment_constructor_count (const std::string &name)
 
void increment_destructor_count (const std::string &name)
 

Static Protected Attributes

static Counts _counts
 
static Threads::atomic< unsigned int > _n_objects
 
static Threads::spin_mutex _mutex
 
static bool _enable_print_counter = true
 

Private Attributes

const CouplingMatrix_dof_coupling
 
const PeriodicBoundaries_periodic_bcs
 
const MeshBase_mesh
 
unsigned int _n_levels
 

Detailed Description

This class implements the default algebraic coupling in libMesh: elements couple to themselves, but may also couple to neighbors both locally and across periodic boundary conditions.

Author
Roy H. Stogner
Date
2016

Definition at line 41 of file point_neighbor_coupling.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 110 of file reference_counter.h.

typedef LIBMESH_BEST_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

libMesh::PointNeighborCoupling::PointNeighborCoupling ( )
inline

Constructor.

Definition at line 48 of file point_neighbor_coupling.h.

48  :
50 #ifdef LIBMESH_ENABLE_PERIODIC
52 #endif
54  _n_levels(0)
55  {}
const class libmesh_nullptr_t libmesh_nullptr
const PeriodicBoundaries * _periodic_bcs

Member Function Documentation

virtual void libMesh::PointNeighborCoupling::delete_remote_elements ( )
inlinevirtual

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 from libMesh::GhostingFunctor.

Definition at line 90 of file point_neighbor_coupling.h.

References mesh_reinit(), and operator()().

91  { this->mesh_reinit(); }
virtual void mesh_reinit() libmesh_override
void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited
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 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 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

101 {
102  _enable_print_counter = true;
103  return;
104 }
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)
Definition: elem_quality.C:39
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 160 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().

161 {
162  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
163  std::pair<unsigned int, unsigned int> & p = _counts[name];
164 
165  p.first++;
166 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
spin_mutex spin_mtx
Definition: threads.C:29
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 173 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().

174 {
175  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
176  std::pair<unsigned int, unsigned int> & p = _counts[name];
177 
178  p.second++;
179 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
spin_mutex spin_mtx
Definition: threads.C:29
void libMesh::PointNeighborCoupling::mesh_reinit ( )
virtual

If we have periodic boundaries, then we'll need the mesh to have an updated point locator whenever we're about to query them.

Reimplemented from libMesh::GhostingFunctor.

Definition at line 33 of file point_neighbor_coupling.C.

References _mesh, _periodic_bcs, libMesh::libmesh_assert(), and libMesh::MeshBase::sub_point_locator().

Referenced by delete_remote_elements(), redistribute(), and set_mesh().

34 {
35  // Unless we have periodic boundary conditions, we don't need
36  // anything precomputed.
37 #ifdef LIBMESH_ENABLE_PERIODIC
38  if (_periodic_bcs && !_periodic_bcs->empty())
39 #endif
40  {
41  // If we do have periodic boundary conditions, we'll need a master
42  // point locator, so we'd better have a mesh to build it on.
44 
45  // Make sure an up-to-date master point locator has been
46  // constructed; we'll need to grab sub-locators soon.
48  }
49 }
libmesh_assert(j)
const PeriodicBoundaries * _periodic_bcs
UniquePtr< PointLocatorBase > sub_point_locator() const
Definition: mesh_base.C:531
unsigned int libMesh::PointNeighborCoupling::n_levels ( )
inline

Definition at line 62 of file point_neighbor_coupling.h.

References _n_levels.

Referenced by set_n_levels().

63  { return _n_levels; }
static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited
void libMesh::PointNeighborCoupling::operator() ( const MeshBase::const_element_iterator range_begin,
const MeshBase::const_element_iterator range_end,
processor_id_type  p,
map_type coupled_elements 
)
virtual

For the specified range of active elements, find the elements which will be coupled to them in the sparsity pattern.

This will include the point neighbors, point neighbors of point neighbors, etc, to n_levels depth.

Implements libMesh::GhostingFunctor.

Definition at line 54 of file point_neighbor_coupling.C.

References _dof_coupling, _mesh, _n_levels, _periodic_bcs, libMesh::Elem::find_point_neighbors(), libMesh::libmesh_assert(), libMesh::DofObject::processor_id(), and libMesh::MeshBase::sub_point_locator().

Referenced by delete_remote_elements().

58 {
59  LOG_SCOPE("operator()", "PointNeighborCoupling");
60 
61 #ifdef LIBMESH_ENABLE_PERIODIC
62  bool check_periodic_bcs =
63  (_periodic_bcs && !_periodic_bcs->empty());
64  UniquePtr<PointLocatorBase> point_locator;
65  if (check_periodic_bcs)
66  {
68  point_locator = _mesh->sub_point_locator();
69  }
70 #endif
71 
72  if (!this->_n_levels)
73  {
74  for (MeshBase::const_element_iterator elem_it = range_begin;
75  elem_it != range_end; ++elem_it)
76  {
77  const Elem * const elem = *elem_it;
78 
79  if (elem->processor_id() != p)
80  coupled_elements.insert (std::make_pair(elem,_dof_coupling));
81  }
82  return;
83  }
84 
85  typedef LIBMESH_BEST_UNORDERED_SET<const Elem*> set_type;
86  set_type next_elements_to_check(range_begin, range_end);
87  set_type elements_to_check;
88  set_type elements_checked;
89 
90  for (unsigned int i=0; i != this->_n_levels; ++i)
91  {
92  elements_to_check.swap(next_elements_to_check);
93  next_elements_to_check.clear();
94  elements_checked.insert(elements_to_check.begin(), elements_to_check.end());
95 
96  for (set_type::const_iterator elem_it = elements_to_check.begin(),
97  elem_end = elements_to_check.end();
98  elem_it != elem_end; ++elem_it)
99  {
100  std::set<const Elem *> point_neighbors;
101 
102  const Elem * const elem = *elem_it;
103 
104  if (elem->processor_id() != p)
105  coupled_elements.insert (std::make_pair(elem,_dof_coupling));
106 
107 #ifdef LIBMESH_ENABLE_PERIODIC
108  // We might have a periodic neighbor here
109  if (check_periodic_bcs)
110  {
111  libmesh_not_implemented();
112  }
113  else
114 #endif
115  {
116  elem->find_point_neighbors(point_neighbors);
117  }
118 
119  for (std::set<const Elem *>::const_iterator
120  it = point_neighbors.begin(),
121  end_it = point_neighbors.end();
122  it != end_it; ++it)
123  {
124  const Elem * neighbor = *it;
125 
126  if (!elements_checked.count(neighbor))
127  next_elements_to_check.insert(neighbor);
128 
129  if (neighbor->processor_id() != p)
130  coupled_elements.insert
131  (std::make_pair(neighbor, _dof_coupling));
132  }
133  }
134  }
135 }
libmesh_assert(j)
const PeriodicBoundaries * _periodic_bcs
UniquePtr< PointLocatorBase > sub_point_locator() const
Definition: mesh_base.C:531
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 }
static std::string get_info()
virtual void libMesh::PointNeighborCoupling::redistribute ( )
inlinevirtual

GhostingFunctor subclasses with relatively long-lasting caches may want to redistribute those caches whenever the relevant Mesh is redistributed; we will give them an opportunity when that happens. At the point in the code where this is called, element processor ids have been set to their new destinations, and those elements have been copied to their new destinations, but the elements have not yet been deleted by the processors which previously held them..

Reimplemented from libMesh::GhostingFunctor.

Definition at line 87 of file point_neighbor_coupling.h.

References mesh_reinit().

88  { this->mesh_reinit(); }
virtual void mesh_reinit() libmesh_override
void libMesh::PointNeighborCoupling::set_dof_coupling ( const CouplingMatrix dof_coupling)
inline

Definition at line 58 of file point_neighbor_coupling.h.

References _dof_coupling.

59  { _dof_coupling = dof_coupling; }
void libMesh::PointNeighborCoupling::set_mesh ( const MeshBase mesh)
inline

Definition at line 78 of file point_neighbor_coupling.h.

References _mesh, mesh, and mesh_reinit().

79  { _mesh = mesh; }
MeshBase & mesh
void libMesh::PointNeighborCoupling::set_n_levels ( unsigned int  n_levels)
inline

Definition at line 66 of file point_neighbor_coupling.h.

References _n_levels, and n_levels().

void libMesh::PointNeighborCoupling::set_periodic_boundaries ( const PeriodicBoundaries periodic_bcs)
inline

Definition at line 73 of file point_neighbor_coupling.h.

References _periodic_bcs.

74  { _periodic_bcs = periodic_bcs; }
const PeriodicBoundaries * _periodic_bcs

Member Data Documentation

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited
const CouplingMatrix* libMesh::PointNeighborCoupling::_dof_coupling
private

Definition at line 107 of file point_neighbor_coupling.h.

Referenced by operator()(), and set_dof_coupling().

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

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

const MeshBase* libMesh::PointNeighborCoupling::_mesh
private

Definition at line 111 of file point_neighbor_coupling.h.

Referenced by mesh_reinit(), operator()(), and set_mesh().

Threads::spin_mutex libMesh::ReferenceCounter::_mutex
staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 128 of file reference_counter.h.

unsigned int libMesh::PointNeighborCoupling::_n_levels
private

Definition at line 112 of file point_neighbor_coupling.h.

Referenced by n_levels(), operator()(), and set_n_levels().

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

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

const PeriodicBoundaries* libMesh::PointNeighborCoupling::_periodic_bcs
private

Definition at line 109 of file point_neighbor_coupling.h.

Referenced by mesh_reinit(), operator()(), and set_periodic_boundaries().


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