https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
ThermalContactAction Class Reference

#include <ThermalContactAction.h>

Inheritance diagram for ThermalContactAction:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 ThermalContactAction (const InputParameters &params)
 
virtual void act () override
 
void timedAct ()
 
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 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 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 Member Functions

virtual void addAuxKernels ()
 
virtual void addAuxVariables ()
 
virtual void addBCs ()
 
virtual void addDiracKernels ()
 
virtual void addMaterials ()
 
virtual void addSecondaryFluxVector ()
 
virtual void addRelationshipManagers (Moose::RelationshipManagerType input_rm) override
 
virtual void addRelationshipManagers (Moose::RelationshipManagerType when_type)
 
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

const bool _quadrature
 
const MooseEnum _order
 
const AuxVariableName _penetration_var_name
 
const AuxVariableName _gap_value_name
 
const AuxVariableName _gap_conductivity_name
 
const std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
 Primary/Secondary boundary name pairs for thermal contact.
 
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

bool addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)
 
virtual std::string meshPropertyPrefix (const std::string &data_name) const
 
const RestartableDataValue & getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const
 
void mooseErrorInternal (Args &&... args) const
 

Static Private Member Functions

static const hit::Node * getHitNode (const InputParameters &params)
 
static std::string messagePrefix (const InputParameters &params, const bool hit_prefix)
 

Private Attributes

const ParallelParamObject & _parent
 
MooseApp & _meta_data_app
 
const MooseObject *const _meta_data_object
 
const MooseBase & _si_moose_base
 
const FEProblemBase * _si_problem
 

Detailed Description

Definition at line 16 of file ThermalContactAction.h.

Constructor & Destructor Documentation

◆ ThermalContactAction()

ThermalContactAction::ThermalContactAction ( const InputParameters &  params)

Definition at line 134 of file ThermalContactAction.C.

135 : Action(params),
136 _quadrature(getParam<bool>("quadrature")),
137 _order(getParam<MooseEnum>("order")),
138 _penetration_var_name(_quadrature ? "qpoint_penetration" : "penetration"),
139 _gap_value_name("paired_" + getParam<NonlinearVariableName>("variable")),
140 _gap_conductivity_name("paired_k_" + getParam<NonlinearVariableName>("variable")),
141 _boundary_pairs(getParam<BoundaryName, BoundaryName>("primary", "secondary"))
142{
143 if (!params.get<bool>("check_boundary_restricted"))
144 {
145 if (_quadrature)
146 paramInfo(
147 "check_boundary_restricted",
148 "This parameter is set to 'false'. Although thermal contact ",
149 "will be correctly enforced, the contact-related output may have issues ",
150 "in cases where where more than one face of an element belongs to a contact surface ",
151 "because the values from only one of the faces will be reported.");
152 else
153 paramError("check_boundary_restricted",
154 "This parameter cannot be 'false' when 'quadrature=false'");
155 }
156 if (params.isParamSetByUser("penalty") &&
157 getParam<std::string>("type") != "GapPerfectConductance")
158 paramError("penalty",
159 "This parameter should only be set by the user when 'type=GapPerfectConductance'.");
160}
InputParameters::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Action::paramInfo
void paramInfo(const std::string &param, Args... args) const
Action::paramError
void paramError(const std::string &param, Args... args) const
Action::getParam
const T & getParam(const std::string &name) const
ThermalContactAction::_boundary_pairs
const std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
Primary/Secondary boundary name pairs for thermal contact.
Definition ThermalContactAction.h:40
ThermalContactAction::_gap_conductivity_name
const AuxVariableName _gap_conductivity_name
Definition ThermalContactAction.h:37
ThermalContactAction::_gap_value_name
const AuxVariableName _gap_value_name
Definition ThermalContactAction.h:36
ThermalContactAction::_penetration_var_name
const AuxVariableName _penetration_var_name
Definition ThermalContactAction.h:35

Member Function Documentation

◆ act()

void ThermalContactAction::act ( )
overridevirtual

