libMesh::PointLocatorTree Class Reference

#include <point_locator_tree.h>

Inheritance diagram for libMesh::PointLocatorTree:

List of all members.

Public Member Functions
	PointLocatorTree (const MeshBase &mesh, const PointLocatorBase *master=NULL)
	PointLocatorTree (const MeshBase &mesh, const Trees::BuildType build_type, const PointLocatorBase *master=NULL)
	~PointLocatorTree ()
virtual void	clear ()
void	init (Trees::BuildType build_type)
virtual void	init ()
virtual const Elem *	operator() (const Point &p, const std::set< subdomain_id_type > *allowed_subdomains=NULL) const
const Elem *	perform_linear_search (const Point &p, const std::set< subdomain_id_type > *allowed_subdomains, bool use_close_to_point, Real close_to_point_tolerance=TOLERANCE) const
virtual void	enable_out_of_mesh_mode ()
virtual void	disable_out_of_mesh_mode ()
void	set_target_bin_size (unsigned int target)
unsigned int	get_target_bin_size () const
bool	initialized () const
virtual void	set_close_to_point_tol (Real close_to_point_tol)
virtual void	unset_close_to_point_tol ()
Static Public Member Functions
static UniquePtr < PointLocatorBase >	build (PointLocatorType t, const MeshBase &mesh, const PointLocatorBase *master=NULL)
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 ()
Public Attributes
bool	_verbose
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)
Protected Attributes
TreeBase *	_tree
const Elem *	_element
bool	_out_of_mesh_mode
unsigned int	_target_bin_size
Trees::BuildType	_build_type
const PointLocatorBase *	_master
const MeshBase &	_mesh
bool	_initialized
bool	_use_close_to_point_tol
Real	_close_to_point_tol
Static Protected Attributes
static Counts	_counts
static Threads::atomic < unsigned int >	_n_objects
static Threads::spin_mutex	_mutex
static bool	_enable_print_counter = true

---

Detailed Description

This is a point locator. It locates points in space using a tree: given a mesh they return the element and local coordinates for a given point in global coordinates. Use PointLocatorBase::build() to create objects of this type at run time.

Author:

Daniel Dreyer, 2003

Definition at line 49 of file point_locator_tree.h.

---

Member Typedef Documentation

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts [protected, inherited]

Data structure to log the information. The log is identified by the class name.

Definition at line 113 of file reference_counter.h.

---

Constructor & Destructor Documentation

libMesh::PointLocatorTree::PointLocatorTree	(	const MeshBase &	mesh,
		const PointLocatorBase *	master = NULL
	)

Constructor. Needs the mesh in which the points should be located. Optionally takes a master interpolator. This master helps in saving memory by reducing the number of trees in use. Only the master locator holds a tree, the others simply use the master's tree.

Definition at line 37 of file point_locator_tree.C.

References _build_type, and init().

                                                                    :
  PointLocatorBase (mesh,master),
  _tree            (NULL),
  _element         (NULL),
  _out_of_mesh_mode(false),
  _target_bin_size (200),
  _build_type(Trees::NODES)
{
  this->init(_build_type);
}

libMesh::PointLocatorTree::PointLocatorTree	(	const MeshBase &	mesh,
		const Trees::BuildType	build_type,
		const PointLocatorBase *	master = NULL
	)

Constructor. Needs the mesh in which the points should be located. Allows the user to specify the method to use when building the tree. Optionally takes a master interpolator. This master helps in saving memory by reducing the number of trees in use. Only the master locator holds a tree, the others simply use the master's tree. Allows the user to specify the build type.

Definition at line 51 of file point_locator_tree.C.

References _build_type, and init().

                                                                    :
  PointLocatorBase (mesh,master),
  _tree            (NULL),
  _element         (NULL),
  _out_of_mesh_mode(false),
  _target_bin_size (200),
  _build_type(build_type)
{
  this->init(_build_type);
}

libMesh::PointLocatorTree::~PointLocatorTree

