GeometricSearchData Class Reference

#include <GeometricSearchData.h>

Public Types
enum	GeometricSearchType {   ALL , NEAREST_NODE , PENETRATION , QUADRATURE ,   ELEMENTPAIR }
	Used to select groups of geometric search objects to update. More...

Public Member Functions
	GeometricSearchData (SubProblem &subproblem, MooseMesh &mesh)
virtual	~GeometricSearchData ()
PenetrationLocator &	getPenetrationLocator (const BoundaryName &primary, const BoundaryName &secondary, libMesh::Order order=libMesh::FIRST)
PenetrationLocator &	getQuadraturePenetrationLocator (const BoundaryName &primary, const BoundaryName &secondary, libMesh::Order order=libMesh::FIRST)
NearestNodeLocator &	getNearestNodeLocator (const BoundaryName &primary, const BoundaryName &secondary)
NearestNodeLocator &	getNearestNodeLocator (const BoundaryID primary_id, const BoundaryID secondary_id)
NearestNodeLocator &	getQuadratureNearestNodeLocator (const BoundaryName &primary, const BoundaryName &secondary)
NearestNodeLocator &	getQuadratureNearestNodeLocator (const BoundaryID primary_id, const BoundaryID secondary_id)
const std::map< std::pair< BoundaryID, BoundaryID >, PenetrationLocator * > &	getPenetrationLocators () const
void	addElementPairLocator (BoundaryID interface_id, std::shared_ptr< ElementPairLocator > epl)
void	setSearchUsingPointLocator (bool state)
void	update (GeometricSearchType type=ALL)
	Update all of the search objects.
void	reinit ()
	Completely redo all geometric search objects.
void	clearNearestNodeLocators ()
	Clear out the Penetration Locators so they will redo the search.
void	backup ()
	Snapshot the PenetrationLocators' restartable state (the same state used for restart/recover), so it can be restored() if the current timestep is later rejected.
void	restore ()
	Restore the PenetrationLocators' state captured by the most recent backup().
Real	maxPatchPercentage ()
	Maximum percentage through the search patch that any NearestNodeLocator had to look.
void	updateGhostedElems ()
	Updates the list of ghosted elements at the start of each time step for the nonlinear iteration patch update strategy.

Public Attributes
SubProblem &	_subproblem
MooseMesh &	_mesh
std::map< std::pair< BoundaryID, BoundaryID >, PenetrationLocator * >	_penetration_locators
std::map< std::pair< BoundaryID, BoundaryID >, NearestNodeLocator * >	_nearest_node_locators
std::map< BoundaryID, std::shared_ptr< ElementPairLocator > >	_element_pair_locators

Protected Attributes
std::set< BoundaryID >	_quadrature_boundaries
	These are real boundaries that have quadrature nodes on them.
std::map< BoundaryID, BoundaryID >	_secondary_to_qsecondary
	A mapping of the real boundary id to the secondary boundary ids.

Private Member Functions
void	generateQuadratureNodes (const BoundaryID secondary_id, const BoundaryID qsecondary_id, bool reiniting=false)
	Add Quadrature Nodes to the Mesh in support of Quadrature based penetration location and nearest node searching.
void	updateQuadratureNodes (const BoundaryID secondary_id)
	Update the positions of the quadrature nodes.
void	reinitQuadratureNodes (const BoundaryID secondary_id)
	Completely redo quadrature nodes.

Private Attributes
bool	_first
	Denotes whether this is the first time the geometric search objects have been updated.
bool	_search_using_point_locator
	Denotes whether the PenetrationLocator objects should use a point locator rather than cheaper node-to-element connectivity searches once the nearest nodes have been identified.
std::map< std::pair< BoundaryID, BoundaryID >, std::string >	_penetration_locator_backups
	Per-locator PenetrationLocator::backup() snapshots taken by backup(), keyed the same way as _penetration_locators.

Detailed Description

Definition at line 28 of file GeometricSearchData.h.

Member Enumeration Documentation

GeometricSearchType

enum GeometricSearchData::GeometricSearchType

Used to select groups of geometric search objects to update.

Enumerator
ALL
NEAREST_NODE
PENETRATION
QUADRATURE
ELEMENTPAIR

