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 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::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 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::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:531
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 elem_it = elements_to_check.begin(),
117  elem_end = elements_to_check.end();
118  elem_it != elem_end; ++elem_it)
119  {
120  std::vector<const Elem *> active_neighbors;
121 
122  const Elem * const elem = *elem_it;
123 
124  if (elem->processor_id() != p)
125  coupled_elements.insert (std::make_pair(elem,_dof_coupling));
126 
127  for (unsigned int s=0; s<elem->n_sides(); s++)
128  {
129  const Elem *neigh = elem->neighbor_ptr(s);
130 
131  // If we have a neighbor here
132  if (neigh)
133  {
134  // Mesh ghosting might ask us about what we want to
135  // distribute along with non-local elements, and those
136  // non-local elements might have remote neighbors, and
137  // if they do then we can't say anything about them.
138  if (neigh == remote_elem)
139  continue;
140  }
141 #ifdef LIBMESH_ENABLE_PERIODIC
142  // We might still have a periodic neighbor here
143  else if (check_periodic_bcs)
144  {
146 
147  neigh = elem->topological_neighbor
148  (s, *_mesh, *point_locator, _periodic_bcs);
149  }
150 #endif
151 
152  // With no regular *or* periodic neighbors we have nothing
153  // to do.
154  if (!neigh)
155  continue;
156 
157  // With any kind of neighbor, we need to couple to all the
158  // active descendants on our side.
159 #ifdef LIBMESH_ENABLE_AMR
160  if (neigh == elem->neighbor_ptr(s))
161  neigh->active_family_tree_by_neighbor(active_neighbors,elem);
162 # ifdef LIBMESH_ENABLE_PERIODIC
163  else
164  neigh->active_family_tree_by_topological_neighbor
165  (active_neighbors,elem,*_mesh,*point_locator,_periodic_bcs);
166 # endif
167 #else
168  active_neighbors.clear();
169  active_neighbors.push_back(neigh);
170 #endif
171 
172  for (std::size_t a=0; a != active_neighbors.size(); ++a)
173  {
174  const Elem * neighbor = active_neighbors[a];
175 
176  if (!elements_checked.count(neighbor))
177  next_elements_to_check.insert(neighbor);
178 
179  if (neighbor->processor_id() != p)
180  coupled_elements.insert
181  (std::make_pair(neighbor, _dof_coupling));
182  }
183  }
184  }
185  }
186 }
libmesh_assert(j)
const CouplingMatrix * _dof_coupling
const PeriodicBoundaries * _periodic_bcs
UniquePtr< PointLocatorBase > sub_point_locator() const
Definition: mesh_base.C:531
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 }
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 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::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 128 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 123 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: