libMesh::PointLocatorBase Class Reference

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

#include <point_locator_base.h>

Inheritance diagram for libMesh::PointLocatorBase:

Public Member Functions
virtual	~PointLocatorBase ()
	Destructor.
virtual void	clear ()=0
	Clears the PointLocator.
virtual void	init ()=0
	Initializes the point locator, so that the operator() methods can be used.
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.
virtual void	operator() (const Point &p, std::set< const Elem * > &candidate_elements, const std::set< subdomain_id_type > *allowed_subdomains=nullptr) const =0
	Finds elements in proximity to the point with global coordinates p and adds them to a set of candidate elements.
virtual const Node *	locate_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.
virtual void	disable_out_of_mesh_mode ()=0
	Disables out-of-mesh mode (default).
Real	get_close_to_point_tol () const
	Get the close-to-point tolerance.
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.
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.
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.
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.
virtual Real	get_contains_point_tol () const
	Get the tolerance for determining element containment in the point locator.
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.
const MeshBase &	get_mesh () const
	Get a const reference to this PointLocator's mesh.
bool	get_verbose () const
	Get the verbosity setting (whether to print extra info to screen, default false) for this PointLocator.
void	set_verbose (bool verbosity)
	Set the verbosity setting for this PointLocator.
void	libmesh_assert_valid_point_locator ()
	Verifies that, for every node of every element, the point locator finds that element when searching at that node.

Static Public Member Functions
static std::unique_ptr< PointLocatorBase >	build (PointLocatorType t, const MeshBase &mesh, const PointLocatorBase *master=nullptr)
	Builds an PointLocator for the mesh mesh.
static std::string	get_info ()
	Gets a string containing the reference information.
static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to libMesh::out.
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info().
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.

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

Protected Attributes
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.
const MeshBase &	_mesh
	constant reference to the mesh in which the point is looked for.
bool	_initialized
	true when properly initialized, false otherwise.
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.
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.

Static Protected Attributes
static Counts	_counts
	Actually holds the data.
static Threads::atomic< unsigned int >	_n_objects
	The number of objects.
static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.
static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

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 36 of file point_locator_base.C.

                                                                     :
  _verbose                 (false),
  _master                  (master),
  _mesh                    (mesh),
  _initialized             (false),
  _use_close_to_point_tol  (false),
  _close_to_point_tol      (TOLERANCE),
  _use_contains_point_tol  (false),
  _contains_point_tol      (TOLERANCE)
{
  // If we have a non-nullptr master, inherit its close-to-point tolerances.
  if (_master)
    {
      _use_close_to_point_tol = _master->_use_close_to_point_tol;
      _close_to_point_tol = _master->_close_to_point_tol;
    }
}

References _close_to_point_tol, _master, and _use_close_to_point_tol.

~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 68 of file point_locator_base.C.

{
  switch (t)
    {
    case TREE:
      return std::make_unique<PointLocatorTree>(mesh, /*Trees::NODES,*/ master);
 
    case TREE_ELEMENTS:
      return std::make_unique<PointLocatorTree>(mesh, Trees::ELEMENTS, master);
 
    case TREE_LOCAL_ELEMENTS:
      return std::make_unique<PointLocatorTree>(mesh, Trees::LOCAL_ELEMENTS, master);
 
#ifdef LIBMESH_HAVE_NANOFLANN
    case NANOFLANN:
      return std::make_unique<PointLocatorNanoflann>(mesh, master);
#endif
 
    default:
      libmesh_error_msg("ERROR: Bad PointLocatorType = " << t);
    }
}

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

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::PointLocatorNanoflann, and libMesh::PointLocatorTree.

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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::PointLocatorNanoflann, and libMesh::PointLocatorTree.

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

get_close_to_point_tol()

Real libMesh::PointLocatorBase::get_close_to_point_tol

(

)

const

Get the close-to-point tolerance.

Definition at line 93 of file point_locator_base.C.

{
  return _close_to_point_tol;
}

References _close_to_point_tol.

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

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 123 of file point_locator_base.C.

{
  return _contains_point_tol;
}

References _contains_point_tol.

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.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

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

get_mesh()

const MeshBase & libMesh::PointLocatorBase::get_mesh

(

)

const

Get a const reference to this PointLocator's mesh.

Definition at line 128 of file point_locator_base.C.

{
  return _mesh;
}

References _mesh.

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

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 192 of file point_locator_base.h.

{ return _use_contains_point_tol; }

References _use_contains_point_tol.

get_verbose()

bool libMesh::PointLocatorBase::get_verbose ( ) const

inline

Get the verbosity setting (whether to print extra info to screen, default false) for this PointLocator.

Definition at line 203 of file point_locator_base.h.

{ return _verbose; }

References _verbose.

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.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

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.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

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

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::PointLocatorNanoflann, and libMesh::PointLocatorTree.

initialized()

bool libMesh::PointLocatorBase::initialized

(

)

const

Returns

true when this object is properly initialized and ready for use, false otherwise.

Definition at line 61 of file point_locator_base.C.

{
  return this->_initialized;
}

References _initialized.

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

libmesh_assert_valid_point_locator()

void libMesh::PointLocatorBase::libmesh_assert_valid_point_locator

