ThermalContactAction Class Reference

#include <ThermalContactAction.h>

Inheritance diagram for ThermalContactAction:

Public Member Functions
	ThermalContactAction (const InputParameters &params)
virtual void	act () override

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	addAuxKernels ()
virtual void	addAuxVariables ()
virtual void	addBCs ()
virtual void	addDiracKernels ()
virtual void	addMaterials ()
virtual void	addSlaveFluxVector ()

Protected Attributes
const bool	_quadrature
const MooseEnum	_order
const AuxVariableName	_penetration_var_name
const AuxVariableName	_gap_value_name
const AuxVariableName	_gap_conductivity_name

Detailed Description

Definition at line 16 of file ThermalContactAction.h.

Constructor & Destructor Documentation

ThermalContactAction()

ThermalContactAction::ThermalContactAction

(

const InputParameters &

params

)

Definition at line 93 of file ThermalContactAction.C.

  : Action(params),
    _quadrature(getParam<bool>("quadrature")),
    _order(getParam<MooseEnum>("order")),
    _penetration_var_name(_quadrature ? "qpoint_penetration" : "penetration"),
    _gap_value_name("paired_" + getParam<NonlinearVariableName>("variable")),
    _gap_conductivity_name("paired_k_" + getParam<NonlinearVariableName>("variable"))
{
}

Member Function Documentation

act()

void ThermalContactAction::act ( )

overridevirtual

Definition at line 104 of file ThermalContactAction.C.

{
  if (_current_task == "add_aux_kernel")
    addAuxKernels();
  else if (_current_task == "add_aux_variable")
    addAuxVariables();
  else if (_current_task == "add_bc")
    addBCs();
  else if (_current_task == "add_dirac_kernel")
    addDiracKernels();
  else if (_current_task == "add_material")
    addMaterials();
  else if (_current_task == "add_slave_flux_vector")
    addSlaveFluxVector();
}

addAuxKernels()

void ThermalContactAction::addAuxKernels ( )

protectedvirtual

Definition at line 121 of file ThermalContactAction.C.

{
  // Add gap aux kernel
  {
    InputParameters params = _factory.getValidParams(getParam<std::string>("gap_aux_type"));
 
    params.applySpecificParameters(parameters(),
                                   {"tangential_tolerance",
                                    "normal_smoothing_distance",
                                    "normal_smoothing_method",
                                    "order",
                                    "warnings"});
    params.set<AuxVariableName>("variable") = _gap_value_name;
    params.set<ExecFlagEnum>("execute_on", true) = {EXEC_INITIAL, EXEC_LINEAR};
    params.set<std::vector<BoundaryName>>("boundary") = {getParam<BoundaryName>("slave")};
    params.set<BoundaryName>("paired_boundary") = getParam<BoundaryName>("master");
    params.set<VariableName>("paired_variable") = getParam<NonlinearVariableName>("variable");
 
    _problem->addAuxKernel(getParam<std::string>("gap_aux_type"), "gap_value_" + name(), params);
 
    if (_quadrature)
    {
      params.set<std::vector<BoundaryName>>("boundary") = {getParam<BoundaryName>("master")};
      params.set<BoundaryName>("paired_boundary") = getParam<BoundaryName>("slave");
 
      _problem->addAuxKernel(
          getParam<std::string>("gap_aux_type"), "gap_value_master_" + name(), params);
    }
  }
 
  // Add penetration aux kernel
  {
    InputParameters params = _factory.getValidParams("PenetrationAux");
 
    params.applySpecificParameters(
        parameters(),
        {"tangential_tolerance", "normal_smoothing_distance", "normal_smoothing_method", "order"});
    params.set<AuxVariableName>("variable") = _penetration_var_name;
    params.set<ExecFlagEnum>("execute_on", true) = {EXEC_INITIAL, EXEC_LINEAR};
    params.set<std::vector<BoundaryName>>("boundary") = {getParam<BoundaryName>("slave")};
    params.set<BoundaryName>("paired_boundary") = getParam<BoundaryName>("master");
 
    _problem->addAuxKernel("PenetrationAux", "penetration_" + name(), params);
  }
}

Referenced by act().

addAuxVariables()

void ThermalContactAction::addAuxVariables ( )

protectedvirtual

Definition at line 168 of file ThermalContactAction.C.

