PenetrationLocator Class Reference

#include <PenetrationLocator.h>

Inheritance diagram for PenetrationLocator:

Public Types
enum	NORMAL_SMOOTHING_METHOD { NSM_EDGE_BASED, NSM_NODAL_NORMAL_BASED }

Public Member Functions
	PenetrationLocator (SubProblem &subproblem, GeometricSearchData &geom_search_data, MooseMesh &mesh, const unsigned int primary_id, const unsigned int secondary_id, Order order, NearestNodeLocator &nearest_node)
	~PenetrationLocator ()
void	detectPenetration ()
void	reinit ()
	Completely redo the search from scratch. More...
Real	penetrationDistance (dof_id_type node_id)
RealVectorValue	penetrationNormal (dof_id_type node_id)
Real	normDistance (const Elem &elem, const Elem &side, const Node &p0, Point &closest_point, RealVectorValue &normal)
int	intersect2D_Segments (Point S1P0, Point S1P1, Point S2P0, Point S2P1, Point *I0, Point *I1)
int	inSegment (Point P, Point SP0, Point SP1)
void	setCheckWhetherReasonable (bool state)
void	setUpdate (bool update)
void	setTangentialTolerance (Real tangential_tolerance)
void	setNormalSmoothingDistance (Real normal_smoothing_distance)
void	setNormalSmoothingMethod (std::string nsmString)
Real	getTangentialTolerance ()
PerfGraph &	perfGraph ()
	Get the PerfGraph. More...

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
SubProblem &	_subproblem
MooseMesh &	_mesh
BoundaryID	_primary_boundary
BoundaryID	_secondary_boundary
libMesh::FEType	_fe_type
std::vector< std::vector< libMesh::FEBase * > >	_fe
NearestNodeLocator &	_nearest_node
std::map< dof_id_type, PenetrationInfo * > &	_penetration_info
	Data structure of nodes and their associated penetration information. More...
std::set< dof_id_type > &	_has_penetrated

Protected Member Functions
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing. More...
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. More...
std::string	timedSectionName (const std::string &section_name) const

Protected Attributes
bool	_check_whether_reasonable
	Check whether found candidates are reasonable. More...
bool &	_update_location
Real	_tangential_tolerance
bool	_do_normal_smoothing
Real	_normal_smoothing_distance
NORMAL_SMOOTHING_METHOD	_normal_smoothing_method
const Moose::PatchUpdateType	_patch_update_strategy
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph. More...
const std::string	_prefix
	A prefix to use for all sections. More...

Private 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. More...
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. More...
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. More...
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. More...
template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it. More...
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". More...
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". More...
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. More...

Private Attributes
MooseApp &	_restartable_app
	Reference to the application. More...
const std::string	_restartable_system_name
	The system name this object is in. More...
const THREAD_ID	_restartable_tid
	The thread ID for this object. More...
const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData) More...

Detailed Description

Definition at line 28 of file PenetrationLocator.h.

Member Enumeration Documentation

NORMAL_SMOOTHING_METHOD

enum PenetrationLocator::NORMAL_SMOOTHING_METHOD

Enumerator
NSM_EDGE_BASED
NSM_NODAL_NORMAL_BASED

Definition at line 50 of file PenetrationLocator.h.

  {
    NSM_EDGE_BASED,
    NSM_NODAL_NORMAL_BASED
  };

Constructor & Destructor Documentation

PenetrationLocator()

PenetrationLocator::PenetrationLocator	(	SubProblem &	subproblem,
		GeometricSearchData &	geom_search_data,
		MooseMesh &	mesh,
		const unsigned int	primary_id,
		const unsigned int	secondary_id,
		Order	order,
		NearestNodeLocator &	nearest_node
	)

