ThermalContactAction Class Reference

#include <ThermalContactAction.h>

Inheritance diagram for ThermalContactAction:

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

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 17 of file ThermalContactAction.h.

Constructor & Destructor Documentation

ThermalContactAction()

ThermalContactAction::ThermalContactAction

(

const InputParameters &

params

)

Definition at line 90 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 101 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 118 of file ThermalContactAction.C.

Referenced by act().

{
  // 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);
  }
}

addAuxVariables()

void ThermalContactAction::addAuxVariables ( )

protectedvirtual

Definition at line 165 of file ThermalContactAction.C.

Referenced by act().

{
  // 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";
  }

  _problem->addAuxVariable(_penetration_var_name,
                           FEType(order, Utility::string_to_enum<FEFamily>(family)));

  _problem->addAuxVariable(_gap_value_name,
                           FEType(order, Utility::string_to_enum<FEFamily>(family)));
}

addBCs()

void ThermalContactAction::addBCs ( )

protectedvirtual

Definition at line 187 of file ThermalContactAction.C.

Referenced by act().

{
  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);
  }
}

addDiracKernels()

void ThermalContactAction::addDiracKernels ( )

protectedvirtual

Definition at line 219 of file ThermalContactAction.C.

Referenced by act().

{
  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);
}

addMaterials()

void ThermalContactAction::addMaterials ( )

protectedvirtual

Definition at line 239 of file ThermalContactAction.C.

Referenced by act().

{
  if (getParam<std::string>("type") != "GapHeatTransfer")
    return;

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

addSlaveFluxVector()

void ThermalContactAction::addSlaveFluxVector ( )

protectedvirtual

Definition at line 274 of file ThermalContactAction.C.

Referenced by act().

{
  _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);
}

Member Data Documentation

_gap_conductivity_name

const AuxVariableName ThermalContactAction::_gap_conductivity_name

protected

Definition at line 35 of file ThermalContactAction.h.

_gap_value_name

const AuxVariableName ThermalContactAction::_gap_value_name

protected

Definition at line 34 of file ThermalContactAction.h.

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

_order

const MooseEnum ThermalContactAction::_order

protected

Definition at line 32 of file ThermalContactAction.h.

_penetration_var_name

const AuxVariableName ThermalContactAction::_penetration_var_name

protected

Definition at line 33 of file ThermalContactAction.h.

Referenced by addAuxKernels(), and addAuxVariables().

_quadrature

const bool ThermalContactAction::_quadrature

protected

Definition at line 31 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