NearestNodeLocator Class Reference

Finds the nearest node to each node in boundary1 to each node in boundary2 and the other way around. More...

#include <NearestNodeLocator.h>

Inheritance diagram for NearestNodeLocator:

Classes
class	NearestNodeInfo
	Data structure used to hold nearest node info. More...

Public Member Functions
	NearestNodeLocator (SubProblem &subproblem, MooseMesh &mesh, BoundaryID boundary1, BoundaryID boundary2)
	~NearestNodeLocator ()
void	findNodes ()
	This is the main method that is going to start the search.
void	reinit ()
	Completely redo the search from scratch.
Real	distance (dof_id_type node_id)
	Valid to call this after findNodes() has been called to get the distance to the nearest node.
const Node *	nearestNode (dof_id_type node_id)
	Valid to call this after findNodes() has been called to get a pointer to the nearest node.
std::vector< dof_id_type > &	secondaryNodes ()
	Returns the list of secondary nodes this Locator is tracking.
NodeIdRange &	secondaryNodeRange ()
	Returns the NodeIdRange of secondary nodes to be used for calling threaded functions operating on the secondary nodes.
void	updatePatch (std::vector< dof_id_type > &secondary_nodes)
	Reconstructs the KDtree, updates the patch for the nodes in secondary_nodes, and updates the closest neighbor for these nodes in nearest node info.
void	updateGhostedElems ()
	Updates the ghosted elements at the start of the time step for iteration patch update strategy.
PerfGraph &	perfGraph ()
	Get the PerfGraph.

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
std::map< dof_id_type, NearestNodeInfo >	_nearest_node_info
BoundaryID	_boundary1
BoundaryID	_boundary2
bool	_first
bool	_reinit_iteration
std::vector< dof_id_type >	_secondary_nodes
std::map< dof_id_type, std::vector< dof_id_type > >	_neighbor_nodes
const Moose::PatchUpdateType	_patch_update_strategy
Real	_max_patch_percentage
std::vector< dof_id_type >	_new_ghosted_elems

Static Public Attributes
static const unsigned int	_patch_size

Protected Member Functions
template<typename T , typename... Args>
T &	declareRestartableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "restartable" and initialize it.
template<typename T , typename... Args>
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declares a piece of "managed" restartable data and initialize it.
template<typename T , typename... Args>
const T &	getRestartableData (const std::string &data_name) const
	Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.
template<typename T , typename... Args>
T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declare a piece of data as "restartable" and initialize it.
template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it.
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
	Declare a piece of data as "restartable".
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
	Declare a piece of data as "restartable".
std::string	restartableName (const std::string &data_name) const
	Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing.
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing.
std::string	timedSectionName (const std::string &section_name) const

Protected Attributes
SubProblem &	_subproblem
MooseMesh &	_mesh
std::unique_ptr< NodeIdRange >	_secondary_node_range
MooseApp &	_restartable_app
	Reference to the application.
const std::string	_restartable_system_name
	The system name this object is in.
const THREAD_ID	_restartable_tid
	The thread ID for this object.
const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData)
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.
const std::string	_prefix
	A prefix to use for all sections.

Private Member Functions
RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const
	Helper function for actually registering the restartable data.
void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)
	Helper function for actually registering the restartable data.
template<typename T , typename... Args>
RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const
	Helper function for declaring restartable data.

Private Attributes
const RestartableDataMapName	_metaname
	Restartable metadata name.
std::string	_restartable_name
	The name of the object.

Detailed Description

Finds the nearest node to each node in boundary1 to each node in boundary2 and the other way around.

Definition at line 24 of file NearestNodeLocator.h.

Constructor & Destructor Documentation

NearestNodeLocator()

NearestNodeLocator::NearestNodeLocator	(	SubProblem &	subproblem,
		MooseMesh &	mesh,
		BoundaryID	boundary1,
		BoundaryID	boundary2
	)

