libMesh::LocationMap< T > Class Template Reference

std::map-like data structure using hashed Points for keys. More...

#include <location_maps.h>

Public Member Functions
void	init (MeshBase &)
void	clear ()
void	insert (T &)
bool	empty () const
T *	find (const Point &, const Real tol=TOLERANCE)
Point	point_of (const T &) const
template<>
Point	point_of (const Node &node) const
template<>
Point	point_of (const Elem &elem) const

Protected Member Functions
unsigned int	key (const Point &)
void	fill (MeshBase &)
template<>
void	fill (MeshBase &mesh)
template<>
void	fill (MeshBase &mesh)

Private Types
typedef std::unordered_multimap< unsigned int, T * >	map_type

Private Attributes
map_type	_map
std::vector< Real >	_lower_bound
std::vector< Real >	_upper_bound

Detailed Description

template<typename T>
class libMesh::LocationMap< T >

std::map-like data structure using hashed Points for keys.

Data structures that enable location-based lookups The key is a hash of the Point location. For efficiency we will use a hashed multimap if it is available, otherwise a regular multimap.

Author

Roy Stogner

Date

2008

Definition at line 53 of file location_maps.h.

Member Typedef Documentation

map_type

template<typename T>

typedef std::unordered_multimap<unsigned int, T *> libMesh::LocationMap< T >::map_type

private

Definition at line 55 of file location_maps.h.

Member Function Documentation

clear()

template<typename T>

void libMesh::LocationMap< T >::clear ( )

inline

Definition at line 59 of file location_maps.h.

References libMesh::LocationMap< T >::_map.

{ _map.clear(); }

empty()

template<typename T>

bool libMesh::LocationMap< T >::empty ( ) const

inline

Definition at line 63 of file location_maps.h.

References libMesh::LocationMap< T >::_map.

Referenced by libMesh::Parallel::sync_dofobject_data_by_xyz().

{ return _map.empty(); }

fill() [1/3]

template<typename T>

void libMesh::LocationMap< T >::fill ( MeshBase &  )

protected

fill() [2/3]

template<>

void libMesh::LocationMap< Node >::fill ( MeshBase &  mesh )

protected

Definition at line 183 of file location_maps.C.

References mesh, and libMesh::MeshBase::node_ptr_range().

{
  // Populate the nodes map
  for (auto & node : mesh.node_ptr_range())
    this->insert(*node);
}

fill() [3/3]

template<>

void libMesh::LocationMap< Elem >::fill ( MeshBase &  mesh )

protected

Definition at line 193 of file location_maps.C.

References libMesh::MeshBase::active_element_ptr_range(), and mesh.

{
  // Populate the elem map
  for (auto & elem : mesh.active_element_ptr_range())
    this->insert(*elem);
}

find()

template<typename T >

T * libMesh::LocationMap< T >::find	(	const Point &	p,
		const Real	tol = TOLERANCE
	)

Definition at line 111 of file location_maps.C.

References libMesh::TypeVector< T >::absolute_fuzzy_equals(), and libMesh::as_range().

Referenced by libMesh::Parallel::sync_dofobject_data_by_xyz().

{
  LOG_SCOPE("find()", "LocationMap");

  // Look for a likely key in the multimap
  unsigned int pointkey = this->key(p);

  // Look for the exact key first
  for (const auto & pr : as_range(_map.equal_range(pointkey)))
    if (p.absolute_fuzzy_equals(this->point_of(*(pr.second)), tol))
      return pr.second;

  // Look for neighboring bins' keys next
  for (int xoffset = -1; xoffset != 2; ++xoffset)
    {
      for (int yoffset = -1; yoffset != 2; ++yoffset)
        {
          for (int zoffset = -1; zoffset != 2; ++zoffset)
            {
              auto key_pos = _map.equal_range(pointkey +
                                              xoffset*chunkmax*chunkmax +
                                              yoffset*chunkmax +
                                              zoffset);
              for (const auto & pr : as_range(key_pos))
                if (p.absolute_fuzzy_equals(this->point_of(*(pr.second)), tol))
                  return pr.second;
            }
        }
    }

  return nullptr;
}

init()

template<typename T >

void libMesh::LocationMap< T >::init

(

MeshBase &

mesh

)

Definition at line 46 of file location_maps.C.

