libMesh
Public Member Functions | Static Public Member Functions | Public Attributes | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
libMesh::PointLocatorBase Class Referenceabstract

This is the base class for point locators. More...

#include <point_locator_base.h>

Inheritance diagram for libMesh::PointLocatorBase:
[legend]

Public Member Functions

virtual ~PointLocatorBase ()
 Destructor. More...
 
virtual void clear ()=0
 Clears the PointLocator. More...
 
virtual void init ()=0
 Initializes the point locator, so that the operator() methods can be used. More...
 
virtual const Elemoperator() (const Point &p, const std::set< subdomain_id_type > *allowed_subdomains=nullptr) const =0
 Locates the element in which the point with global coordinates p is located. More...
 
virtual void operator() (const Point &p, std::set< const Elem *> &candidate_elements, const std::set< subdomain_id_type > *allowed_subdomains=nullptr) const =0
 Locates a set of elements in proximity to the point with global coordinates p Pure virtual. More...
 
virtual const Nodelocate_node (const Point &p, const std::set< subdomain_id_type > *allowed_subdomains=nullptr, Real tol=TOLERANCE) const
 
bool initialized () const
 
virtual void enable_out_of_mesh_mode ()=0
 Enables out-of-mesh mode. More...
 
virtual void disable_out_of_mesh_mode ()=0
 Disables out-of-mesh mode (default). More...
 
Real get_close_to_point_tol () const
 Get the close-to-point tolerance. More...
 
virtual void set_close_to_point_tol (Real close_to_point_tol)
 Set a tolerance to use when determining if a point is contained within the mesh. More...
 
virtual void unset_close_to_point_tol ()
 Specify that we do not want to use a user-specified tolerance to determine if a point is contained within the mesh. More...
 
virtual void set_contains_point_tol (Real contains_point_tol)
 Set a tolerance to use when checking if a point is within an element in the mesh. More...
 
virtual void unset_contains_point_tol ()
 Specify that we do not want to use a user-specified tolerance to determine if a point is inside an element in the mesh. More...
 
virtual Real get_contains_point_tol () const
 Get the tolerance for determining element containment in the point locator. More...
 
bool get_use_contains_point_tol () const
 The contains_point_tol may be nonzero (in fact it defaults to non-zero) but unless the user calls set_contains_point_tol(), it won't actually be used. More...
 
const MeshBaseget_mesh () const
 Get a const reference to this PointLocator's mesh. More...
 

Static Public Member Functions

static std::unique_ptr< PointLocatorBasebuild (PointLocatorType t, const MeshBase &mesh, const PointLocatorBase *master=nullptr)
 Builds an PointLocator for the mesh mesh. More...
 
static std::string get_info ()
 Gets a string containing the reference information. More...
 
