libMesh
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Attributes | List of all members
libMesh::Tree< N > Class Template Reference

This class defines a tree that may be used for fast point location in space. More...

#include <tree.h>

Inheritance diagram for libMesh::Tree< N >:
[legend]

Public Member Functions

 Tree (const MeshBase &m, unsigned int target_bin_size, Trees::BuildType bt=Trees::NODES)
 Constructor. More...
 
 Tree (const Tree< N > &other_tree)
 Copy-constructor. More...
 
 ~Tree ()
 Destructor. More...
 
virtual void print_nodes (std::ostream &my_out=libMesh::out) const libmesh_override
 Prints the nodes. More...
 
virtual void print_elements (std::ostream &my_out=libMesh::out) const libmesh_override
 Prints the nodes. More...
 
virtual unsigned int n_active_bins () const libmesh_override
 
virtual const Elemfind_element (const Point &p, const std::set< subdomain_id_type > *allowed_subdomains=libmesh_nullptr, Real relative_tol=TOLERANCE) const libmesh_override
 
const Elemoperator() (const Point &p, const std::set< subdomain_id_type > *allowed_subdomains=libmesh_nullptr, Real relative_tol=TOLERANCE) const
 

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

Protected Attributes

const MeshBasemesh
 Constant reference to a mesh. 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

TreeNode< N > root
 The tree root. More...
 
const Trees::BuildType build_type
 How the tree is built. More...
 

Detailed Description

template<unsigned int N>
class libMesh::Tree< N >

This class defines a tree that may be used for fast point location in space.

Author
Benjamin S. Kirk
Date
2002 Tree class templated on the number of leaves on each node.

Definition at line 44 of file tree.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.

Constructor & Destructor Documentation

template<unsigned int N>
libMesh::Tree< N >::Tree ( const MeshBase m,
unsigned int  target_bin_size,
Trees::BuildType  bt = Trees::NODES 
)

Constructor.

Requires a mesh and the target bin size. Optionally takes the build method.

Definition at line 37 of file tree.C.

References libMesh::MeshBase::active_element_ptr_range(), libMesh::MeshBase::active_local_element_ptr_range(), libMesh::MeshTools::build_nodes_to_elem_map(), libMesh::Tree< N >::build_type, libMesh::MeshTools::create_bounding_box(), libMesh::Trees::ELEMENTS, libMesh::libmesh_assert(), libMesh::Trees::LOCAL_ELEMENTS, libMesh::TreeBase::mesh, libMesh::MeshBase::node_ptr_range(), libMesh::Trees::NODES, and libMesh::Tree< N >::root.

39  :
40  TreeBase(m),
41  root(m,target_bin_size),
42  build_type(bt)
43 {
44  // Set the root node bounding box equal to the bounding
45  // box for the entire domain.
46  root.set_bounding_box (MeshTools::create_bounding_box(mesh));
47 
48  if (build_type == Trees::NODES)
49  {
50  // Add all the nodes to the root node. It will
51  // automagically build the tree for us.
52  for (const auto & node : mesh.node_ptr_range())
53  {
54 #ifndef NDEBUG
55  bool node_was_inserted =
56 #endif
57  root.insert (node);
58  libmesh_assert(node_was_inserted);
59  }
60 
61  // Now the tree contains the nodes.
62  // However, we want element pointers, so here we
63  // convert between the two.
64  std::vector<std::vector<const Elem *>> nodes_to_elem;
65 
67  root.transform_nodes_to_elements (nodes_to_elem);
68  }
69 
70  else if (build_type == Trees::ELEMENTS)
71  {
72  // Add all active elements to the root node. It will
73  // automatically build the tree for us.
74  for (const auto & elem : mesh.active_element_ptr_range())
75  {
76 #ifndef NDEBUG
77  bool elem_was_inserted =
78 #endif
79  root.insert (elem);
80  libmesh_assert(elem_was_inserted);
81  }
82  }
83 
85  {
86  // Add all active, local elements to the root node. It will
87  // automatically build the tree for us.
88  for (const auto & elem : mesh.active_local_element_ptr_range())
89  {
90 #ifndef NDEBUG
91  bool elem_was_inserted =
92 #endif
93  root.insert (elem);
94  libmesh_assert(elem_was_inserted);
95  }
96  }
97 
98  else
99  libmesh_error_msg("Unknown build_type = " << build_type);
100 }
TreeNode< N > root
The tree root.
Definition: tree.h:102
libMesh::BoundingBox create_bounding_box(const MeshBase &mesh)
The same functionality as the deprecated MeshTools::bounding_box().
Definition: mesh_tools.C:329
TreeBase(const MeshBase &m)
Constructor.
Definition: tree_base.h:118
void build_nodes_to_elem_map(const MeshBase &mesh, std::vector< std::vector< dof_id_type >> &nodes_to_elem_map)
After calling this function the input vector nodes_to_elem_map will contain the node to element conne...
Definition: mesh_tools.C:257
virtual SimpleRange< element_iterator > active_element_ptr_range()=0
libmesh_assert(j)
const MeshBase & mesh
Constant reference to a mesh.
Definition: tree_base.h:110
virtual SimpleRange< element_iterator > active_local_element_ptr_range()=0
virtual SimpleRange< node_iterator > node_ptr_range()=0
const Trees::BuildType build_type
How the tree is built.
Definition: tree.h:107
template<unsigned int N>
libMesh::Tree< N >::Tree ( const Tree< N > &  other_tree)