Definition at line 24 of file PenetrationLocator.C.

  : Restartable(subproblem.getMooseApp(),
                Moose::stringify(primary_id) + "to" + Moose::stringify(secondary_id),
                "PenetrationLocator",
                0),
    PerfGraphInterface(subproblem.getMooseApp().perfGraph(),
                       "PenetrationLocator_" + Moose::stringify(primary_id) + "_" +
                           Moose::stringify(secondary_id)),
    _subproblem(subproblem),
    _mesh(mesh),
    _primary_boundary(primary_id),
    _secondary_boundary(secondary_id),
    _fe_type(order),
    _nearest_node(nearest_node),
    _penetration_info(declareRestartableDataWithContext<std::map<dof_id_type, PenetrationInfo *>>(
        "penetration_info", &_mesh)),
    _has_penetrated(declareRestartableData<std::set<dof_id_type>>("has_penetrated")),
    _check_whether_reasonable(true),
    _update_location(declareRestartableData<bool>("update_location", true)),
    _tangential_tolerance(0.0),
    _do_normal_smoothing(false),
    _normal_smoothing_distance(0.0),
    _normal_smoothing_method(NSM_EDGE_BASED),
    _patch_update_strategy(_mesh.getPatchUpdateStrategy())
{
  // Preconstruct an FE object for each thread we're going to use and for each lower-dimensional
  // element
  // This is a time savings so that the thread objects don't do this themselves multiple times
  _fe.resize(libMesh::n_threads());
  for (unsigned int i = 0; i < libMesh::n_threads(); i++)
  {
    unsigned int n_dims = _mesh.dimension();
    _fe[i].resize(n_dims + 1);
    for (unsigned int dim = 0; dim <= n_dims; ++dim)
    {
      _fe[i][dim] = FEBase::build(dim, _fe_type).release();
      _fe[i][dim]->get_xyz();
      _fe[i][dim]->get_phi();
      _fe[i][dim]->get_dphi();
      _fe[i][dim]->get_dxyzdxi();
      _fe[i][dim]->get_d2xyzdxi2();
      _fe[i][dim]->get_d2xyzdxideta();
      _fe[i][dim]->get_dxyzdeta();
      _fe[i][dim]->get_d2xyzdeta2();
      _fe[i][dim]->get_d2xyzdxideta();
    }
  }

  if (_normal_smoothing_method == NSM_NODAL_NORMAL_BASED)
  {
    if (!((_subproblem.hasVariable("nodal_normal_x")) &&
          (_subproblem.hasVariable("nodal_normal_y")) &&
          (_subproblem.hasVariable("nodal_normal_z"))))
    {
      mooseError(
          "To use nodal-normal-based smoothing, the nodal_normal_x, nodal_normal_y, and "
          "nodal_normal_z variables must exist.  Are you missing the \\[NodalNormals\\] block?");
    }
  }
}

~PenetrationLocator()

PenetrationLocator::~PenetrationLocator

(

)

Definition at line 91 of file PenetrationLocator.C.

{
  for (unsigned int i = 0; i < libMesh::n_threads(); i++)
    for (unsigned int dim = 0; dim < _fe[i].size(); dim++)
      delete _fe[i][dim];

  for (auto & it : _penetration_info)
    delete it.second;
}

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 276 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 351 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 269 of file Restartable.h.

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

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 294 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 323 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 333 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;
}

detectPenetration()

void PenetrationLocator::detectPenetration

(

)

Definition at line 102 of file PenetrationLocator.C.

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

{
  TIME_SECTION("detectPenetration", 3, "Detecting Penetration");

  // Get list of boundary (elem, side, id) tuples.
  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> bc_tuples =
      _mesh.buildActiveSideList();

  // Grab the secondary nodes we need to worry about from the NearestNodeLocator
  NodeIdRange & secondary_node_range = _nearest_node.secondaryNodeRange();

  PenetrationThread pt(_subproblem,
                       _mesh,
                       _primary_boundary,
                       _secondary_boundary,
                       _penetration_info,
                       _check_whether_reasonable,
                       _update_location,
                       _tangential_tolerance,
                       _do_normal_smoothing,
                       _normal_smoothing_distance,
                       _normal_smoothing_method,
                       _fe,
                       _fe_type,
                       _nearest_node,
                       _mesh.nodeToElemMap(),
                       bc_tuples);

  Threads::parallel_reduce(secondary_node_range, pt);

  std::vector<dof_id_type> recheck_secondary_nodes = pt._recheck_secondary_nodes;

  // Update the patch for the secondary nodes in recheck_secondary_nodes and re-run penetration
  // thread on these nodes at every nonlinear iteration if patch update strategy is set to
  // "iteration".
  if (recheck_secondary_nodes.size() > 0 && _patch_update_strategy == Moose::Iteration &&
      _subproblem.currentlyComputingJacobian())
  {
    // Update the patch for this subset of secondary nodes and calculate the nearest neighbor_nodes
    _nearest_node.updatePatch(recheck_secondary_nodes);

    // Re-run the penetration thread to see if these nodes are in contact with the updated patch
    NodeIdRange recheck_secondary_node_range(
        recheck_secondary_nodes.begin(), recheck_secondary_nodes.end(), 1);

    Threads::parallel_reduce(recheck_secondary_node_range, pt);
  }

  if (recheck_secondary_nodes.size() > 0 && _patch_update_strategy != Moose::Iteration &&
      _subproblem.currentlyComputingJacobian())
    mooseDoOnce(mooseWarning("Warning in PenetrationLocator. Penetration is not "
                             "detected for one or more secondary nodes. This could be because "
                             "those secondary nodes simply do not project to faces on the primary "
                             "surface. However, this could also be because contact should be "
                             "enforced on those nodes, but the faces that they project to "
                             "are outside the contact patch, which will give an erroneous "
                             "result. Use appropriate options for 'patch_size' and "
                             "'patch_update_strategy' in the Mesh block to avoid this issue. "
                             "Setting 'patch_update_strategy=iteration' is recommended because "
                             "it completely avoids this potential issue. Also note that this "
                             "warning is printed only once, so a similar situation could occur "
                             "multiple times during the simulation but this warning is printed "
                             "only at the first occurrence."));
}

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 287 of file Restartable.h.

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

