https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Types | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Member Functions | List of all members
ExplicitDynamicsContactAction Class Reference

Action class for creating constraints, kernels, and user objects necessary for mechanical contact. More...

#include <ExplicitDynamicsContactAction.h>

Inheritance diagram for ExplicitDynamicsContactAction:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 ExplicitDynamicsContactAction (const InputParameters &params)
 
virtual void act () override
 
void timedAct ()
 
virtual void addRelationshipManagers (Moose::RelationshipManagerType when_type)
 
MooseObjectName uniqueActionName () const
 
const std::string & specificTaskName () const
 
const std::set< std::string > & getAllTasks () const
 
void appendTask (const std::string &task)
 
MooseApp & getMooseApp () const
 
const std::string & type () const
 
const std::string & name () const
 
std::string typeAndName () const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
MooseObjectName uniqueName () const
 
const InputParameters & parameters () const
 
const hit::Node * getHitNode () const
 
bool hasBase () const
 
const std::string & getBase () const
 
const T & getParam (const std::string &name) const
 
std::vector< std::pair< T1, T2 > > getParam (const std::string &param1, const std::string &param2) const
 
const T * queryParam (const std::string &name) const
 
const T & getRenamedParam (const std::string &old_name, const std::string &new_name) const
 
T getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
 
bool haveParameter (const std::string &name) const
 
bool isParamValid (const std::string &name) const
 
bool isParamSetByUser (const std::string &name) const
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void paramError (const std::string &param, Args... args) const
 
void paramWarning (const std::string &param, Args... args) const
 
void paramWarning (const std::string &param, Args... args) const
 
void paramInfo (const std::string &param, Args... args) const
 
std::string messagePrefix (const bool hit_prefix=true) const
 
std::string errorPrefix (const std::string &) const
 
void mooseError (Args &&... args) const
 
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseDeprecatedNoTrace (Args &&... args) const
 
void mooseInfo (Args &&... args) const
 
void callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
 
std::string getDataFileName (const std::string &param) const
 
std::string getDataFileNameByName (const std::string &relative_path) const
 
std::string getDataFilePath (const std::string &relative_path) const
 
PerfGraph & perfGraph ()
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static InputParameters validParams ()
 
static MooseEnum getModelEnum ()
 Get contact model. More...
 
static InputParameters commonParameters ()
 Define parameters used by multiple contact objects. More...
 
static void callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)
 

Public Attributes

 usingCombinedWarningSolutionWarnings
 
const ConsoleStream _console
 

Static Public Attributes

static const std::string unique_action_name_param
 
static const std::string type_param
 
static const std::string name_param
 
static const std::string unique_name_param
 
static const std::string app_param
 
static const std::string moose_base_param
 
static const std::string kokkos_object_param
 
static constexpr auto SYSTEM
 
static constexpr auto NAME
 

Protected Types

typedef std::vector< VariableName > CoupledName
 Type that we use in Actions for declaring coupling. More...
 

Protected Member Functions

bool addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
 
void associateWithParameter (const std::string &param_name, InputParameters &params) const
 
void associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const
 
const T & getMeshProperty (const std::string &data_name, const std::string &prefix)
 
const T & getMeshProperty (const std::string &data_name)
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name) const
 
bool hasMeshProperty (const std::string &data_name) const
 
std::string meshPropertyName (const std::string &data_name) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 
std::string timedSectionName (const std::string &section_name) const
 
void flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
 
InvalidSolutionID registerInvalidSolutionInternal (const std::string &message, const bool warning) const
 

Static Protected Member Functions

static std::string meshPropertyName (const std::string &data_name, const std::string &prefix)
 

Protected Attributes

std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
 Primary/Secondary boundary name pairs for mechanical contact. More...
 
const ExplicitDynamicsContactModel _model
 Contact model type enum. More...
 
const bool _verbose
 Verbose output, may increase runtime. More...
 
const std::vector< SubdomainName > & _blocks
 Restrict contact MooseObjects to these subdomains. More...
 
std::string _registered_identifier
 
std::string _specific_task_name
 
std::set< std::string > _all_tasks
 
ActionWarehouse & _awh
 
const std::string & _current_task
 
std::shared_ptr< MooseMesh > & _mesh
 
std::shared_ptr< MooseMesh > & _displaced_mesh
 
std::shared_ptr< FEProblemBase > & _problem
 