(

)

Destructor.

Definition at line 66 of file point_locator_tree.C.

References clear().

{
  this->clear ();
}

---

Member Function Documentation

UniquePtr< PointLocatorBase > libMesh::PointLocatorBase::build	(	PointLocatorType	t,
		const MeshBase &	mesh,
		const PointLocatorBase *	master = NULL
	)		[static, inherited]

Builds an PointLocator for the mesh mesh. Optionally takes a master PointLocator to save memory. An UniquePtr<PointLocatorBase> is returned to prevent memory leak. This way the user need not remember to delete the object.

Definition at line 64 of file point_locator_base.C.

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

Referenced by libMesh::MeshBase::point_locator(), and libMesh::MeshBase::sub_point_locator().

{
  switch (t)
    {
    case TREE:
      return UniquePtr<PointLocatorBase>(new PointLocatorTree(mesh, /*Trees::NODES,*/ master));

    case TREE_ELEMENTS:
      return UniquePtr<PointLocatorBase>(new PointLocatorTree(mesh, Trees::ELEMENTS, master));

    case TREE_LOCAL_ELEMENTS:
      return UniquePtr<PointLocatorBase>(new PointLocatorTree(mesh, Trees::LOCAL_ELEMENTS, master));

    case LIST:
      return UniquePtr<PointLocatorBase>(new PointLocatorList(mesh, master));

    default:
      libmesh_error_msg("ERROR: Bad PointLocatorType = " << t);
    }

  libmesh_error_msg("We'll never get here!");
  return UniquePtr<PointLocatorBase>();
}

void libMesh::PointLocatorTree::clear

(

)

[virtual]

Clears the locator. This function frees dynamic memory with "delete".

Implements libMesh::PointLocatorBase.

Definition at line 73 of file point_locator_tree.C.

References libMesh::PointLocatorBase::_master, and _tree.

Referenced by ~PointLocatorTree().

{
  // only delete the tree when we are the master
  if (this->_tree != NULL)
    {
      if (this->_master == NULL)
        // we own the tree
        delete this->_tree;
      else
        // someone else owns and therefore deletes the tree
        this->_tree = NULL;
    }
}

void libMesh::PointLocatorTree::disable_out_of_mesh_mode

(

void

)

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

Implements libMesh::PointLocatorBase.

Definition at line 336 of file point_locator_tree.C.

References _out_of_mesh_mode.

{
  _out_of_mesh_mode = false;
}

void libMesh::ReferenceCounter::disable_print_counter_info

(

)

[static, inherited]

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

{
  _enable_print_counter = false;
  return;
}

void libMesh::PointLocatorTree::enable_out_of_mesh_mode

(

)

[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 NULL pointer instead of crashing. Per default, this mode is off.

Implements libMesh::PointLocatorBase.

Definition at line 313 of file point_locator_tree.C.

References libMesh::PointLocatorBase::_mesh, _out_of_mesh_mode, libMesh::MeshBase::active_elements_begin(), and libMesh::MeshBase::active_elements_end().

{
  // Out-of-mesh mode is currently only supported if all of the
  // elements have affine mappings.  The reason is that for quadratic
  // mappings, it is not easy to construct a reliable bounding box of
  // the element, and thus, the fallback linear search in \p
  // operator() is required.  Hence, out-of-mesh mode would be
  // extremely slow.
  if (_out_of_mesh_mode == false)
    {
#ifdef DEBUG
      MeshBase::const_element_iterator       pos     = this->_mesh.active_elements_begin();
      const MeshBase::const_element_iterator end_pos = this->_mesh.active_elements_end();
      for ( ; pos != end_pos; ++pos)
        if (!(*pos)->has_affine_map())
          libmesh_error_msg("ERROR: Out-of-mesh mode is currently only supported if all elements have affine mappings.");
#endif

      _out_of_mesh_mode = true;
    }
}

void libMesh::ReferenceCounter::enable_print_counter_info

(

)

[static, inherited]

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.

{
  _enable_print_counter = true;
  return;
}

std::string libMesh::ReferenceCounter::get_info

(

)

[static, inherited]

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

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)

  std::ostringstream oss;

  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";

  for (Counts::iterator it = _counts.begin();
       it != _counts.end(); ++it)
    {
      const std::string name(it->first);
      const unsigned int creations    = it->second.first;
      const unsigned int destructions = it->second.second;

      oss << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }

  oss << " ---------------------------------------------------------------------------- \n";

  return oss.str();