Definition at line 32 of file GeometricSearchData.h.

  {
    ALL,
    NEAREST_NODE,
    PENETRATION,
    QUADRATURE,
    ELEMENTPAIR
  };

Constructor & Destructor Documentation

GeometricSearchData()

GeometricSearchData::GeometricSearchData	(	SubProblem &	subproblem,
		MooseMesh &	mesh
	)

Definition at line 23 of file GeometricSearchData.C.

  : _subproblem(subproblem), _mesh(mesh), _first(true), _search_using_point_locator(false)
{
  // do a check on the boundary IDs to see if any conflict will rise from computing QP node set IDs
  const auto & nodeset_ids = _mesh.meshNodesetIds();
  for (const auto id : nodeset_ids)
    if (nodeset_ids.find(-id - 1) != nodeset_ids.end())
      mooseError("Your mesh contains nodesets with negative IDs that interfere with QP nodeset IDs "
                 "potentially generated by the GeometricSearch system.");
}

~GeometricSearchData()

GeometricSearchData::~GeometricSearchData ( )

virtual

Definition at line 34 of file GeometricSearchData.C.

{
  for (auto & it : _penetration_locators)
    delete it.second;
 
  for (auto & it : _nearest_node_locators)
    delete it.second;
}

Member Function Documentation

addElementPairLocator()

void GeometricSearchData::addElementPairLocator	(	BoundaryID	interface_id,
		std::shared_ptr< ElementPairLocator >	epl
	)

Definition at line 330 of file GeometricSearchData.C.

{
  _element_pair_locators[interface_id] = epl;
}

backup()

void GeometricSearchData::backup

(

)

Snapshot the PenetrationLocators' restartable state (the same state used for restart/recover), so it can be restored() if the current timestep is later rejected.

Called from FEProblemBase::advanceState(), i.e. once per accepted step, before that step's timestepSetup(). Intentionally not restartable data itself: it is intra-run scratch that a checkpoint never needs, and is only ever read back within the same run.

Definition at line 124 of file GeometricSearchData.C.

{
  for (const auto & [boundary_pair, pl] : _penetration_locators)
    _penetration_locator_backups[boundary_pair] = pl->backup();
}

Referenced by FEProblemBase::backupGeometricSearchState().

clearNearestNodeLocators()

void GeometricSearchData::clearNearestNodeLocators

(

)

Clear out the Penetration Locators so they will redo the search.

Definition at line 138 of file GeometricSearchData.C.

{
  for (const auto & nnl_it : _nearest_node_locators)
  {
    NearestNodeLocator * nnl = nnl_it.second;
    nnl->reinit();
  }
}

Referenced by FEProblemBase::possiblyRebuildGeomSearchPatches().

generateQuadratureNodes()

void GeometricSearchData::generateQuadratureNodes ( const BoundaryID  secondary_id, const BoundaryID  qsecondary_id, bool  reiniting = false  )

private

Add Quadrature Nodes to the Mesh in support of Quadrature based penetration location and nearest node searching.

Parameters

secondary_id	The actual secondary_id (the one in the mesh)
qsecondary_id	The "fictitious" secondary_id that is going to be used for this quadrature nodeset
reiniting	Whether we are reinitializing, e.g. whether we need to re-generate q-nodes

Definition at line 291 of file GeometricSearchData.C.

{
  // Have we already generated quadrature nodes for this boundary id?
  if (_quadrature_boundaries.find(secondary_id) != _quadrature_boundaries.end())
  {
    if (!reiniting)
      return;
  }
  else
    _quadrature_boundaries.insert(secondary_id);
 
  const MooseArray<Point> & points_face = _subproblem.assembly(0, 0).qPointsFace();
 
  ConstBndElemRange & range = *_mesh.getBoundaryElementRange();
  for (const auto & belem : range)
  {
    const Elem * elem = belem->_elem;
    const auto side = belem->_side;
    const auto boundary_id = belem->_bnd_id;
 
    if (elem->processor_id() == _subproblem.processor_id())
    {
      if (boundary_id == (BoundaryID)secondary_id)
      {
        // All we should need to do here is reinit the underlying libMesh::FE object because that
        // will get us the correct points for the current element and side
        _subproblem.setCurrentSubdomainID(elem, 0);
        _subproblem.assembly(0, 0).reinit(elem, side);
 
        for (const auto qp : index_range(points_face))
          _mesh.addQuadratureNode(elem, side, qp, qsecondary_id, points_face[qp]);
      }
    }
  }
}

