libMesh::DefaultCoupling Class Reference

#include <default_coupling.h>

Inheritance diagram for libMesh::DefaultCoupling:

Public Types

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

Public Member Functions

 DefaultCoupling ()
 
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 default_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 119 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::DefaultCoupling::DefaultCoupling ( )
inline

Constructor.

Definition at line 48 of file default_coupling.h.

References set_dof_coupling().

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

Member Function Documentation

virtual void libMesh::DefaultCoupling::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 87 of file default_coupling.h.

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

88  { 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 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 }
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 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)
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 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)
Definition: elem_quality.C:39
spin_mutex spin_mtx
Definition: threads.C:29
void libMesh::DefaultCoupling::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 52 of file default_coupling.C.

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

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

53 {
54  // Unless we have periodic boundary conditions, we don't need
55  // anything precomputed.
56 #ifdef LIBMESH_ENABLE_PERIODIC
57  if (!_periodic_bcs || _periodic_bcs->empty())
58  return;
59 #endif
60 
61  // If we do have periodic boundary conditions, we'll need a master
62  // point locator, so we'd better have a mesh to build it on.
64 
65  // Make sure an up-to-date master point locator has been
66  // constructed; we'll need to grab sub-locators soon.
68 }
libmesh_assert(j)
const PeriodicBoundaries * _periodic_bcs
UniquePtr< PointLocatorBase > sub_point_locator() const
Definition: mesh_base.C:529
unsigned int libMesh::DefaultCoupling::n_levels ( )
inline

Definition at line 61 of file default_coupling.h.

References _n_levels.

Referenced by set_n_levels().

62  { return _n_levels; }
static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited
void libMesh::DefaultCoupling::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 be only the elements themselves by default, but will include side neighbors if an all-discontinuous-variable system is detected and/or if the user specified –implicit_neighbor_dofs on the command line or used set_implicit_neighbor_dofs() in their code.

Implements libMesh::GhostingFunctor.

Definition at line 73 of file default_coupling.C.

