www.mooseframework.org
Public Types | Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Private Member Functions | List of all members
PenetrationLocator Class Reference

#include <PenetrationLocator.h>

Inheritance diagram for PenetrationLocator:
[legend]

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 master_id, const unsigned int slave_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 ()
 

Public Attributes

SubProblem_subproblem
 
MooseMesh_mesh
 
BoundaryID _master_boundary
 
BoundaryID _slave_boundary
 
FEType _fe_type
 
std::vector< std::vector< 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)
 Call to register a named section for timing. More...
 

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
 
PerfID _detect_penetration_timer
 Timers. More...
 
PerfID _reinit_timer
 
const InputParameters_pg_params
 Params. More...
 
PerfGraph_perf_graph
 The performance graph to add to. More...
 
std::string _prefix
 A prefix to use for all sections. More...
 

Private Member Functions

template<typename T >
T & declareRestartableData (std::string data_name)
 Declare a piece of data as "restartable". More...
 
template<typename T >
T & declareRestartableData (std::string data_name, const T &init_value)
 Declare a piece of data as "restartable" and initialize it. More...
 
template<typename T >
T & declareRestartableDataWithContext (std::string data_name, void *context)
 Declare a piece of data as "restartable". More...
 
template<typename T >
T & declareRestartableDataWithContext (std::string data_name, const T &init_value, void *context)
 Declare a piece of data as "restartable" and initialize it. More...
 
template<typename T >
T & declareRecoverableData (std::string data_name)
 Declare a piece of data as "recoverable". More...
 
template<typename T >
T & declareRecoverableData (std::string data_name, const T &init_value)
 Declare a piece of data as "restartable" and initialize it. More...
 
template<typename T >
T & declareRestartableDataWithObjectName (std::string data_name, std::string object_name)
 Declare a piece of data as "restartable". More...
 
template<typename T >
T & declareRestartableDataWithObjectNameWithContext (std::string data_name, std::string object_name, void *context)
 Declare a piece of data as "restartable". More...
 

Detailed Description

Definition at line 28 of file PenetrationLocator.h.

Member Enumeration Documentation

◆ NORMAL_SMOOTHING_METHOD

Enumerator
NSM_EDGE_BASED 
NSM_NODAL_NORMAL_BASED 

Definition at line 50 of file PenetrationLocator.h.

Constructor & Destructor Documentation

◆ PenetrationLocator()

PenetrationLocator::PenetrationLocator ( SubProblem subproblem,
GeometricSearchData geom_search_data,
MooseMesh mesh,
const unsigned int  master_id,
const unsigned int  slave_id,
Order  order,
NearestNodeLocator nearest_node 
)

Definition at line 22 of file PenetrationLocator.C.