Referenced by reinitQuadratureNodes(), and update().

getNearestNodeLocator() [1/2]

NearestNodeLocator & GeometricSearchData::getNearestNodeLocator	(	const BoundaryID	primary_id,
		const BoundaryID	secondary_id
	)

Definition at line 248 of file GeometricSearchData.C.

{
  NearestNodeLocator * nnl =
      _nearest_node_locators[std::pair<BoundaryID, BoundaryID>(primary_id, secondary_id)];
 
  _subproblem.addGhostedBoundary(primary_id);
  _subproblem.addGhostedBoundary(secondary_id);
 
  if (!nnl)
  {
    nnl = new NearestNodeLocator(_subproblem, _mesh, primary_id, secondary_id);
    _nearest_node_locators[std::pair<BoundaryID, BoundaryID>(primary_id, secondary_id)] = nnl;
  }
 
  return *nnl;
}

getNearestNodeLocator() [2/2]

NearestNodeLocator & GeometricSearchData::getNearestNodeLocator	(	const BoundaryName &	primary,
		const BoundaryName &	secondary
	)

Definition at line 235 of file GeometricSearchData.C.

{
  const auto primary_id = _mesh.getBoundaryID(primary);
  const auto secondary_id = _mesh.getBoundaryID(secondary);
 
  _subproblem.addGhostedBoundary(primary_id);
  _subproblem.addGhostedBoundary(secondary_id);
 
  return getNearestNodeLocator(primary_id, secondary_id);
}

Referenced by getNearestNodeLocator(), GeometricSearchInterface::getNearestNodeLocator(), getPenetrationLocator(), and getQuadratureNearestNodeLocator().

getPenetrationLocator()

PenetrationLocator & GeometricSearchData::getPenetrationLocator	(	const BoundaryName &	primary,
		const BoundaryName &	secondary,
		libMesh::Order	order = libMesh::FIRST
	)

Definition at line 164 of file GeometricSearchData.C.

{
  auto primary_id = _mesh.getBoundaryID(primary);
  auto secondary_id = _mesh.getBoundaryID(secondary);
 
  _subproblem.addGhostedBoundary(primary_id);
  _subproblem.addGhostedBoundary(secondary_id);
 
  PenetrationLocator * pl =
      _penetration_locators[std::pair<BoundaryID, BoundaryID>(primary_id, secondary_id)];
 
  if (!pl)
  {
    pl = new PenetrationLocator(_subproblem,
                                *this,
                                _mesh,
                                primary_id,
                                secondary_id,
                                order,
                                getNearestNodeLocator(primary_id, secondary_id));
 
    if (_search_using_point_locator)
      pl->setUsePointLocator(true);
 
    _penetration_locators[std::pair<BoundaryID, BoundaryID>(primary_id, secondary_id)] = pl;
  }
 
  return *pl;
}

Referenced by DMSetUp_Moose_Pre(), and GeometricSearchInterface::getPenetrationLocator().

getPenetrationLocators()

const std::map< std::pair< BoundaryID, BoundaryID >, PenetrationLocator * > & GeometricSearchData::getPenetrationLocators ( ) const

inline

Definition at line 62 of file GeometricSearchData.h.

  {
    return _penetration_locators;
  }

getQuadratureNearestNodeLocator() [1/2]

NearestNodeLocator & GeometricSearchData::getQuadratureNearestNodeLocator	(	const BoundaryID	primary_id,
		const BoundaryID	secondary_id
	)

Definition at line 280 of file GeometricSearchData.C.

{
  // Generate a new boundary id (we use the negative numbers and subtract 1 to disambiguate id=0)
  const auto qsecondary_id = -secondary_id - 1;
 
  _secondary_to_qsecondary[secondary_id] = qsecondary_id;
  return getNearestNodeLocator(primary_id, qsecondary_id);
}