#else

  return "";

#endif
}

unsigned int libMesh::PointLocatorTree::get_target_bin_size

(

)

const

Get the target bin size.

Definition at line 348 of file point_locator_tree.C.

References _target_bin_size.

Referenced by init().

{
  return _target_bin_size;
}

void libMesh::ReferenceCounter::increment_constructor_count

(

const std::string &

name

)

[inline, protected, inherited]

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

Definition at line 163 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.first++;
}

void libMesh::ReferenceCounter::increment_destructor_count

(

const std::string &

name

)

[inline, protected, inherited]

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

Definition at line 176 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.second++;
}

void libMesh::PointLocatorTree::init

(

Trees::BuildType

build_type

)

Initializes the locator, so that the operator() methods can be used. This function allocates dynamic memory with "new".

Definition at line 96 of file point_locator_tree.C.

References _build_type, _element, libMesh::PointLocatorBase::_initialized, libMesh::PointLocatorBase::_master, libMesh::PointLocatorBase::_mesh, _tree, std::abs(), libMesh::MeshTools::bounding_box(), libMesh::err, get_target_bin_size(), libMesh::PointLocatorBase::initialized(), libMesh::libmesh_assert(), libMesh::MeshBase::mesh_dimension(), libMesh::Real, and libMesh::START_LOG().

{
  libmesh_assert (!this->_tree);

  if (this->_initialized)
    {
      // Warn that we are already initialized
      libMesh::err << "Warning: PointLocatorTree already initialized!  Will ignore this call..." << std::endl;

      // Further warn if we try to init() again with a different build_type
      if (_build_type != build_type)
        {
          libMesh::err << "Warning: PointLocatorTree is using build_type = " << _build_type << ".\n"
                       << "Your requested build_type, " << build_type << " will not be used!" << std::endl;
        }
    }

  else
    {
      // Let the requested build_type override the _build_type we were
      // constructed with.  This is no big deal since we have not been
      // initialized before.
      _build_type = build_type;

      if (this->_master == NULL)
        {
          START_LOG("init(no master)", "PointLocatorTree");

          if (this->_mesh.mesh_dimension() == 3)
            _tree = new Trees::OctTree (this->_mesh, get_target_bin_size(), _build_type);
          else
            {
              // A 1D/2D mesh in 3D space needs special consideration.
              // If the mesh is planar XY, we want to build a QuadTree
              // to search efficiently.  If the mesh is truly a manifold,
              // then we need an octree
#if LIBMESH_DIM > 2
              bool is_planar_xy = false;

              // Build the bounding box for the mesh.  If the delta-z bound is
              // negligibly small then we can use a quadtree.
              {
                MeshTools::BoundingBox bbox = MeshTools::bounding_box(this->_mesh);

                const Real
                  Dx = bbox.second(0) - bbox.first(0),
                  Dz = bbox.second(2) - bbox.first(2);

                if (std::abs(Dz/(Dx + 1.e-20)) < 1e-10)
                  is_planar_xy = true;
              }

              if (!is_planar_xy)
                _tree = new Trees::OctTree (this->_mesh, get_target_bin_size(), _build_type);
              else
#endif
#if LIBMESH_DIM > 1
                _tree = new Trees::QuadTree (this->_mesh, get_target_bin_size(), _build_type);
#else
              _tree = new Trees::BinaryTree (this->_mesh, get_target_bin_size(), _build_type);
#endif
            }

          STOP_LOG("init(no master)", "PointLocatorTree");
        }

      else
        {
          // We are _not_ the master.  Let our Tree point to
          // the master's tree.  But for this we first transform
          // the master in a state for which we are friends.
          // And make sure the master @e has a tree!
          const PointLocatorTree* my_master =
            cast_ptr<const PointLocatorTree*>(this->_master);

          if (my_master->initialized())
            this->_tree = my_master->_tree;
          else
            libmesh_error_msg("ERROR: Initialize master first, then servants!");
        }

      // Not all PointLocators may own a tree, but all of them
      // use their own element pointer.  Let the element pointer
      // be unique for every interpolator.
      // Suppose the interpolators are used concurrently
      // at different locations in the mesh, then it makes quite
      // sense to have unique start elements.
      this->_element = NULL;
    }

  // ready for take-off
  this->_initialized = true;
}