{
  // We need to add variables only once per variable name.  However, we don't know how many unique
  // variable names we will have.  So, we'll always add them.
 
  MooseEnum order = getParam<MooseEnum>("order");
  std::string family = "LAGRANGE";
 
  if (_quadrature)
  {
    order = "CONSTANT";
    family = "MONOMIAL";
  }
 
  auto var_type =
      AddVariableAction::determineType(FEType(order, Utility::string_to_enum<FEFamily>(family)), 1);
  auto var_params = _factory.getValidParams(var_type);
  var_params.set<MooseEnum>("order") = order;
  var_params.set<MooseEnum>("family") = family;
 
  _problem->addAuxVariable(var_type, _penetration_var_name, var_params);
  _problem->addAuxVariable(var_type, _gap_value_name, var_params);
}

Referenced by act().

addBCs()

void ThermalContactAction::addBCs ( )

protectedvirtual

Definition at line 193 of file ThermalContactAction.C.

{
  const std::string object_name = getParam<std::string>("type");
  InputParameters params = _factory.getValidParams(object_name);
  params.applyParameters(parameters());
 
  if (_quadrature)
  {
    params.set<BoundaryName>("paired_boundary") = getParam<BoundaryName>("master");
    params.set<bool>("use_displaced_mesh") = true;
  }
  else
  {
    params.set<std::vector<VariableName>>("gap_distance") = {"penetration"};
    params.set<std::vector<VariableName>>("gap_temp") = {_gap_value_name};
  }
 
  params.set<std::vector<BoundaryName>>("boundary") = {getParam<BoundaryName>("slave")};
 
  _problem->addBoundaryCondition(object_name, "gap_bc_" + name(), params);
 
  if (_quadrature)
  {
    // Swap master and slave for this one
    params.set<std::vector<BoundaryName>>("boundary") = {getParam<BoundaryName>("master")};
    params.set<BoundaryName>("paired_boundary") = getParam<BoundaryName>("slave");
 
    _problem->addBoundaryCondition(object_name, "gap_bc_master_" + name(), params);
  }
}

Referenced by act().

addDiracKernels()

void ThermalContactAction::addDiracKernels ( )

protectedvirtual

Definition at line 225 of file ThermalContactAction.C.

{
  if (_quadrature)
    return;
 
  const std::string object_name = "GapHeatPointSourceMaster";
  InputParameters params = _factory.getValidParams(object_name);
  params.applySpecificParameters(parameters(),
                                 {"tangential_tolerance",
                                  "normal_smoothing_distance",
                                  "normal_smoothing_method",
                                  "order",
                                  "slave",
                                  "variable"});
  params.set<BoundaryName>("boundary") = getParam<BoundaryName>("master");
 
  _problem->addDiracKernel(object_name, object_name + "_" + name(), params);
}

Referenced by act().

addMaterials()

void ThermalContactAction::addMaterials ( )

protectedvirtual

Definition at line 245 of file ThermalContactAction.C.

{
  if (getParam<std::string>("type") != "GapHeatTransfer")
    return;
 
  if (parameters().isParamSetByUser("gap_conductance"))
  {
    if (parameters().isParamSetByUser("gap_conductivity") ||
        parameters().isParamSetByUser("gap_conductivity_function"))
      mooseError(
          "Cannot specify both gap_conductance and gap_conductivity or gap_conductivity_function");
 
    const std::string object_type = "GapConductanceConstant";
    InputParameters params = _factory.getValidParams(object_type);
    params.applyParameters(parameters());
    params.set<std::vector<BoundaryName>>("boundary") = {getParam<BoundaryName>("slave")};
    _problem->addMaterial(object_type, name() + "_" + "gap_value", params);
 
    if (_quadrature)
    {
      params.set<std::vector<BoundaryName>>("boundary") = {getParam<BoundaryName>("master")};
      _problem->addMaterial(object_type, name() + "_" + "gap_value_master", params);
    }
  }
  else
  {
    const std::string object_type = "GapConductance";
 
    InputParameters params = _factory.getValidParams(object_type);
    params.applyParameters(parameters(), {"variable"});
 
    params.set<std::vector<VariableName>>("variable") = {
        getParam<NonlinearVariableName>("variable")};
    params.set<std::vector<BoundaryName>>("boundary") = {getParam<BoundaryName>("slave")};
 
    if (_quadrature)
    {
      params.set<BoundaryName>("paired_boundary") = getParam<BoundaryName>("master");
    }
    else
    {
      params.set<std::vector<VariableName>>("gap_temp") = {_gap_value_name};
      params.set<std::vector<VariableName>>("gap_distance") = {"penetration"};
    }
 
    _problem->addMaterial(object_type, name() + "_" + "gap_value", params);
 
    if (_quadrature)
    {
      params.set<BoundaryName>("paired_boundary") = getParam<BoundaryName>("slave");
      params.set<std::vector<BoundaryName>>("boundary") = {getParam<BoundaryName>("master")};
 
      _problem->addMaterial(object_type, name() + "_" + "gap_value_master", params);
    }
  }
}