getQuadratureNearestNodeLocator() [2/2]

NearestNodeLocator & GeometricSearchData::getQuadratureNearestNodeLocator	(	const BoundaryName &	primary,
		const BoundaryName &	secondary
	)

Definition at line 267 of file GeometricSearchData.C.

{
  const auto primary_id = _mesh.getBoundaryID(primary);
  const auto secondary_id = _mesh.getBoundaryID(secondary);
 
  _subproblem.addGhostedBoundary(primary_id);
  _subproblem.addGhostedBoundary(secondary_id);
 
  return getQuadratureNearestNodeLocator(primary_id, secondary_id);
}

Referenced by getQuadratureNearestNodeLocator(), GeometricSearchInterface::getQuadratureNearestNodeLocator(), and getQuadraturePenetrationLocator().

getQuadraturePenetrationLocator()

PenetrationLocator & GeometricSearchData::getQuadraturePenetrationLocator	(	const BoundaryName &	primary,
		const BoundaryName &	secondary,
		libMesh::Order	order = libMesh::FIRST
	)

Definition at line 197 of file GeometricSearchData.C.

{
  const auto primary_id = _mesh.getBoundaryID(primary);
  const auto secondary_id = _mesh.getBoundaryID(secondary);
 
  _subproblem.addGhostedBoundary(primary_id);
  _subproblem.addGhostedBoundary(secondary_id);
 
  // Generate a new boundary id (we use the negative numbers and subtract 1 to disambiguate id=0)
  const auto qsecondary_id = -secondary_id - 1;
 
  _secondary_to_qsecondary[secondary_id] = qsecondary_id;
 
  PenetrationLocator * pl =
      _penetration_locators[std::pair<BoundaryID, BoundaryID>(primary_id, qsecondary_id)];
 
  if (!pl)
  {
    pl = new PenetrationLocator(_subproblem,
                                *this,
                                _mesh,
                                primary_id,
                                qsecondary_id,
                                order,
                                getQuadratureNearestNodeLocator(primary_id, secondary_id));
 
    if (_search_using_point_locator)
      pl->setUsePointLocator(true);
 
    _penetration_locators[std::pair<BoundaryID, BoundaryID>(primary_id, qsecondary_id)] = pl;
  }
 
  return *pl;
}

Referenced by GeometricSearchInterface::getQuadraturePenetrationLocator().

maxPatchPercentage()

Real GeometricSearchData::maxPatchPercentage

(

)

Maximum percentage through the search patch that any NearestNodeLocator had to look.

As this goes towards 1.0 it's indicative of needing to rebuild the patches.

Definition at line 148 of file GeometricSearchData.C.

{
  Real max = 0.0;
 
  for (const auto & nnl_it : _nearest_node_locators)
  {
    NearestNodeLocator * nnl = nnl_it.second;
 
    if (nnl->_max_patch_percentage > max)
      max = nnl->_max_patch_percentage;
  }
 
  return max;
}

reinit()

void GeometricSearchData::reinit

(

)

Completely redo all geometric search objects.

This should be called when the mesh is adapted.

Definition at line 97 of file GeometricSearchData.C.

{
  _mesh.clearQuadratureNodes();
  // Update the position of quadrature nodes first
  for (const auto & qbnd : _quadrature_boundaries)
    reinitQuadratureNodes(qbnd);
 
  for (const auto & nnl_it : _nearest_node_locators)
  {
    NearestNodeLocator * nnl = nnl_it.second;
    nnl->reinit();
  }
 
  for (const auto & pl_it : _penetration_locators)
  {
    PenetrationLocator * pl = pl_it.second;
    pl->reinit();
  }
 
  for (const auto & epl_it : _element_pair_locators)
  {
    ElementPairLocator & epl = *(epl_it.second);
    epl.reinit();
  }
}

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

reinitQuadratureNodes()

void GeometricSearchData::reinitQuadratureNodes ( const BoundaryID  secondary_id )

private

Completely redo quadrature nodes.

Definition at line 381 of file GeometricSearchData.C.