Implements Action.

Definition at line 163 of file ThermalContactAction.C.

164{
165 if (_current_task == "add_aux_kernel")
166 addAuxKernels();
167 else if (_current_task == "add_aux_variable")
168 addAuxVariables();
169 else if (_current_task == "add_bc")
170 addBCs();
171 else if (_current_task == "add_dirac_kernel")
172 addDiracKernels();
173 else if (_current_task == "add_material")
174 addMaterials();
175 else if (_current_task == "add_secondary_flux_vector")
176 addSecondaryFluxVector();
177}
Action::_current_task
const std::string & _current_task
ThermalContactAction::addSecondaryFluxVector
virtual void addSecondaryFluxVector()
Definition ThermalContactAction.C:423

◆ addAuxKernels()

void ThermalContactAction::addAuxKernels ( )
protectedvirtual

Definition at line 180 of file ThermalContactAction.C.

181{
182 for (const auto & contact_pair : _boundary_pairs)
183 {
184 // Add gap aux kernel
185 {
186 InputParameters params = _factory.getValidParams(getParam<std::string>("gap_aux_type"));
187
188 params.applySpecificParameters(parameters(),
189 {"tangential_tolerance",
190 "normal_smoothing_distance",
191 "normal_smoothing_method",
192 "order",
193 "warnings",
194 "search_method",
195 "check_boundary_restricted"});
196 params.set<AuxVariableName>("variable") = _gap_value_name;
197 params.set<ExecFlagEnum>("execute_on", true) = {EXEC_INITIAL, EXEC_LINEAR};
198
199 params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
200 params.set<BoundaryName>("paired_boundary") = contact_pair.first;
201 params.set<VariableName>("paired_variable") = getParam<NonlinearVariableName>("variable");
202
203 _problem->addAuxKernel(getParam<std::string>("gap_aux_type"),
204 "gap_value_" + name() + "_" + Moose::stringify(aux_kenels_counter),
205 params);
206
207 if (_quadrature)
208 {
209 params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.first};
210 params.set<BoundaryName>("paired_boundary") = contact_pair.second;
211
212 _problem->addAuxKernel(getParam<std::string>("gap_aux_type"),
213 "gap_value_primary_" + name() + "_" +
214 Moose::stringify(aux_kenels_counter),
215 params);
216 }
217 }
218
219 // Add penetration aux kernel
220 {
221 InputParameters params = _factory.getValidParams("PenetrationAux");
222
223 params.applySpecificParameters(parameters(),
224 {"tangential_tolerance",
225 "normal_smoothing_distance",
226 "normal_smoothing_method",
227 "order",
228 "search_method",
229 "check_boundary_restricted"});
230 params.set<AuxVariableName>("variable") = _penetration_var_name;
231 if (isParamValid("secondary_gap_offset"))
232 params.set<std::vector<VariableName>>("secondary_gap_offset") = {
233 getParam<VariableName>("secondary_gap_offset")};
234 if (isParamValid("mapped_primary_gap_offset"))
235 params.set<std::vector<VariableName>>("mapped_primary_gap_offset") = {
236 getParam<VariableName>("mapped_primary_gap_offset")};
237 params.set<ExecFlagEnum>("execute_on", true) = {EXEC_INITIAL, EXEC_LINEAR};
238 params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
239 params.set<BoundaryName>("paired_boundary") = contact_pair.first;
240
241 _problem->addAuxKernel("PenetrationAux",
242 "penetration_" + name() + "_" + Moose::stringify(aux_kenels_counter++),
243 params);
244 }
245 }
246}
EXEC_INITIAL
const ExecFlagType EXEC_INITIAL
EXEC_LINEAR
const ExecFlagType EXEC_LINEAR
aux_kenels_counter
static unsigned int aux_kenels_counter
Definition ThermalContactAction.C:30
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
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::set
T & set(const std::string &name, bool quiet_mode=false)
Action::parameters
const InputParameters & parameters() const
Action::name
const std::string & name() const
Action::isParamValid
bool isParamValid(const std::string &name) const
Action::_factory
Factory & _factory
Moose::stringify
std::string stringify(const T &t)