Definition at line 26 of file NearestNodeLocator.C.

  : Restartable(subproblem.getMooseApp(),
                Moose::stringify(boundary1) + Moose::stringify(boundary2),
                "NearestNodeLocator",
                0),
    PerfGraphInterface(subproblem.getMooseApp().perfGraph(),
                       "NearestNodeLocator_" + Moose::stringify(boundary1) + "_" +
                           Moose::stringify(boundary2)),
    _subproblem(subproblem),
    _mesh(mesh),
    _boundary1(boundary1),
    _boundary2(boundary2),
    _first(true),
    _reinit_iteration(true),
    _patch_update_strategy(_mesh.getPatchUpdateStrategy())
{
  /*
  //sanity check on boundary ids
  const std::set<BoundaryID>& bids=_mesh.getBoundaryIDs();
  std::set<BoundaryID>::const_iterator sit;
  sit=bids.find(_boundary1);
  if (sit == bids.end())
    mooseError("NearestNodeLocator being created for boundaries ", _boundary1, " and ", _boundary2,
  ", but boundary ", _boundary1, " does not exist");
  sit=bids.find(_boundary2);
  if (sit == bids.end())
    mooseError("NearestNodeLocator being created for boundaries ", _boundary1, " and ", _boundary2,
  ", but boundary ", _boundary2, " does not exist");
  */
}

~NearestNodeLocator()

NearestNodeLocator::~NearestNodeLocator ( )

default

Member Function Documentation

declareManagedRestartableDataWithContext()

template<typename T , typename... Args>

Restartable::ManagedValue< T > Restartable::declareManagedRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

protectedinherited

Declares a piece of "managed" restartable data and initialize it.

Here, "managed" restartable data means that the caller can destruct this data upon destruction of the return value of this method. Therefore, this ManagedValue<T> wrapper should survive after the final calls to dataStore() for it. That is... at the very end.

This is needed for objects whose destruction ordering is important, and enables natural c++ destruction in reverse construction order of the object that declares it.

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 283 of file Restartable.h.

{
  auto & data_ptr =
      declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
  return Restartable::ManagedValue<T>(data_ptr);
}

declareRecoverableData()

template<typename T , typename... Args>

T & Restartable::declareRecoverableData ( const std::string &  data_name, Args &&...  args  )

protectedinherited

Declare a piece of data as "recoverable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 358 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);
 
  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
 
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableData()

template<typename T , typename... Args>

T & Restartable::declareRestartableData ( const std::string &  data_name, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 276 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataHelper()

template<typename T , typename... Args>

RestartableData< T > & Restartable::declareRestartableDataHelper ( const std::string &  data_name, void *  context, Args &&...  args  ) const

privateinherited

Helper function for declaring restartable data.

We use this function to reduce code duplication when returning const/nonconst references to the data.

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 310 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);
 
  // Here we will create the RestartableData even though we may not use this instance.
  // If it's already in use, the App will return a reference to the existing instance and we'll
  // return that one instead. We might refactor this to have the app create the RestartableData
  // at a later date.
  auto data_ptr =
      std::make_unique<RestartableData<T>>(full_name, context, std::forward<Args>(args)...);
  auto & restartable_data_ref = static_cast<RestartableData<T> &>(
      registerRestartableDataOnApp(std::move(data_ptr), _restartable_tid));
 
  return restartable_data_ref;
}

declareRestartableDataWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 301 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...).set();
}