{
  // Regenerate the quadrature nodes
  for (const auto & it : _secondary_to_qsecondary)
    generateQuadratureNodes(it.first, it.second, /*reiniting=*/true);
}

Referenced by reinit().

restore()

void GeometricSearchData::restore

(

)

Restore the PenetrationLocators' state captured by the most recent backup().

Called from TimeStepper::rejectStep(), before FEProblemBase::restoreSolutions() re-projects the geometric search onto the restored mesh, so that re-projection starts from the same seeds attempt 1 did rather than from attempt 1's discarded, converged state.

Definition at line 131 of file GeometricSearchData.C.

{
  for (const auto & [boundary_pair, pl] : _penetration_locators)
    pl->restore(libmesh_map_find(_penetration_locator_backups, boundary_pair));
}

Referenced by FEProblemBase::restoreGeometricSearchState().

setSearchUsingPointLocator()

void GeometricSearchData::setSearchUsingPointLocator

(

bool

state

)

Definition at line 337 of file GeometricSearchData.C.

{
  if (state != _search_using_point_locator)
  {
    for (auto & [key, val] : _penetration_locators)
    {
      libmesh_ignore(key);
      if (val)
        val->setUsePointLocator(state);
    }
  }
 
  _search_using_point_locator = state;
}

Referenced by GeometricSearchInterface::GeometricSearchInterface().

update()

void GeometricSearchData::update

(

GeometricSearchType

type = ALL

)

Update all of the search objects.

Definition at line 44 of file GeometricSearchData.C.

{
  if (type == ALL || type == QUADRATURE || type == NEAREST_NODE)
  {
    if (_first) // Only do this once
    {
      _first = false;
 
      for (const auto & it : _secondary_to_qsecondary)
        generateQuadratureNodes(it.first, it.second);
 
      // reinit on displaced mesh before update
      for (const auto & epl_it : _element_pair_locators)
      {
        ElementPairLocator & epl = *(epl_it.second);
        epl.reinit();
      }
    }
 
    // Update the position of quadrature nodes first
    for (const auto & qbnd : _quadrature_boundaries)
      updateQuadratureNodes(qbnd);
  }
 
  if (type == ALL || type == NEAREST_NODE)
  {
    for (const auto & nnl_it : _nearest_node_locators)
    {
      NearestNodeLocator * nnl = nnl_it.second;
      nnl->findNodes();
    }
  }
 
  if (type == ALL || type == PENETRATION)
  {
    for (const auto & pl_it : _penetration_locators)
    {
      PenetrationLocator * pl = pl_it.second;
      pl->detectPenetration();
    }
  }
 
  if (type == ALL || type == PENETRATION)
  {
    for (auto & elem_pair_locator_pair : _element_pair_locators)
    {
      ElementPairLocator & epl = (*elem_pair_locator_pair.second);
      epl.update();
    }
  }
}

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

updateGhostedElems()

void GeometricSearchData::updateGhostedElems

(

)

Updates the list of ghosted elements at the start of each time step for the nonlinear iteration patch update strategy.

Definition at line 389 of file GeometricSearchData.C.

{
  for (const auto & nnl_it : _nearest_node_locators)
  {
    NearestNodeLocator * nnl = nnl_it.second;
    nnl->updateGhostedElems();
  }
}

Referenced by FEProblemBase::possiblyRebuildGeomSearchPatches().

updateQuadratureNodes()

void GeometricSearchData::updateQuadratureNodes ( const BoundaryID  secondary_id )

private

Update the positions of the quadrature nodes.

Definition at line 353 of file GeometricSearchData.C.

{
  const MooseArray<Point> & points_face = _subproblem.assembly(0, 0).qPointsFace();
 
  ConstBndElemRange & range = *_mesh.getBoundaryElementRange();
  for (const auto & belem : range)
  {
    const Elem * elem = belem->_elem;
    const auto side = belem->_side;
    const auto boundary_id = belem->_bnd_id;
 
    if (elem->processor_id() == _subproblem.processor_id())
    {
      if (boundary_id == (BoundaryID)secondary_id)
      {
        // All we should need to do here is reinit the underlying libMesh::FE object because that
        // will get us the correct points for the current element and side
        _subproblem.setCurrentSubdomainID(elem, 0);
        _subproblem.assembly(0, 0).reinit(elem, side);
 
        for (const auto qp : index_range(points_face))
          (*_mesh.getQuadratureNode(elem, side, qp)) = points_face[qp];
      }
    }
  }
}