29  : Restartable(subproblem.getMooseApp(),
30  Moose::stringify(master_id) + "to" + Moose::stringify(slave_id),
31  "PenetrationLocator",
32  0),
34  "PenetrationLocator_" + Moose::stringify(master_id) + "_" +
35  Moose::stringify(slave_id)),
36  _subproblem(subproblem),
37  _mesh(mesh),
38  _master_boundary(master_id),
39  _slave_boundary(slave_id),
40  _fe_type(order),
41  _nearest_node(nearest_node),
42  _penetration_info(declareRestartableDataWithContext<std::map<dof_id_type, PenetrationInfo *>>(
43  "penetration_info", &_mesh)),
44  _has_penetrated(declareRestartableData<std::set<dof_id_type>>("has_penetrated")),
46  _update_location(declareRestartableData<bool>("update_location", true)),
48  _do_normal_smoothing(false),
52  _detect_penetration_timer(registerTimedSection("detectPenetration", 3)),
54 
55 {
56  // Preconstruct an FE object for each thread we're going to use and for each lower-dimensional
57  // element
58  // This is a time savings so that the thread objects don't do this themselves multiple times
59  _fe.resize(libMesh::n_threads());
60  for (unsigned int i = 0; i < libMesh::n_threads(); i++)
61  {
62  unsigned int n_dims = _mesh.dimension();
63  _fe[i].resize(n_dims + 1);
64  for (unsigned int dim = 0; dim <= n_dims; ++dim)
65  _fe[i][dim] = FEBase::build(dim, _fe_type).release();
66  }
67 
69  {
70  if (!((_subproblem.hasVariable("nodal_normal_x")) &&
71  (_subproblem.hasVariable("nodal_normal_y")) &&
72  (_subproblem.hasVariable("nodal_normal_z"))))
73  {
74  mooseError("To use nodal-normal-based smoothing, the nodal_normal_x, nodal_normal_y, and "
75  "nodal_normal_z variables must exist. Are you missing the [NodalNormals] block?");
76  }
77  }
78 }
const Moose::PatchUpdateType _patch_update_strategy
PerfID registerTimedSection(const std::string &section_name, const unsigned int level)
Call to register a named section for timing.
PerfID _detect_penetration_timer
Timers.
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
std::vector< std::vector< FEBase * > > _fe
std::map< dof_id_type, PenetrationInfo * > & _penetration_info
Data structure of nodes and their associated penetration information.
bool _check_whether_reasonable
Check whether found candidates are reasonable.
virtual unsigned int dimension() const
Returns MeshBase::mesh_dimsension(), (not MeshBase::spatial_dimension()!) of the underlying libMesh m...
Definition: MooseMesh.C:2099
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:58
virtual bool hasVariable(const std::string &var_name) const =0
Restartable(const MooseObject *moose_object, const std::string &system_name)
Class constructor.
Definition: Restartable.C:17
SubProblem & _subproblem
T & declareRestartableDataWithContext(std::string data_name, void *context)
Declare a piece of data as "restartable".
Definition: Restartable.h:216
MooseApp & getMooseApp() const
Get the MooseApp this object is associated with.
Definition: MooseObject.h:86
PerfGraphInterface(const MooseObject *moose_object)
For objects that are MooseObjects with a default prefix of type()
const Moose::PatchUpdateType & getPatchUpdateStrategy() const
Get the current patch update strategy.
Definition: MooseMesh.C:2483
std::set< dof_id_type > & _has_penetrated
PerfGraph & perfGraph()
Get the PerfGraph for this app.
Definition: MooseApp.h:97
NORMAL_SMOOTHING_METHOD _normal_smoothing_method
NearestNodeLocator & _nearest_node
T & declareRestartableData(std::string data_name)
Declare a piece of data as "restartable".
Definition: Restartable.h:202

◆ ~PenetrationLocator()

PenetrationLocator::~PenetrationLocator ( )

Definition at line 80 of file PenetrationLocator.C.

81 {
82  for (unsigned int i = 0; i < libMesh::n_threads(); i++)
83  for (unsigned int dim = 0; dim < _fe[i].size(); dim++)
84  delete _fe[i][dim];
85 
86  for (auto & it : _penetration_info)
87  delete it.second;
88 }
std::vector< std::vector< FEBase * > > _fe
std::map< dof_id_type, PenetrationInfo * > & _penetration_info
Data structure of nodes and their associated penetration information.

Member Function Documentation

◆ declareRecoverableData() [1/2]

template<typename T >
T & Restartable::declareRecoverableData ( std::string  data_name)
protectedinherited

Declare a piece of data as "recoverable".

This means that in the event of a recovery 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_nameThe name of the data (usually just use the same name as the member variable)

Definition at line 269 of file Restartable.h.

270 {
271  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
272 
273  registerRecoverableDataOnApp(full_name);
274 
275  return declareRestartableDataWithContext<T>(data_name, nullptr);
276 }
std::string _restartable_system_name
The system name this object is in.
Definition: Restartable.h:194
std::string _restartable_name
The name of the object.
Definition: Restartable.h:191
void registerRecoverableDataOnApp(std::string name)
Helper function for actually registering the restartable data.
Definition: Restartable.C:54

◆ declareRecoverableData() [2/2]

template<typename T >
T & Restartable::declareRecoverableData ( std::string  data_name,
const T &  init_value 
)
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 data will NOT be restored on Restart!

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

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
init_valueThe initial value of the data

Definition at line 280 of file Restartable.h.

281 {
282  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
283 
284  registerRecoverableDataOnApp(full_name);
285 
286  return declareRestartableDataWithContext<T>(data_name, init_value, nullptr);
287 }
std::string _restartable_system_name
The system name this object is in.
Definition: Restartable.h:194
std::string _restartable_name
The name of the object.
Definition: Restartable.h:191
void registerRecoverableDataOnApp(std::string name)
Helper function for actually registering the restartable data.
Definition: Restartable.C:54

◆ declareRestartableData() [1/2]

template<typename T >
T & Restartable::declareRestartableData ( std::string  data_name)
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_nameThe name of the data (usually just use the same name as the member variable)

Definition at line 202 of file Restartable.h.

203 {
204  return declareRestartableDataWithContext<T>(data_name, nullptr);
205 }

◆ declareRestartableData() [2/2]