declareRestartableDataWithObjectName()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectName ( const std::string &  data_name, const std::string &  object_name, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
args	Arguments to forward to the constructor of the data

Definition at line 330 of file Restartable.h.

{
  return declareRestartableDataWithObjectNameWithContext<T>(
      data_name, object_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectNameWithContext ( const std::string &  data_name, const std::string &  object_name, void *  context, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 340 of file Restartable.h.

{
  std::string old_name = _restartable_name;
 
  _restartable_name = object_name;
 
  T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);
 
  _restartable_name = old_name;
 
  return value;
}

distance()

Real NearestNodeLocator::distance

(

dof_id_type

node_id

)

Valid to call this after findNodes() has been called to get the distance to the nearest node.

Definition at line 233 of file NearestNodeLocator.C.

{
  return _nearest_node_info[node_id]._distance;
}

Referenced by NearestNodeDistanceAux::computeValue(), NearestNodeValueAux::computeValue(), findNodes(), and updatePatch().

findNodes()

void NearestNodeLocator::findNodes

(

)

This is the main method that is going to start the search.

If this is the first time through we're going to build up a "neighborhood" of nodes surrounding each of the secondary nodes. This will speed searching later.

Definition at line 63 of file NearestNodeLocator.C.

{
  TIME_SECTION("findNodes", 3, "Finding Nearest Nodes");
 
  const auto & node_to_elem_map = _mesh.nodeToElemMap();
 
  if (_first || (_reinit_iteration && _patch_update_strategy == Moose::Iteration))
  {
    _first = false;
 
    // Trial secondary nodes are all the nodes on the secondary side
    // We only keep the ones that are either on this processor or are likely
    // to interact with elements on this processor (ie nodes owned by this processor
    // are in the "neighborhood" of the secondary node
    std::vector<dof_id_type> trial_secondary_nodes;
    std::vector<dof_id_type> trial_primary_nodes;
 
    // Build a bounding box.  No reason to consider nodes outside of our inflated BB
    std::unique_ptr<BoundingBox> my_inflated_box = nullptr;
 
    const std::vector<Real> & inflation = _mesh.getGhostedBoundaryInflation();
 
    // This means there was a user specified inflation... so we can build a BB
    if (inflation.size() > 0)
    {
      BoundingBox my_box = MeshTools::create_local_bounding_box(_mesh);
 
      Point distance;
      for (unsigned int i = 0; i < inflation.size(); ++i)
        distance(i) = inflation[i];
 
      my_inflated_box =
          std::make_unique<BoundingBox>(my_box.first - distance, my_box.second + distance);
    }
 
    // Data structures to hold the boundary nodes
    ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange();
    for (const auto & bnode : bnd_nodes)
    {
      BoundaryID boundary_id = bnode->_bnd_id;
      dof_id_type node_id = bnode->_node->id();
 
      // If we have a BB only consider saving this node if it's in our inflated BB
      if (!my_inflated_box || (my_inflated_box->contains_point(*bnode->_node)))
      {
        if (boundary_id == _boundary1)
          trial_primary_nodes.push_back(node_id);
        else if (boundary_id == _boundary2)
          trial_secondary_nodes.push_back(node_id);
      }
    }
 
    // Convert trial primary nodes to a vector of Points. This will be used to
    // construct the Kdtree.
    std::vector<Point> primary_points(trial_primary_nodes.size());
    for (unsigned int i = 0; i < trial_primary_nodes.size(); ++i)
    {
      const Node & node = _mesh.nodeRef(trial_primary_nodes[i]);
      primary_points[i] = node;
    }
 
    // Create object kd_tree of class KDTree using the coordinates of trial
    // primary nodes.
    KDTree kd_tree(primary_points, _mesh.getMaxLeafSize());
 
    NodeIdRange trial_secondary_node_range(
        trial_secondary_nodes.begin(), trial_secondary_nodes.end(), 1);
 
    SecondaryNeighborhoodThread snt(
        _mesh, trial_primary_nodes, node_to_elem_map, _mesh.getPatchSize(), kd_tree);
 
    Threads::parallel_reduce(trial_secondary_node_range, snt);
 
    _secondary_nodes = snt._secondary_nodes;
    _neighbor_nodes = snt._neighbor_nodes;
 
    // If 'iteration' patch update strategy is used, a second neighborhood
    // search using the ghosting_patch_size, which is larger than the regular
    // patch_size used for contact search, is conducted. The ghosted element set
    // given by this search is used for ghosting the elements connected to the
    // secondary and neighboring primary nodes.
    if (_patch_update_strategy == Moose::Iteration)
    {
      SecondaryNeighborhoodThread snt_ghosting(
          _mesh, trial_primary_nodes, node_to_elem_map, _mesh.getGhostingPatchSize(), kd_tree);
 
      Threads::parallel_reduce(trial_secondary_node_range, snt_ghosting);
 
      for (const auto & dof : snt_ghosting._ghosted_elems)
        _subproblem.addGhostedElem(dof);
    }
    else
    {
      for (const auto & dof : snt._ghosted_elems)
        _subproblem.addGhostedElem(dof);
    }
 
    // Cache the secondary_node_range so we don't have to build it each time
    _secondary_node_range =
        std::make_unique<NodeIdRange>(_secondary_nodes.begin(), _secondary_nodes.end(), 1);
  }
 
  _nearest_node_info.clear();
 
  NearestNodeThread nnt(_mesh, _neighbor_nodes);
 
  Threads::parallel_reduce(*_secondary_node_range, nnt);
 
  _max_patch_percentage = nnt._max_patch_percentage;
 
  _nearest_node_info = nnt._nearest_node_info;
 
  if (_patch_update_strategy == Moose::Iteration)
  {
    // Get the set of elements that are currently being ghosted
    std::set<dof_id_type> ghost = _subproblem.ghostedElems();
 
    for (const auto & node_id : *_secondary_node_range)
    {
      const Node * nearest_node = _nearest_node_info[node_id]._nearest_node;
 
      // Check if the elements attached to the nearest node are within the ghosted
      // set of elements. If not produce an error.
      auto node_to_elem_pair = node_to_elem_map.find(nearest_node->id());
 
      if (node_to_elem_pair != node_to_elem_map.end())
      {
        const std::vector<dof_id_type> & elems_connected_to_node = node_to_elem_pair->second;
        for (const auto & dof : elems_connected_to_node)
          if (std::find(ghost.begin(), ghost.end(), dof) == ghost.end() &&
              _mesh.elemPtr(dof)->processor_id() != _mesh.processor_id())
            mooseError("Error in NearestNodeLocator: The nearest neighbor lies outside the "
                       "ghosted set of elements. Increase the ghosting_patch_size parameter in the "
                       "mesh block and try again.");
      }
    }
  }
}

Referenced by reinit(), and GeometricSearchData::update().

getRestartableData()

template<typename T , typename... Args>

const T & Restartable::getRestartableData ( const std::string &  data_name ) const

protectedinherited

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

NOTE: This returns a const reference! Make sure you store it in a const reference!

Parameters

data_name

The name of the data (usually just use the same name as the member variable)

Definition at line 294 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, nullptr).get();
}

nearestNode()

const Node * NearestNodeLocator::nearestNode

(

dof_id_type

node_id

)

Valid to call this after findNodes() has been called to get a pointer to the nearest node.

Definition at line 239 of file NearestNodeLocator.C.

{
  const Node * returnval = _nearest_node_info[node_id]._nearest_node;
  libmesh_assert(_mesh.getMesh().get_boundary_info().has_boundary_id(returnval, _boundary1));
  return returnval;
}

Referenced by NearestNodeValueAux::computeValue(), and PenetrationThread::operator()().

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), PerfGraphReporter::finalize(), and PerfGraphOutput::output().

