DiracKernelInfo Class Reference

The DiracKernelInfo object is a place where all the Dirac points added by different DiracKernels are collected. More...

#include <DiracKernelInfo.h>

Public Types
typedef std::map< const Elem *, std::pair< std::vector< Point >, std::vector< Real > > >	MultiPointMap

Public Member Functions
	DiracKernelInfo ()
virtual	~DiracKernelInfo ()
void	addPoint (const Elem *elem, const Point &p, const Real &value=1)
	Adds a point source.
void	clearPoints ()
	Remove all of the current points and elements.
bool	hasPoint (const Elem *elem, const Point &p)
	Return true if we have Point 'p' in Element 'elem'.
std::set< const Elem * > &	getElements ()
	Returns a writeable reference to the _elements container.
MultiPointMap &	getPoints ()
	Returns a writeable reference to the _points container.
void	updatePointLocator (const MooseMesh &mesh)
	Called during FEProblemBase::meshChanged() to update the PointLocator object used by the DiracKernels.
	CreateMooseEnumClass (PointNotFoundBehavior, ERROR, WARNING, IGNORE)
	Point-not-found behavior.
const Elem *	findPoint (const Point &p, const MooseMesh &mesh, const std::set< SubdomainID > &blocks, const PointNotFoundBehavior point_not_found_behavior, const MooseBase &consumer)
	Used by client DiracKernel classes to determine the Elem in which the Point p resides.

Protected Member Functions
bool	pointsFuzzyEqual (const Point &, const Point &)
	Check if two points are equal with respect to a tolerance.

Protected Attributes
std::set< const Elem * >	_elements
	The list of elements that need distributions.
MultiPointMap	_points
	The list of physical xyz Points that need to be evaluated in each element.
std::unique_ptr< libMesh::PointLocatorBase >	_point_locator
	The DiracKernelInfo object manages a PointLocator object which is used by all DiracKernels to find Points.
const Real	_point_equal_distance_sq
	threshold distance squared below which two points are considered identical

Detailed Description

The DiracKernelInfo object is a place where all the Dirac points added by different DiracKernels are collected.

It is used, for example, by the FEProblemBase class to determine if finite element data needs to be recomputed on a given element.

Definition at line 37 of file DiracKernelInfo.h.

Member Typedef Documentation

MultiPointMap

typedef std::map<const Elem *, std::pair<std::vector<Point>, std::vector<Real> > > DiracKernelInfo::MultiPointMap

Definition at line 67 of file DiracKernelInfo.h.

Constructor & Destructor Documentation

DiracKernelInfo()

DiracKernelInfo::DiracKernelInfo

(

)

Definition at line 24 of file DiracKernelInfo.C.

  : _point_locator(), _point_equal_distance_sq(libMesh::TOLERANCE * libMesh::TOLERANCE)
{
}

~DiracKernelInfo()

DiracKernelInfo::~DiracKernelInfo ( )

virtual

Definition at line 29 of file DiracKernelInfo.C.

{}

Member Function Documentation

addPoint()

void DiracKernelInfo::addPoint	(	const Elem *	elem,
		const Point &	p,
		const Real &	value = 1
	)

Adds a point source.

Parameters

elem	Pointer to the geometric element in which the point is located
p	The (x,y,z) location of the Dirac point
value	The value accumulated for this point when it coincides with an existing point

Definition at line 32 of file DiracKernelInfo.C.

{
  _elements.insert(elem);
 
  std::pair<std::vector<Point>, std::vector<Real>> & multi_point_list = _points[elem];
 
  const unsigned int npoint = multi_point_list.first.size();
  mooseAssert(npoint == multi_point_list.second.size(),
              "Different sizes for location and point value data");
 
  for (unsigned int i = 0; i < npoint; ++i)
    if (pointsFuzzyEqual(multi_point_list.first[i], p))
    {
      // A point at the same (within a tolerance) location as p exists, accumulate its value.
      multi_point_list.second[i] += value;
      return;
    }
 
  // No prior point found at this location, add it with its initial value.
  multi_point_list.first.push_back(p);
  multi_point_list.second.push_back(value);
}

Referenced by DiracKernelBase::addPoint().

clearPoints()

void DiracKernelInfo::clearPoints

(

)

Remove all of the current points and elements.