Copy-constructor.

Not currently implemented.

Definition at line 106 of file tree.C.

106  :
107  TreeBase (other_tree),
108  root (other_tree.root),
109  build_type (other_tree.build_type)
110 {
111  libmesh_not_implemented();
112 }
TreeNode< N > root
The tree root.
Definition: tree.h:102
TreeBase(const MeshBase &m)
Constructor.
Definition: tree_base.h:118
const Trees::BuildType build_type
How the tree is built.
Definition: tree.h:107
template<unsigned int N>
libMesh::Tree< N >::~Tree ( )

Destructor.

Definition at line 62 of file tree.h.

References libMesh::out, libMesh::Tree< N >::print_elements(), and libMesh::Tree< N >::print_nodes().

62 {}

Member Function Documentation

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...
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...
template<unsigned int N>
const Elem * libMesh::Tree< N >::find_element ( const Point p,
const std::set< subdomain_id_type > *  allowed_subdomains = libmesh_nullptr,
Real  relative_tol = TOLERANCE 
) const
virtual
Returns
A pointer to the element containing point p, optionally restricted to a set of allowed subdomains, optionally using a non-zero relative tolerance for searches.

Implements libMesh::TreeBase.

Definition at line 139 of file tree.C.

References libMesh::Tree< N >::root.

Referenced by libMesh::Tree< N >::n_active_bins(), and libMesh::Tree< N >::operator()().

142 {
143  return root.find_element(p, allowed_subdomains, relative_tol);
144 }
TreeNode< N > root
The tree root.
Definition: tree.h:102
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.
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.
template<unsigned int N>
virtual unsigned int libMesh::Tree< N >::n_active_bins ( ) const
virtual
Returns
The number of active bins.

Implements libMesh::TreeBase.

Definition at line 77 of file tree.h.

References libMesh::Tree< N >::find_element(), libmesh_nullptr, libMesh::Tree< N >::operator()(), libMesh::Real, libMesh::Tree< N >::root, and libMesh::TOLERANCE.

78  { return root.n_active_bins(); }
TreeNode< N > root
The tree root.
Definition: tree.h:102
static unsigned int libMesh::ReferenceCounter::n_objects ( )
staticinherited
template<unsigned int N>
const Elem * libMesh::Tree< N >::operator() ( const Point p,
const std::set< subdomain_id_type > *  allowed_subdomains = libmesh_nullptr,
Real  relative_tol = TOLERANCE 
) const
Returns
A pointer to the element containing point p, optionally restricted to a set of allowed subdomains, optionally using a non-zero relative tolerance for searches.

Definition at line 150 of file tree.C.

References libMesh::Tree< N >::find_element().

Referenced by libMesh::Tree< N >::n_active_bins().

153 {
154  return this->find_element(p, allowed_subdomains, relative_tol);
155 }
virtual const Elem * find_element(const Point &p, const std::set< subdomain_id_type > *allowed_subdomains=libmesh_nullptr, Real relative_tol=TOLERANCE) const libmesh_override
Definition: tree.C:139
template<unsigned int N>
void libMesh::Tree< N >::print_elements ( std::ostream &  my_out = libMesh::out) const
virtual

Prints the nodes.

Implements libMesh::TreeBase.

Definition at line 129 of file tree.C.

References libMesh::Tree< N >::root.

Referenced by libMesh::Tree< N >::~Tree().

130 {
131  my_out << "Printing elements...\n";
132  root.print_elements(my_out);
133 }
TreeNode< N > root
The tree root.
Definition: tree.h:102
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...
template<unsigned int N>
void libMesh::Tree< N >::print_nodes ( std::ostream &  my_out = libMesh::out) const
virtual

Prints the nodes.

Implements libMesh::TreeBase.

Definition at line 120 of file tree.C.

References libMesh::Tree< N >::root.

Referenced by libMesh::Tree< N >::~Tree().

121 {
122  my_out << "Printing nodes...\n";
123  root.print_nodes(my_out);
124 }
TreeNode< N > root
The tree root.
Definition: tree.h:102

Member Data Documentation

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

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

template<unsigned int N>
const Trees::BuildType libMesh::Tree< N >::build_type
private

How the tree is built.

Definition at line 107 of file tree.h.

Referenced by libMesh::Tree< N >::Tree().

const MeshBase& libMesh::TreeBase::mesh
protectedinherited

Constant reference to a mesh.

Declared at construction.

Definition at line 110 of file tree_base.h.

Referenced by libMesh::Tree< N >::Tree().

template<unsigned int N>
TreeNode<N> libMesh::Tree< N >::root
private

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