References _dof_coupling, _mesh, _n_levels, _periodic_bcs, libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::active_family_tree_by_topological_neighbor(), libMesh::libmesh_assert(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor_ptr(), libMesh::DofObject::processor_id(), libMesh::remote_elem, libMesh::MeshBase::sub_point_locator(), and libMesh::Elem::topological_neighbor().

Referenced by delete_remote_elements().

77 {
78  LOG_SCOPE("operator()", "DefaultCoupling");
79 
80 #ifdef LIBMESH_ENABLE_PERIODIC
81  bool check_periodic_bcs =
82  (_periodic_bcs && !_periodic_bcs->empty());
83 
84  UniquePtr<PointLocatorBase> point_locator;
85  if (check_periodic_bcs)
86  {
88  point_locator = _mesh->sub_point_locator();
89  }
90 #endif
91 
92  if (!this->_n_levels)
93  {
94  for (MeshBase::const_element_iterator elem_it = range_begin;
95  elem_it != range_end; ++elem_it)
96  {
97  const Elem * const elem = *elem_it;
98 
99  if (elem->processor_id() != p)
100  coupled_elements.insert (std::make_pair(elem,_dof_coupling));
101  }
102  return;
103  }
104 
105  typedef LIBMESH_BEST_UNORDERED_SET<const Elem*> set_type;
106  set_type next_elements_to_check(range_begin, range_end);
107  set_type elements_to_check;
108  set_type elements_checked;
109 
110  for (unsigned int i=0; i != this->_n_levels; ++i)
111  {
112  elements_to_check.swap(next_elements_to_check);
113  next_elements_to_check.clear();
114  elements_checked.insert(elements_to_check.begin(), elements_to_check.end());
115 
116  for (set_type::const_iterator
117  elem_it = elements_to_check.begin(),
118  elem_end = elements_to_check.end();
119  elem_it != elem_end; ++elem_it)
120  {
121  std::vector<const Elem *> active_neighbors;
122 
123  const Elem * const elem = *elem_it;
124 
125  if (elem->processor_id() != p)
126  coupled_elements.insert (std::make_pair(elem,_dof_coupling));
127 
128  for (unsigned int s=0; s<elem->n_sides(); s++)
129  {
130  const Elem * neigh = elem->neighbor_ptr(s);
131 
132  // If we have a neighbor here
133  if (neigh)
134  {
135  // Mesh ghosting might ask us about what we want to
136  // distribute along with non-local elements, and those
137  // non-local elements might have remote neighbors, and
138  // if they do then we can't say anything about them.
139  if (neigh == remote_elem)
140  continue;
141  }
142 #ifdef LIBMESH_ENABLE_PERIODIC
143  // We might still have a periodic neighbor here
144  else if (check_periodic_bcs)
145  {
147 
148  neigh = elem->topological_neighbor
149  (s, *_mesh, *point_locator, _periodic_bcs);
150  }
151 #endif
152 
153  // With no regular *or* periodic neighbors we have nothing
154  // to do.
155  if (!neigh)
156  continue;
157 
158  // With any kind of neighbor, we need to couple to all the
159  // active descendants on our side.
160 #ifdef LIBMESH_ENABLE_AMR
161  if (neigh == elem->neighbor_ptr(s))
162  neigh->active_family_tree_by_neighbor(active_neighbors,elem);
163 # ifdef LIBMESH_ENABLE_PERIODIC
164  else
165  neigh->active_family_tree_by_topological_neighbor
166  (active_neighbors,elem,*_mesh,*point_locator,_periodic_bcs);
167 # endif
168 #else
169  active_neighbors.clear();
170  active_neighbors.push_back(neigh);
171 #endif
172 
173  for (std::size_t a=0; a != active_neighbors.size(); ++a)
174  {
175  const Elem * neighbor = active_neighbors[a];
176 
177  if (!elements_checked.count(neighbor))
178  next_elements_to_check.insert(neighbor);
179 
180  if (neighbor->processor_id() != p)
181  coupled_elements.insert
182  (std::make_pair(neighbor, _dof_coupling));
183  }
184  }
185  }
186  }
187 }
libmesh_assert(j)
const CouplingMatrix * _dof_coupling
const PeriodicBoundaries * _periodic_bcs
UniquePtr< PointLocatorBase > sub_point_locator() const
Definition: mesh_base.C:529
const RemoteElem * remote_elem
Definition: remote_elem.C:57
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()
virtual void libMesh::DefaultCoupling::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 84 of file default_coupling.h.

References mesh_reinit().

85  { this->mesh_reinit(); }
virtual void mesh_reinit() libmesh_override
void libMesh::DefaultCoupling::set_dof_coupling ( const CouplingMatrix dof_coupling)

Definition at line 34 of file default_coupling.C.

References _dof_coupling, and libMesh::CouplingMatrix::empty().

Referenced by DefaultCoupling().

35 {
36  // We used to treat an empty 0x0 _dof_coupling matrix as if it
37  // were an NxN all-ones matrix. We'd like to stop supporting this
38  // behavior, but for now we'll just warn about it, while supporting
39  // it via the preferred mechanism: a NULL _dof_coupling
40  // matrix pointer is interpreted as a full coupling matrix.
41  if (dof_coupling && dof_coupling->empty())
42  {
43  libmesh_deprecated();
44  _dof_coupling = NULL;
45  }
46  else
47  _dof_coupling = dof_coupling;
48 }
const CouplingMatrix * _dof_coupling
void libMesh::DefaultCoupling::set_mesh ( const MeshBase mesh)
inline

Definition at line 75 of file default_coupling.h.

References _mesh, mesh, and mesh_reinit().

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

Definition at line 65 of file default_coupling.h.

References _n_levels, and n_levels().

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

Definition at line 70 of file default_coupling.h.

References _periodic_bcs.

71  { _periodic_bcs = periodic_bcs; }
const PeriodicBoundaries * _periodic_bcs

Member Data Documentation

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

Definition at line 107 of file default_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 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().

const MeshBase* libMesh::DefaultCoupling::_mesh
private

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

unsigned int libMesh::DefaultCoupling::_n_levels
private

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

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

const PeriodicBoundaries* libMesh::DefaultCoupling::_periodic_bcs
private

Definition at line 109 of file default_coupling.h.

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


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