static void print_info (std::ostream &out_stream=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 ()
 

Public Attributes

bool _verbose
 Boolean flag to indicate whether to print out extra info. More...
 

Protected Types

typedef std::map< std::string, std::pair< unsigned int, unsigned int > > Counts
 Data structure to log the information. More...
 

Protected Member Functions

 PointLocatorBase (const MeshBase &mesh, const PointLocatorBase *master)
 Constructor. More...
 
void increment_constructor_count (const std::string &name) noexcept
 Increments the construction counter. More...
 
void increment_destructor_count (const std::string &name) noexcept
 Increments the destruction counter. More...
 

Protected Attributes

const PointLocatorBase_master
 Const pointer to our master, initialized to nullptr if none given. More...
 
const MeshBase_mesh
 constant reference to the mesh in which the point is looked for. More...
 
bool _initialized
 true when properly initialized, false otherwise. More...
 
bool _use_close_to_point_tol
 true if we will use a user-specified tolerance for locating the element in an exhaustive search. More...
 
Real _close_to_point_tol
 The tolerance to use. More...
 
bool _use_contains_point_tol
 true if we will use a user-specified tolerance for locating the element. More...
 
Real _contains_point_tol
 The tolerance to use when locating an element in the tree. 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...
 

Detailed Description

This is the base class for point locators.

They locate points in space: given a mesh they return the element and local coordinates for a given point in global coordinates.

Author
Daniel Dreyer
Date
2003

Definition at line 54 of file point_locator_base.h.

Member Typedef Documentation

◆ Counts

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

◆ PointLocatorBase()

libMesh::PointLocatorBase::PointLocatorBase ( const MeshBase mesh,
const PointLocatorBase master 
)
protected

Constructor.

Protected so that this base class cannot be explicitly instantiated. Takes a master PointLocator that helps in saving memory.

Definition at line 35 of file point_locator_base.C.

References _close_to_point_tol, _master, and _use_close_to_point_tol.

36  :
37  _verbose (false),
38  _master (master),
39  _mesh (mesh),
40  _initialized (false),
45 {
46  // If we have a non-nullptr master, inherit its close-to-point tolerances.
47  if (_master)
48  {
51  }
52 }
bool _use_close_to_point_tol
true if we will use a user-specified tolerance for locating the element in an exhaustive search...
static constexpr Real TOLERANCE
Real _close_to_point_tol
The tolerance to use.
bool _initialized
true when properly initialized, false otherwise.
MeshBase & mesh
const MeshBase & _mesh
constant reference to the mesh in which the point is looked for.
bool _verbose
Boolean flag to indicate whether to print out extra info.
const PointLocatorBase * _master
Const pointer to our master, initialized to nullptr if none given.
bool _use_contains_point_tol
true if we will use a user-specified tolerance for locating the element.
Real _contains_point_tol
The tolerance to use when locating an element in the tree.

◆ ~PointLocatorBase()

libMesh::PointLocatorBase::~PointLocatorBase ( )
virtualdefault

Destructor.

Member Function Documentation

◆ build()

std::unique_ptr< PointLocatorBase > libMesh::PointLocatorBase::build ( PointLocatorType  t,
const MeshBase mesh,
const PointLocatorBase master = nullptr 
)
static

Builds an PointLocator for the mesh mesh.

Optionally takes a master PointLocator to save memory. An std::unique_ptr<PointLocatorBase> is returned to prevent memory leak. This way the user need not remember to delete the object.

Definition at line 67 of file point_locator_base.C.

References libMesh::Trees::ELEMENTS, libMesh::Trees::LOCAL_ELEMENTS, mesh, libMesh::NANOFLANN, libMesh::TREE, libMesh::TREE_ELEMENTS, and libMesh::TREE_LOCAL_ELEMENTS.

Referenced by libMesh::MeshBase::sub_point_locator().

70 {
71  switch (t)
72  {
73  case TREE:
74  return std::make_unique<PointLocatorTree>(mesh, /*Trees::NODES,*/ master);
75 
76  case TREE_ELEMENTS:
77  return std::make_unique<PointLocatorTree>(mesh, Trees::ELEMENTS, master);
78 
80  return std::make_unique<PointLocatorTree>(mesh, Trees::LOCAL_ELEMENTS, master);
81 
82 #ifdef LIBMESH_HAVE_NANOFLANN
83  case NANOFLANN:
84  return std::make_unique<PointLocatorNanoflann>(mesh, master);
85 #endif
86 
87  default:
88  libmesh_error_msg("ERROR: Bad PointLocatorType = " << t);
89  }
90 }
MeshBase & mesh

◆ clear()

virtual void libMesh::PointLocatorBase::clear ( )
pure virtual

Clears the PointLocator.

Implemented in libMesh::PointLocatorNanoflann, and libMesh::PointLocatorTree.

◆ disable_out_of_mesh_mode()

virtual void libMesh::PointLocatorBase::disable_out_of_mesh_mode ( )
pure virtual

Disables out-of-mesh mode (default).

If asked to find a point that is contained in no mesh at all, the point locator will now crash.

Implemented in libMesh::PointLocatorTree, and libMesh::PointLocatorNanoflann.

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

101 {
102  _enable_print_counter = false;
103  return;
104 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ enable_out_of_mesh_mode()

virtual void libMesh::PointLocatorBase::enable_out_of_mesh_mode ( )
pure virtual

Enables out-of-mesh mode.

In this mode, if asked to find a point that is contained in no mesh at all, the point locator will return a nullptr instead of crashing. Per default, this mode is off.

Implemented in libMesh::PointLocatorTree, and libMesh::PointLocatorNanoflann.

Referenced by libMesh::System::point_gradient(), libMesh::System::point_hessian(), and libMesh::System::point_value().

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

95 {
96  _enable_print_counter = true;
97  return;
98 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ get_close_to_point_tol()

Real libMesh::PointLocatorBase::get_close_to_point_tol ( ) const

Get the close-to-point tolerance.

Definition at line 92 of file point_locator_base.C.

References _close_to_point_tol.

Referenced by libMesh::MeshFunction::MeshFunction().

93 {
94  return _close_to_point_tol;
95 }
Real _close_to_point_tol
The tolerance to use.

◆ get_contains_point_tol()

Real libMesh::PointLocatorBase::get_contains_point_tol ( ) const
virtual

Get the tolerance for determining element containment in the point locator.

Definition at line 122 of file point_locator_base.C.

References _contains_point_tol.

123 {
124  return _contains_point_tol;
125 }
Real _contains_point_tol
The tolerance to use when locating an element in the tree.

◆ get_info()

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 (const auto & [name, cd] : _counts)
59  oss << "| " << name << " reference count information:\n"
60  << "| Creations: " << cd.first << '\n'
61  << "| Destructions: " << cd.second << '\n';
62 
63  oss << " ---------------------------------------------------------------------------- \n";
64 
65  return oss.str();
66 
67 #else
68 
69  return "";
70 
71 #endif
72 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
static Counts _counts
Actually holds the data.

◆ get_mesh()

const MeshBase & libMesh::PointLocatorBase::get_mesh ( ) const

Get a const reference to this PointLocator's mesh.

Definition at line 127 of file point_locator_base.C.

References _mesh.

Referenced by libMesh::PeriodicBoundaries::neighbor().

128 {
129  return _mesh;
130 }
const MeshBase & _mesh
constant reference to the mesh in which the point is looked for.

◆ get_use_contains_point_tol()

bool libMesh::PointLocatorBase::get_use_contains_point_tol ( ) const
inline

The contains_point_tol may be nonzero (in fact it defaults to non-zero) but unless the user calls set_contains_point_tol(), it won't actually be used.

This const accessor can be used to determine the current status of this flag.

Definition at line 191 of file point_locator_base.h.

References _use_contains_point_tol.

191 { return _use_contains_point_tol; }
bool _use_contains_point_tol
true if we will use a user-specified tolerance for locating the element.

◆ increment_constructor_count()

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name)
inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

184 {
185  libmesh_try
186  {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189  p.first++;
190  }
191  libmesh_catch (...)
192  {
193  auto stream = libMesh::err.get();
194  stream->exceptions(stream->goodbit); // stream must not throw
195  libMesh::err << "Encountered unrecoverable error while calling "
196  << "ReferenceCounter::increment_constructor_count() "
197  << "for a(n) " << name << " object." << std::endl;
198  std::terminate();
199  }
200 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ increment_destructor_count()

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name)
inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

208 {
209  libmesh_try
210  {
211  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
212  std::pair<unsigned int, unsigned int> & p = _counts[name];
213  p.second++;
214  }
215  libmesh_catch (...)
216  {
217  auto stream = libMesh::err.get();
218  stream->exceptions(stream->goodbit); // stream must not throw
219  libMesh::err << "Encountered unrecoverable error while calling "
220  << "ReferenceCounter::increment_destructor_count() "
221  << "for a(n) " << name << " object." << std::endl;
222  std::terminate();
223  }
224 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ init()

virtual void libMesh::PointLocatorBase::init ( )
pure virtual

Initializes the point locator, so that the operator() methods can be used.

Pure virtual.

Implemented in libMesh::PointLocatorTree, and libMesh::PointLocatorNanoflann.

◆ initialized()

bool libMesh::PointLocatorBase::initialized ( ) const
Returns
true when this object is properly initialized and ready for use, false otherwise.

Definition at line 60 of file point_locator_base.C.

References _initialized.

Referenced by libMesh::PointLocatorTree::init(), and libMesh::MeshFunction::MeshFunction().

61 {
62  return this->_initialized;
63 }
bool _initialized
true when properly initialized, false otherwise.

◆ locate_node()

const Node * libMesh::PointLocatorBase::locate_node ( const Point p,
const std::set< subdomain_id_type > *  allowed_subdomains = nullptr,
Real  tol = TOLERANCE 
) const
virtual
Returns
A pointer to a Node with global coordinates p or nullptr if no such Node can be found.

Virtual subclasses can override for efficiency, but the base class has a default implementation that works based on element lookup.

Optionally allows the user to restrict the subdomains searched; with such a restriction, only a Node belonging to an element on one or more of those subdomains will be returned.

Will only return a Node whose distance from p is less than tol multiplied by the size of a semilocal element which contains p.

Definition at line 135 of file point_locator_base.C.

References libMesh::TensorTools::norm_sq(), operator()(), and libMesh::Real.

138 {
139  std::set<const Elem *> candidate_elements;
140  this->operator()(p, candidate_elements, allowed_subdomains);
141 
142  for (const auto & elem : candidate_elements)
143  {
144  const int elem_n_nodes = elem->n_nodes();
145  const Real hmax = elem->hmax();
146  const Real dist_tol_sq = (tol * hmax) * (tol * hmax);
147 
148  for (int n=0; n != elem_n_nodes; ++n)
149  if ((elem->point(n) - p).norm_sq() < dist_tol_sq)
150  return elem->node_ptr(n);
151  }
152 
153  return nullptr;
154 }
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
auto norm_sq(const T &a) -> decltype(std::norm(a))
Definition: tensor_tools.h:104
virtual const Elem * operator()(const Point &p, const std::set< subdomain_id_type > *allowed_subdomains=nullptr) const =0
Locates the element in which the point with global coordinates p is located.

◆ n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

86  { return _n_objects; }
static Threads::atomic< unsigned int > _n_objects
The number of objects.

◆ operator()() [1/2]

virtual const Elem* libMesh::PointLocatorBase::operator() ( const Point p,
const std::set< subdomain_id_type > *  allowed_subdomains = nullptr 
) const
pure virtual

Locates the element in which the point with global coordinates p is located.

Pure virtual. Optionally allows the user to restrict the subdomains searched.

Implemented in libMesh::PointLocatorTree, and libMesh::PointLocatorNanoflann.

Referenced by locate_node().

◆ operator()() [2/2]

virtual void libMesh::PointLocatorBase::operator() ( const Point p,
std::set< const Elem *> &  candidate_elements,
const std::set< subdomain_id_type > *  allowed_subdomains = nullptr 
) const
pure virtual

Locates a set of elements in proximity to the point with global coordinates p Pure virtual.

Optionally allows the user to restrict the subdomains searched.

Implemented in libMesh::PointLocatorNanoflann, and libMesh::PointLocatorTree.

◆ print_info()

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

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

Definition at line 81 of file reference_counter.C.

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

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

82 {
84  out_stream << ReferenceCounter::get_info();
85 }
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...

◆ set_close_to_point_tol()

void libMesh::PointLocatorBase::set_close_to_point_tol ( Real  close_to_point_tol)
virtual

Set a tolerance to use when determining if a point is contained within the mesh.

Definition at line 98 of file point_locator_base.C.

References _close_to_point_tol, and _use_close_to_point_tol.

99 {
101  _close_to_point_tol = close_to_point_tol;
102 }
bool _use_close_to_point_tol
true if we will use a user-specified tolerance for locating the element in an exhaustive search...
Real _close_to_point_tol
The tolerance to use.

◆ set_contains_point_tol()

void libMesh::PointLocatorBase::set_contains_point_tol ( Real  contains_point_tol)
virtual

Set a tolerance to use when checking if a point is within an element in the mesh.

Definition at line 110 of file point_locator_base.C.

References _contains_point_tol, and _use_contains_point_tol.

111 {
113  _contains_point_tol = contains_point_tol;
114 }
bool _use_contains_point_tol
true if we will use a user-specified tolerance for locating the element.
Real _contains_point_tol
The tolerance to use when locating an element in the tree.

◆ unset_close_to_point_tol()

void libMesh::PointLocatorBase::unset_close_to_point_tol ( )
virtual

Specify that we do not want to use a user-specified tolerance to determine if a point is contained within the mesh.

Definition at line 104 of file point_locator_base.C.

References _close_to_point_tol, _use_close_to_point_tol, and libMesh::TOLERANCE.

105 {
106  _use_close_to_point_tol = false;
108 }
bool _use_close_to_point_tol
true if we will use a user-specified tolerance for locating the element in an exhaustive search...
static constexpr Real TOLERANCE
Real _close_to_point_tol
The tolerance to use.

◆ unset_contains_point_tol()

void libMesh::PointLocatorBase::unset_contains_point_tol ( )
virtual

Specify that we do not want to use a user-specified tolerance to determine if a point is inside an element in the mesh.

Definition at line 116 of file point_locator_base.C.

References _contains_point_tol, _use_contains_point_tol, and libMesh::TOLERANCE.

117 {
118  _use_contains_point_tol = false;
120 }
static constexpr Real TOLERANCE
bool _use_contains_point_tol
true if we will use a user-specified tolerance for locating the element.
Real _contains_point_tol
The tolerance to use when locating an element in the tree.

Member Data Documentation

◆ _close_to_point_tol

Real libMesh::PointLocatorBase::_close_to_point_tol
protected

◆ _contains_point_tol

Real libMesh::PointLocatorBase::_contains_point_tol
protected

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _enable_print_counter

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

◆ _initialized

bool libMesh::PointLocatorBase::_initialized
protected

◆ _master

const PointLocatorBase* libMesh::PointLocatorBase::_master
protected

Const pointer to our master, initialized to nullptr if none given.

When using multiple PointLocators, one can be assigned master and be in charge of something that all can have access to.

Definition at line 209 of file point_locator_base.h.

Referenced by libMesh::PointLocatorTree::init(), libMesh::PointLocatorNanoflann::init(), and PointLocatorBase().

◆ _mesh

const MeshBase& libMesh::PointLocatorBase::_mesh
protected

◆ _mutex

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.

◆ _n_objects

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

◆ _use_close_to_point_tol

bool libMesh::PointLocatorBase::_use_close_to_point_tol
protected

true if we will use a user-specified tolerance for locating the element in an exhaustive search.

Definition at line 225 of file point_locator_base.h.

Referenced by libMesh::PointLocatorTree::operator()(), PointLocatorBase(), set_close_to_point_tol(), and unset_close_to_point_tol().

◆ _use_contains_point_tol

bool libMesh::PointLocatorBase::_use_contains_point_tol
protected

true if we will use a user-specified tolerance for locating the element.

Definition at line 236 of file point_locator_base.h.

Referenced by get_use_contains_point_tol(), libMesh::PointLocatorNanoflann::operator()(), libMesh::PointLocatorTree::operator()(), set_contains_point_tol(), and unset_contains_point_tol().

◆ _verbose

bool libMesh::PointLocatorBase::_verbose

Boolean flag to indicate whether to print out extra info.

Definition at line 201 of file point_locator_base.h.

Referenced by libMesh::PointLocatorTree::operator()().


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