void libMesh::PointLocatorTree::init

(

)

[virtual]

Initializes the locator, so that the operator() methods can be used. This function allocates dynamic memory with "new".

Implements libMesh::PointLocatorBase.

Definition at line 89 of file point_locator_tree.C.

References _build_type.

Referenced by PointLocatorTree().

{
  this->init(_build_type);
}

bool libMesh::PointLocatorBase::initialized

(

)

const [inherited]

Returns:

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

Definition at line 57 of file point_locator_base.C.

References libMesh::PointLocatorBase::_initialized.

Referenced by init(), and libMesh::PointLocatorList::init().

{
  return this->_initialized;
}

static unsigned int libMesh::ReferenceCounter::n_objects

(

)

[inline, static, inherited]

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

Definition at line 79 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

  { return _n_objects; }

const Elem * libMesh::PointLocatorTree::operator()	(	const Point &	p,
		const std::set< subdomain_id_type > *	allowed_subdomains = NULL
	)		const [virtual]

Locates the element in which the point with global coordinates p is located, optionally restricted to a set of allowed subdomains. The mutable _element member is used to cache the result and allow it to be used during the next call to operator().

Implements libMesh::PointLocatorBase.

Definition at line 192 of file point_locator_tree.C.

References libMesh::PointLocatorBase::_close_to_point_tol, _element, libMesh::PointLocatorBase::_initialized, _out_of_mesh_mode, _tree, libMesh::PointLocatorBase::_use_close_to_point_tol, libMesh::PointLocatorBase::_verbose, libMesh::Elem::active(), libMesh::Elem::contains_point(), libMesh::TreeBase::find_element(), libMesh::libmesh_assert(), libMesh::out, perform_linear_search(), and libMesh::START_LOG().

{
  libmesh_assert (this->_initialized);

  START_LOG("operator()", "PointLocatorTree");

  // If we're provided with an allowed_subdomains list and have a cached element, make sure it complies
  if (allowed_subdomains && this->_element && !allowed_subdomains->count(this->_element->subdomain_id())) this->_element = NULL;

  // First check the element from last time before asking the tree
  if (this->_element==NULL || !(this->_element->contains_point(p)))
    {
      // ask the tree
      this->_element = this->_tree->find_element (p,allowed_subdomains);

      if (this->_element == NULL)
        {
          // No element seems to contain this point. Thus:
          // 1.) If _out_of_mesh_mode == true, we can just return NULL
          //     without searching further.
          // 2.) If _out_of_mesh_mode == false, we perform a linear
          //     search over all active (possibly local) elements.
          //     The idea here is that, in the case of curved elements,
          //     the bounding box computed in \p TreeNode::insert(const
          //     Elem*) might be slightly inaccurate and therefore we may
          //     have generated a false negative.
          if (_out_of_mesh_mode == false)
            {
              this->_element = this->perform_linear_search(p, allowed_subdomains, /*use_close_to_point*/ false);

              STOP_LOG("operator()", "PointLocatorTree");
              return this->_element;
            }

          // If we haven't found the element, we may want to do a linear
          // search using a tolerance. We only do this if _out_of_mesh_mode == true,
          // since we're looking for a point that may be outside of the mesh (within the
          // specified tolerance).
          if( _use_close_to_point_tol )
            {
              if(_verbose)
                {
                  libMesh::out << "Performing linear search using close-to-point tolerance "
                               << _close_to_point_tol
                               << std::endl;
                }

              this->_element =
                this->perform_linear_search(p,
                                            allowed_subdomains,
                                            /*use_close_to_point*/ true,
                                            _close_to_point_tol);

              STOP_LOG("operator()", "PointLocatorTree");
              return this->_element;
            }
        }
    }

  // If we found an element, it should be active
  libmesh_assert (!this->_element || this->_element->active());

  // If we found an element and have a restriction list, they better match
  libmesh_assert (!this->_element || !allowed_subdomains || allowed_subdomains->count(this->_element->subdomain_id()));

  STOP_LOG("operator()", "PointLocatorTree");

  // return the element
  return this->_element;
}