registerRestartableDataOnApp()

RestartableDataValue & Restartable::registerRestartableDataOnApp ( std::unique_ptr< RestartableDataValue >  data, THREAD_ID  tid  ) const

privateinherited

Helper function for actually registering the restartable data.

Definition at line 63 of file Restartable.C.

{
  return _restartable_app.registerRestartableData(
      std::move(data), tid, _restartable_read_only, _metaname);
}

Referenced by Restartable::declareRestartableDataHelper().

registerRestartableNameWithFilterOnApp()

void Restartable::registerRestartableNameWithFilterOnApp ( const std::string &  name, Moose::RESTARTABLE_FILTER  filter  )

privateinherited

Helper function for actually registering the restartable data.

Definition at line 71 of file Restartable.C.

{
  _restartable_app.registerRestartableNameWithFilter(name, filter);
}

Referenced by Restartable::declareRecoverableData().

registerTimedSection() [1/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level  ) const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns

The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

registerTimedSection() [2/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level, const std::string &  live_message, const bool  print_dots = true  ) const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns

The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(
        timedSectionName(section_name), level, live_message, print_dots);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

reinit()

void NearestNodeLocator::reinit

(

)

Completely redo the search from scratch.

Most likely called because of mesh adaptivity.

Definition at line 207 of file NearestNodeLocator.C.