PerfID _act_timer
 
MooseApp & _app
 
Factory & _factory
 
ActionFactory & _action_factory
 
const std::string & _type
 
const std::string & _name
 
const InputParameters & _pars
 
MooseApp & _pg_moose_app
 
const std::string _prefix
 
const Parallel::Communicator & _communicator
 

Private Member Functions

void addNodeFaceContact ()
 Generate constraints for node to face contact. More...
 
void addContactPressureAuxKernel ()
 Add single contact pressure auxiliary kernel for various contact action objects. More...
 

Detailed Description

Action class for creating constraints, kernels, and user objects necessary for mechanical contact.

Definition at line 26 of file ExplicitDynamicsContactAction.h.

Member Typedef Documentation

◆ CoupledName

typedef std::vector<VariableName> ExplicitDynamicsContactAction::CoupledName
protected

Type that we use in Actions for declaring coupling.

Definition at line 56 of file ExplicitDynamicsContactAction.h.

Constructor & Destructor Documentation

◆ ExplicitDynamicsContactAction()

ExplicitDynamicsContactAction::ExplicitDynamicsContactAction ( const InputParameters &  params)

Definition at line 83 of file ExplicitDynamicsContactAction.C.

84  : Action(params),
85  _boundary_pairs(getParam<BoundaryName, BoundaryName>("primary", "secondary")),
86  _model(getParam<MooseEnum>("model").getEnum<ExplicitDynamicsContactModel>()),
87  _verbose(getParam<bool>("verbose")),
88  _blocks(getParam<std::vector<SubdomainName>>("block"))
89 {
90  // The resulting velocity of the contact algorithm is applied, as the code stands, by modifying
91  // the old position. This causes artifacts in the internal forces as old position, new position,
92  // and velocities are not fully consistent. Results improve with shorter time steps, but it would
93  // be best to modify all the solution arrays for consistency or replace the way the explicit
94  // system is solved to obtain accelerations (a = M^{-1}F) such that only velocities on the
95  // contacting boundary need to be updated with the contact algorithm output.
96  mooseWarning("Verification of explicit dynamics capabilities is an ongoing effort.");
97 }
Action::getParam
const T & getParam(const std::string &name) const
Action::Action
Action(const InputParameters &parameters)
ExplicitDynamicsContactAction::_model
const ExplicitDynamicsContactModel _model
Contact model type enum.
Definition: ExplicitDynamicsContactAction.h:53
ExplicitDynamicsContactAction::_blocks
const std::vector< SubdomainName > & _blocks
Restrict contact MooseObjects to these subdomains.
Definition: ExplicitDynamicsContactAction.h:62
ExplicitDynamicsContactAction::_boundary_pairs
std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
Primary/Secondary boundary name pairs for mechanical contact.
Definition: ExplicitDynamicsContactAction.h:50
ExplicitDynamicsContactAction::_verbose
const bool _verbose
Verbose output, may increase runtime.
Definition: ExplicitDynamicsContactAction.h:59
Action::mooseWarning
void mooseWarning(Args &&... args) const

Member Function Documentation

◆ act()

void ExplicitDynamicsContactAction::act ( )
overridevirtual

Implements Action.

Definition at line 100 of file ExplicitDynamicsContactAction.C.

