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
 
virtual const std::string & name () const
 
std::string typeAndName () const
 
std::string errorPrefix (const std::string &error_type) const
 
void callMooseError (std::string msg, const bool with_prefix) const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
const InputParameters & parameters () const
 
MooseObjectName uniqueName () 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 &nm) 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
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void mooseError (Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseInfo (Args &&... args) 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 ()
 

Public Attributes

const ConsoleStream _console
 

Static Public Attributes

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
 
const std::string _type
 
const std::string _name
 
const InputParameters & _pars
 
Factory & _factory
 
ActionFactory & _action_factory
 
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 132 of file ThermalContactAction.C.

133  : Action(params),
134  _quadrature(getParam<bool>("quadrature")),
135  _order(getParam<MooseEnum>("order")),
136  _penetration_var_name(_quadrature ? "qpoint_penetration" : "penetration"),
137  _gap_value_name("paired_" + getParam<NonlinearVariableName>("variable")),
138  _gap_conductivity_name("paired_k_" + getParam<NonlinearVariableName>("variable")),
139  _boundary_pairs(getParam<BoundaryName, BoundaryName>("primary", "secondary"))
140 {
141  if (!params.get<bool>("check_boundary_restricted"))
142  {
143  if (_quadrature)
144  paramInfo(
145  "check_boundary_restricted",
146  "This parameter is set to 'false'. Although thermal contact ",
147  "will be correctly enforced, the contact-related output may have issues ",
148  "in cases where where more than one face of an element belongs to a contact surface ",
149  "because the values from only one of the faces will be reported.");
150  else
151  paramError("check_boundary_restricted",
152  "This parameter cannot be 'false' when 'quadrature=false'");
153  }
154  if (params.isParamSetByUser("penalty") &&
155  getParam<std::string>("type") != "GapPerfectConductance")
156  paramError("penalty",
157  "This parameter should only be set by the user when 'type=GapPerfectConductance'.");
158 }
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
Action::paramError
void paramError(const std::string &param, Args... args) const
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
Action::paramInfo
void paramInfo(const std::string &param, Args... args) const
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 161 of file ThermalContactAction.C.

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

◆ addAuxKernels()

void ThermalContactAction::addAuxKernels ( )
protectedvirtual

Definition at line 178 of file ThermalContactAction.C.

Referenced by act().

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

Referenced by act().

246 {
247  // We need to add variables only once per variable name. However, we don't know how many unique
248  // variable names we will have. So, we'll always add them.
249 
250  auto order = getParam<MooseEnum>("order");
251  std::string family = "LAGRANGE";
252 
253  if (_quadrature)
254  {
255  order = "CONSTANT";
256  family = "MONOMIAL";
257  }
258 
259  auto var_type =
260  AddVariableAction::variableType(FEType(order, Utility::string_to_enum<FEFamily>(family)));
261  auto var_params = _factory.getValidParams(var_type);
262  var_params.set<MooseEnum>("order") = order;
263  var_params.set<MooseEnum>("family") = family;
264 
265  _problem->addAuxVariable(var_type, _penetration_var_name, var_params);
266  _problem->addAuxVariable(var_type, _gap_value_name, var_params);
267 }
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
Action::_factory
Factory & _factory
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 270 of file ThermalContactAction.C.

Referenced by act().

271 {
272  for (const auto & contact_pair : _boundary_pairs)
273  {
274  const std::string object_name = getParam<std::string>("type");
275  InputParameters params = _factory.getValidParams(object_name);
276  params.applyParameters(parameters());
277 
278  if (object_name == "GapPerfectConductance")
279  {
280  params.set<Real>("penalty") = getParam<Real>("penalty");
281  params.set<std::vector<VariableName>>("gap_distance") = {"penetration"};
282  params.set<std::vector<VariableName>>("gap_temp") = {_gap_value_name};
283  params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
284  _problem->addBoundaryCondition(
285  object_name, "gap_bc_" + name() + "_" + Moose::stringify(bcs_counter), params);
286  }
287  else
288  {
289  if (_quadrature)
290  {
291  params.set<BoundaryName>("paired_boundary") = contact_pair.first;
292  params.set<bool>("use_displaced_mesh") = true;
293  }
294  else
295  {
296  params.set<std::vector<VariableName>>("gap_distance") = {"penetration"};
297  params.set<std::vector<VariableName>>("gap_temp") = {_gap_value_name};
298  }
299 
300  params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
301 
302  _problem->addBoundaryCondition(
303  object_name, "gap_bc_" + name() + "_" + Moose::stringify(bcs_counter), params);
304 
305  if (_quadrature)
306  {
307  // Swap primary and secondary for this one
308  params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.first};
309  params.set<BoundaryName>("paired_boundary") = contact_pair.second;
310 
311  _problem->addBoundaryCondition(
312  object_name, "gap_bc_primary_" + name() + "_" + Moose::stringify(bcs_counter), params);
313  }
314  }
315  bcs_counter++;
316  }
317 }
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)
Action::name
virtual const std::string & name() const
Action::_factory
Factory & _factory
ThermalContactAction::_boundary_pairs
const std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
Primary/Secondary boundary name pairs for thermal contact.
Definition: ThermalContactAction.h:40
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
Action::parameters
const InputParameters & parameters() const
bcs_counter
static unsigned int bcs_counter
Definition: ThermalContactAction.C:27

