https://mooseframework.inl.gov
Loading...
Searching...
No Matches
ContactAction.C
Go to the documentation of this file.
1//* This file is part of the MOOSE framework
2//* https://mooseframework.inl.gov
3//*
4//* All rights reserved, see COPYRIGHT for full restrictions
5//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6//*
7//* Licensed under LGPL 2.1, please see LICENSE for details
8//* https://www.gnu.org/licenses/lgpl-2.1.html
9
10#include "ContactAction.h"
11
12#include "Factory.h"
13#include "FEProblem.h"
14#include "Conversion.h"
15#include "AddVariableAction.h"
16#include "MortarConstraintBase.h"
17#include "MortarConsumerInterface.h"
18#include "NonlinearSystemBase.h"
19#include "Parser.h"
20#include "AugmentedLagrangianContactProblem.h"
21#include "AutomaticContactPairingGenerator.h"
22
23#include <set>
24#include <algorithm>
25#include <unordered_map>
26#include <limits>
27
28#include "libmesh/petsc_nonlinear_solver.h"
29#include "libmesh/string_to_enum.h"
30
31// Counter for naming mortar auxiliary kernels
32static unsigned int contact_mortar_auxkernel_counter = 0;
33
34// Counter for naming auxiliary kernels
35static unsigned int contact_auxkernel_counter = 0;
36
37// Counter for naming nodal area user objects
38static unsigned int contact_userobject_counter = 0;
39
40// Counter for distinct contact action objects
41static unsigned int contact_action_counter = 0;
42
43// For mortar subdomains
44registerMooseAction("ContactApp", ContactAction, "append_mesh_generator");
45registerMooseAction("ContactApp", ContactAction, "add_aux_variable");
46// For mortar Lagrange multiplier
47registerMooseAction("ContactApp", ContactAction, "add_contact_aux_variable");
48registerMooseAction("ContactApp", ContactAction, "add_mortar_variable");
49registerMooseAction("ContactApp", ContactAction, "add_aux_kernel");
50// For mortar constraint
51registerMooseAction("ContactApp", ContactAction, "add_constraint");
52registerMooseAction("ContactApp", ContactAction, "output_penetration_info_vars");
53registerMooseAction("ContactApp", ContactAction, "add_user_object");
54// For automatic generation of contact pairs
55registerMooseAction("ContactApp", ContactAction, "post_mesh_prepared");
56
57InputParameters
58ContactAction::validParams()
59{
60 InputParameters params = Action::validParams();
61 params += ContactAction::commonParameters();
62
63 params.addParam<std::vector<BoundaryName>>(
64 "primary", "The list of boundary IDs referring to primary sidesets");
65 params.addParam<std::vector<BoundaryName>>(
66 "secondary", "The list of boundary IDs referring to secondary sidesets");
67 params.addParam<std::vector<BoundaryName>>(
68 "automatic_pairing_boundaries",
69 {},
70 "List of boundary IDs for sidesets that are automatically paired with any other boundary in "
71 "this list having a centroid-to-centroid distance less than the value specified in the "
72 "'automatic_pairing_distance' parameter. ");
73 params.addRangeCheckedParam<Real>(
74 "automatic_pairing_distance",
75 "automatic_pairing_distance>=0",
76 "The maximum distance the centroids of the boundaries provided in the "
77 "'automatic_pairing_boundaries' parameter can be to generate a contact pair automatically. "
78 "Due to numerical error in the determination of the centroids, it is encouraged that "
79 "the user adds a tolerance to this distance (e.g. extra 10%) to make sure no suitable "
80 "contact pair is missed. If the 'automatic_pairing_method = NODE' option is chosen instead, "
81 "this distance is recommended to be set to at least twice the minimum distance between "
82 "nodes of boundaries to be paired.");
83 params.addDeprecatedParam<MeshGeneratorName>(
84 "mesh",
85 "The mesh generator for mortar method",
86 "This parameter is not used anymore and can simply be removed");
87 params.addParam<VariableName>("secondary_gap_offset",
88 "Offset to gap distance from secondary side");
89 params.addParam<VariableName>("mapped_primary_gap_offset",
90 "Offset to gap distance mapped from primary side");
91 params.addParam<std::vector<VariableName>>(
92 "displacements",
93 {},
94 "The displacements appropriate for the simulation geometry and coordinate system");
95 params.addParam<Real>(
96 "penalty",
97 1e8,
98 "The penalty to apply. This can vary depending on the stiffness of your materials");
99 params.addParam<Real>(
100 "penalty_friction",
101 1e8,
102 "The penalty factor to apply in mortar penalty frictional constraints. It is applied to the "
103 "tangential accumulated slip to build the frictional force");
104 params.addRangeCheckedParam<Real>(
105 "penalty_multiplier",
106 1.0,
107 "penalty_multiplier > 0",
108 "The growth factor for the penalty applied at the end of each augmented "
109 "Lagrange update iteration (a value larger than one, e.g., 10, tends to speed up "
110 "convergence.)");
111 params.addRangeCheckedParam<Real>(
112 "penalty_multiplier_friction",
113 1.0,
114 "penalty_multiplier_friction > 0",
115 "The penalty growth factor between augmented Lagrange "
116 "iterations for penalizing relative slip distance if the node is under stick conditions.(a "
117 "value larger than one, e.g., 10, tends to speed up convergence.)");
118 params.addParam<Real>("friction_coefficient", 0, "The friction coefficient");
119 params.addParam<Real>("tension_release",
120 0.0,
121 "Tension release threshold. A node in contact "
122 "will not be released if its tensile load is below "
123 "this value. No tension release if negative.");
124 params.addParam<MooseEnum>("model", ContactAction::getModelEnum(), "The contact model to use");
125 params.addParam<Real>("tangential_tolerance",
126 "Tangential distance to extend edges of contact surfaces");
127 params.addParam<Real>("capture_tolerance",
128 0.0,
129 "Normal distance from surface within which nodes are captured. This "
130 "parameter is used for node-face and mortar formulations.");
131 params.addParam<Real>(
132 "normal_smoothing_distance",
133 "Distance from edge in parametric coordinates over which to smooth contact normal");
134
135 params.addParam<bool>("normalize_penalty",
136 false,
137 "Whether to normalize the penalty parameter with the nodal area.");
138 params.addParam<bool>(
139 "primary_secondary_jacobian",
140 true,
141 "Whether to include Jacobian entries coupling primary and secondary nodes.");
142 params.addParam<bool>(
143 "ghost_whole_interface",
144 false,
145 "Whether to geometrically and algebraically ghost the entire primary side of the interface "
146 "for node-face contact constraints.");
147 params.addParam<Real>("al_penetration_tolerance",
148 "The tolerance of the penetration for augmented Lagrangian method.");
149 params.addParam<Real>("al_incremental_slip_tolerance",
150 "The tolerance of the incremental slip for augmented Lagrangian method.");
151 params.addRangeCheckedParam<Real>(
152 "max_penalty_multiplier",
153 1.0e3,
154 "max_penalty_multiplier >= 1.0",
155 "Maximum multiplier applied to penalty factors when adaptivity is used in an augmented "
156 "Lagrange setting. The penalty factor supplied by the user is used as a reference to "
157 "determine its maximum. If this multiplier is too large, the condition number of the system "
158 "to be solved may be negatively impacted.");
159 MooseEnum adaptivity_penalty_normal("SIMPLE BUSSETTA", "SIMPLE");
160 adaptivity_penalty_normal.addDocumentation(
161 "SIMPLE", "Keep multiplying by the penalty multiplier between AL iterations");
162 adaptivity_penalty_normal.addDocumentation(
163 "BUSSETTA",
164 "Modify the penalty using an algorithm from Bussetta et al, 2012, Comput Mech 49:259-275 "
165 "between AL iterations.");
166 params.addParam<MooseEnum>(
167 "adaptivity_penalty_normal",
168 adaptivity_penalty_normal,
169 "The augmented Lagrange update strategy used on the normal penalty coefficient.");
170 MooseEnum adaptivity_penalty_friction("SIMPLE FRICTION_LIMIT", "FRICTION_LIMIT");
171 adaptivity_penalty_friction.addDocumentation(
172 "SIMPLE", "Keep multiplying by the frictional penalty multiplier between AL iterations");
173 adaptivity_penalty_friction.addDocumentation(
174 "FRICTION_LIMIT",
175 "This strategy will be guided by the Coulomb limit and be less reliant on the initial "
176 "penalty factor provided by the user.");
177 params.addParam<MooseEnum>(
178 "adaptivity_penalty_friction",
179 adaptivity_penalty_friction,
180 "The augmented Lagrange update strategy used on the frictional penalty coefficient.");
181 params.addParam<Real>("al_frictional_force_tolerance",
182 "The tolerance of the frictional force for augmented Lagrangian method.");
183 params.addParam<Real>(
184 "c_normal",
185 1e6,
186 "Parameter for balancing the size of the gap and contact pressure for a mortar formulation. "
187 "This purely numerical "
188 "parameter affects convergence behavior and, in general, should be larger for stiffer "
189 "materials. It is recommended that the user tries out various orders of magnitude for this "
190 "parameter if the default value generates poor contact convergence.");
191 params.addParam<Real>(
192 "c_tangential", 1, "Numerical parameter for nonlinear mortar frictional constraints");
193 MooseEnum friction_projection_degree("ONE TWO", "TWO");
194 friction_projection_degree.addDocumentation(
195 "ONE", "Use the degree-one Alart-Curnier friction residual.");
196 friction_projection_degree.addDocumentation(
197 "TWO", "Use the degree-two Hueber-Stadler-Wohlmuth friction residual.");
198 params.addParam<MooseEnum>("friction_projection_degree",
199 friction_projection_degree,
200 "Degree of the friction-residual projection; see "
201 "MortarContactUtils.h. Only valid for Coulomb friction mortar "
202 "contact.");
203 params.addParam<bool>("ping_pong_protection",
204 false,
205 "Whether to protect against ping-ponging, e.g. the oscillation of the "
206 "secondary node between two "
207 "different primary faces, by tying the secondary node to the "
208 "edge between the involved primary faces");
209 params.addParam<Real>(
210 "normal_lm_scaling",
211 1.,
212 "Scaling factor to apply to the normal LM variable for a mortar formulation");
213 params.addParam<Real>(
214 "tangential_lm_scaling",
215 1.,
216 "Scaling factor to apply to the tangential LM variable for a mortar formulation");
217 MooseEnum lm_space(getContactLMSpaceOptions(), "MATCH_DISPLACEMENT");
218 lm_space.addDocumentation(
219 "MATCH_DISPLACEMENT",
220 "Use the same finite element order as the displacement variables for generated mortar "
221 "Lagrange multiplier variables.");
222 lm_space.addDocumentation(
223 "LINEAR",
224 "Use first-order LAGRANGE generated mortar Lagrange multiplier variables, independent "
225 "of the displacement variable order.");
226 params.addParam<MooseEnum>(
227 "lm_space",
228 lm_space,
229 "Finite element space for mortar Lagrange multiplier variables generated by the "
230 "contact action. This parameter only applies to the 'mortar' contact formulation.");
231 params.addParam<bool>(
232 "normalize_c",
233 false,
234 "Whether to normalize c by weighting function norm for mortar contact. When unnormalized "
235 "the value of c effectively depends on element size since in the constraint we compare nodal "
236 "Lagrange Multiplier values to integrated gap values (LM nodal value is independent of "
237 "element size, where integrated values are dependent on element size).");
238 params.addClassDescription("Sets up all objects needed for mechanical contact enforcement");
239 params.addParam<bool>(
240 "use_dual",
241 "Whether to use the dual mortar approach within a mortar formulation. It is defaulted to "
242 "true for "
243 "weighted quantity approach, and to false for the legacy approach. To avoid instabilities "
244 "in the solution and obtain the full benefits of a variational enforcement,"
245 "use of dual mortar with weighted constraints is strongly recommended. This "
246 "input is only intended for advanced users.");
247 params.addParam<bool>(
248 "correct_edge_dropping",
249 false,
250 "Whether to enable correct edge dropping treatment for mortar constraints. When disabled "
251 "any Lagrange Multiplier degree of freedom on a secondary element without full primary "
252 "contributions will be set (strongly) to 0.");
253 params.addParam<bool>(
254 "use_nodal_scaling",
255 false,
256 "Whether to apply the node-based Lagrange-multiplier scaling of Popp et al. (2013) to "
257 "improve the conditioning of the linear system when secondary elements are only partially "
258 "covered (edge dropping). See the documentation for the current limitations.");
259 params += MortarConsumerInterface::triangulationParams();
260 params.addParam<bool>(
261 "generate_mortar_mesh",
262 true,
263 "Whether to generate the mortar mesh from the action. Typically this will be the case, but "
264 "one may also want to reuse an existing lower-dimensional mesh prior to a restart.");
265 params.addParam<MooseEnum>("automatic_pairing_method",
266 ContactAction::getProximityMethod(),
267 "The proximity method used for automatic pairing of boundaries.");
268 params.addParam<bool>(
269 "mortar_dynamics",
270 false,
271 "Whether to use constraints that account for the persistency condition, giving rise to "
272 "smoother normal contact pressure evolution. This flag should only be set to yes for dynamic "
273 "simulations using the Newmark-beta numerical integrator");
274 params.addParam<Real>(
275 "newmark_beta",
276 0.25,
277 "Newmark-beta beta parameter for its inclusion in the weighted gap update formula");
278 params.addParam<Real>(
279 "newmark_gamma",
280 0.5,
281 "Newmark-beta gamma parameter for its inclusion in the weighted gap update formula");
282 params.addCoupledVar("wear_depth",
283 "The name of the mortar auxiliary variable that is used to modify the "
284 "weighted gap definition");
285 params.addParam<std::vector<TagName>>(
286 "extra_vector_tags",
287 "The tag names for extra vectors that residual data should be saved into");
288 params.addParam<std::vector<TagName>>(
289 "absolute_value_vector_tags",
290 "The tags for the vectors this residual object should fill with the "
291 "absolute value of the residual contribution");
292 params.addParam<bool>(
293 "use_petrov_galerkin",
294 false,
295 "Whether to use the Petrov-Galerkin approach for the mortar-based constraints. If set to "
296 "true, we use the standard basis as the test function and dual basis as "
297 "the shape function for the interpolation of the Lagrange multiplier variable.");
298 params.addParam<bool>(
299 "debug_mesh",
300 false,
301 "Whether we are going to enable mortar segment mesh debug information. An exodus"
302 "file will be generated if the user sets this flag to true");
303 const auto mortar_constraint_params = MortarConstraintBase::validParams();
304 params.transferParam<MooseEnum>(mortar_constraint_params, "segment_quadrature");
305 params.transferParam<Real>(mortar_constraint_params, "minimum_projection_angle");
306 params.transferParam<MooseEnum>(mortar_constraint_params, "mortar_3d_subpatch_plane");
307 params.transferParam<MooseEnum>(mortar_constraint_params, "mortar_3d_qp_mapping");
308
309 // Contact surface definition
310 params.addParamNamesToGroup("primary secondary displacements", "Contact Surface Definition");
311 // Automatic pairing
312 params.addParamNamesToGroup(
313 "automatic_pairing_boundaries automatic_pairing_distance automatic_pairing_method",
314 "Automatic Contact Pair Generation");
315 // Contact formulation and model
316 params.addParamNamesToGroup("formulation model", "Contact Formulation");
317 // Penalty parameters
318 params.addParamNamesToGroup(
319 "penalty penalty_friction penalty_multiplier penalty_multiplier_friction "
320 "max_penalty_multiplier normalize_penalty",
321 "Penalty Parameters");
322 // Augmented Lagrange settings
323 params.addParamNamesToGroup(
324 "al_penetration_tolerance al_incremental_slip_tolerance al_frictional_force_tolerance "
325 "adaptivity_penalty_normal adaptivity_penalty_friction",
326 "Augmented Lagrange");
327 // Friction
328 params.addParamNamesToGroup("friction_coefficient tension_release friction_projection_degree",
329 "Friction");
330 // Mortar-specific parameters
331 params.addParamNamesToGroup("c_normal c_tangential normal_lm_scaling tangential_lm_scaling "
332 "lm_space "
333 "use_dual correct_edge_dropping normalize_c use_petrov_galerkin "
334 "use_nodal_scaling "
335 "generate_mortar_mesh segment_quadrature minimum_projection_angle "
336 "mortar_3d_subpatch_plane mortar_3d_qp_mapping wear_depth debug_mesh",
337 "Mortar");
338 // Mortar dynamics (Newmark-beta)
339 params.addParamNamesToGroup("mortar_dynamics newmark_beta newmark_gamma", "Mortar Dynamics");
340 // Gap and tolerance settings
341 params.addParamNamesToGroup(
342 "secondary_gap_offset mapped_primary_gap_offset capture_tolerance "
343 "tangential_tolerance normal_smoothing_distance normal_smoothing_method",
344 "Gap and Tolerance");
345 // Jacobian and solver options
346 params.addParamNamesToGroup("primary_secondary_jacobian ping_pong_protection", "Solver Options");
347 // Interface ghosting
348 params.addParamNamesToGroup("ghost_whole_interface", "Interface Ghosting");
349 // Residual vector tags
350 params.addParamNamesToGroup("extra_vector_tags absolute_value_vector_tags", "Residual Tags");
351
352 return params;
353}
354
355ContactAction::ContactAction(const InputParameters & params)
356 : Action(params),
357 _boundary_pairs(getParam<BoundaryName, BoundaryName>("primary", "secondary")),
358 _model(getParam<MooseEnum>("model").getEnum<ContactModel>()),
359 _formulation(getParam<MooseEnum>("formulation").getEnum<ContactFormulation>()),
360 _lm_space(getParam<MooseEnum>("lm_space").getEnum<ContactLMSpace>()),
361 _generate_mortar_mesh(getParam<bool>("generate_mortar_mesh")),
362 _mortar_dynamics(getParam<bool>("mortar_dynamics"))
363{
364 // Check for automatic selection of contact pairs.
365 if (getParam<std::vector<BoundaryName>>("automatic_pairing_boundaries").size() > 1)
366 _automatic_pairing_boundaries =
367 getParam<std::vector<BoundaryName>>("automatic_pairing_boundaries");
368
369 if (_automatic_pairing_boundaries.size() > 0 && !isParamValid("automatic_pairing_distance"))
370 paramError("automatic_pairing_distance",
371 "For automatic selection of contact pairs (for particular geometries) in contact "
372 "action, 'automatic_pairing_distance' needs to be provided.");
373
374 if (_automatic_pairing_boundaries.size() > 0 && !isParamValid("automatic_pairing_method"))
375 paramError("automatic_pairing_distance",
376 "For automatic selection of contact pairs (for particular geometries) in contact "
377 "action, 'automatic_pairing_method' needs to be provided.");
378
379 if (_automatic_pairing_boundaries.size() > 0 && _boundary_pairs.size() != 0)
380 paramError("automatic_pairing_boundaries",
381 "If a boundary list is provided, primary and secondary surfaces will be identified "
382 "automatically. Therefore, one cannot provide an automatic pairing boundary list "
383 "and primary/secondary lists.");
384 else if (_automatic_pairing_boundaries.size() == 0 && _boundary_pairs.size() == 0)
385 paramError("primary",
386 "'primary' and 'secondary' surfaces or a list of boundaries for automatic pair "
387 "generation need to be provided.");
388
389 // End of checks for automatic selection of contact pairs.
390
391 if ((_formulation == ContactFormulation::MORTAR ||
392 _formulation == ContactFormulation::MORTAR_PENALTY) &&
393 params.isParamSetByUser("ghost_whole_interface"))
394 paramError("ghost_whole_interface",
395 "The 'ghost_whole_interface' parameter is only supported for node-face contact "
396 "formulations. Mortar contact always geometrically and algebraically ghosts the "
397 "interface.");
398
399 if (_formulation == ContactFormulation::TANGENTIAL_PENALTY && _model != ContactModel::COULOMB)
400 paramError("formulation",
401 "The 'tangential_penalty' formulation can only be used with the 'coulomb' model");
402
403 if (_formulation == ContactFormulation::MORTAR_PENALTY)
404 {
405 // Use dual basis functions for contact traction interpolation
406 if (isParamValid("use_dual"))
407 _use_dual = getParam<bool>("use_dual");
408 else
409 _use_dual = true;
410
411 if (_model == ContactModel::GLUED)
412 paramError("model", "The 'mortar_penalty' formulation does not support glued contact");
413
414 if (getParam<bool>("mortar_dynamics"))
415 paramError("mortar_dynamics",
416 "The 'mortar_penalty' formulation does not support implicit dynamic simulations");
417
418 if (getParam<bool>("use_petrov_galerkin"))
419 paramError("use_petrov_galerkin",
420 "The 'mortar_penalty' formulation does not support usage of the Petrov-Galerkin "
421 "flag. The default (use_dual = true) behavior is such that contact tractions are "
422 "interpolated with dual bases whereas mortar or weighted contact quantities are "
423 "interpolated with Lagrange shape functions.");
424 }
425
426 if (_formulation == ContactFormulation::MORTAR)
427 {
428 if (_model == ContactModel::GLUED)
429 paramError("model", "The 'mortar' formulation does not support glued contact (yet)");
430
431 // use dual basis function for Lagrange multipliers?
432 if (isParamValid("use_dual"))
433 _use_dual = getParam<bool>("use_dual");
434 else
435 _use_dual = true;
436
437 if (!getParam<bool>("mortar_dynamics"))
438 {
439 if (params.isParamSetByUser("newmark_beta"))
440 paramError("newmark_beta", "newmark_beta can only be used with the mortar_dynamics option");
441
442 if (params.isParamSetByUser("newmark_gamma"))
443 paramError("newmark_gamma",
444 "newmark_gamma can only be used with the mortar_dynamics option");
445 }
446
447 if (isParamSetByUser("penalty"))
448 paramError("penalty",
449 "The 'penalty' parameter is not used for the 'mortar' formulation which instead "
450 "uses Lagrange multipliers");
451
452 if (isParamSetByUser("friction_projection_degree") && _model != ContactModel::COULOMB)
453 paramError("friction_projection_degree",
454 "'friction_projection_degree' is only valid for Coulomb friction mortar "
455 "contact.");
456 }
457 else
458 {
459 if (params.isParamSetByUser("correct_edge_dropping"))
460 paramError(
461 "correct_edge_dropping",
462 "The 'correct_edge_dropping' option can only be used with the 'mortar' formulation "
463 "(weighted)");
464 else if (params.isParamSetByUser("use_nodal_scaling"))
465 paramError("use_nodal_scaling",
466 "The 'use_nodal_scaling' option can only be used with the 'mortar' formulation "
467 "(weighted)");
468 else if (params.isParamSetByUser("triangulation") &&
469 _formulation != ContactFormulation::MORTAR_PENALTY)
470 paramError("triangulation",
471 "The 'triangulation' option can only be used with mortar-based formulations.");
472 else if (params.isParamSetByUser("triangulate_triangles") &&
473 _formulation != ContactFormulation::MORTAR_PENALTY)
474 paramError("triangulate_triangles",
475 "The 'triangulate_triangles' option can only be used with mortar-based "
476 "formulations.");
477 else if (params.isParamSetByUser("minimum_projection_angle") &&
478 _formulation != ContactFormulation::MORTAR_PENALTY)
479 paramError("minimum_projection_angle",
480 "The 'minimum_projection_angle' option can only be used with mortar-based "
481 "formulations.");
482 else if (params.isParamSetByUser("mortar_3d_subpatch_plane") &&
483 _formulation != ContactFormulation::MORTAR_PENALTY)
484 paramError("mortar_3d_subpatch_plane",
485 "The 'mortar_3d_subpatch_plane' option can only be used with mortar-based "
486 "formulations.");
487 else if (params.isParamSetByUser("mortar_3d_qp_mapping") &&
488 _formulation != ContactFormulation::MORTAR_PENALTY)
489 paramError("mortar_3d_qp_mapping",
490 "The 'mortar_3d_qp_mapping' option can only be used with mortar-based "
491 "formulations.");
492 else if (params.isParamSetByUser("use_dual") &&
493 _formulation != ContactFormulation::MORTAR_PENALTY)
494 paramError("use_dual",
495 "The 'use_dual' option can only be used with the 'mortar' formulation");
496 else if (params.isParamSetByUser("c_normal"))
497 paramError("c_normal",
498 "The 'c_normal' option can only be used with the 'mortar' formulation");
499 else if (params.isParamSetByUser("c_tangential"))
500 paramError("c_tangential",
501 "The 'c_tangential' option can only be used with the 'mortar' formulation");
502 else if (params.isParamSetByUser("mortar_dynamics"))
503 paramError("mortar_dynamics",
504 "The 'mortar_dynamics' constraint option can only be used with the 'mortar' "
505 "formulation and in dynamic simulations using Newmark-beta");
506 else if (params.isParamSetByUser("segment_quadrature"))
507 paramError("segment_quadrature",
508 "The 'segment_quadrature' option can only be used with the "
509 "'mortar' formulation.");
510 else if (params.isParamSetByUser("lm_space"))
511 paramError("lm_space",
512 "The 'lm_space' option can only be used with the 'mortar' formulation.");
513 }
514
515 if (_formulation == ContactFormulation::RANFS)
516 {
517 if (isParamValid("secondary_gap_offset"))
518 paramError("secondary_gap_offset",
519 "The 'secondary_gap_offset' option can only be used with the "
520 "'MechanicalContactConstraint'");
521 if (isParamValid("mapped_primary_gap_offset"))
522 paramError("mapped_primary_gap_offset",
523 "The 'mapped_primary_gap_offset' option can only be used with the "
524 "'MechanicalContactConstraint'");
525 }
526 else if (getParam<bool>("ping_pong_protection"))
527 paramError("ping_pong_protection",
528 "The 'ping_pong_protection' option can only be used with the 'ranfs' formulation");
529
530 // Remove repeated pairs from input file.
531 removeRepeatedPairs();
532}
533
534void
535ContactAction::removeRepeatedPairs()
536{
537 if (_boundary_pairs.size() == 0 && _automatic_pairing_boundaries.size() == 0)
538 paramError(
539 "primary",
540 "Number of contact pairs in the contact action is zero. Please revise your input file.");
541
542 // Remove repeated interactions
543 std::vector<std::pair<BoundaryName, BoundaryName>> lean_boundary_pairs;
544
545 for (const auto & [primary, secondary] : _boundary_pairs)
546 {
547 // Structured bindings are not capturable (primary_copy, secondary_copy)
548 auto it = std::find_if(lean_boundary_pairs.begin(),
549 lean_boundary_pairs.end(),
550 [&, primary_copy = primary, secondary_copy = secondary](
551 const std::pair<BoundaryName, BoundaryName> & lean_pair)
552 {
553 const bool match_one = lean_pair.second == secondary_copy &&
554 lean_pair.first == primary_copy;
555 const bool match_two = lean_pair.second == primary_copy &&
556 lean_pair.first == secondary_copy;
557 const bool exist = match_one || match_two;
558 return exist;
559 });
560
561 if (it == lean_boundary_pairs.end())
562 lean_boundary_pairs.emplace_back(primary, secondary);
563 else
564 mooseInfo("Contact pair ",
565 primary,
566 "--",
567 secondary,
568 " has been removed from the contact interaction list due to "
569 "duplicates in the input file.");
570 }
571
572 _boundary_pairs = lean_boundary_pairs;
573}
574
575void
576ContactAction::act()
577{
578 // proform problem checks/corrections once during the first feasible task
579 if (_current_task == "add_contact_aux_variable")
580 {
581 if (!_problem->getDisplacedProblem())
582 mooseError(
583 "Contact requires updated coordinates. Use the 'displacements = ...' parameter in the "
584 "Mesh block.");
585
586 // It is risky to apply this optimization to contact problems
587 // since the problem configuration may be changed during Jacobian
588 // evaluation. We therefore turn it off for all contact problems so that
589 // PETSc-3.8.4 or higher will have the same behavior as PETSc-3.8.3.
590 if (!_problem->isSNESMFReuseBaseSetbyUser())
591 _problem->setSNESMFReuseBase(false, false);
592 }
593
594 if (_automatic_pairing_boundaries.size() > 0)
595 {
596 if (_current_task == "append_mesh_generator")
597 appendAutomaticPairingGenerator();
598 else if (_current_task == "post_mesh_prepared")
599 getAutomaticContactPairs();
600 }
601
602 if (_formulation == ContactFormulation::MORTAR ||
603 _formulation == ContactFormulation::MORTAR_PENALTY)
604 addMortarContact();
605 else
606 addNodeFaceContact();
607
608 if (_current_task == "add_aux_kernel")
609 {
610 if (!_problem->getDisplacedProblem())
611 mooseError("Contact requires updated coordinates. Use the 'displacements = ...' line in the "
612 "Mesh block.");
613
614 // Create auxiliary kernels for each contact pairs
615 for (const auto & contact_pair : _boundary_pairs)
616 {
617 const auto & [primary_name, secondary_name] = contact_pair;
618 if ((_formulation != ContactFormulation::MORTAR) &&
619 (_formulation != ContactFormulation::MORTAR_PENALTY))
620 {
621 InputParameters params = _factory.getValidParams("PenetrationAux");
622 params.applyParameters(parameters(),
623 {"secondary_gap_offset", "mapped_primary_gap_offset", "order"});
624
625 std::vector<VariableName> displacements =
626 getParam<std::vector<VariableName>>("displacements");
627 const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
628 .system()
629 .variable_type(displacements[0])
630 .order.get_order();
631
632 params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
633 params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_LINEAR};
634 params.set<std::vector<BoundaryName>>("boundary") = {secondary_name};
635 params.set<BoundaryName>("paired_boundary") = primary_name;
636 params.set<AuxVariableName>("variable") = "penetration";
637 if (isParamValid("secondary_gap_offset"))
638 params.set<std::vector<VariableName>>("secondary_gap_offset") = {
639 getParam<VariableName>("secondary_gap_offset")};
640 if (isParamValid("mapped_primary_gap_offset"))
641 params.set<std::vector<VariableName>>("mapped_primary_gap_offset") = {
642 getParam<VariableName>("mapped_primary_gap_offset")};
643 params.set<bool>("use_displaced_mesh") = true;
644 std::string name = _name + "_contact_" + Moose::stringify(contact_auxkernel_counter++);
645
646 _problem->addAuxKernel("PenetrationAux", name, params);
647 }
648 else
649 {
650 const auto type = "MortarUserObjectAux";
651 InputParameters params = _factory.getValidParams(type);
652 params.set<std::vector<BoundaryName>>("boundary") = {secondary_name};
653 params.set<AuxVariableName>("variable") = "gap";
654 params.set<bool>("use_displaced_mesh") = true; // Unnecessary as this object only operates
655 // on nodes, but we'll do it for consistency
656 params.set<MooseEnum>("contact_quantity") = "normal_gap";
657 const auto & [primary_id, secondary_id, uo_name] =
658 libmesh_map_find(_bnd_pair_to_mortar_info, contact_pair);
659 params.set<UserObjectName>("user_object") = uo_name;
660 std::string name = _name + "_contact_gap_" + std::to_string(primary_id) + "_" +
661 std::to_string(secondary_id);
662
663 _problem->addAuxKernel(type, name, params);
664 }
665 }
666
667 addContactPressureAuxKernel();
668
669 const unsigned int ndisp = getParam<std::vector<VariableName>>("displacements").size();
670
671 // Add MortarFrictionalPressureVectorAux
672 if (_formulation == ContactFormulation::MORTAR && _model == ContactModel::COULOMB && ndisp > 2)
673 {
674 std::string action_name = MooseUtils::shortName(name());
675 for (const auto & [primary_boundary, secondary_boundary] : _boundary_pairs)
676 {
677 const std::string suffix = pairSuffix({primary_boundary, secondary_boundary});
678 InputParameters params = _factory.getValidParams("MortarFrictionalPressureVectorAux");
679
680 params.set<BoundaryName>("primary_boundary") = primary_boundary;
681 params.set<BoundaryName>("secondary_boundary") = secondary_boundary;
682 params.set<std::vector<BoundaryName>>("boundary") = {secondary_boundary};
683 params.set<ExecFlagEnum>("execute_on", true) = {EXEC_NONLINEAR};
684 params.set<std::vector<VariableName>>("tangent_one") = {action_name + "_tangential_lm" +
685 suffix};
686 params.set<std::vector<VariableName>>("tangent_two") = {action_name + "_tangential_3d_lm" +
687 suffix};
688
689 std::vector<std::string> disp_components({"x", "y", "z"});
690 unsigned component_index = 0;
691
692 // Loop over three displacements
693 for (const auto & disp_component : disp_components)
694 {
695 params.set<AuxVariableName>("variable") = _name + "_tangent_" + disp_component;
696 params.set<unsigned int>("component") = component_index;
697
698 std::string name = _name + "_mortar_frictional_pressure_" + disp_component + "_" +
699 Moose::stringify(contact_mortar_auxkernel_counter++);
700
701 _problem->addAuxKernel("MortarFrictionalPressureVectorAux", name, params);
702 component_index++;
703 }
704 }
705 }
706 }
707
708 if (_current_task == "add_contact_aux_variable")
709 {
710 std::vector<VariableName> displacements = getParam<std::vector<VariableName>>("displacements");
711 const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
712 .system()
713 .variable_type(displacements[0])
714 .order.get_order();
715 const auto mortar_lm_order =
716 _lm_space == ContactLMSpace::LINEAR ? static_cast<int>(FIRST) : order;
717 std::unique_ptr<InputParameters> current_params;
718 const auto create_aux_var_params =
719 [this, order, mortar_lm_order, &current_params]() -> InputParameters &
720 {
721 current_params = std::make_unique<InputParameters>(_factory.getValidParams("MooseVariable"));
722 // Node/face and mortar-penalty contact aux variables continue to follow the displacement
723 // order. Mortar LM contact aux variables live on the same contact surface as the generated LM
724 // field, so they use the selected generated LM space.
725 const auto aux_order = _formulation == ContactFormulation::MORTAR ? mortar_lm_order : order;
726 current_params->set<MooseEnum>("order") =
727 Utility::enum_to_string<Order>(OrderWrapper{aux_order});
728 current_params->set<MooseEnum>("family") = "LAGRANGE";
729 return *current_params;
730 };
731
732 if ((_formulation != ContactFormulation::MORTAR) &&
733 (_formulation != ContactFormulation::MORTAR_PENALTY))
734 {
735 // Add penetration aux variable
736 _problem->addAuxVariable("MooseVariable", "penetration", create_aux_var_params());
737 // Add nodal area aux variable
738 _problem->addAuxVariable("MooseVariable", "nodal_area", create_aux_var_params());
739 }
740 else
741 _problem->addAuxVariable("MooseVariable", "gap", create_aux_var_params());
742
743 // Add contact pressure aux variable
744 _problem->addAuxVariable("MooseVariable", "contact_pressure", create_aux_var_params());
745
746 const unsigned int ndisp = getParam<std::vector<VariableName>>("displacements").size();
747
748 // Add MortarFrictionalPressureVectorAux variables
749 if (_formulation == ContactFormulation::MORTAR && _model == ContactModel::COULOMB && ndisp > 2)
750 {
751 {
752 std::vector<std::string> disp_components({"x", "y", "z"});
753 // Loop over three displacements
754 for (const auto & disp_component : disp_components)
755 {
756 auto var_params = _factory.getValidParams("MooseVariable");
757 var_params.set<MooseEnum>("order") =
758 Utility::enum_to_string<Order>(OrderWrapper{mortar_lm_order});
759 var_params.set<MooseEnum>("family") = "LAGRANGE";
760
761 _problem->addAuxVariable(
762 "MooseVariable", _name + "_tangent_" + disp_component, var_params);
763 }
764 }
765 }
766 }
767
768 if (_current_task == "add_user_object" && (_formulation != ContactFormulation::MORTAR) &&
769 (_formulation != ContactFormulation::MORTAR_PENALTY))
770 {
771 auto var_params = _factory.getValidParams("NodalArea");
772
773 // Get secondary_boundary_vector from possibly updated set from the
774 // ContactAction constructor cleanup
775 const auto actions = _awh.getActions<ContactAction>();
776
777 std::vector<BoundaryName> secondary_boundary_vector;
778 for (const auto * const action : actions)
779 for (const auto j : index_range(action->_boundary_pairs))
780 secondary_boundary_vector.push_back(action->_boundary_pairs[j].second);
781
782 var_params.set<std::vector<BoundaryName>>("boundary") = secondary_boundary_vector;
783 var_params.set<std::vector<VariableName>>("variable") = {"nodal_area"};
784
785 mooseAssert(_problem, "Problem pointer is NULL");
786 var_params.set<ExecFlagEnum>("execute_on", true) = {EXEC_INITIAL, EXEC_TIMESTEP_BEGIN};
787 var_params.set<bool>("use_displaced_mesh") = true;
788
789 _problem->addUserObject("NodalArea",
790 "nodal_area_object_" + Moose::stringify(contact_userobject_counter++),
791 var_params);
792 }
793}
794
795void
796ContactAction::addContactPressureAuxKernel()
797{
798 // Increment counter for contact action objects
799 contact_action_counter++;
800
801 if ((_formulation != ContactFormulation::MORTAR) &&
802 (_formulation != ContactFormulation::MORTAR_PENALTY))
803 {
804 // Add ContactPressureAux: Only one object for all contact pairs
805 const auto actions = _awh.getActions<ContactAction>();
806
807 // Add auxiliary kernel if we are the last contact action object.
808 if (contact_action_counter == actions.size())
809 {
810 std::vector<BoundaryName> boundary_vector;
811 std::vector<BoundaryName> pair_boundary_vector;
812
813 for (const auto * const action : actions)
814 for (const auto j : index_range(action->_boundary_pairs))
815 {
816 boundary_vector.push_back(action->_boundary_pairs[j].second);
817 pair_boundary_vector.push_back(action->_boundary_pairs[j].first);
818 }
819
820 InputParameters params = _factory.getValidParams("ContactPressureAux");
821 params.applyParameters(parameters(), {"order"});
822
823 std::vector<VariableName> displacements =
824 getParam<std::vector<VariableName>>("displacements");
825 const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
826 .system()
827 .variable_type(displacements[0])
828 .order.get_order();
829
830 params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
831 params.set<std::vector<BoundaryName>>("boundary") = boundary_vector;
832 params.set<std::vector<BoundaryName>>("paired_boundary") = pair_boundary_vector;
833 params.set<AuxVariableName>("variable") = "contact_pressure";
834 params.addRequiredCoupledVar("nodal_area", "The nodal area");
835 params.set<std::vector<VariableName>>("nodal_area") = {"nodal_area"};
836 params.set<bool>("use_displaced_mesh") = true;
837
838 std::string name = _name + "_contact_pressure";
839 params.set<ExecFlagEnum>("execute_on",
840 true) = {EXEC_NONLINEAR, EXEC_TIMESTEP_END, EXEC_TIMESTEP_BEGIN};
841 _problem->addAuxKernel("ContactPressureAux", name, params);
842 }
843 }
844 else
845 for (const auto & contact_pair : _boundary_pairs)
846 {
847 const auto & [_, secondary_name] = contact_pair;
848 const auto type = "MortarUserObjectAux";
849 InputParameters params = _factory.getValidParams(type);
850 params.set<std::vector<BoundaryName>>("boundary") = {secondary_name};
851 params.set<AuxVariableName>("variable") = "contact_pressure";
852 params.set<bool>("use_displaced_mesh") = true; // Unecessary as this object only operates on
853 // nodes, but we'll do it for consistency
854 params.set<MooseEnum>("contact_quantity") = "normal_pressure";
855 const auto & [primary_id, secondary_id, uo_name] =
856 libmesh_map_find(_bnd_pair_to_mortar_info, contact_pair);
857 params.set<UserObjectName>("user_object") = uo_name;
858 const std::string name = _name + "_contact_pressure" + std::to_string(primary_id) + "_" +
859 std::to_string(secondary_id);
860
861 _problem->addAuxKernel(type, name, params);
862 }
863}
864
865void
866ContactAction::addRelationshipManagers(Moose::RelationshipManagerType input_rm_type)
867{
868 if (_formulation == ContactFormulation::MORTAR ||
869 _formulation == ContactFormulation::MORTAR_PENALTY)
870 {
871 std::string action_name = MooseUtils::shortName(name());
872 for (const auto & [primary_boundary, secondary_boundary] : _boundary_pairs)
873 {
874 const std::string suffix = pairSuffix({primary_boundary, secondary_boundary});
875 auto params = MortarConstraintBase::validParams();
876 params.set<bool>("use_displaced_mesh") = true;
877 params.set<BoundaryName>("primary_boundary") = primary_boundary;
878 params.set<BoundaryName>("secondary_boundary") = secondary_boundary;
879 params.set<SubdomainName>("primary_subdomain") = action_name + "_primary_subdomain" + suffix;
880 params.set<SubdomainName>("secondary_subdomain") =
881 action_name + "_secondary_subdomain" + suffix;
882 params.set<bool>("use_petrov_galerkin") = getParam<bool>("use_petrov_galerkin");
883 params.set<Real>("minimum_projection_angle") = getParam<Real>("minimum_projection_angle");
884 params.set<MooseEnum>("mortar_3d_subpatch_plane") =
885 getParam<MooseEnum>("mortar_3d_subpatch_plane");
886 params.set<bool>("ghost_point_neighbors") = true;
887 addRelationshipManagers(input_rm_type, params);
888 }
889 }
890 else
891 {
892 const std::string constraint_type = _formulation == ContactFormulation::RANFS
893 ? "RANFSNormalMechanicalContact"
894 : "MechanicalContactConstraint";
895
896 for (const auto & contact_pair : _boundary_pairs)
897 {
898 auto params = _factory.getValidParams(constraint_type);
899 params.set<bool>("use_displaced_mesh") = true;
900 params.set<bool>("ghost_whole_interface") = getParam<bool>("ghost_whole_interface");
901 params.set<BoundaryName>("primary") = contact_pair.first;
902 params.set<BoundaryName>("secondary") = contact_pair.second;
903 addRelationshipManagers(input_rm_type, params);
904 }
905 }
906}
907
908std::string
909ContactAction::pairSuffix(const std::pair<BoundaryName, BoundaryName> & pair) const
910{
911 return _boundary_pairs.size() > 1 ? AutomaticContactPairingGenerator::pairSuffix(pair) : "";
912}
913
914void
915ContactAction::addMortarContact()
916{
917 std::string action_name = MooseUtils::shortName(name());
918
919 std::vector<VariableName> displacements = getParam<std::vector<VariableName>>("displacements");
920 const unsigned int ndisp = displacements.size();
921
922 // Add the lagrange multiplier on the secondary subdomain.
923 const auto addLagrangeMultiplier = [this, &displacements](const std::string & secondary_subdomain,
924 const std::string & variable_name,
925 const Real scaling_factor,
926 const bool add_aux_lm,
927 const bool penalty_traction) //
928 {
929 InputParameters params = _factory.getValidParams("MooseVariableBase");
930
931 // Allow the user to select "weighted" constraints and standard bases (use_dual = false) or
932 // "legacy" constraints and dual bases (use_dual = true). Unless it's for testing purposes,
933 // this combination isn't recommended
934 if (!add_aux_lm || penalty_traction)
935 params.set<bool>("use_dual") = _use_dual;
936
937 mooseAssert(_problem->systemBaseNonlinear(/*nl_sys_num=*/0).hasVariable(displacements[0]),
938 "Displacement variable is missing");
939 const auto primal_type =
940 _problem->systemBaseNonlinear(/*nl_sys_num=*/0).system().variable_type(displacements[0]);
941
942 // The lm_space option is only valid for the mortar Lagrange multiplier formulation. Mortar
943 // penalty traction variables continue to use the displacement order.
944 const int lm_order =
945 _formulation == ContactFormulation::MORTAR && _lm_space == ContactLMSpace::LINEAR
946 ? static_cast<int>(FIRST)
947 : primal_type.order.get_order();
948
949 if (primal_type.family == LAGRANGE)
950 {
951 params.set<MooseEnum>("family") = Utility::enum_to_string<FEFamily>(primal_type.family);
952 params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{lm_order});
953 }
954 else
955 mooseError("Invalid bases for mortar contact.");
956
957 params.set<std::vector<SubdomainName>>("block") = {secondary_subdomain};
958 if (!(add_aux_lm || penalty_traction))
959 params.set<std::vector<Real>>("scaling") = {scaling_factor};
960
961 auto fe_type = AddVariableAction::feType(params);
962 auto var_type = AddVariableAction::variableType(fe_type);
963 if (add_aux_lm || penalty_traction)
964 _problem->addAuxVariable(var_type, variable_name, params);
965 else
966 _problem->addVariable(var_type, variable_name, params);
967 };
968
969 if (_current_task == "append_mesh_generator")
970 {
971 // Don't do mesh generators when recovering or when the user has requested for us not to
972 // (presumably because the lower-dimensional blocks are already in the mesh due to manual
973 // addition or because we are restarting). Automatically detected pairs get their
974 // lower-dimensional blocks from the generator appended in appendAutomaticPairingGenerator()
975 if (!(_app.isRecovering() && _app.isUltimateMaster()) && !_app.useMasterMesh() &&
976 _generate_mortar_mesh && _automatic_pairing_boundaries.empty())
977 {
978 for (const auto & [primary_boundary, secondary_boundary] : _boundary_pairs)
979 {
980 const std::string suffix = pairSuffix({primary_boundary, secondary_boundary});
981 const std::string primary_subdomain_name = action_name + "_primary_subdomain" + suffix;
982 const std::string secondary_subdomain_name = action_name + "_secondary_subdomain" + suffix;
983
984 const MeshGeneratorName primary_name = primary_subdomain_name + "_generator";
985 const MeshGeneratorName secondary_name = secondary_subdomain_name + "_generator";
986
987 auto primary_params = _factory.getValidParams("LowerDBlockFromSidesetGenerator");
988 auto secondary_params = _factory.getValidParams("LowerDBlockFromSidesetGenerator");
989
990 primary_params.set<SubdomainName>("new_block_name") = primary_subdomain_name;
991 secondary_params.set<SubdomainName>("new_block_name") = secondary_subdomain_name;
992
993 primary_params.set<std::vector<BoundaryName>>("sidesets") = {primary_boundary};
994 secondary_params.set<std::vector<BoundaryName>>("sidesets") = {secondary_boundary};
995
996 _app.appendMeshGenerator("LowerDBlockFromSidesetGenerator", primary_name, primary_params);
997 _app.appendMeshGenerator(
998 "LowerDBlockFromSidesetGenerator", secondary_name, secondary_params);
999 }
1000 }
1001 }
1002
1003 if (_current_task == "add_mortar_variable" && _formulation == ContactFormulation::MORTAR)
1004 {
1005 for (const auto & contact_pair : _boundary_pairs)
1006 {
1007 const std::string suffix = pairSuffix(contact_pair);
1008 const std::string secondary_subdomain_name = action_name + "_secondary_subdomain" + suffix;
1009 const std::string normal_lagrange_multiplier_name = action_name + "_normal_lm" + suffix;
1010 const std::string tangential_lagrange_multiplier_name =
1011 action_name + "_tangential_lm" + suffix;
1012 const std::string tangential_lagrange_multiplier_3d_name =
1013 action_name + "_tangential_3d_lm" + suffix;
1014 const std::string auxiliary_lagrange_multiplier_name = action_name + "_aux_lm" + suffix;
1015
1016 addLagrangeMultiplier(secondary_subdomain_name,
1017 normal_lagrange_multiplier_name,
1018 getParam<Real>("normal_lm_scaling"),
1019 false,
1020 false);
1021
1022 if (_model == ContactModel::COULOMB)
1023 {
1024 addLagrangeMultiplier(secondary_subdomain_name,
1025 tangential_lagrange_multiplier_name,
1026 getParam<Real>("tangential_lm_scaling"),
1027 false,
1028 false);
1029 if (ndisp > 2)
1030 addLagrangeMultiplier(secondary_subdomain_name,
1031 tangential_lagrange_multiplier_3d_name,
1032 getParam<Real>("tangential_lm_scaling"),
1033 false,
1034 false);
1035 }
1036
1037 if (getParam<bool>("use_petrov_galerkin"))
1038 addLagrangeMultiplier(
1039 secondary_subdomain_name, auxiliary_lagrange_multiplier_name, 1.0, true, false);
1040 }
1041 }
1042 else if (_current_task == "add_mortar_variable" &&
1043 _formulation == ContactFormulation::MORTAR_PENALTY)
1044 {
1045 for (const auto & contact_pair : _boundary_pairs)
1046 {
1047 const std::string suffix = pairSuffix(contact_pair);
1048 const std::string secondary_subdomain_name = action_name + "_secondary_subdomain" + suffix;
1049 const std::string auxiliary_lagrange_multiplier_name = action_name + "_aux_lm" + suffix;
1050
1051 if (_use_dual)
1052 addLagrangeMultiplier(
1053 secondary_subdomain_name, auxiliary_lagrange_multiplier_name, 1.0, false, true);
1054 }
1055 }
1056
1057 if (_current_task == "add_user_object")
1058 {
1059 // check if the correct problem class is selected if AL parameters are provided
1060 if (_formulation == ContactFormulation::MORTAR_PENALTY &&
1061 !dynamic_cast<AugmentedLagrangianContactProblemInterface *>(_problem.get()))
1062 {
1063 const std::vector<std::string> params = {"penalty_multiplier",
1064 "penalty_multiplier_friction",
1065 "al_penetration_tolerance",
1066 "al_incremental_slip_tolerance",
1067 "al_frictional_force_tolerance"};
1068 for (const auto & param : params)
1069 if (parameters().isParamSetByUser(param))
1070 paramError(param,
1071 "Augmented Lagrange parameter was specified, but the selected problem type "
1072 "does not support Augmented Lagrange iterations.");
1073 }
1074
1075 for (const auto & [primary_boundary, secondary_boundary] : _boundary_pairs)
1076 {
1077 const std::string suffix = pairSuffix({primary_boundary, secondary_boundary});
1078 const std::string primary_subdomain_name = action_name + "_primary_subdomain" + suffix;
1079 const std::string secondary_subdomain_name = action_name + "_secondary_subdomain" + suffix;
1080 const std::string normal_lagrange_multiplier_name = action_name + "_normal_lm" + suffix;
1081 const std::string tangential_lagrange_multiplier_name =
1082 action_name + "_tangential_lm" + suffix;
1083 const std::string tangential_lagrange_multiplier_3d_name =
1084 action_name + "_tangential_3d_lm" + suffix;
1085 const std::string auxiliary_lagrange_multiplier_name = action_name + "_aux_lm" + suffix;
1086
1087 const auto register_mortar_uo_name =
1088 [this, &suffix](const auto & bnd_pair, const auto & uo_prefix)
1089 {
1090 const auto & [primary_name, secondary_name] = bnd_pair;
1091 const auto primary_id = _mesh->getBoundaryID(primary_name);
1092 const auto secondary_id = _mesh->getBoundaryID(secondary_name);
1093 const auto uo_name = uo_prefix + name() + suffix;
1094 _bnd_pair_to_mortar_info.emplace(bnd_pair, MortarInfo{primary_id, secondary_id, uo_name});
1095 return uo_name;
1096 };
1097
1098 if (_model != ContactModel::COULOMB && _formulation == ContactFormulation::MORTAR)
1099 {
1100 auto uo_params = _factory.getValidParams("LMWeightedGapUserObject");
1101
1102 uo_params.set<BoundaryName>("primary_boundary") = primary_boundary;
1103 uo_params.set<BoundaryName>("secondary_boundary") = secondary_boundary;
1104 uo_params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
1105 uo_params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
1106 uo_params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};
1107 uo_params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};
1108 if (ndisp > 2)
1109 uo_params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};
1110 uo_params.set<bool>("use_displaced_mesh") = true;
1111 uo_params.set<std::vector<VariableName>>("lm_variable") = {normal_lagrange_multiplier_name};
1112 uo_params.applySpecificParameters(parameters(),
1113 {"correct_edge_dropping",
1114 "use_nodal_scaling",
1115 "triangulation",
1116 "triangulate_triangles",
1117 "minimum_projection_angle",
1118 "mortar_3d_subpatch_plane",
1119 "mortar_3d_qp_mapping",
1120 "use_petrov_galerkin",
1121 "debug_mesh"});
1122 if (getParam<bool>("use_petrov_galerkin"))
1123 uo_params.set<std::vector<VariableName>>("aux_lm") = {auxiliary_lagrange_multiplier_name};
1124
1125 _problem->addUserObject(
1126 "LMWeightedGapUserObject",
1127 register_mortar_uo_name(std::make_pair(primary_boundary, secondary_boundary),
1128 "lm_weightedgap_object_"),
1129 uo_params);
1130 }
1131 else if (_model == ContactModel::COULOMB && _formulation == ContactFormulation::MORTAR)
1132 {
1133 auto uo_params = _factory.getValidParams("LMWeightedVelocitiesUserObject");
1134 uo_params.set<BoundaryName>("primary_boundary") = primary_boundary;
1135 uo_params.set<BoundaryName>("secondary_boundary") = secondary_boundary;
1136 uo_params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
1137 uo_params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
1138 uo_params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};
1139 uo_params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};
1140 if (ndisp > 2)
1141 uo_params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};
1142
1143 uo_params.set<VariableName>("secondary_variable") = displacements[0];
1144 uo_params.set<bool>("use_displaced_mesh") = true;
1145 uo_params.set<std::vector<VariableName>>("lm_variable_normal") = {
1146 normal_lagrange_multiplier_name};
1147 uo_params.set<std::vector<VariableName>>("lm_variable_tangential_one") = {
1148 tangential_lagrange_multiplier_name};
1149 if (ndisp > 2)
1150 uo_params.set<std::vector<VariableName>>("lm_variable_tangential_two") = {
1151 tangential_lagrange_multiplier_3d_name};
1152 uo_params.applySpecificParameters(parameters(),
1153 {"correct_edge_dropping",
1154 "use_nodal_scaling",
1155 "triangulation",
1156 "triangulate_triangles",
1157 "minimum_projection_angle",
1158 "mortar_3d_subpatch_plane",
1159 "mortar_3d_qp_mapping",
1160 "use_petrov_galerkin",
1161 "debug_mesh"});
1162 if (getParam<bool>("use_petrov_galerkin"))
1163 uo_params.set<std::vector<VariableName>>("aux_lm") = {auxiliary_lagrange_multiplier_name};
1164
1165 _problem->addUserObject(
1166 "LMWeightedVelocitiesUserObject",
1167 register_mortar_uo_name(std::make_pair(primary_boundary, secondary_boundary),
1168 "lm_weightedvelocities_object_"),
1169 uo_params);
1170 }
1171
1172 if (_model != ContactModel::COULOMB && _formulation == ContactFormulation::MORTAR_PENALTY)
1173 {
1174 auto uo_params = _factory.getValidParams("PenaltyWeightedGapUserObject");
1175
1176 uo_params.set<BoundaryName>("primary_boundary") = primary_boundary;
1177 uo_params.set<BoundaryName>("secondary_boundary") = secondary_boundary;
1178 uo_params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
1179 uo_params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
1180 uo_params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};
1181 uo_params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};
1182
1183 // AL parameters
1184 uo_params.applySpecificParameters(parameters(),
1185 {"correct_edge_dropping",
1186 "triangulation",
1187 "triangulate_triangles",
1188 "minimum_projection_angle",
1189 "mortar_3d_subpatch_plane",
1190 "mortar_3d_qp_mapping",
1191 "penalty",
1192 "debug_mesh",
1193 "max_penalty_multiplier",
1194 "adaptivity_penalty_normal"});
1195
1196 if (isParamValid("al_penetration_tolerance"))
1197 uo_params.set<Real>("penetration_tolerance") = getParam<Real>("al_penetration_tolerance");
1198 if (isParamValid("penalty_multiplier"))
1199 uo_params.set<Real>("penalty_multiplier") = getParam<Real>("penalty_multiplier");
1200 // In the contact action, we force the physical value of the normal gap, which also
1201 // normalizes the penalty factor with the "area" around the node
1202 uo_params.set<bool>("use_physical_gap") = true;
1203
1204 if (_use_dual)
1205 uo_params.set<std::vector<VariableName>>("aux_lm") = {auxiliary_lagrange_multiplier_name};
1206
1207 if (ndisp > 2)
1208 uo_params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};
1209 uo_params.set<bool>("use_displaced_mesh") = true;
1210
1211 _problem->addUserObject(
1212 "PenaltyWeightedGapUserObject",
1213 register_mortar_uo_name(std::make_pair(primary_boundary, secondary_boundary),
1214 "penalty_weightedgap_object_"),
1215 uo_params);
1216 _problem->haveADObjects(true);
1217 }
1218 else if (_model == ContactModel::COULOMB &&
1219 _formulation == ContactFormulation::MORTAR_PENALTY)
1220 {
1221 auto uo_params = _factory.getValidParams("PenaltyFrictionUserObject");
1222 uo_params.set<BoundaryName>("primary_boundary") = primary_boundary;
1223 uo_params.set<BoundaryName>("secondary_boundary") = secondary_boundary;
1224 uo_params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
1225 uo_params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
1226 uo_params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};
1227 uo_params.set<bool>("correct_edge_dropping") = getParam<bool>("correct_edge_dropping");
1228 uo_params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};
1229 if (ndisp > 2)
1230 uo_params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};
1231
1232 uo_params.set<VariableName>("secondary_variable") = displacements[0];
1233 uo_params.set<bool>("use_displaced_mesh") = true;
1234 uo_params.set<Real>("friction_coefficient") = getParam<Real>("friction_coefficient");
1235 uo_params.set<Real>("penalty") = getParam<Real>("penalty");
1236 uo_params.set<Real>("penalty_friction") = getParam<Real>("penalty_friction");
1237
1238 // AL parameters
1239 uo_params.set<Real>("max_penalty_multiplier") = getParam<Real>("max_penalty_multiplier");
1240 uo_params.set<MooseEnum>("adaptivity_penalty_normal") =
1241 getParam<MooseEnum>("adaptivity_penalty_normal");
1242 uo_params.set<MooseEnum>("adaptivity_penalty_friction") =
1243 getParam<MooseEnum>("adaptivity_penalty_friction");
1244 if (isParamValid("al_penetration_tolerance"))
1245 uo_params.set<Real>("penetration_tolerance") = getParam<Real>("al_penetration_tolerance");
1246 if (isParamValid("penalty_multiplier"))
1247 uo_params.set<Real>("penalty_multiplier") = getParam<Real>("penalty_multiplier");
1248 if (isParamValid("penalty_multiplier_friction"))
1249 uo_params.set<Real>("penalty_multiplier_friction") =
1250 getParam<Real>("penalty_multiplier_friction");
1251
1252 if (isParamValid("al_incremental_slip_tolerance"))
1253 uo_params.set<Real>("slip_tolerance") = getParam<Real>("al_incremental_slip_tolerance");
1254 // In the contact action, we force the physical value of the normal gap, which also
1255 // normalizes the penalty factor with the "area" around the node
1256 uo_params.set<bool>("use_physical_gap") = true;
1257
1258 if (_use_dual)
1259 uo_params.set<std::vector<VariableName>>("aux_lm") = {auxiliary_lagrange_multiplier_name};
1260
1261 uo_params.applySpecificParameters(parameters(),
1262 {"triangulation",
1263 "triangulate_triangles",
1264 "minimum_projection_angle",
1265 "mortar_3d_subpatch_plane",
1266 "mortar_3d_qp_mapping",
1267 "friction_coefficient",
1268 "penalty",
1269 "penalty_friction"});
1270
1271 _problem->addUserObject(
1272 "PenaltyFrictionUserObject",
1273 register_mortar_uo_name(std::make_pair(primary_boundary, secondary_boundary),
1274 "penalty_friction_object_"),
1275 uo_params);
1276 _problem->haveADObjects(true);
1277 }
1278 }
1279 }
1280
1281 if (_current_task == "add_constraint")
1282 {
1283 for (const auto & contact_pair : _boundary_pairs)
1284 {
1285 const BoundaryName & primary_boundary = contact_pair.first;
1286 const BoundaryName & secondary_boundary = contact_pair.second;
1287 const std::string suffix = pairSuffix(contact_pair);
1288 const std::string primary_subdomain_name = action_name + "_primary_subdomain" + suffix;
1289 const std::string secondary_subdomain_name = action_name + "_secondary_subdomain" + suffix;
1290 const std::string normal_lagrange_multiplier_name = action_name + "_normal_lm" + suffix;
1291 const std::string tangential_lagrange_multiplier_name =
1292 action_name + "_tangential_lm" + suffix;
1293 const std::string tangential_lagrange_multiplier_3d_name =
1294 action_name + "_tangential_3d_lm" + suffix;
1295
1296 // Prepare problem for enforcement with Lagrange multipliers
1297 if (_model != ContactModel::COULOMB && _formulation == ContactFormulation::MORTAR)
1298 {
1299 std::string mortar_constraint_name;
1300
1301 if (!_mortar_dynamics)
1302 mortar_constraint_name = "ComputeWeightedGapLMMechanicalContact";
1303 else
1304 mortar_constraint_name = "ComputeDynamicWeightedGapLMMechanicalContact";
1305
1306 InputParameters params = _factory.getValidParams(mortar_constraint_name);
1307 if (_mortar_dynamics)
1308 params.applySpecificParameters(
1309 parameters(), {"newmark_beta", "newmark_gamma", "capture_tolerance", "wear_depth"});
1310
1311 else // We need user objects for quasistatic constraints
1312 params.set<UserObjectName>("weighted_gap_uo") =
1313 "lm_weightedgap_object_" + name() + suffix;
1314
1315 params.set<BoundaryName>("primary_boundary") = primary_boundary;
1316 params.set<BoundaryName>("secondary_boundary") = secondary_boundary;
1317 params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
1318 params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
1319 params.set<NonlinearVariableName>("variable") = normal_lagrange_multiplier_name;
1320 params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};
1321 params.set<Real>("c") = getParam<Real>("c_normal");
1322
1323 if (ndisp > 1)
1324 params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};
1325 if (ndisp > 2)
1326 params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};
1327
1328 params.set<bool>("use_displaced_mesh") = true;
1329
1330 params.applySpecificParameters(parameters(),
1331 {"correct_edge_dropping",
1332 "triangulation",
1333 "triangulate_triangles",
1334 "minimum_projection_angle",
1335 "mortar_3d_subpatch_plane",
1336 "mortar_3d_qp_mapping",
1337 "normalize_c",
1338 "extra_vector_tags",
1339 "absolute_value_vector_tags",
1340 "debug_mesh"});
1341
1342 _problem->addConstraint(
1343 mortar_constraint_name, action_name + "_normal_lm_weighted_gap" + suffix, params);
1344 _problem->haveADObjects(true);
1345 }
1346 // Add the tangential and normal Lagrange's multiplier constraints on the secondary boundary.
1347 else if (_model == ContactModel::COULOMB && _formulation == ContactFormulation::MORTAR)
1348 {
1349 std::string mortar_constraint_name;
1350
1351 if (!_mortar_dynamics)
1352 mortar_constraint_name = "ComputeFrictionalForceLMMechanicalContact";
1353 else
1354 mortar_constraint_name = "ComputeDynamicFrictionalForceLMMechanicalContact";
1355
1356 InputParameters params = _factory.getValidParams(mortar_constraint_name);
1357 if (_mortar_dynamics)
1358 params.applySpecificParameters(
1359 parameters(), {"newmark_beta", "newmark_gamma", "capture_tolerance", "wear_depth"});
1360 else
1361 { // We need user objects for quasistatic constraints
1362 params.set<UserObjectName>("weighted_gap_uo") =
1363 "lm_weightedvelocities_object_" + name() + suffix;
1364 params.set<UserObjectName>("weighted_velocities_uo") =
1365 "lm_weightedvelocities_object_" + name() + suffix;
1366 }
1367
1368 params.set<bool>("correct_edge_dropping") = getParam<bool>("correct_edge_dropping");
1369 params.set<BoundaryName>("primary_boundary") = primary_boundary;
1370 params.set<BoundaryName>("secondary_boundary") = secondary_boundary;
1371 params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
1372 params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
1373 params.set<bool>("use_displaced_mesh") = true;
1374 params.set<Real>("c_t") = getParam<Real>("c_tangential");
1375 params.set<Real>("c") = getParam<Real>("c_normal");
1376 params.set<bool>("normalize_c") = getParam<bool>("normalize_c");
1377 params.set<bool>("compute_primal_residuals") = false;
1378
1379 params.set<MooseEnum>("segment_quadrature") = getParam<MooseEnum>("segment_quadrature");
1380
1381 params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};
1382
1383 if (ndisp > 1)
1384 params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};
1385 if (ndisp > 2)
1386 params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};
1387
1388 params.set<NonlinearVariableName>("variable") = normal_lagrange_multiplier_name;
1389 params.set<std::vector<VariableName>>("friction_lm") = {
1390 tangential_lagrange_multiplier_name};
1391
1392 if (ndisp > 2)
1393 params.set<std::vector<VariableName>>("friction_lm_dir") = {
1394 tangential_lagrange_multiplier_3d_name};
1395
1396 params.set<Real>("mu") = getParam<Real>("friction_coefficient");
1397 params.set<MooseEnum>("friction_projection_degree") =
1398 getParam<MooseEnum>("friction_projection_degree");
1399 params.applySpecificParameters(parameters(),
1400 {"triangulation",
1401 "triangulate_triangles",
1402 "minimum_projection_angle",
1403 "mortar_3d_subpatch_plane",
1404 "mortar_3d_qp_mapping",
1405 "extra_vector_tags",
1406 "absolute_value_vector_tags",
1407 "debug_mesh"});
1408
1409 _problem->addConstraint(
1410 mortar_constraint_name, action_name + "_tangential_lm" + suffix, params);
1411 _problem->haveADObjects(true);
1412 }
1413
1414 const auto addMechanicalContactConstraints =
1415 [this,
1416 &primary_boundary,
1417 &secondary_boundary,
1418 &suffix,
1419 &primary_subdomain_name,
1420 &secondary_subdomain_name,
1421 &displacements](const std::string & variable_name,
1422 const std::string & constraint_prefix,
1423 const std::string & constraint_type,
1424 const bool is_additional_frictional_constraint,
1425 const bool is_normal_constraint)
1426 {
1427 InputParameters params = _factory.getValidParams(constraint_type);
1428
1429 params.set<bool>("correct_edge_dropping") = getParam<bool>("correct_edge_dropping");
1430 params.set<BoundaryName>("primary_boundary") = primary_boundary;
1431 params.set<BoundaryName>("secondary_boundary") = secondary_boundary;
1432 params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
1433 params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
1434
1435 if (_formulation == ContactFormulation::MORTAR)
1436 params.set<NonlinearVariableName>("variable") = variable_name;
1437
1438 params.set<MooseEnum>("segment_quadrature") = getParam<MooseEnum>("segment_quadrature");
1439 params.set<bool>("use_displaced_mesh") = true;
1440 params.set<bool>("compute_lm_residuals") = false;
1441
1442 // Additional displacement residual for frictional problem
1443 // The second frictional LM acts on a perpendicular direction.
1444 if (is_additional_frictional_constraint)
1445 params.set<MooseEnum>("direction") = "direction_2";
1446 params.applySpecificParameters(parameters(),
1447 {"triangulation",
1448 "triangulate_triangles",
1449 "minimum_projection_angle",
1450 "mortar_3d_subpatch_plane",
1451 "mortar_3d_qp_mapping",
1452 "extra_vector_tags",
1453 "absolute_value_vector_tags",
1454 "debug_mesh"});
1455
1456 for (const auto i : index_range(displacements))
1457 {
1458 std::string constraint_name = constraint_prefix + Moose::stringify(i);
1459
1460 params.set<VariableName>("secondary_variable") = displacements[i];
1461 params.set<MooseEnum>("component") = i;
1462
1463 if (is_normal_constraint && _model != ContactModel::COULOMB &&
1464 _formulation == ContactFormulation::MORTAR)
1465 params.set<UserObjectName>("weighted_gap_uo") =
1466 "lm_weightedgap_object_" + name() + suffix;
1467 else if (is_normal_constraint && _model == ContactModel::COULOMB &&
1468 _formulation == ContactFormulation::MORTAR)
1469 params.set<UserObjectName>("weighted_gap_uo") =
1470 "lm_weightedvelocities_object_" + name() + suffix;
1471 else if (_formulation == ContactFormulation::MORTAR)
1472 params.set<UserObjectName>("weighted_velocities_uo") =
1473 "lm_weightedvelocities_object_" + name() + suffix;
1474 else if (is_normal_constraint && _model != ContactModel::COULOMB &&
1475 _formulation == ContactFormulation::MORTAR_PENALTY)
1476 params.set<UserObjectName>("weighted_gap_uo") =
1477 "penalty_weightedgap_object_" + name() + suffix;
1478 else if (is_normal_constraint && _model == ContactModel::COULOMB &&
1479 _formulation == ContactFormulation::MORTAR_PENALTY)
1480 params.set<UserObjectName>("weighted_gap_uo") =
1481 "penalty_friction_object_" + name() + suffix;
1482 else if (_formulation == ContactFormulation::MORTAR_PENALTY)
1483 params.set<UserObjectName>("weighted_velocities_uo") =
1484 "penalty_friction_object_" + name() + suffix;
1485
1486 _problem->addConstraint(constraint_type, constraint_name, params);
1487 }
1488 _problem->haveADObjects(true);
1489 };
1490
1491 // Add mortar mechanical contact constraint objects for primal variables
1492 addMechanicalContactConstraints(normal_lagrange_multiplier_name,
1493 action_name + "_normal_constraint" + suffix + "_",
1494 "NormalMortarMechanicalContact",
1495 /* is_additional_frictional_constraint = */ false,
1496 /* is_normal_constraint = */ true);
1497
1498 if (_model == ContactModel::COULOMB)
1499 {
1500 addMechanicalContactConstraints(tangential_lagrange_multiplier_name,
1501 action_name + "_tangential_constraint" + suffix + "_",
1502 "TangentialMortarMechanicalContact",
1503 /* is_additional_frictional_constraint = */ false,
1504 /* is_normal_constraint = */ false);
1505 if (ndisp > 2)
1506 addMechanicalContactConstraints(tangential_lagrange_multiplier_3d_name,
1507 action_name + "_tangential_constraint_3d" + suffix + "_",
1508 "TangentialMortarMechanicalContact",
1509 /* is_additional_frictional_constraint = */ true,
1510 /* is_normal_constraint = */ false);
1511 }
1512 }
1513 }
1514}
1515
1516void
1517ContactAction::addNodeFaceContact()
1518{
1519 if (_current_task != "add_constraint")
1520 return;
1521
1522 std::string action_name = MooseUtils::shortName(name());
1523 std::vector<VariableName> displacements = getParam<std::vector<VariableName>>("displacements");
1524 const unsigned int ndisp = displacements.size();
1525
1526 std::string constraint_type;
1527
1528 if (_formulation == ContactFormulation::RANFS)
1529 constraint_type = "RANFSNormalMechanicalContact";
1530 else
1531 constraint_type = "MechanicalContactConstraint";
1532
1533 InputParameters params = _factory.getValidParams(constraint_type);
1534
1535 params.applyParameters(parameters(),
1536 {"displacements",
1537 "secondary_gap_offset",
1538 "mapped_primary_gap_offset",
1539 "primary",
1540 "secondary"});
1541
1542 const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
1543 .system()
1544 .variable_type(displacements[0])
1545 .order.get_order();
1546
1547 params.set<std::vector<VariableName>>("displacements") = displacements;
1548 params.set<bool>("use_displaced_mesh") = true;
1549 params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
1550
1551 for (const auto & contact_pair : _boundary_pairs)
1552 {
1553 if (_formulation != ContactFormulation::RANFS)
1554 {
1555 params.set<std::vector<VariableName>>("nodal_area") = {"nodal_area"};
1556 params.set<BoundaryName>("boundary") = contact_pair.first;
1557 if (isParamValid("secondary_gap_offset"))
1558 params.set<std::vector<VariableName>>("secondary_gap_offset") = {
1559 getParam<VariableName>("secondary_gap_offset")};
1560 if (isParamValid("mapped_primary_gap_offset"))
1561 params.set<std::vector<VariableName>>("mapped_primary_gap_offset") = {
1562 getParam<VariableName>("mapped_primary_gap_offset")};
1563 }
1564
1565 for (unsigned int i = 0; i < ndisp; ++i)
1566 {
1567 std::string name = action_name + "_constraint_" + Moose::stringify(contact_pair, "_") + "_" +
1568 Moose::stringify(i);
1569
1570 if (_formulation == ContactFormulation::RANFS)
1571 params.set<MooseEnum>("component") = i;
1572 else
1573 params.set<unsigned int>("component") = i;
1574
1575 params.set<BoundaryName>("primary") = contact_pair.first;
1576 params.set<BoundaryName>("secondary") = contact_pair.second;
1577 params.set<NonlinearVariableName>("variable") = displacements[i];
1578 params.set<std::vector<VariableName>>("primary_variable") = {displacements[i]};
1579 params.applySpecificParameters(parameters(),
1580 {"extra_vector_tags", "absolute_value_vector_tags"});
1581 _problem->addConstraint(constraint_type, name, params);
1582 }
1583 }
1584}
1585
1586std::string
1587ContactAction::automaticPairingGeneratorName() const
1588{
1589 return MooseUtils::shortName(name()) + "_auto_pairing_generator";
1590}
1591
1592void
1593ContactAction::appendAutomaticPairingGenerator()
1594{
1595 // A sub-app cloning its parent mesh runs no mesh generators, so there would be no generator to
1596 // detect the pairs
1597 if (_app.useMasterMesh())
1598 paramError("automatic_pairing_boundaries",
1599 "Automatic contact pairing is not supported when cloning the parent app mesh.");
1600 if (_app.getMeshGeneratorNames().empty())
1601 paramError("automatic_pairing_boundaries",
1602 "Automatic contact pairing requires the mesh to be built by mesh generators. Use a "
1603 "FileMeshGenerator in the [Mesh] block to read a mesh file.");
1604
1605 // The generator is appended even when recovering. Generation is then skipped, but constructing
1606 // the generator declares the contact pairs mesh meta-data, which is restored from the checkpoint
1607 auto params = _factory.getValidParams("AutomaticContactPairingGenerator");
1608 params.set<std::vector<BoundaryName>>("automatic_pairing_boundaries") =
1609 _automatic_pairing_boundaries;
1610 params.set<Real>("automatic_pairing_distance") = getParam<Real>("automatic_pairing_distance");
1611 params.set<MooseEnum>("automatic_pairing_method") =
1612 getParam<MooseEnum>("automatic_pairing_method");
1613 params.set<std::string>("prefix") = MooseUtils::shortName(name());
1614 params.set<bool>("create_lower_d_blocks") =
1615 (_formulation == ContactFormulation::MORTAR ||
1616 _formulation == ContactFormulation::MORTAR_PENALTY) &&
1617 _generate_mortar_mesh;
1618 _app.appendMeshGenerator(
1619 "AutomaticContactPairingGenerator", automaticPairingGeneratorName(), params);
1620}
1621
1622void
1623ContactAction::getAutomaticContactPairs()
1624{
1625 const auto & pairs = getMeshProperty<AutomaticContactPairingGenerator::ContactPairs>(
1626 AutomaticContactPairingGenerator::contact_pairs_property, automaticPairingGeneratorName());
1627 _boundary_pairs.assign(pairs.begin(), pairs.end());
1628
1629 mooseInfo("The following boundary pairs were detected automatically by the contact action:");
1630 for (const auto & [primary, secondary] : _boundary_pairs)
1631 mooseInfoRepeated("Primary boundary: ", primary, " and secondary boundary: ", secondary, ".");
1632}
1633
1634MooseEnum
1635ContactAction::getModelEnum()
1636{
1637 return MooseEnum(getContactModelOptions(), "frictionless");
1638}
1639
1640MooseEnum
1641ContactAction::getProximityMethod()
1642{
1643 return MooseEnum(getProximityMethodOptions());
1644}
1645
1646MooseEnum
1647ContactAction::getFormulationEnum()
1648{
1649 auto formulations = MooseEnum(getContactFormulationOptions(), "kinematic");
1650
1651 formulations.addDocumentation(
1652 "ranfs",
1653 "Reduced Active Nonlinear Function Set scheme for node-on-face contact. Provides exact "
1654 "enforcement without Lagrange multipliers or penalty terms.");
1655 formulations.addDocumentation(
1656 "kinematic",
1657 "Kinematic contact constraint enforcement transfers the internal forces at secondary nodes "
1658 "to the corresponding primary face for node-on-face contact. Provides exact "
1659 "enforcement without Lagrange multipliers or penalty terms.");
1660 formulations.addDocumentation(
1661 "penalty",
1662 "Node-on-face penalty based contact constraint enforcement. Interpenetration is penalized. "
1663 "Enforcement depends on the penalty magnitude. High penalties can introduce ill conditioning "
1664 "of the system.");
1665 formulations.addDocumentation("augmented_lagrange",
1666 "Node-on-face augmented Lagrange penalty based contact constraint "
1667 "enforcement. Interpenetration is enforced up to a user specified "
1668 "tolerance, ill-conditioning is generally avoided. Requires an "
1669 "Augmented Lagrange Problem class to be used in the simulation.");
1670 formulations.addDocumentation(
1671 "tangential_penalty",
1672 "Node-on-face penalty based frictional contact constraint enforcement. Interpenetration and "
1673 "slip distance for sticking nodes are penalized. Enforcement depends on the penalty "
1674 "magnitudes. High penalties can introduce ill conditioning of the system.");
1675 formulations.addDocumentation(
1676 "mortar",
1677 "Mortar based contact constraint enforcement using Lagrange multipliers. Provides exact "
1678 "enforcement and a variationally consistent formulation. Lagrange multipliers introduce a "
1679 "saddle point character in the system matrix which can have a negative impact on scalability "
1680 "with iterative solvers");
1681 formulations.addDocumentation(
1682 "mortar_penalty",
1683 "Mortar and penalty based contact constraint enforcement. When using an Augmented Lagrange "
1684 "Problem class this provides normal (and tangential) contact constratint enforced up to a "
1685 "user specified tolerances. Without AL the enforcement depends on the penalty magnitudes. "
1686 "High penalties can introduce ill conditioning of the system.");
1687
1688 return formulations;
1689}
1690
1691MooseEnum
1692ContactAction::getSystemEnum()
1693{
1694 return MooseEnum("Constraint", "Constraint");
1695}
1696
1697MooseEnum
1698ContactAction::getSmoothingEnum()
1699{
1700 return MooseEnum("edge_based nodal_normal_based", "");
1701}
1702
1703InputParameters
1704ContactAction::commonParameters()
1705{
1706 InputParameters params = emptyInputParameters();
1707
1708 params.addParam<MooseEnum>("normal_smoothing_method",
1709 ContactAction::getSmoothingEnum(),
1710 "Method to use to smooth normals");
1711 params.addParam<Real>(
1712 "normal_smoothing_distance",
1713 "Distance from edge in parametric coordinates over which to smooth contact normal");
1714
1715 params.addParam<MooseEnum>(
1716 "formulation", ContactAction::getFormulationEnum(), "The contact formulation");
1717
1718 params.addParam<MooseEnum>("model", ContactAction::getModelEnum(), "The contact model to use");
1719
1720 return params;
1721}
contact_userobject_counter
static unsigned int contact_userobject_counter
Definition ContactAction.C:38
registerMooseAction
registerMooseAction("ContactApp", ContactAction, "append_mesh_generator")
contact_mortar_auxkernel_counter
static unsigned int contact_mortar_auxkernel_counter
Definition ContactAction.C:32
contact_action_counter
static unsigned int contact_action_counter
Definition ContactAction.C:41
contact_auxkernel_counter
static unsigned int contact_auxkernel_counter
Definition ContactAction.C:35
emptyInputParameters
InputParameters emptyInputParameters()
mooseInfoRepeated
void mooseInfoRepeated(Args &&... args)
EXEC_TIMESTEP_END
const ExecFlagType EXEC_TIMESTEP_END
EXEC_TIMESTEP_BEGIN
const ExecFlagType EXEC_TIMESTEP_BEGIN
EXEC_INITIAL
const ExecFlagType EXEC_INITIAL
EXEC_LINEAR
const ExecFlagType EXEC_LINEAR
EXEC_NONLINEAR
const ExecFlagType EXEC_NONLINEAR
ActionWarehouse::getActions
std::vector< const T * > getActions()
Action::_mesh
std::shared_ptr< MooseMesh > & _mesh
Action::validParams
static InputParameters validParams()
Action::_app
MooseApp & _app
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::_current_task
const std::string & _current_task
Action::_awh
ActionWarehouse & _awh
AddVariableAction::feType
static libMesh::FEType feType(const InputParameters &params)
AddVariableAction::variableType
static std::string variableType(const libMesh::FEType &fe_type, const bool is_fv=false, const bool is_array=false)
AugmentedLagrangianContactProblemInterface
Class to provide an interface for parameters and routines required to check convergence for the augme...
Definition AugmentedLagrangianContactProblemInterface.h:22
AutomaticContactPairingGenerator::pairSuffix
static std::string pairSuffix(const std::pair< BoundaryName, BoundaryName > &pair)
Name suffix identifying a (primary, secondary) boundary pair, used to build unique object names when ...
Definition AutomaticContactPairingGenerator.C:129
AutomaticContactPairingGenerator::contact_pairs_property
static constexpr auto contact_pairs_property
Name of the mesh meta-data holding the detected contact pairs.
Definition AutomaticContactPairingGenerator.h:30
ContactAction
Action class for creating constraints, kernels, and user objects necessary for mechanical contact.
Definition ContactAction.h:33
ContactAction::addNodeFaceContact
void addNodeFaceContact()
Generate constraints for node to face contact.
Definition ContactAction.C:1517
ContactAction::appendAutomaticPairingGenerator
void appendAutomaticPairingGenerator()
Append the AutomaticContactPairingGenerator that detects contact pairs among _automatic_pairing_bound...
Definition ContactAction.C:1593
ContactAction::_use_dual
bool _use_dual
Whether to use the dual Mortar approach.
Definition ContactAction.h:97
ContactAction::_mortar_dynamics
const bool _mortar_dynamics
Whether mortar dynamic contact constraints are to be used.
Definition ContactAction.h:103
ContactAction::ContactAction
ContactAction(const InputParameters &params)
Definition ContactAction.C:355
ContactAction::getFormulationEnum
static MooseEnum getFormulationEnum()
Get contact formulation.
Definition ContactAction.C:1647
ContactAction::addRelationshipManagers
virtual void addRelationshipManagers(Moose::RelationshipManagerType input_rm_type) override
Definition ContactAction.C:866
ContactAction::_model
const ContactModel _model
Contact model type enum.
Definition ContactAction.h:88
ContactAction::getModelEnum
static MooseEnum getModelEnum()
Get contact model.
Definition ContactAction.C:1635
ContactAction::_bnd_pair_to_mortar_info
std::map< std::pair< BoundaryName, BoundaryName >, const MortarInfo > _bnd_pair_to_mortar_info
Map from boundary pair to mortar user object name.
Definition ContactAction.h:113
ContactAction::getSmoothingEnum
static MooseEnum getSmoothingEnum()
Get smoothing type.
Definition ContactAction.C:1698
ContactAction::addContactPressureAuxKernel
void addContactPressureAuxKernel()
Add single contact pressure auxiliary kernel for various contact action objects.
Definition ContactAction.C:796
ContactAction::pairSuffix
std::string pairSuffix(const std::pair< BoundaryName, BoundaryName > &pair) const
Returns a name suffix encoding the boundary pair for multi-pair mortar setups, or an empty string whe...
Definition ContactAction.C:909
ContactAction::_formulation
const ContactFormulation _formulation
Contact formulation.
Definition ContactAction.h:91
ContactAction::getProximityMethod
static MooseEnum getProximityMethod()
Get proximity method for automatic pairing.
Definition ContactAction.C:1641
ContactAction::getSystemEnum
static MooseEnum getSystemEnum()
Get contact system.
Definition ContactAction.C:1692
ContactAction::addMortarContact
void addMortarContact()
Generate mesh and other Moose objects for Mortar contact.
Definition ContactAction.C:915
ContactAction::removeRepeatedPairs
void removeRepeatedPairs()
Remove repeated contact pairs from _boundary_pairs.
Definition ContactAction.C:535
ContactAction::_automatic_pairing_boundaries
std::vector< BoundaryName > _automatic_pairing_boundaries
List of all possible boundaries for contact for automatic pairing (optional)
Definition ContactAction.h:85
ContactAction::_generate_mortar_mesh
const bool _generate_mortar_mesh
Whether to generate the mortar mesh (useful in a restart simulation e.g.).
Definition ContactAction.h:100
ContactAction::commonParameters
static InputParameters commonParameters()
Define parameters used by multiple contact objects.
Definition ContactAction.C:1704
ContactAction::_boundary_pairs
std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
Primary/Secondary boundary name pairs for mechanical contact.
Definition ContactAction.h:82
ContactAction::_lm_space
const ContactLMSpace _lm_space
Finite element space to use for action-generated mortar Lagrange multiplier variables.
Definition ContactAction.h:94
ContactAction::validParams
static InputParameters validParams()
Definition ContactAction.C:58
ContactAction::automaticPairingGeneratorName
std::string automaticPairingGeneratorName() const
Name of the AutomaticContactPairingGenerator appended by this action.
Definition ContactAction.C:1587
ContactAction::act
virtual void act() override
Definition ContactAction.C:576
ContactAction::getAutomaticContactPairs
void getAutomaticContactPairs()
Fill _boundary_pairs from the contact pairs mesh meta-data of the appended generator.
Definition ContactAction.C:1623
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::applySpecificParameters
void applySpecificParameters(const InputParameters &common, const std::vector< std::string > &include, bool allow_private=false)
InputParameters::addParamNamesToGroup
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
InputParameters::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
InputParameters::addRequiredCoupledVar
void addRequiredCoupledVar(const std::string &name, const std::string &doc_string)
InputParameters::addDeprecatedParam
void addDeprecatedParam(const std::string &name, const T &value, const std::string &doc_string, const std::string &deprecation_message)
InputParameters::transferParam
void transferParam(const InputParameters &source_param, const std::string &name, const std::string &new_name="", const std::string &new_description="")
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
InputParameters::addClassDescription
void addClassDescription(const std::string &doc_string)
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
InputParameters::addCoupledVar
void addCoupledVar(const std::string &name, const std::string &doc_string)
InputParameters::addRangeCheckedParam
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
MooseApp::getMeshGeneratorNames
std::vector< std::string > getMeshGeneratorNames() const
MooseApp::isUltimateMaster
bool isUltimateMaster() const
MooseApp::appendMeshGenerator
const MeshGenerator & appendMeshGenerator(const std::string &type, const std::string &name, InputParameters params)
MooseApp::isRecovering
bool isRecovering() const
MooseApp::useMasterMesh
bool useMasterMesh() const
Action::parameters
const InputParameters & parameters() const
Action::type
const std::string & type() const
Action::name
const std::string & name() const
Action::paramError
void paramError(const std::string &param, Args... args) const
Action::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
Action::mooseError
void mooseError(Args &&... args) const
Action::_name
const std::string & _name
Action::getParam
const T & getParam(const std::string &name) const
Action::mooseInfo
void mooseInfo(Args &&... args) const
Action::isParamValid
bool isParamValid(const std::string &name) const
MortarConstraintBase::validParams
static InputParameters validParams()
MortarConsumerInterface::triangulationParams
static InputParameters triangulationParams()
Action::_factory
Factory & _factory
MooseUtils::shortName
std::string shortName(const std::string &name)
Moose::stringify
std::string stringify(const T &t)
Moose::RelationshipManagerType
RelationshipManagerType
Generated on Thu Oct 22 2026 20:36:10 for https://mooseframework.inl.gov by doxygen 1.9.8