Definition at line 56 of file DiracKernelInfo.C.

{
  _elements.clear();
  _points.clear();
}

Referenced by DisplacedProblem::clearDiracInfo(), FEProblemBase::clearDiracInfo(), and DiracKernelBase::clearPoints().

CreateMooseEnumClass()

DiracKernelInfo::CreateMooseEnumClass	(	PointNotFoundBehavior	,
		ERROR	,
		WARNING	,
		IGNORE
	)

Point-not-found behavior.

findPoint()

const Elem * DiracKernelInfo::findPoint	(	const Point &	p,
		const MooseMesh &	mesh,
		const std::set< SubdomainID > &	blocks,
		const PointNotFoundBehavior	point_not_found_behavior,
		const MooseBase &	consumer
	)

Used by client DiracKernel classes to determine the Elem in which the Point p resides.

Uses the PointLocator owned by this object.

Parameters

p	the point to find the element which contains it
mesh	the mesh with elements to look at
blocks	block restriction to find the element in
point_not_found_behavior	what to do if the point is not found
consumer	the object calling calling this routine

Definition at line 116 of file DiracKernelInfo.C.

{
  // If the PointLocator has never been created, do so now.  NOTE - WE
  // CAN'T DO THIS if findPoint() is only called on some processors,
  // PointLocatorBase::build() is a 'parallel_only' method!
  if (_point_locator.get() == NULL)
  {
    _point_locator = PointLocatorBase::build(TREE_LOCAL_ELEMENTS, mesh);
    _point_locator->enable_out_of_mesh_mode();
  }
 
  // Check that the PointLocator is ready to start locating points.
  // So far I do not have any tests that trip this...
  if (_point_locator->initialized() == false)
    consumer.mooseError("PointLocator is not initialized!");
 
  // Note: The PointLocator object returns NULL when the Point is not
  // found within the Mesh.  This is not considered to be an error as
  // far as the DiracKernels are concerned: sometimes the Mesh moves
  // out from the Dirac point entirely and in that case the Point just
  // gets "deactivated".
  const Elem * elem = (*_point_locator)(p, &blocks);
 
  // The processors may not agree on which Elem the point is in.  This
  // can happen if a Dirac point lies on the processor boundary, and
  // two or more neighboring processors think the point is in the Elem
  // on *their* side.
  dof_id_type elem_id = elem ? elem->id() : DofObject::invalid_id;
 
  // We are going to let the element with the smallest ID "win", all other
  // procs will return NULL.
  dof_id_type min_elem_id = elem_id;
  mesh.comm().min(min_elem_id);
 
  if (min_elem_id == DofObject::invalid_id)
  {
    std::stringstream msg;
    msg << "Point " << p << " not found in block(s) " << Moose::stringify(blocks, ", ") << ".\n";
    switch (point_not_found_behavior)
    {
      case PointNotFoundBehavior::ERROR:
        consumer.mooseError(msg.str());
        break;
      case PointNotFoundBehavior::WARNING:
        mooseDoOnce(consumer.mooseWarning(msg.str() + "This message will not be repeated."));
        break;
      case PointNotFoundBehavior::IGNORE:
        break;
      default:
        consumer.mooseError("Internal enum error.");
    }
  }
 
  // But we notably need the processor which owns elem_id to return it!
  if (min_elem_id != DofObject::invalid_id)
    if (const auto min_elem = mesh.queryElemPtr(min_elem_id);
        min_elem && min_elem->processor_id() == mesh.processor_id())
      return min_elem;
  return nullptr;
}

Referenced by DiracKernelBase::addPoint(), and DiracKernelBase::addPointWithValidId().

getElements()

std::set< const Elem * > & DiracKernelInfo::getElements ( )

inline

Returns a writeable reference to the _elements container.

Definition at line 65 of file DiracKernelInfo.h.

{ return _elements; }

Referenced by DisplacedProblem::getDiracElements(), FEProblemBase::getDiracElements(), and DiracKernelBase::hasPointsOnElem().

getPoints()

MultiPointMap & DiracKernelInfo::getPoints ( )

inline

Returns a writeable reference to the _points container.

Definition at line 72 of file DiracKernelInfo.h.

{ return _points; }

Referenced by ADDiracKernel::computeADResiduals(), DisplacedProblem::reinitDirac(), and FEProblemBase::reinitDirac().