getTangentialTolerance()

Real PenetrationLocator::getTangentialTolerance ( )

inline

Definition at line 89 of file PenetrationLocator.h.

{ return _tangential_tolerance; }

inSegment()

int PenetrationLocator::inSegment	(	Point	P,
		Point	SP0,
		Point	SP1
	)

intersect2D_Segments()

int PenetrationLocator::intersect2D_Segments	(	Point	S1P0,
		Point	S1P1,
		Point	S2P0,
		Point	S2P1,
		Point *	I0,
		Point *	I1
	)

normDistance()

Real PenetrationLocator::normDistance	(	const Elem &	elem,
		const Elem &	side,
		const Node &	p0,
		Point &	closest_point,
		RealVectorValue &	normal
	)

penetrationDistance()

Real PenetrationLocator::penetrationDistance

(

dof_id_type

node_id

)

Definition at line 185 of file PenetrationLocator.C.

{
  PenetrationInfo * info = _penetration_info[node_id];

  if (info)
    return info->_distance;
  else
    return 0;
}

penetrationNormal()

RealVectorValue PenetrationLocator::penetrationNormal

(

dof_id_type

node_id

)

Definition at line 196 of file PenetrationLocator.C.

{
  std::map<dof_id_type, PenetrationInfo *>::const_iterator found_it =
      _penetration_info.find(node_id);

  if (found_it != _penetration_info.end())
    return found_it->second->_normal;
  else
    return RealVectorValue(0, 0, 0);
}

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 78 of file PerfGraphInterface.C.

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

{
  return _pg_moose_app.perfGraph();
}

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 53 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 64 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 PenetrationLocator::reinit

(

)

Completely redo the search from scratch.

This is probably getting called because of mesh adaptivity.

Definition at line 168 of file PenetrationLocator.C.

Referenced by GeometricSearchData::reinit().

{
  TIME_SECTION("reinit", 3, "Reinitializing PenetrationLocator");

  // Delete the PenetrationInfo objects we own before clearing the
  // map, or we have a memory leak.
  for (auto & it : _penetration_info)
    delete it.second;

  _penetration_info.clear();

  _has_penetrated.clear();

  detectPenetration();
}

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 66 of file Restartable.C.

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

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

setCheckWhetherReasonable()

void PenetrationLocator::setCheckWhetherReasonable

(

bool

state

)

Definition at line 208 of file PenetrationLocator.C.

{
  _check_whether_reasonable = state;
}

setNormalSmoothingDistance()

void PenetrationLocator::setNormalSmoothingDistance

(

Real

normal_smoothing_distance

)

Definition at line 226 of file PenetrationLocator.C.

Referenced by GapValueAux::GapValueAux(), NodeFaceConstraint::NodeFaceConstraint(), and PenetrationAux::PenetrationAux().

{
  _normal_smoothing_distance = normal_smoothing_distance;
  if (_normal_smoothing_distance > 0.0)
    _do_normal_smoothing = true;
}

setNormalSmoothingMethod()

void PenetrationLocator::setNormalSmoothingMethod

(

std::string

nsmString

)

Definition at line 234 of file PenetrationLocator.C.

Referenced by GapValueAux::GapValueAux(), NodeFaceConstraint::NodeFaceConstraint(), and PenetrationAux::PenetrationAux().

{
  if (nsmString == "edge_based")
    _normal_smoothing_method = NSM_EDGE_BASED;
  else if (nsmString == "nodal_normal_based")
    _normal_smoothing_method = NSM_NODAL_NORMAL_BASED;
  else
    mooseError("Invalid normal_smoothing_method: ", nsmString);
  _do_normal_smoothing = true;
}

setTangentialTolerance()

void PenetrationLocator::setTangentialTolerance

(

Real

tangential_tolerance

)

Definition at line 220 of file PenetrationLocator.C.

Referenced by GapValueAux::GapValueAux(), NodeFaceConstraint::NodeFaceConstraint(), and PenetrationAux::PenetrationAux().