const Elem * libMesh::PointLocatorTree::perform_linear_search	(	const Point &	p,
		const std::set< subdomain_id_type > *	allowed_subdomains,
		bool	use_close_to_point,
		Real	close_to_point_tolerance = TOLERANCE
	)		const

As a fallback option, it's helpful to be able to do a linear search over the entire mesh. This can be used if operator() fails to find an element that contains p, for example. Optionally specify a "close to point" tolerance to use in the linear search. Return NULL if no element is found.

Definition at line 265 of file point_locator_tree.C.

References _build_type, libMesh::PointLocatorBase::_mesh, libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), libMesh::MeshBase::active_local_elements_begin(), libMesh::MeshBase::active_local_elements_end(), libMesh::Trees::LOCAL_ELEMENTS, and libMesh::START_LOG().

Referenced by operator()().

{
  START_LOG("perform_linear_search", "PointLocatorTree");

  // The type of iterator depends on the Trees::BuildType
  // used for this PointLocator.  If it's
  // TREE_LOCAL_ELEMENTS, we only want to double check
  // local elements during this linear search.
  MeshBase::const_element_iterator pos =
    this->_build_type == Trees::LOCAL_ELEMENTS ?
    this->_mesh.active_local_elements_begin() : this->_mesh.active_elements_begin();

  const MeshBase::const_element_iterator end_pos =
    this->_build_type == Trees::LOCAL_ELEMENTS ?
    this->_mesh.active_local_elements_end() : this->_mesh.active_elements_end();

  for ( ; pos != end_pos; ++pos)
    {
      if (!allowed_subdomains ||
          allowed_subdomains->count((*pos)->subdomain_id()))
        {
          if(!use_close_to_point)
            {
              if ((*pos)->contains_point(p))
                {
                  STOP_LOG("perform_linear_search", "PointLocatorTree");
                  return (*pos);
                }
            }
          else
            {
              if ((*pos)->close_to_point(p, close_to_point_tolerance))
                {
                  STOP_LOG("perform_linear_search", "PointLocatorTree");
                  return (*pos);
                }
            }
        }
    }

  STOP_LOG("perform_linear_search", "PointLocatorTree");
  return NULL;
}

void libMesh::ReferenceCounter::print_info

(

std::ostream &

out = libMesh::out

)

[static, inherited]

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

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

void libMesh::PointLocatorBase::set_close_to_point_tol

(

Real

close_to_point_tol

)

[virtual, inherited]

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

Reimplemented in libMesh::PointLocatorList.

Definition at line 90 of file point_locator_base.C.

References libMesh::PointLocatorBase::_close_to_point_tol, and libMesh::PointLocatorBase::_use_close_to_point_tol.

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

{
  _use_close_to_point_tol = true;
  _close_to_point_tol = close_to_point_tol;
}

void libMesh::PointLocatorTree::set_target_bin_size

(

unsigned int

target

)