Referenced by act().

addSlaveFluxVector()

void ThermalContactAction::addSlaveFluxVector ( )

protectedvirtual

Definition at line 303 of file ThermalContactAction.C.

{
  _problem->getNonlinearSystemBase().addVector("slave_flux", false, GHOSTED);
  _problem->getNonlinearSystemBase().zeroVectorForResidual("slave_flux");
 
  // It is risky to apply this optimization to contact problems
  // since the problem configuration may be changed during Jacobian
  // evaluation. We therefore turn it off for all contact problems so that
  // PETSc-3.8.4 or higher will have the same behavior as PETSc-3.8.3 or older.
  if (!_problem->isSNESMFReuseBaseSetbyUser())
    _problem->setSNESMFReuseBase(false, false);
}

Referenced by act().

validParams()

InputParameters ThermalContactAction::validParams ( )

static

Definition at line 29 of file ThermalContactAction.C.

{
  InputParameters params = Action::validParams();
  params.addClassDescription(
      "Action that controls the creation of all of the necessary objects for "
      "calculation of Thermal Contact");
 
  params.addParam<std::string>(
      "gap_aux_type",
      "GapValueAux",
      "A string representing the Moose object that will be used for computing the gap size");
  params.addRequiredParam<NonlinearVariableName>("variable", "The variable for thermal contact");
  params.addRequiredParam<BoundaryName>("master", "The master surface");
  params.addRequiredParam<BoundaryName>("slave", "The slave surface");
  params.addRangeCheckedParam<Real>("tangential_tolerance",
                                    "tangential_tolerance>=0",
                                    "Tangential distance to extend edges of contact surfaces");
  params.addRangeCheckedParam<Real>(
      "normal_smoothing_distance",
      "normal_smoothing_distance>=0 & normal_smoothing_distance<=1",
      "Distance from edge in parametric coordinates over which to smooth contact normal");
  params.addParam<std::string>("normal_smoothing_method",
                               "Method to use to smooth normals (edge_based|nodal_normal_based)");
 
  MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
  params.addParam<MooseEnum>("order", orders, "The finite element order");
 
  params.addParam<bool>(
      "warnings", false, "Whether to output warning messages concerning nodes not being found");
  params.addParam<bool>(
      "quadrature", false, "Whether or not to use quadrature point based gap heat transfer");
 
  params.addParam<std::string>(
      "appended_property_name", "", "Name appended to material properties to make them unique");
  params.addRequiredParam<std::string>(
      "type",
      "A string representing the Moose object that will be used for heat conduction over the gap");
 
  params.addParam<std::vector<VariableName>>("disp_x", "The x displacement");
  params.addParam<std::vector<VariableName>>("disp_y", "The y displacement");
  params.addParam<std::vector<VariableName>>("disp_z", "The z displacement");
  params.addParam<std::vector<VariableName>>(
      "displacements",
      "The displacements appropriate for the simulation geometry and coordinate system");
 
  params.addParam<std::vector<AuxVariableName>>(
      "save_in", "The Auxiliary Variable to (optionally) save the boundary flux in");
  params.addRangeCheckedParam<Real>("gap_conductivity",
                                    1.0,
                                    "gap_conductivity>0",
                                    "The thermal conductivity of the gap material");
  params.addParam<FunctionName>(
      "gap_conductivity_function",
      "Thermal conductivity of the gap material as a function.  Multiplied by gap_conductivity.");
  params.addParam<std::vector<VariableName>>(
      "gap_conductivity_function_variable",
      "Variable to be used in gap_conductivity_function in place of time");
 
  params += GapConductance::actionParameters();
  params += GapConductanceConstant::actionParameters();
 
  return params;
}

Member Data Documentation

_gap_conductivity_name

const AuxVariableName ThermalContactAction::_gap_conductivity_name

protected

Definition at line 36 of file ThermalContactAction.h.

_gap_value_name

const AuxVariableName ThermalContactAction::_gap_value_name

protected

Definition at line 35 of file ThermalContactAction.h.

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

_order

const MooseEnum ThermalContactAction::_order

protected

Definition at line 33 of file ThermalContactAction.h.

_penetration_var_name

const AuxVariableName ThermalContactAction::_penetration_var_name

protected

Definition at line 34 of file ThermalContactAction.h.

Referenced by addAuxKernels(), and addAuxVariables().

_quadrature

const bool ThermalContactAction::_quadrature

protected

Definition at line 32 of file ThermalContactAction.h.

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

---

The documentation for this class was generated from the following files:

• heat_conduction/include/actions/ThermalContactAction.h
• heat_conduction/src/actions/ThermalContactAction.C