{
  _tangential_tolerance = tangential_tolerance;
}

setUpdate()

void PenetrationLocator::setUpdate

(

bool

update

)

Definition at line 214 of file PenetrationLocator.C.

{
  _update_location = update;
}

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 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

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

validParams()

InputParameters PerfGraphInterface::validParams ( )

staticinherited

Definition at line 16 of file PerfGraphInterface.C.

Referenced by Convergence::validParams().

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

Member Data Documentation

_check_whether_reasonable

bool PenetrationLocator::_check_whether_reasonable

protected

Check whether found candidates are reasonable.

Definition at line 93 of file PenetrationLocator.h.

Referenced by detectPenetration(), and setCheckWhetherReasonable().

_do_normal_smoothing

bool PenetrationLocator::_do_normal_smoothing

protected

Definition at line 97 of file PenetrationLocator.h.

Referenced by detectPenetration(), setNormalSmoothingDistance(), and setNormalSmoothingMethod().

_fe

std::vector<std::vector<libMesh::FEBase *> > PenetrationLocator::_fe

Definition at line 74 of file PenetrationLocator.h.

Referenced by detectPenetration(), PenetrationLocator(), and ~PenetrationLocator().

_fe_type

libMesh::FEType PenetrationLocator::_fe_type

Definition at line 71 of file PenetrationLocator.h.

Referenced by detectPenetration(), and PenetrationLocator().

_has_penetrated

std::set<dof_id_type>& PenetrationLocator::_has_penetrated

Definition at line 82 of file PenetrationLocator.h.

Referenced by reinit().

_mesh

MooseMesh& PenetrationLocator::_mesh

Definition at line 67 of file PenetrationLocator.h.

Referenced by detectPenetration(), and PenetrationLocator().

_nearest_node

NearestNodeLocator& PenetrationLocator::_nearest_node

Definition at line 76 of file PenetrationLocator.h.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), detectPenetration(), NonlinearSystemBase::overwriteNodeFace(), and NonlinearSystemBase::setConstraintSecondaryValues().

_normal_smoothing_distance

Real PenetrationLocator::_normal_smoothing_distance

protected

Definition at line 98 of file PenetrationLocator.h.

Referenced by detectPenetration(), and setNormalSmoothingDistance().

_normal_smoothing_method

NORMAL_SMOOTHING_METHOD PenetrationLocator::_normal_smoothing_method

protected

Definition at line 100 of file PenetrationLocator.h.

Referenced by detectPenetration(), PenetrationLocator(), and setNormalSmoothingMethod().

_patch_update_strategy

const Moose::PatchUpdateType PenetrationLocator::_patch_update_strategy

protected

Definition at line 102 of file PenetrationLocator.h.

Referenced by detectPenetration().

_penetration_info

std::map<dof_id_type, PenetrationInfo *>& PenetrationLocator::_penetration_info

Data structure of nodes and their associated penetration information.

Definition at line 79 of file PenetrationLocator.h.

Referenced by GapValueAux::computeValue(), PenetrationAux::computeValue(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), detectPenetration(), NonlinearSystemBase::overwriteNodeFace(), penetrationDistance(), penetrationNormal(), reinit(), NonlinearSystemBase::setConstraintSecondaryValues(), and ~PenetrationLocator().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 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 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_primary_boundary

BoundaryID PenetrationLocator::_primary_boundary

Definition at line 68 of file PenetrationLocator.h.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), detectPenetration(), NonlinearSystemBase::overwriteNodeFace(), and NonlinearSystemBase::setConstraintSecondaryValues().

_restartable_app

MooseApp& Restartable::_restartable_app

protectedinherited

Reference to the application.

Definition at line 227 of file Restartable.h.

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

_restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 236 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 230 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 233 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

_secondary_boundary

BoundaryID PenetrationLocator::_secondary_boundary

Definition at line 69 of file PenetrationLocator.h.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), detectPenetration(), NonlinearSystemBase::overwriteNodeFace(), and NonlinearSystemBase::setConstraintSecondaryValues().

_subproblem

SubProblem& PenetrationLocator::_subproblem

Definition at line 56 of file PenetrationLocator.h.

Referenced by detectPenetration(), and PenetrationLocator().

_tangential_tolerance

Real PenetrationLocator::_tangential_tolerance

protected

Definition at line 95 of file PenetrationLocator.h.

Referenced by detectPenetration(), getTangentialTolerance(), and setTangentialTolerance().

_update_location

bool& PenetrationLocator::_update_location

protected

Definition at line 94 of file PenetrationLocator.h.

Referenced by detectPenetration(), and setUpdate().

---

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

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