Set the target bin size.

Definition at line 342 of file point_locator_tree.C.

References _target_bin_size.

{
  _target_bin_size = target_bin_size;
}

void libMesh::PointLocatorBase::unset_close_to_point_tol

(

)

[virtual, inherited]

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

Reimplemented in libMesh::PointLocatorList.

Definition at line 97 of file point_locator_base.C.

References libMesh::PointLocatorBase::_close_to_point_tol, libMesh::PointLocatorBase::_use_close_to_point_tol, and libMesh::TOLERANCE.

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

{
  _use_close_to_point_tol = false;
  _close_to_point_tol = TOLERANCE;
}

---

Member Data Documentation

Trees::BuildType libMesh::PointLocatorTree::_build_type [protected]

How the underlying tree is built.

Definition at line 177 of file point_locator_tree.h.

Referenced by init(), perform_linear_search(), and PointLocatorTree().

Real libMesh::PointLocatorBase::_close_to_point_tol [protected, inherited]

The tolerance to use.

Definition at line 164 of file point_locator_base.h.

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

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts [static, protected, inherited]

Actually holds the data.

Definition at line 118 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

const Elem* libMesh::PointLocatorTree::_element [mutable, protected]

Pointer to the last element that was found by the tree. Chances are that this may be close to the next call to operator()...

Definition at line 161 of file point_locator_tree.h.

Referenced by init(), and operator()().

bool libMesh::ReferenceCounter::_enable_print_counter = true [static, protected, inherited]

Flag to control whether reference count information is printed when print_info is called.

Definition at line 137 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

bool libMesh::PointLocatorBase::_initialized [protected, inherited]

true when properly initialized, false otherwise.

Definition at line 153 of file point_locator_base.h.

Referenced by init(), libMesh::PointLocatorList::init(), libMesh::PointLocatorBase::initialized(), libMesh::PointLocatorList::operator()(), and operator()().

const PointLocatorBase* libMesh::PointLocatorBase::_master [protected, inherited]

Const pointer to our master, initialized to NULL 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 143 of file point_locator_base.h.

Referenced by clear(), libMesh::PointLocatorList::clear(), init(), and libMesh::PointLocatorList::init().

const MeshBase& libMesh::PointLocatorBase::_mesh [protected, inherited]

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

Definition at line 148 of file point_locator_base.h.

Referenced by enable_out_of_mesh_mode(), init(), libMesh::PointLocatorList::init(), and perform_linear_search().

Threads::spin_mutex libMesh::ReferenceCounter::_mutex [static, protected, inherited]

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 131 of file reference_counter.h.

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects [static, protected, inherited]

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 126 of file reference_counter.h.

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

bool libMesh::PointLocatorTree::_out_of_mesh_mode [protected]

true if out-of-mesh mode is enabled. See enable_out_of_mesh_mode() for details.

Definition at line 167 of file point_locator_tree.h.

Referenced by disable_out_of_mesh_mode(), enable_out_of_mesh_mode(), and operator()().

unsigned int libMesh::PointLocatorTree::_target_bin_size [protected]

Target bin size, which gets passed to the constructor of _tree.

Definition at line 172 of file point_locator_tree.h.

Referenced by get_target_bin_size(), and set_target_bin_size().

TreeBase* libMesh::PointLocatorTree::_tree [protected]

Pointer to our tree. The tree is built at run-time through init(). For servant PointLocators (not master), this simply points to the tree of the master.

Definition at line 154 of file point_locator_tree.h.

Referenced by clear(), init(), and operator()().

bool libMesh::PointLocatorBase::_use_close_to_point_tol [protected, inherited]

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

Definition at line 159 of file point_locator_base.h.

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

bool libMesh::PointLocatorBase::_verbose [inherited]

Boolean flag to indicate whether to print out extra info.

Definition at line 135 of file point_locator_base.h.

Referenced by operator()().

---

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

• point_locator_tree.h
• point_locator_tree.C