101 {
102  // proform problem checks/corrections once during the first feasible task
103  if (_current_task == "add_contact_aux_variable")
104  {
105  if (!_problem->getDisplacedProblem())
106  mooseError(
107  "Contact requires updated coordinates. Use the 'displacements = ...' parameter in the "
108  "Mesh block.");
109 
110  // It is risky to apply this optimization to contact problems
111  // since the problem configuration may be changed during Jacobian
112  // evaluation. We therefore turn it off for all contact problems so that
113  // PETSc-3.8.4 or higher will have the same behavior as PETSc-3.8.3.
114  if (!_problem->isSNESMFReuseBaseSetbyUser())
115  _problem->setSNESMFReuseBase(false, false);
116  }
117 
118  addNodeFaceContact();
119 
120  if (_current_task == "add_aux_kernel" && _verbose)
121  { // Add ContactPenetrationAuxAction.
122  if (!_problem->getDisplacedProblem())
123  mooseError("Contact requires updated coordinates. Use the 'displacements = ...' line in the "
124  "Mesh block.");
125  unsigned int pair_number(0);
126  // Create auxiliary kernels for each contact pairs
127  for (const auto & contact_pair : _boundary_pairs)
128  {
129  {
130  InputParameters params = _factory.getValidParams("PenetrationAux");
131  params.applyParameters(parameters(),
132  {"secondary_gap_offset", "mapped_primary_gap_offset", "order"});
133 
134  std::vector<VariableName> displacements =
135  getParam<std::vector<VariableName>>("displacements");
136  const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
137  .system()
138  .variable_type(displacements[0])
139  .order.get_order();
140 
141  params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
142  params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_LINEAR};
143  params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
144  params.set<BoundaryName>("paired_boundary") = contact_pair.first;
145  params.set<AuxVariableName>("variable") = "penetration";
146  if (isParamValid("secondary_gap_offset"))
147  params.set<std::vector<VariableName>>("secondary_gap_offset") = {
148  getParam<VariableName>("secondary_gap_offset")};
149  if (isParamValid("mapped_primary_gap_offset"))
150  params.set<std::vector<VariableName>>("mapped_primary_gap_offset") = {
151  getParam<VariableName>("mapped_primary_gap_offset")};
152  params.set<bool>("use_displaced_mesh") = true;
153  std::string name = _name + "_contact_" + Moose::stringify(pair_number);
154  pair_number++;
155  _problem->addAuxKernel("PenetrationAux", name, params);
156  }
157  }
158 
159  addContactPressureAuxKernel();
160  }
161 
162  if (_current_task == "add_contact_aux_variable")
163  {
164  std::vector<VariableName> displacements = getParam<std::vector<VariableName>>("displacements");
165  const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
166  .system()
167  .variable_type(displacements[0])
168  .order.get_order();
169 
170  // Add gap rate for output
171  {
172  auto var_params = _factory.getValidParams("MooseVariable");
173  var_params.applyParameters(parameters());
174  var_params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
175  var_params.set<MooseEnum>("family") = "LAGRANGE";
176  _problem->addAuxVariable("MooseVariable", "gap_rate", var_params);
177  }
178  if (_verbose)
179  {
180  // Add ContactPenetrationVarAction
181  {
182  auto var_params = _factory.getValidParams("MooseVariable");
183  var_params.applyParameters(parameters());
184  var_params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
185  var_params.set<MooseEnum>("family") = "LAGRANGE";
186  _problem->addAuxVariable("MooseVariable", "penetration", var_params);
187  }
188  {
189  auto var_params = _factory.getValidParams("MooseVariable");
190  var_params.applyParameters(parameters());
191  var_params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
192  var_params.set<MooseEnum>("family") = "LAGRANGE";
193  _problem->addAuxVariable("MooseVariable", "contact_pressure", var_params);
194  }
195  // Add nodal area contact variable
196  {
197  auto var_params = _factory.getValidParams("MooseVariable");
198  var_params.applyParameters(parameters());
199  var_params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
200  var_params.set<MooseEnum>("family") = "LAGRANGE";
201  _problem->addAuxVariable("MooseVariable", "nodal_area", var_params);
202  }
203  // Add nodal density variable
204  {
205  auto var_params = _factory.getValidParams("MooseVariable");
206  var_params.applyParameters(parameters());
207  var_params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
208  var_params.set<MooseEnum>("family") = "LAGRANGE";
209  _problem->addAuxVariable("MooseVariable", "nodal_density", var_params);
210  }
211  // Add nodal wave speed
212  {
213  auto var_params = _factory.getValidParams("MooseVariable");
214  var_params.applyParameters(parameters());
215  var_params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
216  var_params.set<MooseEnum>("family") = "LAGRANGE";
217  _problem->addAuxVariable("MooseVariable", "nodal_wave_speed", var_params);
218  }
219  }
220  }
221 
222  if (_current_task == "add_user_object" && _verbose)
223  {
224  {
225  auto var_params = _factory.getValidParams("NodalArea");
226 
227  // Get secondary_boundary_vector from possibly updated set from the
228  // ContactAction constructor cleanup
229  const auto actions = _awh.getActions<ExplicitDynamicsContactAction>();
230 
231  std::vector<BoundaryName> secondary_boundary_vector;
232  for (const auto * const action : actions)
233  for (const auto j : index_range(action->_boundary_pairs))
234  secondary_boundary_vector.push_back(action->_boundary_pairs[j].second);
235 
236  var_params.set<std::vector<BoundaryName>>("boundary") = secondary_boundary_vector;
237  var_params.set<std::vector<VariableName>>("variable") = {"nodal_area"};
238 
239  mooseAssert(_problem, "Problem pointer is NULL");
240  var_params.set<ExecFlagEnum>("execute_on", true) = {EXEC_INITIAL, EXEC_TIMESTEP_BEGIN};
241  var_params.set<bool>("use_displaced_mesh") = true;
242 
243  _problem->addUserObject(
244  "NodalArea", "nodal_area_object_" + Moose::stringify(name()), var_params);
245  }
246  // Add nodal density and nodal wave speed user
247  {
248  // Add nodal density
249  auto var_params = _factory.getValidParams("NodalDensity");
250 
251  // Get secondary_boundary_vector from possibly updated set from the
252  // ContactAction constructor cleanup
253  const auto actions = _awh.getActions<ExplicitDynamicsContactAction>();
254 
255  std::vector<BoundaryName> secondary_boundary_vector;
256  for (const auto * const action : actions)
257  for (const auto j : index_range(action->_boundary_pairs))
258  secondary_boundary_vector.push_back(action->_boundary_pairs[j].second);
259 
260  var_params.set<std::vector<BoundaryName>>("boundary") = secondary_boundary_vector;
261  var_params.set<std::vector<VariableName>>("variable") = {"nodal_density"};
262 
263  mooseAssert(_problem, "Problem pointer is NULL");
264  var_params.set<ExecFlagEnum>("execute_on", true) = {EXEC_INITIAL, EXEC_TIMESTEP_BEGIN};
265  var_params.set<bool>("use_displaced_mesh") = true;
266 
267  _problem->addUserObject(
268  "NodalDensity", "nodal_density_object_" + Moose::stringify(name()), var_params);
269  }
270  {
271  // Add wave speed
272  auto var_params = _factory.getValidParams("NodalWaveSpeed");
273 
274  // Get secondary_boundary_vector from possibly updated set from the
275  // ContactAction constructor cleanup
276  const auto actions = _awh.getActions<ExplicitDynamicsContactAction>();
277 
278  std::vector<BoundaryName> secondary_boundary_vector;
279  for (const auto * const action : actions)
280  for (const auto j : index_range(action->_boundary_pairs))
281  secondary_boundary_vector.push_back(action->_boundary_pairs[j].second);
282 
283  var_params.set<std::vector<BoundaryName>>("boundary") = secondary_boundary_vector;
284  var_params.set<std::vector<VariableName>>("variable") = {"nodal_wave_speed"};
285 
286  mooseAssert(_problem, "Problem pointer is NULL");
287  var_params.set<ExecFlagEnum>("execute_on", true) = {EXEC_INITIAL, EXEC_TIMESTEP_BEGIN};
288  var_params.set<bool>("use_displaced_mesh") = true;
289 
290  _problem->addUserObject(
291  "NodalWaveSpeed", "nodal_wavespeed_object_" + Moose::stringify(name()), var_params);
292  }
293  }
294 }
ExplicitDynamicsContactAction::addContactPressureAuxKernel
void addContactPressureAuxKernel()
Add single contact pressure auxiliary kernel for various contact action objects.
Definition: ExplicitDynamicsContactAction.C:297
Action::_name
const std::string & _name
Action::_awh
ActionWarehouse & _awh
Action::_factory
Factory & _factory
Action::parameters
const InputParameters & parameters() const
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
ExplicitDynamicsContactAction::addNodeFaceContact
void addNodeFaceContact()
Generate constraints for node to face contact.
Definition: ExplicitDynamicsContactAction.C:342
Action::name
const std::string & name() const
EXEC_TIMESTEP_BEGIN
const ExecFlagType EXEC_TIMESTEP_BEGIN
Action::_current_task
const std::string & _current_task
ExplicitDynamicsContactAction::_boundary_pairs
std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
Primary/Secondary boundary name pairs for mechanical contact.
Definition: ExplicitDynamicsContactAction.h:50
EXEC_LINEAR
const ExecFlagType EXEC_LINEAR
Moose::stringify
std::string stringify(const T &t)
ExplicitDynamicsContactAction
Action class for creating constraints, kernels, and user objects necessary for mechanical contact...
Definition: ExplicitDynamicsContactAction.h:26
ExplicitDynamicsContactAction::_verbose
const bool _verbose
Verbose output, may increase runtime.
Definition: ExplicitDynamicsContactAction.h:59
Action::mooseError
void mooseError(Args &&... args) const
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
EM::j
static const std::complex< double > j(0, 1)
Complex number "j" (also known as "i")
Action::isParamValid
bool isParamValid(const std::string &name) const
ActionWarehouse::getActions
std::vector< const T *> getActions()
index_range
auto index_range(const T &sizable)
EXEC_INITIAL
const ExecFlagType EXEC_INITIAL