hasPoint()

bool DiracKernelInfo::hasPoint	(	const Elem *	elem,
		const Point &	p
	)

Return true if we have Point 'p' in Element 'elem'.

Definition at line 63 of file DiracKernelInfo.C.

{
  std::vector<Point> & point_list = _points[elem].first;
 
  for (const auto & pt : point_list)
    if (pointsFuzzyEqual(pt, p))
      return true;
 
  // If we haven't found it, we don't have it.
  return false;
}

Referenced by DiracKernelBase::isActiveAtPoint().

pointsFuzzyEqual()

bool DiracKernelInfo::pointsFuzzyEqual ( const Point &  , const Point &    )

protected

Check if two points are equal with respect to a tolerance.

Definition at line 182 of file DiracKernelInfo.C.

{
  const Real dist_sq = (a - b).norm_sq();
  return dist_sq < _point_equal_distance_sq;
}

Referenced by addPoint(), and hasPoint().

updatePointLocator()

void DiracKernelInfo::updatePointLocator

(

const MooseMesh &

mesh

)

Called during FEProblemBase::meshChanged() to update the PointLocator object used by the DiracKernels.

Definition at line 76 of file DiracKernelInfo.C.

{
  // Note: we could update the PointLocator *every* time we call this
  // function, but that may introduce an unacceptable overhead in
  // problems which don't need a PointLocator at all.  This issue will
  // most likely become a moot point when we eventually add a shared
  // "CachingPointLocator" to MOOSE.
  // _point_locator = PointLocatorBase::build(TREE_LOCAL_ELEMENTS, mesh);
 
  // Construct the PointLocator object if *any* processors have Dirac
  // points.  Note: building a PointLocator object is a parallel_only()
  // function, so this is an all-or-nothing thing.
  unsigned pl_needs_rebuild = _elements.size();
  mesh.comm().max(pl_needs_rebuild);
 
  if (pl_needs_rebuild)
  {
    // PointLocatorBase::build() is a parallel_only function!  So we
    // can't skip building it just becuase our local _elements is
    // empty, it might be non-empty on some other processor!
    _point_locator = PointLocatorBase::build(TREE_LOCAL_ELEMENTS, mesh);
 
    // We may be querying for points which are not in the semilocal
    // part of a distributed mesh.
    _point_locator->enable_out_of_mesh_mode();
  }
  else
  {
    // There are no elements with Dirac points, but we have been
    // requested to update the PointLocator so we have to assume the
    // old one is invalid.  Therefore we reset it to NULL... however
    // adding this line causes the code to hang because it triggers
    // the PointLocator to be rebuilt in a non-parallel-only segment
    // of the code later... so it's commented out for now even though
    // it's probably the right behavior.
    // _point_locator.reset(NULL);
  }
}

Referenced by FEProblemBase::meshChanged(), and DisplacedProblem::updateMesh().

Member Data Documentation

_elements

std::set<const Elem *> DiracKernelInfo::_elements

protected

The list of elements that need distributions.

Definition at line 105 of file DiracKernelInfo.h.

Referenced by addPoint(), clearPoints(), getElements(), and updatePointLocator().

_point_equal_distance_sq

const Real DiracKernelInfo::_point_equal_distance_sq

protected

threshold distance squared below which two points are considered identical

Definition at line 117 of file DiracKernelInfo.h.

Referenced by pointsFuzzyEqual().

_point_locator

std::unique_ptr<libMesh::PointLocatorBase> DiracKernelInfo::_point_locator

protected

The DiracKernelInfo object manages a PointLocator object which is used by all DiracKernels to find Points.

It needs to be centrally managed and it also needs to be rebuilt in FEProblemBase::meshChanged() to work with Mesh adaptivity.

Definition at line 114 of file DiracKernelInfo.h.

Referenced by findPoint(), and updatePointLocator().

_points

MultiPointMap DiracKernelInfo::_points

protected

The list of physical xyz Points that need to be evaluated in each element.

Definition at line 108 of file DiracKernelInfo.h.

Referenced by addPoint(), clearPoints(), getPoints(), and hasPoint().

---

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

• include/dirackernels/DiracKernelInfo.h
• src/dirackernels/DiracKernelInfo.C