template<typename T >
T & Restartable::declareRestartableData ( std::string  data_name,
const T &  init_value 
)
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_nameThe name of the data (usually just use the same name as the member variable)
init_valueThe initial value of the data

Definition at line 209 of file Restartable.h.

210 {
211  return declareRestartableDataWithContext<T>(data_name, init_value, nullptr);
212 }

◆ declareRestartableDataWithContext() [1/2]

template<typename T >
T & Restartable::declareRestartableDataWithContext ( std::string  data_name,
void *  context 
)
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_nameThe name of the data (usually just use the same name as the member variable)
contextContext pointer that will be passed to the load and store functions

Definition at line 216 of file Restartable.h.

217 {
218  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
219  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, context);
220  T & restartable_data_ref = data_ptr->get();
221 
222  registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid);
223 
224  return restartable_data_ref;
225 }
std::string _restartable_system_name
The system name this object is in.
Definition: Restartable.h:194
std::string _restartable_name
The name of the object.
Definition: Restartable.h:191
THREAD_ID _restartable_tid
The thread ID for this object.
Definition: Restartable.h:197
void registerRestartableDataOnApp(std::string name, std::unique_ptr< RestartableDataValue > data, THREAD_ID tid)
Helper function for actually registering the restartable data.
Definition: Restartable.C:46

◆ declareRestartableDataWithContext() [2/2]

template<typename T >
T & Restartable::declareRestartableDataWithContext ( std::string  data_name,
const T &  init_value,
void *  context 
)
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_nameThe name of the data (usually just use the same name as the member variable)
init_valueThe initial value of the data
contextContext pointer that will be passed to the load and store functions

Definition at line 229 of file Restartable.h.

232 {
233  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
234  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, context);
235  data_ptr->set() = init_value;
236 
237  T & restartable_data_ref = data_ptr->get();
238  registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid);
239 
240  return restartable_data_ref;
241 }
std::string _restartable_system_name
The system name this object is in.
Definition: Restartable.h:194
std::string _restartable_name
The name of the object.
Definition: Restartable.h:191
THREAD_ID _restartable_tid
The thread ID for this object.
Definition: Restartable.h:197
void registerRestartableDataOnApp(std::string name, std::unique_ptr< RestartableDataValue > data, THREAD_ID tid)
Helper function for actually registering the restartable data.
Definition: Restartable.C:46

◆ declareRestartableDataWithObjectName()

template<typename T >
T & Restartable::declareRestartableDataWithObjectName ( std::string  data_name,
std::string  object_name 
)
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_nameThe name of the data (usually just use the same name as the member variable)
object_nameA supplied name for the object that is declaring this data.

Definition at line 245 of file Restartable.h.

246 {
247  return declareRestartableDataWithObjectNameWithContext<T>(data_name, object_name, nullptr);
248 }

◆ declareRestartableDataWithObjectNameWithContext()

template<typename T >
T & Restartable::declareRestartableDataWithObjectNameWithContext ( std::string  data_name,
std::string  object_name,
void *  context 
)
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_nameThe name of the data (usually just use the same name as the member variable)
object_nameA supplied name for the object that is declaring this data.
contextContext pointer that will be passed to the load and store functions

Definition at line 252 of file Restartable.h.

255 {
256  std::string old_name = _restartable_name;
257 
258  _restartable_name = object_name;
259 
260  T & value = declareRestartableDataWithContext<T>(data_name, context);
261 
262  _restartable_name = old_name;
263 
264  return value;
265 }
std::string _restartable_name
The name of the object.
Definition: Restartable.h:191

◆ detectPenetration()

void PenetrationLocator::detectPenetration ( )

Definition at line 91 of file PenetrationLocator.C.

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