◆ addContactPressureAuxKernel()

void ExplicitDynamicsContactAction::addContactPressureAuxKernel ( )
private

Add single contact pressure auxiliary kernel for various contact action objects.

Definition at line 297 of file ExplicitDynamicsContactAction.C.

Referenced by act().

298 {
299  // Add ContactPressureAux: Only one object for all contact pairs
300  const auto actions = _awh.getActions<ExplicitDynamicsContactAction>();
301 
302  // Increment counter for contact action objects
303  ed_contact_action_counter++;
304 
305  // Add auxiliary kernel if we are the last contact action object.
306  if (ed_contact_action_counter == actions.size() && _verbose)
307  {
308  std::vector<BoundaryName> boundary_vector;
309  std::vector<BoundaryName> pair_boundary_vector;
310 
311  for (const auto * const action : actions)
312  for (const auto j : index_range(action->_boundary_pairs))
313  {
314  boundary_vector.push_back(action->_boundary_pairs[j].second);
315  pair_boundary_vector.push_back(action->_boundary_pairs[j].first);
316  }
317 
318  InputParameters params = _factory.getValidParams("ContactPressureAux");
319  params.applyParameters(parameters(), {"order"});
320 
321  std::vector<VariableName> displacements = getParam<std::vector<VariableName>>("displacements");
322  const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
323  .system()
324  .variable_type(displacements[0])
325  .order.get_order();
326 
327  params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
328  params.set<std::vector<BoundaryName>>("boundary") = boundary_vector;
329  params.set<std::vector<BoundaryName>>("paired_boundary") = pair_boundary_vector;
330  params.set<AuxVariableName>("variable") = "contact_pressure";
331  params.addRequiredCoupledVar("nodal_area", "The nodal area");
332  params.set<std::vector<VariableName>>("nodal_area") = {"nodal_area"};
333  params.set<bool>("use_displaced_mesh") = true;
334 
335  std::string name = _name + "_contact_pressure";
336  params.set<ExecFlagEnum>("execute_on", true) = {EXEC_TIMESTEP_END};
337  _problem->addAuxKernel("ContactPressureAux", name, params);
338  }
339 }
Action::_name
const std::string & _name
Action::_awh
ActionWarehouse & _awh
Action::_factory
Factory & _factory
Action::parameters
const InputParameters & parameters() const
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
EXEC_TIMESTEP_END
const ExecFlagType EXEC_TIMESTEP_END
ed_contact_action_counter
static unsigned int ed_contact_action_counter
Definition: ExplicitDynamicsContactAction.C:31
Action::name
const std::string & name() const
InputParameters::addRequiredCoupledVar
void addRequiredCoupledVar(const std::string &name, const std::string &doc_string)
ExplicitDynamicsContactAction
Action class for creating constraints, kernels, and user objects necessary for mechanical contact...
Definition: ExplicitDynamicsContactAction.h:26
ExplicitDynamicsContactAction::_verbose
const bool _verbose
Verbose output, may increase runtime.
Definition: ExplicitDynamicsContactAction.h:59
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
EM::j
static const std::complex< double > j(0, 1)
Complex number "j" (also known as "i")
ActionWarehouse::getActions
std::vector< const T *> getActions()
index_range
auto index_range(const T &sizable)