Referenced by update().

Member Data Documentation

_element_pair_locators

std::map<BoundaryID, std::shared_ptr<ElementPairLocator> > GeometricSearchData::_element_pair_locators

Definition at line 121 of file GeometricSearchData.h.

Referenced by addElementPairLocator(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), reinit(), and update().

_first

bool GeometricSearchData::_first

private

Denotes whether this is the first time the geometric search objects have been updated.

Definition at line 157 of file GeometricSearchData.h.

Referenced by update().

_mesh

MooseMesh& GeometricSearchData::_mesh

Definition at line 118 of file GeometricSearchData.h.

Referenced by generateQuadratureNodes(), GeometricSearchData(), getNearestNodeLocator(), getNearestNodeLocator(), getPenetrationLocator(), getQuadratureNearestNodeLocator(), getQuadraturePenetrationLocator(), reinit(), and updateQuadratureNodes().

_nearest_node_locators

std::map<std::pair<BoundaryID, BoundaryID>, NearestNodeLocator *> GeometricSearchData::_nearest_node_locators

Definition at line 120 of file GeometricSearchData.h.

Referenced by clearNearestNodeLocators(), NonlinearSystemBase::findImplicitGeometricCouplingEntries(), getNearestNodeLocator(), maxPatchPercentage(), reinit(), FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects(), update(), updateGhostedElems(), and ~GeometricSearchData().

_penetration_locator_backups

std::map<std::pair<BoundaryID, BoundaryID>, std::string> GeometricSearchData::_penetration_locator_backups

private

Per-locator PenetrationLocator::backup() snapshots taken by backup(), keyed the same way as _penetration_locators.

Not restartable: see the comment on backup() above.

Definition at line 170 of file GeometricSearchData.h.

Referenced by backup(), and restore().

_penetration_locators

std::map<std::pair<BoundaryID, BoundaryID>, PenetrationLocator *> GeometricSearchData::_penetration_locators

Definition at line 119 of file GeometricSearchData.h.

Referenced by backup(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), DMMooseGetEmbedding_Private(), getPenetrationLocator(), getPenetrationLocators(), getQuadraturePenetrationLocator(), NonlinearSystemBase::overwriteNodeFace(), reinit(), restore(), NonlinearSystemBase::setConstraintSecondaryValues(), setSearchUsingPointLocator(), update(), and ~GeometricSearchData().

_quadrature_boundaries

std::set<BoundaryID> GeometricSearchData::_quadrature_boundaries

protected

These are real boundaries that have quadrature nodes on them.

Definition at line 125 of file GeometricSearchData.h.

Referenced by generateQuadratureNodes(), reinit(), and update().

_search_using_point_locator

bool GeometricSearchData::_search_using_point_locator

private

Denotes whether the PenetrationLocator objects should use a point locator rather than cheaper node-to-element connectivity searches once the nearest nodes have been identified.

Definition at line 164 of file GeometricSearchData.h.

Referenced by getPenetrationLocator(), getQuadraturePenetrationLocator(), and setSearchUsingPointLocator().

_secondary_to_qsecondary

std::map<BoundaryID, BoundaryID> GeometricSearchData::_secondary_to_qsecondary

protected

A mapping of the real boundary id to the secondary boundary ids.

Definition at line 128 of file GeometricSearchData.h.

Referenced by getQuadratureNearestNodeLocator(), getQuadraturePenetrationLocator(), reinitQuadratureNodes(), and update().

_subproblem

SubProblem& GeometricSearchData::_subproblem

Definition at line 117 of file GeometricSearchData.h.

Referenced by generateQuadratureNodes(), getNearestNodeLocator(), getNearestNodeLocator(), getPenetrationLocator(), getQuadratureNearestNodeLocator(), getQuadraturePenetrationLocator(), and updateQuadratureNodes().

---

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

• include/geomsearch/GeometricSearchData.h
• src/geomsearch/GeometricSearchData.C