◆ addDiracKernels()

void ThermalContactAction::addDiracKernels ( )
protectedvirtual

Definition at line 320 of file ThermalContactAction.C.

Referenced by act().

321 {
322  if (_quadrature)
323  return;
324 
325  for (const auto & contact_pair : _boundary_pairs)
326  {
327  const std::string object_name = "GapHeatPointSourceMaster";
328  InputParameters params = _factory.getValidParams(object_name);
329  params.applySpecificParameters(parameters(),
330  {"tangential_tolerance",
331  "normal_smoothing_distance",
332  "normal_smoothing_method",
333  "order",
334  "variable"});
335  params.set<BoundaryName>("boundary") = contact_pair.first;
336  params.set<BoundaryName>("secondary") = contact_pair.second;
337 
338  _problem->addDiracKernel(
339  object_name, object_name + "_" + name() + "_" + Moose::stringify(dirac_counter++), params);
340  }
341 }
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)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
Action::name
virtual const std::string & name() const
dirac_counter
static unsigned int dirac_counter
Definition: ThermalContactAction.C:24
Action::_factory
Factory & _factory
ThermalContactAction::_boundary_pairs
const std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
Primary/Secondary boundary name pairs for thermal contact.
Definition: ThermalContactAction.h:40
Moose::stringify
std::string stringify(const T &t)
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::parameters
const InputParameters & parameters() const

◆ addMaterials()

void ThermalContactAction::addMaterials ( )
protectedvirtual

Definition at line 344 of file ThermalContactAction.C.

Referenced by act().

345 {
346  if (getParam<std::string>("type") != "GapHeatTransfer")
347  return;
348 
349  if (parameters().isParamSetByUser("gap_conductance"))
350  {
351  if (parameters().isParamSetByUser("gap_conductivity") ||
352  parameters().isParamSetByUser("gap_conductivity_function"))
353  mooseError(
354  "Cannot specify both gap_conductance and gap_conductivity or gap_conductivity_function");
355 
356  for (const auto & contact_pair : _boundary_pairs)
357  {
358  const std::string object_type = "GapConductanceConstant";
359  InputParameters params = _factory.getValidParams(object_type);
360  params.applyParameters(parameters());
361  params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
362  _problem->addMaterial(object_type,
363  name() + "_" + "gap_value" + "_" + Moose::stringify(materials_counter),
364  params);
365 
366  if (_quadrature)
367  {
368  params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.first};
369  _problem->addMaterial(object_type,
370  name() + "_" + "gap_value_primary" + "_" +
371  Moose::stringify(materials_counter),
372  params);
373  }
374  materials_counter++;
375  }
376  }
377  else
378  {
379  const std::string object_type = "GapConductance";
380 
381  for (const auto & contact_pair : _boundary_pairs)
382  {
383  InputParameters params = _factory.getValidParams(object_type);
384  params.applyParameters(parameters(), {"variable"});
385 
386  params.set<std::vector<VariableName>>("variable") = {
387  getParam<NonlinearVariableName>("variable")};
388  params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
389 
390  if (_quadrature)
391  params.set<BoundaryName>("paired_boundary") = contact_pair.first;
392  else
393  {
394  params.set<std::vector<VariableName>>("gap_temp") = {_gap_value_name};
395  params.set<std::vector<VariableName>>("gap_distance") = {"penetration"};
396  }
397 
398  _problem->addMaterial(object_type,
399  name() + "_" + "gap_value" + "_" + Moose::stringify(materials_counter),
400  params);
401 
402  if (_quadrature)
403  {
404  params.set<BoundaryName>("paired_boundary") = contact_pair.second;
405  params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.first};
406 
407  _problem->addMaterial(object_type,
408  name() + "_" + "gap_value_primary" + "_" +
409  Moose::stringify(materials_counter),
410  params);
411  }
412  materials_counter++;
413  }
414  }
415 }
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
Action::name
virtual const std::string & name() const
Action::_factory
Factory & _factory
ThermalContactAction::_boundary_pairs
const std::vector< std::pair< BoundaryName, BoundaryName > > _boundary_pairs
Primary/Secondary boundary name pairs for thermal contact.
Definition: ThermalContactAction.h:40
Moose::stringify
std::string stringify(const T &t)
ThermalContactAction::_gap_value_name
const AuxVariableName _gap_value_name
Definition: ThermalContactAction.h:36
Action::isParamSetByUser
bool isParamSetByUser(const std::string &nm) const
Action::mooseError
void mooseError(Args &&... args) const
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::parameters
const InputParameters & parameters() const