{
  TIME_SECTION("reinit", 3, "Reinitializing Nearest Node Search");
 
  // Reset all data
  _secondary_node_range.reset();
  _nearest_node_info.clear();
 
  _first = true;
 
  _secondary_nodes.clear();
  _neighbor_nodes.clear();
 
  _new_ghosted_elems.clear();
 
  // After a call from system reinit, mesh has been updated with initial adaptivity.
  // Moose::Iteration relies on data generated for ghosting (i.e. trial_primary_nodes)
  _reinit_iteration = true;
 
  // Redo the search
  findNodes();
 
  _reinit_iteration = false;
}

Referenced by GeometricSearchData::clearNearestNodeLocators(), and GeometricSearchData::reinit().

restartableName()

std::string Restartable::restartableName ( const std::string &  data_name ) const

protectedinherited

Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

This should only be used in this interface and in testing.

Definition at line 78 of file Restartable.C.

{
  return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
}

Referenced by Restartable::declareRecoverableData(), and Restartable::declareRestartableDataHelper().

secondaryNodeRange()

NodeIdRange & NearestNodeLocator::secondaryNodeRange ( )

inline

Returns the NodeIdRange of secondary nodes to be used for calling threaded functions operating on the secondary nodes.

Definition at line 64 of file NearestNodeLocator.h.

{ return *_secondary_node_range; }

Referenced by PenetrationLocator::detectPenetration().

secondaryNodes()

std::vector< dof_id_type > & NearestNodeLocator::secondaryNodes ( )

inline

Returns the list of secondary nodes this Locator is tracking.

Definition at line 58 of file NearestNodeLocator.h.

{ return _secondary_nodes; }

timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string &  section_name ) const

protectedinherited

Returns

The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

{
  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
}

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

updateGhostedElems()

void NearestNodeLocator::updateGhostedElems

(

)

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

Definition at line 360 of file NearestNodeLocator.C.

{
  TIME_SECTION("updateGhostedElems", 5, "Updating Nearest Node Search Because of Ghosting");
 
  // When 'iteration' patch update strategy is used, add the elements in
  // _new_ghosted_elems, which were accumulated in the nonlinear iterations
  // during the previous time step, to the list of ghosted elements. Also clear
  // the _new_ghosted_elems array for storing the ghosted elements from the
  // nonlinear iterations in the current time step.
 
  for (const auto & dof : _new_ghosted_elems)
    _subproblem.addGhostedElem(dof);
 
  _new_ghosted_elems.clear();
}

Referenced by GeometricSearchData::updateGhostedElems().

updatePatch()

void NearestNodeLocator::updatePatch

(

std::vector< dof_id_type > &

secondary_nodes

)

Reconstructs the KDtree, updates the patch for the nodes in secondary_nodes, and updates the closest neighbor for these nodes in nearest node info.

Definition at line 247 of file NearestNodeLocator.C.