(

)

Verifies that, for every node of every element, the point locator finds that element when searching at that node.

This is an O(N log N) operation, and so only available in builds with NDEBUG undefined, for asserting internal consistency (the PointLocator works) and external consistency (user code didn't change the mesh without updating the PointLocator afterward) that we hope should never be broken in opt.

Definition at line 159 of file point_locator_base.C.

{
  // We might only have been built with TREE_LOCAL_ELEMENTS as an
  // option; let's just check local elements to be safe.
  for (const Elem * elem : this->_mesh.active_local_element_ptr_range())
    {
      // For non-Lagrange mappings, we might have nodes that are
      // really control points, not contained in the element they
      // define; we can only safely check containment of vertices.
      auto range = make_range(0u, (elem->mapping_type() == LAGRANGE_MAP) ?
                                 elem->n_nodes() : elem->n_vertices());
 
        for (auto n : range)
          {
            const Node & node = elem->node_ref(n);
            std::set<const Elem *> candidate_elements;
            this->operator()(node, candidate_elements);
            libmesh_assert(candidate_elements.count(elem));
          }
    }
}

References _mesh, libMesh::LAGRANGE_MAP, libMesh::libmesh_assert(), libMesh::make_range(), and operator()().

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.

{
  std::set<const Elem *> candidate_elements;
  this->operator()(p, candidate_elements, allowed_subdomains);
 
  for (const auto & elem : candidate_elements)
    {
      const int elem_n_nodes = elem->n_nodes();
      const Real hmax = elem->hmax();
      const Real dist_tol_sq = (tol * hmax) * (tol * hmax);
 
      for (int n=0; n != elem_n_nodes; ++n)
        if ((elem->point(n) - p).norm_sq() < dist_tol_sq)
          return elem->node_ptr(n);
    }
 
  return nullptr;
}

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

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.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

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

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::PointLocatorNanoflann, and libMesh::PointLocatorTree.

Referenced by libmesh_assert_valid_point_locator(), and 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

Finds elements in proximity to the point with global coordinates p and adds them to a set of candidate elements.

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.

{
  if (_enable_print_counter)
    out_stream << ReferenceCounter::get_info();
}

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

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

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 99 of file point_locator_base.C.

{
  _use_close_to_point_tol = true;
  _close_to_point_tol = close_to_point_tol;
}

References _close_to_point_tol, and _use_close_to_point_tol.

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 111 of file point_locator_base.C.

{
  _use_contains_point_tol = true;
  _contains_point_tol = contains_point_tol;
}

References _contains_point_tol, and _use_contains_point_tol.

set_verbose()

void libMesh::PointLocatorBase::set_verbose ( bool  verbosity )

inline

Set the verbosity setting for this PointLocator.

Definition at line 208 of file point_locator_base.h.

{ _verbose = verbosity; }

References _verbose.

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 105 of file point_locator_base.C.

{
  _use_close_to_point_tol = false;
  _close_to_point_tol = TOLERANCE;
}

References _close_to_point_tol, _use_close_to_point_tol, and libMesh::TOLERANCE.

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 117 of file point_locator_base.C.

{
  _use_contains_point_tol = false;
  _contains_point_tol = TOLERANCE;
}

References _contains_point_tol, _use_contains_point_tol, and libMesh::TOLERANCE.

Member Data Documentation

_close_to_point_tol

Real libMesh::PointLocatorBase::_close_to_point_tol

protected

The tolerance to use.

Definition at line 260 of file point_locator_base.h.

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

_contains_point_tol

Real libMesh::PointLocatorBase::_contains_point_tol

protected

The tolerance to use when locating an element in the tree.

Definition at line 271 of file point_locator_base.h.

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

_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

true when properly initialized, false otherwise.

Definition at line 249 of file point_locator_base.h.

Referenced by libMesh::PointLocatorNanoflann::clear(), libMesh::PointLocatorTree::clear(), libMesh::PointLocatorNanoflann::init(), libMesh::PointLocatorTree::init(), initialized(), libMesh::PointLocatorNanoflann::operator()(), libMesh::PointLocatorTree::operator()(), libMesh::PointLocatorNanoflann::operator()(), and libMesh::PointLocatorTree::operator()().

_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 239 of file point_locator_base.h.

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

_mesh

const MeshBase& libMesh::PointLocatorBase::_mesh

protected

constant reference to the mesh in which the point is looked for.

Definition at line 244 of file point_locator_base.h.

Referenced by get_mesh(), libMesh::PointLocatorNanoflann::init(), libMesh::PointLocatorTree::init(), libmesh_assert_valid_point_locator(), libMesh::PointLocatorTree::perform_fuzzy_linear_search(), and libMesh::PointLocatorTree::perform_linear_search().

_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(), libMesh::ReferenceCounter::ReferenceCounter(), 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 255 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 266 of file point_locator_base.h.

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

_verbose

bool libMesh::PointLocatorBase::_verbose

protected

Boolean flag to indicate whether to print out extra info.

Definition at line 231 of file point_locator_base.h.

Referenced by get_verbose(), libMesh::PointLocatorTree::operator()(), and set_verbose().

---

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

• include/utils/point_locator_base.h
• src/utils/point_locator_base.C