Referenced by act().

◆ addAuxVariables()

void ThermalContactAction::addAuxVariables ( )
protectedvirtual

Definition at line 249 of file ThermalContactAction.C.

250{
251 // We need to add variables only once per variable name. However, we don't know how many unique
252 // variable names we will have. So, we'll always add them.
253
254 auto order = getParam<MooseEnum>("order");
255 std::string family = "LAGRANGE";
256
257 if (_quadrature)
258 {
259 order = "CONSTANT";
260 family = "MONOMIAL";
261 }
262
263 auto var_type =
264 AddVariableAction::variableType(FEType(order, Utility::string_to_enum<FEFamily>(family)));
265 auto var_params = _factory.getValidParams(var_type);
266 var_params.set<MooseEnum>("order") = order;
267 var_params.set<MooseEnum>("family") = family;
268
269 _problem->addAuxVariable(var_type, _penetration_var_name, var_params);
270 _problem->addAuxVariable(var_type, _gap_value_name, var_params);
271}
AddVariableAction::variableType
static std::string variableType(const libMesh::FEType &fe_type, const bool is_fv=false, const bool is_array=false)

Referenced by act().

◆ addBCs()

void ThermalContactAction::addBCs ( )
protectedvirtual

Definition at line 274 of file ThermalContactAction.C.

275{
276 for (const auto & contact_pair : _boundary_pairs)
277 {
278 const std::string object_name = getParam<std::string>("type");
279 InputParameters params = _factory.getValidParams(object_name);
280 params.applyParameters(parameters());
281
282 if (object_name == "GapPerfectConductance")
283 {
284 params.set<Real>("penalty") = getParam<Real>("penalty");
285 params.set<std::vector<VariableName>>("gap_distance") = {"penetration"};
286 params.set<std::vector<VariableName>>("gap_temp") = {_gap_value_name};
287 params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
288 _problem->addBoundaryCondition(
289 object_name, "gap_bc_" + name() + "_" + Moose::stringify(bcs_counter), params);
290 }
291 else
292 {
293 if (_quadrature)
294 {
295 params.set<BoundaryName>("paired_boundary") = contact_pair.first;
296 params.set<bool>("use_displaced_mesh") = true;
297 }
298 else
299 {
300 params.set<std::vector<VariableName>>("gap_distance") = {"penetration"};
301 params.set<std::vector<VariableName>>("gap_temp") = {_gap_value_name};
302 }
303
304 params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
305
306 _problem->addBoundaryCondition(
307 object_name, "gap_bc_" + name() + "_" + Moose::stringify(bcs_counter), params);
308
309 if (_quadrature)
310 {
311 // Swap primary and secondary for this one
312 params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.first};
313 params.set<BoundaryName>("paired_boundary") = contact_pair.second;
314
315 _problem->addBoundaryCondition(
316 object_name, "gap_bc_primary_" + name() + "_" + Moose::stringify(bcs_counter), params);
317 }
318 }
319 bcs_counter++;
320 }
321}
bcs_counter
static unsigned int bcs_counter
Definition ThermalContactAction.C:27
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

Referenced by act().

◆ addDiracKernels()

void ThermalContactAction::addDiracKernels ( )
protectedvirtual

Definition at line 324 of file ThermalContactAction.C.

325{
326 if (_quadrature)
327 return;
328
329 for (const auto & contact_pair : _boundary_pairs)
330 {
331 const std::string object_name = "GapHeatPointSourceMaster";
332 InputParameters params = _factory.getValidParams(object_name);
333 params.applySpecificParameters(parameters(),
334 {"tangential_tolerance",
335 "normal_smoothing_distance",
336 "normal_smoothing_method",
337 "order",
338 "search_method",
339 "variable"});
340 params.set<BoundaryName>("boundary") = contact_pair.first;
341 params.set<BoundaryName>("secondary") = contact_pair.second;
342
343 _problem->addDiracKernel(
344 object_name, object_name + "_" + name() + "_" + Moose::stringify(dirac_counter++), params);
345 }
346}
dirac_counter
static unsigned int dirac_counter
Definition ThermalContactAction.C:24