◆ addNodeFaceContact()

void ExplicitDynamicsContactAction::addNodeFaceContact ( )
private

Generate constraints for node to face contact.

Definition at line 342 of file ExplicitDynamicsContactAction.C.

Referenced by act().

343 {
344  if (_current_task != "add_constraint")
345  return;
346 
347  std::string action_name = MooseUtils::shortName(name());
348  std::vector<VariableName> displacements = getParam<std::vector<VariableName>>("displacements");
349  const unsigned int ndisp = displacements.size();
350 
351  std::string constraint_type;
352 
353  constraint_type = "ExplicitDynamicsContactConstraint";
354 
355  InputParameters params = _factory.getValidParams(constraint_type);
356 
357  params.applyParameters(parameters(),
358  {"displacements",
359  "secondary_gap_offset",
360  "mapped_primary_gap_offset",
361  "primary",
362  "secondary"});
363 
364  const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
365  .system()
366  .variable_type(displacements[0])
367  .order.get_order();
368 
369  params.set<std::vector<VariableName>>("displacements") = displacements;
370  params.set<bool>("use_displaced_mesh") = true;
371  params.set<Real>("penalty") = getParam<Real>("penalty");
372 
373  params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
374 
375  for (const auto & contact_pair : _boundary_pairs)
376  {
377 
378  if (isParamValid("vel_x"))
379  params.set<std::vector<VariableName>>("vel_x") = getParam<std::vector<VariableName>>("vel_x");
380  if (isParamValid("vel_y"))
381  params.set<std::vector<VariableName>>("vel_y") = getParam<std::vector<VariableName>>("vel_y");
382  if (isParamValid("vel_z"))
383  params.set<std::vector<VariableName>>("vel_z") = getParam<std::vector<VariableName>>("vel_z");
384 
385  params.set<std::vector<VariableName>>("gap_rate") = {"gap_rate"};
386 
387  params.set<BoundaryName>("boundary") = contact_pair.first;
388  if (isParamValid("secondary_gap_offset"))
389  params.set<std::vector<VariableName>>("secondary_gap_offset") = {
390  getParam<VariableName>("secondary_gap_offset")};
391  if (isParamValid("mapped_primary_gap_offset"))
392  params.set<std::vector<VariableName>>("mapped_primary_gap_offset") = {
393  getParam<VariableName>("mapped_primary_gap_offset")};
394 
395  for (unsigned int i = 0; i < ndisp; ++i)
396  {
397  std::string name = action_name + "_constraint_" + Moose::stringify(contact_pair, "_") + "_" +
398  Moose::stringify(i);
399 
400  params.set<unsigned int>("component") = i;
401 
402  params.set<BoundaryName>("primary") = contact_pair.first;
403  params.set<BoundaryName>("secondary") = contact_pair.second;
404  params.set<NonlinearVariableName>("variable") = displacements[i];
405  params.set<std::vector<VariableName>>("primary_variable") = {displacements[i]};
406  params.applySpecificParameters(parameters(),
407  {"extra_vector_tags", "absolute_value_vector_tags"});
408  _problem->addConstraint(constraint_type, name, params);
409  }
410  }
411 }
InputParameters::applySpecificParameters
void applySpecificParameters(const InputParameters &common, const std::vector< std::string > &include, bool allow_private=false)
Action::_factory
Factory & _factory
Action::parameters
const InputParameters & parameters() const
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
if
if(subdm)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
MooseUtils::shortName
std::string shortName(const std::string &name)
Action::name
const std::string & name() const
Action::_current_task
const std::string & _current_task
ExplicitDynamicsContactAction::_boundary_pairs
std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
Primary/Secondary boundary name pairs for mechanical contact.
Definition: ExplicitDynamicsContactAction.h:50
Moose::stringify
std::string stringify(const T &t)
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::isParamValid
bool isParamValid(const std::string &name) const