◆ addRelationshipManagers() [1/3]

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

Reimplemented from Action.

Definition at line 433 of file ThermalContactAction.C.

434 {
435  if (!_quadrature)
436  return;
437 
438  for (const auto & contact_pair : _boundary_pairs)
439  {
440  const auto & object_name = getParam<std::string>("type");
441  auto params = _factory.getValidParams(object_name);
442  params.applyParameters(parameters());
443 
444  params.set<BoundaryName>("paired_boundary") = contact_pair.first;
445  params.set<bool>("use_displaced_mesh") = true;
446  params.set<std::vector<BoundaryName>>("boundary") = {contact_pair.second};
447  addRelationshipManagers(input_rm_type, params);
448  }
449 }
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)
Action::_factory
Factory & _factory
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::parameters
const InputParameters & parameters() const
ThermalContactAction::addRelationshipManagers
virtual void addRelationshipManagers(Moose::RelationshipManagerType input_rm) override
Definition: ThermalContactAction.C:433

◆ addRelationshipManagers() [2/3]

virtual void Action::addRelationshipManagers
protected

◆ addRelationshipManagers() [3/3]

bool Action::addRelationshipManagers
protected

◆ addSecondaryFluxVector()

void ThermalContactAction::addSecondaryFluxVector ( )
protectedvirtual

Definition at line 418 of file ThermalContactAction.C.

Referenced by act().

419 {
420  _problem->getNonlinearSystemBase(/*nl_sys_num=*/0)
421  .addVector("secondary_flux", false, libMesh::GHOSTED);
422  _problem->getNonlinearSystemBase(/*nl_sys_num=*/0).zeroVectorForResidual("secondary_flux");
423 
424  // It is risky to apply this optimization to contact problems
425  // since the problem configuration may be changed during Jacobian
426  // evaluation. We therefore turn it off for all contact problems so that
427  // PETSc-3.8.4 or higher will have the same behavior as PETSc-3.8.3 or older.
428  if (!_problem->isSNESMFReuseBaseSetbyUser())
429  _problem->setSNESMFReuseBase(false, false);
430 }
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.addParamNamesToGroup("primary secondary", "Gap surface definition");
117  params.addParamNamesToGroup(
118  "tangential_tolerance normal_smoothing_distance normal_smoothing_method",
119  "Gap edge and edge normal smoothing");
120  params.addParamNamesToGroup("gap_aux_type secondary_gap_offset mapped_primary_gap_offset",
121  "Gap size");
122  params.addParamNamesToGroup("order quadrature", "Integration");
123  params.addParamNamesToGroup(
124  "gap_conductivity gap_conductivity_function gap_conductivity_function_variable",
125  "Gap conductivity");
126  params.addParamNamesToGroup("save_in check_boundary_restricted warnings",
127  "Diagnostics and debug");
128 
129  return params;
130 }
GapConductanceConstant::actionParameters
static InputParameters actionParameters()
Definition: GapConductanceConstant.C:28
GapConductance::actionParameters
static InputParameters actionParameters()
Definition: GapConductance.C:81
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)

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 Jul 18 2025 13:51:45 for https://mooseframework.inl.gov by   doxygen 1.8.14