Referenced by act().

◆ addMaterials()

void ThermalContactAction::addMaterials ( )
protectedvirtual

Definition at line 349 of file ThermalContactAction.C.

350{
351 if (getParam<std::string>("type") != "GapHeatTransfer")
352 return;
353
354 if (parameters().isParamSetByUser("gap_conductance"))
355 {
356 if (parameters().isParamSetByUser("gap_conductivity") ||
357 parameters().isParamSetByUser("gap_conductivity_function"))
358 mooseError(
359 "Cannot specify both gap_conductance and gap_conductivity or gap_conductivity_function");
360
361 for (const auto & contact_pair : _boundary_pairs)
362 {
363 const std::string object_type = "GapConductanceConstant";
364 InputParameters params = _factory.getValidParams(object_type);
365 params.applyParameters(parameters());
366 params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
367 _problem->addMaterial(object_type,
368 name() + "_" + "gap_value" + "_" + Moose::stringify(materials_counter),
369 params);
370
371 if (_quadrature)
372 {
373 params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.first};
374 _problem->addMaterial(object_type,
375 name() + "_" + "gap_value_primary" + "_" +
376 Moose::stringify(materials_counter),
377 params);
378 }
379 materials_counter++;
380 }
381 }
382 else
383 {
384 const std::string object_type = "GapConductance";
385
386 for (const auto & contact_pair : _boundary_pairs)
387 {
388 InputParameters params = _factory.getValidParams(object_type);
389 params.applyParameters(parameters(), {"variable"});
390
391 params.set<std::vector<VariableName>>("variable") = {
392 getParam<NonlinearVariableName>("variable")};
393 params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
394
395 if (_quadrature)
396 params.set<BoundaryName>("paired_boundary") = contact_pair.first;
397 else
398 {
399 params.set<std::vector<VariableName>>("gap_temp") = {_gap_value_name};
400 params.set<std::vector<VariableName>>("gap_distance") = {"penetration"};
401 }
402
403 _problem->addMaterial(object_type,
404 name() + "_" + "gap_value" + "_" + Moose::stringify(materials_counter),
405 params);
406
407 if (_quadrature)
408 {
409 params.set<BoundaryName>("paired_boundary") = contact_pair.second;
410 params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.first};
411
412 _problem->addMaterial(object_type,
413 name() + "_" + "gap_value_primary" + "_" +
414 Moose::stringify(materials_counter),
415 params);
416 }
417 materials_counter++;
418 }
419 }
420}
materials_counter
static unsigned int materials_counter
Definition ThermalContactAction.C:21
Action::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
Action::mooseError
void mooseError(Args &&... args) const

Referenced by act().

◆ addRelationshipManagers() [1/3]

void ThermalContactAction::addRelationshipManagers ( Moose::RelationshipManagerType  input_rm)
overrideprotectedvirtual

Reimplemented from Action.

Definition at line 438 of file ThermalContactAction.C.

439{
440 if (!_quadrature)
441 return;
442
443 for (const auto & contact_pair : _boundary_pairs)
444 {
445 const auto & object_name = getParam<std::string>("type");
446 auto params = _factory.getValidParams(object_name);
447 params.applyParameters(parameters());
448
449 params.set<BoundaryName>("paired_boundary") = contact_pair.first;
450 params.set<bool>("use_displaced_mesh") = true;
451 params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
452 addRelationshipManagers(input_rm_type, params);
453 }
454}
ThermalContactAction::addRelationshipManagers
virtual void addRelationshipManagers(Moose::RelationshipManagerType input_rm) override
Definition ThermalContactAction.C:438

Referenced by addRelationshipManagers().