References libMesh::ParallelObject::comm(), libMesh::MeshBase::is_serial(), std::max(), libMesh::Parallel::Communicator::max(), mesh, std::min(), libMesh::Parallel::Communicator::min(), and libMesh::MeshBase::node_ptr_range().

{
  // This function must be run on all processors at once
  // for non-serial meshes
  if (!mesh.is_serial())
    libmesh_parallel_only(mesh.comm());

  LOG_SCOPE("init()", "LocationMap");

  // Clear the old map
  _map.clear();

  // Cache a bounding box
  _lower_bound.clear();
  _lower_bound.resize(LIBMESH_DIM, std::numeric_limits<Real>::max());
  _upper_bound.clear();
  _upper_bound.resize(LIBMESH_DIM, -std::numeric_limits<Real>::max());

  for (auto & node : mesh.node_ptr_range())
    for (unsigned int i=0; i != LIBMESH_DIM; ++i)
      {
        // Expand the bounding box if necessary
        _lower_bound[i] = std::min(_lower_bound[i],
                                   (*node)(i));
        _upper_bound[i] = std::max(_upper_bound[i],
                                   (*node)(i));
      }

  // On a parallel mesh we might not yet have a full bounding box
  if (!mesh.is_serial())
    {
      mesh.comm().min(_lower_bound);
      mesh.comm().max(_upper_bound);
    }

  this->fill(mesh);
}

insert()

template<typename T >

void libMesh::LocationMap< T >::insert

(

T &

t

)

Definition at line 87 of file location_maps.C.

{
  this->_map.insert(std::make_pair(this->key(this->point_of(t)), &t));
}

key()

template<typename T >

unsigned int libMesh::LocationMap< T >::key ( const Point &  p )

protected

Definition at line 148 of file location_maps.C.

References std::abs(), libMesh::Real, and libMesh::TOLERANCE.

{
  Real xscaled = 0., yscaled = 0., zscaled = 0.;

  Real deltax = _upper_bound[0] - _lower_bound[0];

  if (std::abs(deltax) > TOLERANCE)
    xscaled = (p(0) - _lower_bound[0])/deltax;

  // Only check y-coords if libmesh is compiled with LIBMESH_DIM>1
#if LIBMESH_DIM > 1
  Real deltay = _upper_bound[1] - _lower_bound[1];

  if (std::abs(deltay) > TOLERANCE)
    yscaled = (p(1) - _lower_bound[1])/deltay;
#endif

  // Only check z-coords if libmesh is compiled with LIBMESH_DIM>2
#if LIBMESH_DIM > 2
  Real deltaz = _upper_bound[2] - _lower_bound[2];

  if (std::abs(deltaz) > TOLERANCE)
    zscaled = (p(2) - _lower_bound[2])/deltaz;
#endif

  unsigned int n0 = static_cast<unsigned int> (chunkfloat * xscaled),
    n1 = static_cast<unsigned int> (chunkfloat * yscaled),
    n2 = static_cast<unsigned int> (chunkfloat * zscaled);

  return chunkmax*chunkmax*n0 + chunkmax*n1 + n2;
}

point_of() [1/3]

template<typename T>

Point libMesh::LocationMap< T >::point_of

(

const T &

)

const

Referenced by libMesh::Parallel::sync_dofobject_data_by_xyz().

point_of() [2/3]

template<>

Point libMesh::LocationMap< Node >::point_of

(

const Node &

node

)

const

Definition at line 95 of file location_maps.C.

{
  return node;
}

point_of() [3/3]

template<>

Point libMesh::LocationMap< Elem >::point_of

(

const Elem &

elem

)

const

Definition at line 103 of file location_maps.C.

References libMesh::Elem::centroid().

{
  return elem.centroid();
}

Member Data Documentation

_lower_bound

template<typename T>

std::vector<Real> libMesh::LocationMap< T >::_lower_bound

private

Definition at line 77 of file location_maps.h.

_map

template<typename T>

map_type libMesh::LocationMap< T >::_map

private

Definition at line 76 of file location_maps.h.

Referenced by libMesh::LocationMap< T >::clear(), and libMesh::LocationMap< T >::empty().

_upper_bound

template<typename T>

std::vector<Real> libMesh::LocationMap< T >::_upper_bound

private

Definition at line 78 of file location_maps.h.

---

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

• location_maps.h
• location_maps.C