{
  TIME_SECTION("updatePatch", 3, "Updating Nearest Node Search Patch");
 
  std::vector<dof_id_type> trial_primary_nodes;
 
  // Build a bounding box.  No reason to consider nodes outside of our inflated BB
  std::unique_ptr<BoundingBox> my_inflated_box = nullptr;
 
  const std::vector<Real> & inflation = _mesh.getGhostedBoundaryInflation();
 
  // This means there was a user specified inflation... so we can build a BB
  if (inflation.size() > 0)
  {
    BoundingBox my_box = MeshTools::create_local_bounding_box(_mesh);
 
    Point distance;
    for (unsigned int i = 0; i < inflation.size(); ++i)
      distance(i) = inflation[i];
 
    my_inflated_box =
        std::make_unique<BoundingBox>(my_box.first - distance, my_box.second + distance);
  }
 
  // Data structures to hold the boundary nodes
  ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange();
  for (const auto & bnode : bnd_nodes)
  {
    BoundaryID boundary_id = bnode->_bnd_id;
    dof_id_type node_id = bnode->_node->id();
 
    // If we have a BB only consider saving this node if it's in our inflated BB
    if (!my_inflated_box || (my_inflated_box->contains_point(*bnode->_node)))
    {
      if (boundary_id == _boundary1)
        trial_primary_nodes.push_back(node_id);
    }
  }
 
  // Convert trial primary nodes to a vector of Points. This will be used to construct the KDTree.
  std::vector<Point> primary_points(trial_primary_nodes.size());
  for (unsigned int i = 0; i < trial_primary_nodes.size(); ++i)
  {
    const Node & node = _mesh.nodeRef(trial_primary_nodes[i]);
    primary_points[i] = node;
  }
 
  const auto & node_to_elem_map = _mesh.nodeToElemMap();
 
  // Create object kd_tree of class KDTree using the coordinates of trial
  // primary nodes.
  KDTree kd_tree(primary_points, _mesh.getMaxLeafSize());
 
  NodeIdRange secondary_node_range(secondary_nodes.begin(), secondary_nodes.end(), 1);
 
  SecondaryNeighborhoodThread snt(
      _mesh, trial_primary_nodes, node_to_elem_map, _mesh.getPatchSize(), kd_tree);
 
  Threads::parallel_reduce(secondary_node_range, snt);
 
  // Calculate new ghosting patch for the secondary_node_range
  SecondaryNeighborhoodThread snt_ghosting(
      _mesh, trial_primary_nodes, node_to_elem_map, _mesh.getGhostingPatchSize(), kd_tree);
 
  Threads::parallel_reduce(secondary_node_range, snt_ghosting);
 
  // Add the new set of elements that need to be ghosted into _new_ghosted_elems
  for (const auto & dof : snt_ghosting._ghosted_elems)
    _new_ghosted_elems.push_back(dof);
 
  std::vector<dof_id_type> tracked_secondary_nodes = snt._secondary_nodes;
 
  // Update the neighbor nodes (patch) for these tracked secondary nodes
  for (const auto & node_id : tracked_secondary_nodes)
    _neighbor_nodes[node_id] = snt._neighbor_nodes[node_id];
 
  NodeIdRange tracked_secondary_node_range(
      tracked_secondary_nodes.begin(), tracked_secondary_nodes.end(), 1);
 
  NearestNodeThread nnt(_mesh, snt._neighbor_nodes);
 
  Threads::parallel_reduce(tracked_secondary_node_range, nnt);
 
  _max_patch_percentage = nnt._max_patch_percentage;
 
  // Get the set of elements that are currently being ghosted
  std::set<dof_id_type> ghost = _subproblem.ghostedElems();
 
  // Update the nearest node information corresponding to these tracked secondary nodes
  for (const auto & node_id : tracked_secondary_node_range)
  {
    _nearest_node_info[node_id] = nnt._nearest_node_info[node_id];
 
    // Check if the elements attached to the nearest node are within the ghosted
    // set of elements. If not produce an error.
    const Node * nearest_node = nnt._nearest_node_info[node_id]._nearest_node;
 
    auto node_to_elem_pair = node_to_elem_map.find(nearest_node->id());
 
    if (node_to_elem_pair != node_to_elem_map.end())
    {
      const std::vector<dof_id_type> & elems_connected_to_node = node_to_elem_pair->second;
      for (const auto & dof : elems_connected_to_node)
        if (std::find(ghost.begin(), ghost.end(), dof) == ghost.end() &&
            _mesh.elemPtr(dof)->processor_id() != _mesh.processor_id())
          mooseError("Error in NearestNodeLocator: The nearest neighbor lies outside the ghosted "
                     "set of elements. Increase the ghosting_patch_size parameter in the mesh "
                     "block and try again.");
    }
  }
}

Referenced by PenetrationLocator::detectPenetration().

validParams()

InputParameters PerfGraphInterface::validParams ( )

staticinherited

Definition at line 16 of file PerfGraphInterface.C.

