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

Constructor & Destructor Documentation

ThermalContactAction()

ThermalContactAction::ThermalContactAction

(

const InputParameters &

params

)

Definition at line 92 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 103 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 120 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 167 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 189 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 221 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 241 of file ThermalContactAction.C.

Referenced by act().

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

addSlaveFluxVector()

void ThermalContactAction::addSlaveFluxVector ( )

protectedvirtual

Definition at line 299 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 34 of file ThermalContactAction.h.

_gap_value_name

const AuxVariableName ThermalContactAction::_gap_value_name

protected

Definition at line 33 of file ThermalContactAction.h.

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

_order

const MooseEnum ThermalContactAction::_order

protected

Definition at line 31 of file ThermalContactAction.h.

_penetration_var_name

const AuxVariableName ThermalContactAction::_penetration_var_name

protected

Definition at line 32 of file ThermalContactAction.h.

Referenced by addAuxKernels(), and addAuxVariables().

_quadrature

const bool ThermalContactAction::_quadrature

protected

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