◆ addRelationshipManagers() [2/3]

virtual void Action::addRelationshipManagers ( Moose::RelationshipManagerType  when_type)
protectedvirtual

Reimplemented from Action.

◆ addRelationshipManagers() [3/3]

bool Action::addRelationshipManagers ( Moose::RelationshipManagerType  when_type,
const InputParameters &  moose_object_pars 
)
protected

◆ addSecondaryFluxVector()

void ThermalContactAction::addSecondaryFluxVector ( )
protectedvirtual

Definition at line 423 of file ThermalContactAction.C.

424{
425 _problem->getNonlinearSystemBase(/*nl_sys_num=*/0)
426 .addVector("secondary_flux", false, libMesh::GHOSTED);
427 _problem->getNonlinearSystemBase(/*nl_sys_num=*/0).zeroVectorForResidual("secondary_flux");
428
429 // It is risky to apply this optimization to contact problems
430 // since the problem configuration may be changed during Jacobian
431 // evaluation. We therefore turn it off for all contact problems so that
432 // PETSc-3.8.4 or higher will have the same behavior as PETSc-3.8.3 or older.
433 if (!_problem->isSNESMFReuseBaseSetbyUser())
434 _problem->setSNESMFReuseBase(false, false);
435}

Referenced by act().

◆ validParams()

InputParameters ThermalContactAction::validParams ( )
static

Definition at line 40 of file ThermalContactAction.C.

41{
42 InputParameters params = Action::validParams();
43 params.addClassDescription(
44 "Action that controls the creation of all of the necessary objects for "
45 "calculation of Thermal Contact");
46
47 params.addParam<std::string>(
48 "gap_aux_type",
49 "GapValueAux",
50 "A string representing the Moose object that will be used for computing the gap size");
51 params.addRequiredParam<NonlinearVariableName>("variable", "The variable for thermal contact");
52 params.addParam<std::vector<BoundaryName>>(
53 "primary", "The list of boundary IDs referring to primary sidesets");
54 params.addRequiredParam<std::vector<BoundaryName>>(
55 "secondary", "The list of boundary IDs referring to secondary sidesets");
56 params.addRangeCheckedParam<Real>("tangential_tolerance",
57 "tangential_tolerance>=0",
58 "Tangential distance to extend edges of contact surfaces");
59 params.addRangeCheckedParam<Real>(
60 "normal_smoothing_distance",
61 "normal_smoothing_distance>=0 & normal_smoothing_distance<=1",
62 "Distance from edge in parametric coordinates over which to smooth contact normal");
63 params.addParam<std::string>("normal_smoothing_method",
64 "Method to use to smooth normals (edge_based|nodal_normal_based)");
65
66 MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
67 params.addParam<MooseEnum>("order", orders, "The finite element order");
68
69 params.addParam<bool>(
70 "warnings", false, "Whether to output warning messages concerning nodes not being found");
71 params.addParam<bool>(
72 "quadrature", false, "Whether or not to use quadrature point based gap heat transfer");
73 params.addRangeCheckedParam<Real>("penalty",
74 1e3,
75 "penalty>0",
76 "The penalty used in the residual and Jacobian calculations "
77 "when using the GapPerfectConductance model");
78 params.addParam<std::string>(
79 "appended_property_name", "", "Name appended to material properties to make them unique");
80 params.addRequiredParam<std::string>(
81 "type",
82 "A string representing the Moose object that will be used for heat conduction over the gap");
83
84 params.addParam<std::vector<VariableName>>(
85 "displacements",
86 "The displacements appropriate for the simulation geometry and coordinate system");
87
88 params.addParam<std::vector<AuxVariableName>>(
89 "save_in", {}, "The Auxiliary Variable to (optionally) save the boundary flux in");
90 params.addRangeCheckedParam<Real>("gap_conductivity",
91 1.0,
92 "gap_conductivity>0",
93 "The thermal conductivity of the gap material");
94 params.addParam<FunctionName>(
95 "gap_conductivity_function",
96 "Thermal conductivity of the gap material as a function. Multiplied by gap_conductivity.");
97 params.addParam<std::vector<VariableName>>(
98 "gap_conductivity_function_variable",
99 "Variable to be used in gap_conductivity_function in place of time");
100 params.addParam<VariableName>("secondary_gap_offset",
101 "Offset to gap distance from secondary side");
102 params.addParam<VariableName>("mapped_primary_gap_offset",
103 "Offset to gap distance mapped from primary side");
104 params.addParam<bool>(
105 "check_boundary_restricted",
106 true,
107 "Whether to check for multiple element sides on the boundary for the boundary restricted, "
108 "element aux variable set up for thermal contact enforcement. Setting this to false will "
109 "allow contribution to a single element's elemental value(s) from multiple boundary sides "
110 "on the same element (example: when the restricted boundary exists on two or more sides "
111 "of an element, such as at a corner of a mesh");
112
113 params += GapConductance::actionParameters();
114 params += GapConductanceConstant::actionParameters();
115
116 params += GeometricSearchInterface::validParams();
117
118 params.addParamNamesToGroup("primary secondary", "Gap surface definition");
119 params.addParamNamesToGroup(
120 "tangential_tolerance normal_smoothing_distance normal_smoothing_method",
121 "Gap edge and edge normal smoothing");
122 params.addParamNamesToGroup("gap_aux_type secondary_gap_offset mapped_primary_gap_offset",
123 "Gap size");
124 params.addParamNamesToGroup("order quadrature", "Integration");
125 params.addParamNamesToGroup(
126 "gap_conductivity gap_conductivity_function gap_conductivity_function_variable",
127 "Gap conductivity");
128 params.addParamNamesToGroup("save_in check_boundary_restricted warnings",
129 "Diagnostics and debug");
130
131 return params;
132}
Action::validParams
static InputParameters validParams()
AddVariableAction::getNonlinearVariableOrders
static MooseEnum getNonlinearVariableOrders()
GapConductanceConstant::actionParameters
static InputParameters actionParameters()
Definition GapConductanceConstant.C:28
GapConductance::actionParameters
static InputParameters actionParameters()
Definition GapConductance.C:84
GeometricSearchInterface::validParams
static InputParameters validParams()
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
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::addRangeCheckedParam
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)