◆ commonParameters()

InputParameters ExplicitDynamicsContactAction::commonParameters ( )
static

Define parameters used by multiple contact objects.

Returns
InputParameters object populated with common parameters

Definition at line 420 of file ExplicitDynamicsContactAction.C.

Referenced by ExplicitDynamicsContactConstraint::validParams(), and validParams().

421 {
422  InputParameters params = emptyInputParameters();
423 
424  params.addParam<MooseEnum>(
425  "model", ExplicitDynamicsContactAction::getModelEnum(), "The contact model to use");
426 
427  // Gap rate input
428  params.addCoupledVar("vel_x", "x-component of velocity.");
429  params.addCoupledVar("vel_y", "y-component of velocity.");
430  params.addCoupledVar("vel_z", "z-component of velocity.");
431  // Gap rate output
432  params.addCoupledVar("gap_rate", "Gap rate for output.");
433 
434  return params;
435 }
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
emptyInputParameters
InputParameters emptyInputParameters()
InputParameters::addCoupledVar
void addCoupledVar(const std::string &name, const std::string &doc_string)
ExplicitDynamicsContactAction::getModelEnum
static MooseEnum getModelEnum()
Get contact model.
Definition: ExplicitDynamicsContactAction.C:414

◆ getModelEnum()

MooseEnum ExplicitDynamicsContactAction::getModelEnum ( )
static