{
  InputParameters params = emptyInputParameters();
  return params;
}

Referenced by Convergence::validParams().

Member Data Documentation

_boundary1

BoundaryID NearestNodeLocator::_boundary1

Definition at line 100 of file NearestNodeLocator.h.

Referenced by findNodes(), nearestNode(), PenetrationThread::operator()(), and updatePatch().

_boundary2

BoundaryID NearestNodeLocator::_boundary2

Definition at line 101 of file NearestNodeLocator.h.

Referenced by findNodes().

_first

bool NearestNodeLocator::_first

Definition at line 103 of file NearestNodeLocator.h.

Referenced by findNodes(), and reinit().

_max_patch_percentage

Real NearestNodeLocator::_max_patch_percentage

Definition at line 121 of file NearestNodeLocator.h.

Referenced by findNodes(), GeometricSearchData::maxPatchPercentage(), and updatePatch().

_mesh

MooseMesh& NearestNodeLocator::_mesh

protected

Definition at line 93 of file NearestNodeLocator.h.

Referenced by findNodes(), nearestNode(), and updatePatch().

_metaname

const RestartableDataMapName Restartable::_metaname

privateinherited

Restartable metadata name.

Definition at line 247 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

_nearest_node_info

std::map<dof_id_type, NearestNodeInfo> NearestNodeLocator::_nearest_node_info

Definition at line 98 of file NearestNodeLocator.h.

Referenced by distance(), findNodes(), nearestNode(), reinit(), and updatePatch().

_neighbor_nodes

std::map<dof_id_type, std::vector<dof_id_type> > NearestNodeLocator::_neighbor_nodes

Definition at line 112 of file NearestNodeLocator.h.

Referenced by findNodes(), reinit(), and updatePatch().

_new_ghosted_elems

std::vector<dof_id_type> NearestNodeLocator::_new_ghosted_elems

Definition at line 124 of file NearestNodeLocator.h.

Referenced by reinit(), updateGhostedElems(), and updatePatch().

_patch_size

const unsigned int NearestNodeLocator::_patch_size

static

Definition at line 115 of file NearestNodeLocator.h.

_patch_update_strategy

const Moose::PatchUpdateType NearestNodeLocator::_patch_update_strategy

Definition at line 118 of file NearestNodeLocator.h.

Referenced by findNodes().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_reinit_iteration

bool NearestNodeLocator::_reinit_iteration

Definition at line 108 of file NearestNodeLocator.h.

Referenced by findNodes(), and reinit().

_restartable_app

MooseApp& Restartable::_restartable_app

protectedinherited

Reference to the application.

Definition at line 234 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp(), and Restartable::registerRestartableNameWithFilterOnApp().

_restartable_name

std::string Restartable::_restartable_name

privateinherited

The name of the object.

Definition at line 250 of file Restartable.h.

Referenced by Restartable::declareRestartableDataWithObjectNameWithContext(), and Restartable::restartableName().

_restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 243 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

_restartable_system_name

const std::string Restartable::_restartable_system_name

protectedinherited

The system name this object is in.

Definition at line 237 of file Restartable.h.

Referenced by Restartable::restartableName().

_restartable_tid

const THREAD_ID Restartable::_restartable_tid

protectedinherited

The thread ID for this object.

Definition at line 240 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

_secondary_node_range

std::unique_ptr<NodeIdRange> NearestNodeLocator::_secondary_node_range

protected

Definition at line 95 of file NearestNodeLocator.h.

Referenced by findNodes(), reinit(), and secondaryNodeRange().

_secondary_nodes

std::vector<dof_id_type> NearestNodeLocator::_secondary_nodes

Definition at line 110 of file NearestNodeLocator.h.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), findNodes(), NonlinearSystemBase::overwriteNodeFace(), reinit(), secondaryNodes(), and NonlinearSystemBase::setConstraintSecondaryValues().

_subproblem

SubProblem& NearestNodeLocator::_subproblem

protected

Definition at line 91 of file NearestNodeLocator.h.

Referenced by findNodes(), updateGhostedElems(), and updatePatch().

---

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

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