Member Data Documentation

◆ _boundary_pairs

const std::vector<std::pair<BoundaryName, BoundaryName> > ThermalContactAction::_boundary_pairs
protected

Primary/Secondary boundary name pairs for thermal contact.

Definition at line 40 of file ThermalContactAction.h.

Referenced by addAuxKernels(), addBCs(), addDiracKernels(), addMaterials(), and addRelationshipManagers().

◆ _gap_conductivity_name

const AuxVariableName ThermalContactAction::_gap_conductivity_name
protected

Definition at line 37 of file ThermalContactAction.h.

◆ _gap_value_name

const AuxVariableName ThermalContactAction::_gap_value_name
protected

Definition at line 36 of file ThermalContactAction.h.

Referenced by addAuxKernels(), addAuxVariables(), addBCs(), and addMaterials().

◆ _order

const MooseEnum ThermalContactAction::_order
protected

Definition at line 34 of file ThermalContactAction.h.

◆ _penetration_var_name

const AuxVariableName ThermalContactAction::_penetration_var_name
protected

Definition at line 35 of file ThermalContactAction.h.

Referenced by addAuxKernels(), and addAuxVariables().

◆ _quadrature

const bool ThermalContactAction::_quadrature
protected

Definition at line 33 of file ThermalContactAction.h.

Referenced by addAuxKernels(), addAuxVariables(), addBCs(), addDiracKernels(), addMaterials(), addRelationshipManagers(), and ThermalContactAction().

The documentation for this class was generated from the following files:
Generated on Fri Sep 11 2026 20:39:38 for https://mooseframework.inl.gov by doxygen 1.9.8