Get contact model.

Returns
enum

Definition at line 414 of file ExplicitDynamicsContactAction.C.

Referenced by commonParameters(), and validParams().

415 {
416  return MooseEnum("frictionless frictionless_balance", "frictionless");
417 }

◆ validParams()

InputParameters ExplicitDynamicsContactAction::validParams ( )
static

Definition at line 41 of file ExplicitDynamicsContactAction.C.

42 {
43  InputParameters params = Action::validParams();
44  params += ExplicitDynamicsContactAction::commonParameters();
45 
46  params.addParam<std::vector<BoundaryName>>(
47  "primary", "The list of boundary IDs referring to primary sidesets");
48  params.addParam<std::vector<BoundaryName>>(
49  "secondary", "The list of boundary IDs referring to secondary sidesets");
50  params.addParam<std::vector<SubdomainName>>(
51  "block",
52  {},
53  "Optional list of subdomain names on which to create the contact MooseObjects. If omitted, "
54  "MooseObjects will be created on all subdomains");
55  params.addParam<std::vector<VariableName>>(
56  "displacements",
57  "The displacements appropriate for the simulation geometry and coordinate system");
58  params.addParam<Real>("friction_coefficient", 0, "The friction coefficient");
59  params.addParam<MooseEnum>(
60  "model", ExplicitDynamicsContactAction::getModelEnum(), "The contact model to use");
61  params.addParam<Real>("tangential_tolerance",
62  "Tangential distance to extend edges of contact surfaces");
63  params.addParam<Real>("penalty", 1e8, "Penalty factor for normal contact.");
64  params.addClassDescription("Sets up all objects needed for mechanical contact enforcement in "
65  "explicit dynamics simulations.");
66  params.addParam<std::vector<TagName>>(
67  "extra_vector_tags",
68  "The tag names for extra vectors that residual data should be saved into");
69  params.addParam<std::vector<TagName>>(
70  "absolute_value_vector_tags",
71  "The tags for the vectors this residual object should fill with the "
72  "absolute value of the residual contribution");
73 
74  params.addParam<VariableName>("secondary_gap_offset",
75  "Offset to gap distance from secondary side");
76  params.addParam<VariableName>("mapped_primary_gap_offset",
77  "Offset to gap distance mapped from primary side");
78  params.addParam<bool>("verbose", false, "Verbose output. May increase runtime.");
79 
80  return params;
81 }
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
ExplicitDynamicsContactAction::commonParameters
static InputParameters commonParameters()
Define parameters used by multiple contact objects.
Definition: ExplicitDynamicsContactAction.C:420
Action::validParams
static InputParameters validParams()
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
InputParameters::addClassDescription
void addClassDescription(const std::string &doc_string)
ExplicitDynamicsContactAction::getModelEnum
static MooseEnum getModelEnum()
Get contact model.
Definition: ExplicitDynamicsContactAction.C:414

Member Data Documentation

◆ _blocks

const std::vector<SubdomainName>& ExplicitDynamicsContactAction::_blocks
protected

Restrict contact MooseObjects to these subdomains.

Definition at line 62 of file ExplicitDynamicsContactAction.h.

◆ _boundary_pairs

std::vector<std::pair<BoundaryName, BoundaryName> > ExplicitDynamicsContactAction::_boundary_pairs
protected

Primary/Secondary boundary name pairs for mechanical contact.

Definition at line 50 of file ExplicitDynamicsContactAction.h.

Referenced by act(), and addNodeFaceContact().

◆ _model

const ExplicitDynamicsContactModel ExplicitDynamicsContactAction::_model
protected

Contact model type enum.

Definition at line 53 of file ExplicitDynamicsContactAction.h.

◆ _verbose

const bool ExplicitDynamicsContactAction::_verbose
protected

Verbose output, may increase runtime.

Definition at line 59 of file ExplicitDynamicsContactAction.h.

Referenced by act(), and addContactPressureAuxKernel().

The documentation for this class was generated from the following files:
Generated on Sun Jun 21 2026 21:44:22 for https://mooseframework.inl.gov by   doxygen 1.8.14