92 {
93  TIME_SECTION(_detect_penetration_timer);
94 
95  // Get list of boundary (elem, side, id) tuples.
96  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> bc_tuples =
98 
99  // Grab the slave nodes we need to worry about from the NearestNodeLocator
100  NodeIdRange & slave_node_range = _nearest_node.slaveNodeRange();
101 
103  _mesh,
113  _fe,
114  _fe_type,
117  bc_tuples);
118 
119  Threads::parallel_reduce(slave_node_range, pt);
120 
121  std::vector<dof_id_type> recheck_slave_nodes = pt._recheck_slave_nodes;
122 
123  // Update the patch for the slave nodes in recheck_slave_nodes and re-run penetration thread on
124  // these nodes at every nonlinear iteration if patch update strategy is set to "iteration".
125  if (recheck_slave_nodes.size() > 0 && _patch_update_strategy == Moose::Iteration &&
127  {
128  // Update the patch for this subset of slave nodes and calculate the nearest neighbor_nodes
129  _nearest_node.updatePatch(recheck_slave_nodes);
130 
131  // Re-run the penetration thread to see if these nodes are in contact with the updated patch
132  NodeIdRange recheck_slave_node_range(recheck_slave_nodes.begin(), recheck_slave_nodes.end(), 1);
133 
134  Threads::parallel_reduce(recheck_slave_node_range, pt);
135  }
136 
137  if (recheck_slave_nodes.size() > 0 && _patch_update_strategy != Moose::Iteration &&
139  mooseDoOnce(mooseWarning("Warning in PenetrationLocator. Penetration is not "
140  "detected for one or more slave nodes. This could be because "
141  "those slave nodes simply do not project to faces on the master "
142  "surface. However, this could also be because contact should be "
143  "enforced on those nodes, but the faces that they project to "
144  "are outside the contact patch, which will give an erroneous "
145  "result. Use appropriate options for 'patch_size' and "
146  "'patch_update_strategy' in the Mesh block to avoid this issue. "
147  "Setting 'patch_update_strategy=iteration' is recommended because "
148  "it completely avoids this potential issue. Also note that this "
149  "warning is printed only once, so a similar situation could occur "
150  "multiple times during the simulation but this warning is printed "
151  "only at the first occurrence."));
152 }
const Moose::PatchUpdateType _patch_update_strategy
PerfID _detect_penetration_timer
Timers.
StoredRange< std::vector< dof_id_type >::iterator, dof_id_type > NodeIdRange
Definition: MooseTypes.h:101
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition: MooseError.h:220
void updatePatch(std::vector< dof_id_type > &slave_nodes)
Reconstructs the KDtree, updates the patch for the nodes in slave_nodes, and updates the closest neig...
std::vector< std::vector< FEBase * > > _fe
std::map< dof_id_type, PenetrationInfo * > & _penetration_info
Data structure of nodes and their associated penetration information.
void buildSideList(std::vector< dof_id_type > &el, std::vector< unsigned short int > &sl, std::vector< boundary_id_type > &il)
Calls BoundaryInfo::build_side_list().
Definition: MooseMesh.C:2126
bool _check_whether_reasonable
Check whether found candidates are reasonable.
NodeIdRange & slaveNodeRange()
Returns the NodeIdRange of slave nodes to be used for calling threaded functions operating on the sla...
virtual bool currentlyComputingJacobian() const
Returns true if the problem is in the process of computing Jacobian.
Definition: SubProblem.h:501
SubProblem & _subproblem
NORMAL_SMOOTHING_METHOD _normal_smoothing_method
NearestNodeLocator & _nearest_node
const std::map< dof_id_type, std::vector< dof_id_type > > & nodeToElemMap()
If not already created, creates a map from every node to all elements to which they are connected...
Definition: MooseMesh.C:732

◆ getTangentialTolerance()

Real PenetrationLocator::getTangentialTolerance ( )
inline

Definition at line 89 of file PenetrationLocator.h.

◆ 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 172 of file PenetrationLocator.C.

173 {
174  PenetrationInfo * info = _penetration_info[node_id];
175 
176  if (info)
177  return info->_distance;
178  else
179  return 0;
180 }
Data structure used to hold penetration information.
std::map< dof_id_type, PenetrationInfo * > & _penetration_info
Data structure of nodes and their associated penetration information.

◆ penetrationNormal()

RealVectorValue PenetrationLocator::penetrationNormal ( dof_id_type  node_id)

Definition at line 183 of file PenetrationLocator.C.

184 {
185  std::map<dof_id_type, PenetrationInfo *>::const_iterator found_it =
186  _penetration_info.find(node_id);
187 
188  if (found_it != _penetration_info.end())
189  return found_it->second->_normal;
190  else
191  return RealVectorValue(0, 0, 0);
192 }
std::map< dof_id_type, PenetrationInfo * > & _penetration_info
Data structure of nodes and their associated penetration information.

◆ registerTimedSection()

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

Call to register a named section for timing.

Parameters
section_nameThe name of the code section to be timed
levelThe 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 50 of file PerfGraphInterface.C.

51 {
52  if (_prefix != "")
53  return _perf_graph.registerSection(_prefix + "::" + section_name, level);
54  else
55  return _perf_graph.registerSection(section_name, level);
56 }
PerfGraph & _perf_graph
The performance graph to add to.
std::string _prefix
A prefix to use for all sections.
PerfID registerSection(const std::string &section_name, unsigned int level)
Registers a named section of code.
Definition: PerfGraph.C:41

◆ reinit()

void PenetrationLocator::reinit ( )

Completely redo the search from scratch.

This is probably getting called because of mesh adaptivity.

Definition at line 155 of file PenetrationLocator.C.

Referenced by GeometricSearchData::reinit().

156 {
157  TIME_SECTION(_reinit_timer);
158 
159  // Delete the PenetrationInfo objects we own before clearing the
160  // map, or we have a memory leak.
161  for (auto & it : _penetration_info)
162  delete it.second;
163 
164  _penetration_info.clear();
165 
166  _has_penetrated.clear();
167 
169 }
std::map< dof_id_type, PenetrationInfo * > & _penetration_info
Data structure of nodes and their associated penetration information.
std::set< dof_id_type > & _has_penetrated

◆ setCheckWhetherReasonable()

void PenetrationLocator::setCheckWhetherReasonable ( bool  state)

Definition at line 195 of file PenetrationLocator.C.

196 {
198 }
bool _check_whether_reasonable
Check whether found candidates are reasonable.

◆ setNormalSmoothingDistance()

void PenetrationLocator::setNormalSmoothingDistance ( Real  normal_smoothing_distance)

Definition at line 213 of file PenetrationLocator.C.

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

214 {
215  _normal_smoothing_distance = normal_smoothing_distance;
216  if (_normal_smoothing_distance > 0.0)
217  _do_normal_smoothing = true;
218 }

◆ setNormalSmoothingMethod()

void PenetrationLocator::setNormalSmoothingMethod ( std::string  nsmString)

Definition at line 221 of file PenetrationLocator.C.

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

222 {
223  if (nsmString == "edge_based")
225  else if (nsmString == "nodal_normal_based")
227  else
228  mooseError("Invalid normal_smoothing_method: ", nsmString);
229  _do_normal_smoothing = true;
230 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
NORMAL_SMOOTHING_METHOD _normal_smoothing_method

◆ setTangentialTolerance()

void PenetrationLocator::setTangentialTolerance ( Real  tangential_tolerance)

Definition at line 207 of file PenetrationLocator.C.

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

208 {
209  _tangential_tolerance = tangential_tolerance;
210 }

◆ setUpdate()

void PenetrationLocator::setUpdate ( bool  update)

Definition at line 201 of file PenetrationLocator.C.

202 {
203  _update_location = update;
204 }

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().

◆ _detect_penetration_timer

PerfID PenetrationLocator::_detect_penetration_timer
protected

Timers.

Definition at line 105 of file PenetrationLocator.h.

Referenced by detectPenetration().

◆ _do_normal_smoothing

bool PenetrationLocator::_do_normal_smoothing
protected

◆ _fe

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

Definition at line 74 of file PenetrationLocator.h.

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

◆ _fe_type

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().

◆ _master_boundary

BoundaryID PenetrationLocator::_master_boundary

Definition at line 68 of file PenetrationLocator.h.

Referenced by detectPenetration().

◆ _mesh

MooseMesh& PenetrationLocator::_mesh

Definition at line 67 of file PenetrationLocator.h.

Referenced by detectPenetration(), and PenetrationLocator().

◆ _nearest_node

NearestNodeLocator& PenetrationLocator::_nearest_node

◆ _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

◆ _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

◆ _perf_graph

PerfGraph& PerfGraphInterface::_perf_graph
protectedinherited

The performance graph to add to.

Definition at line 66 of file PerfGraphInterface.h.

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

◆ _pg_params

const InputParameters* PerfGraphInterface::_pg_params
protectedinherited

Params.

Definition at line 63 of file PerfGraphInterface.h.

◆ _prefix

std::string PerfGraphInterface::_prefix
protectedinherited

A prefix to use for all sections.

Definition at line 69 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::registerTimedSection().

◆ _reinit_timer

PerfID PenetrationLocator::_reinit_timer
protected

Definition at line 106 of file PenetrationLocator.h.

Referenced by reinit().

◆ _slave_boundary

BoundaryID PenetrationLocator::_slave_boundary

◆ _subproblem

SubProblem& PenetrationLocator::_subproblem

Definition at line 56 of file PenetrationLocator.h.

Referenced by detectPenetration(), and PenetrationLocator().

◆ _tangential_tolerance

Real PenetrationLocator::_tangential_tolerance
protected

◆ _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: