https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected 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 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 mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseInfo (Args &&... args) const
 
void callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) 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)
 

Public Attributes

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

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. More...
 
std::string _registered_identifier
 
std::string _specific_task_name
 
std::set< std::string > _all_tasks
 
ActionWarehouse & _awh
 
const std::string & _current_task
 
std::shared_ptr< MooseMesh > & _mesh
 
std::shared_ptr< MooseMesh > & _displaced_mesh
 
std::shared_ptr< FEProblemBase > & _problem
 
PerfID _act_timer
 
MooseApp & _app
 
Factory & _factory
 
ActionFactory & _action_factory
 
const std::string & _type
 
const std::string & _name
 
const InputParameters & _pars
 
MooseApp & _pg_moose_app
 
const std::string _prefix
 
const Parallel::Communicator & _communicator
 

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 }
Action::paramError
void paramError(const std::string &param, Args... args) const
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Action::Action
Action(const InputParameters &parameters)
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_value_name
const AuxVariableName _gap_value_name
Definition: ThermalContactAction.h:36
ThermalContactAction::_gap_conductivity_name
const AuxVariableName _gap_conductivity_name
Definition: ThermalContactAction.h:37
InputParameters::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
ThermalContactAction::_penetration_var_name
const AuxVariableName _penetration_var_name
Definition: ThermalContactAction.h:35
Action::paramInfo
void paramInfo(const std::string &param, Args... args) const

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 }
ThermalContactAction::addAuxVariables
virtual void addAuxVariables()
Definition: ThermalContactAction.C:249
ThermalContactAction::addSecondaryFluxVector
virtual void addSecondaryFluxVector()
Definition: ThermalContactAction.C:423
ThermalContactAction::addDiracKernels
virtual void addDiracKernels()
Definition: ThermalContactAction.C:324
Action::_current_task
const std::string & _current_task

◆ addAuxKernels()

void ThermalContactAction::addAuxKernels ( )
protectedvirtual

Definition at line 180 of file ThermalContactAction.C.

Referenced by act().

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 }
InputParameters::applySpecificParameters
void applySpecificParameters(const InputParameters &common, const std::vector< std::string > &include, bool allow_private=false)
Action::_factory
Factory & _factory
Action::parameters
const InputParameters & parameters() const
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(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
Action::name
const std::string & name() const
EXEC_LINEAR
const ExecFlagType EXEC_LINEAR
Moose::stringify
std::string stringify(const T &t)
ThermalContactAction::_gap_value_name
const AuxVariableName _gap_value_name
Definition: ThermalContactAction.h:36
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::isParamValid
bool isParamValid(const std::string &name) const
ThermalContactAction::_penetration_var_name
const AuxVariableName _penetration_var_name
Definition: ThermalContactAction.h:35
aux_kenels_counter
static unsigned int aux_kenels_counter
Definition: ThermalContactAction.C:30
EXEC_INITIAL
const ExecFlagType EXEC_INITIAL

◆ addAuxVariables()

void ThermalContactAction::addAuxVariables ( )
protectedvirtual

Definition at line 249 of file ThermalContactAction.C.

Referenced by act().

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 }
Action::_factory
Factory & _factory
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
AddVariableAction::variableType
static std::string variableType(const libMesh::FEType &fe_type, const bool is_fv=false, const bool is_array=false)
ThermalContactAction::_gap_value_name
const AuxVariableName _gap_value_name
Definition: ThermalContactAction.h:36
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
ThermalContactAction::_penetration_var_name
const AuxVariableName _penetration_var_name
Definition: ThermalContactAction.h:35

◆ addBCs()

void ThermalContactAction::addBCs ( )
protectedvirtual

Definition at line 274 of file ThermalContactAction.C.

Referenced by act().

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 }
Action::_factory
Factory & _factory
Action::parameters
const InputParameters & parameters() const
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
ThermalContactAction::_boundary_pairs
const std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
Primary/Secondary boundary name pairs for thermal contact.
Definition: ThermalContactAction.h:40
Action::name
const std::string & name() const
Moose::stringify
std::string stringify(const T &t)
ThermalContactAction::_gap_value_name
const AuxVariableName _gap_value_name
Definition: ThermalContactAction.h:36
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
bcs_counter
static unsigned int bcs_counter
Definition: ThermalContactAction.C:27

◆ addDiracKernels()

void ThermalContactAction::addDiracKernels ( )
protectedvirtual

Definition at line 324 of file ThermalContactAction.C.

Referenced by act().

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 }
InputParameters::applySpecificParameters
void applySpecificParameters(const InputParameters &common, const std::vector< std::string > &include, bool allow_private=false)
Action::_factory
Factory & _factory
Action::parameters
const InputParameters & parameters() const
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
dirac_counter
static unsigned int dirac_counter
Definition: ThermalContactAction.C:24
ThermalContactAction::_boundary_pairs
const std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
Primary/Secondary boundary name pairs for thermal contact.
Definition: ThermalContactAction.h:40
Action::name
const std::string & name() const
Moose::stringify
std::string stringify(const T &t)
Action::_problem
std::shared_ptr< FEProblemBase > & _problem

◆ addMaterials()

void ThermalContactAction::addMaterials ( )
protectedvirtual

Definition at line 349 of file ThermalContactAction.C.

Referenced by act().

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 }
Action::_factory
Factory & _factory
Action::parameters
const InputParameters & parameters() const
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
materials_counter
static unsigned int materials_counter
Definition: ThermalContactAction.C:21
ThermalContactAction::_boundary_pairs
const std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
Primary/Secondary boundary name pairs for thermal contact.
Definition: ThermalContactAction.h:40
Action::name
const std::string & name() const
Moose::stringify
std::string stringify(const T &t)
ThermalContactAction::_gap_value_name
const AuxVariableName _gap_value_name
Definition: ThermalContactAction.h:36
Action::mooseError
void mooseError(Args &&... args) const
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::isParamSetByUser
bool isParamSetByUser(const std::string &name) const

◆ 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 }
Action::_factory
Factory & _factory
Action::parameters
const InputParameters & parameters() const
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
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::addRelationshipManagers
virtual void addRelationshipManagers(Moose::RelationshipManagerType input_rm) override
Definition: ThermalContactAction.C:438

◆ addRelationshipManagers() [2/3]

virtual void Action::addRelationshipManagers
protected

◆ addRelationshipManagers() [3/3]

bool Action::addRelationshipManagers
protected

◆ addSecondaryFluxVector()

void ThermalContactAction::addSecondaryFluxVector ( )
protectedvirtual

Definition at line 423 of file ThermalContactAction.C.

Referenced by act().

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 }
Action::_problem
std::shared_ptr< FEProblemBase > & _problem

◆ 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 }
GapConductanceConstant::actionParameters
static InputParameters actionParameters()
Definition: GapConductanceConstant.C:28
GapConductance::actionParameters
static InputParameters actionParameters()
Definition: GapConductance.C:84
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
Action::validParams
static InputParameters validParams()
AddVariableAction::getNonlinearVariableOrders
static MooseEnum getNonlinearVariableOrders()
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
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)
GeometricSearchInterface::validParams
static InputParameters validParams()

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 Sat Oct 11 2025 20:27:03 for https://mooseframework.inl.gov by   doxygen 1.8.14