GapHeatTransfer Class Reference

Generic gap heat transfer model, with h_gap = h_conduction + h_contact + h_radiation. More...

#include <GapHeatTransfer.h>

Inheritance diagram for GapHeatTransfer:

Public Member Functions
	GapHeatTransfer (const InputParameters &parameters)
virtual void	initialSetup () override

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual Real	computeQpResidual () override
virtual Real	computeQpJacobian () override
virtual Real	computeQpOffDiagJacobian (unsigned jvar) override
virtual Real	gapLength () const
virtual Real	dgapLength (Real normalComponent) const
virtual Real	computeSlaveFluxContribution (Real grad_t)
virtual void	computeGapValues ()

Protected Attributes
GapConductance::GAP_GEOMETRY &	_gap_geometry_type
const bool	_quadrature
NumericVector< Number > *	_slave_flux
const MaterialProperty< Real > &	_gap_conductance
const MaterialProperty< Real > &	_gap_conductance_dT
const Real	_min_gap
const unsigned int	_min_gap_order
const Real	_max_gap
Real	_gap_temp
Real	_gap_distance
Real	_radius
Real	_r1
Real	_r2
Real	_edge_multiplier
	This is a factor that is used to gradually taper down the conductance if the contact point is off the face and tangential_tolerance is nonzero. More...
bool	_has_info
std::vector< unsigned int >	_disp_vars
const VariableValue &	_gap_distance_value
const VariableValue &	_gap_temp_value
PenetrationLocator *	_penetration_locator
const bool	_warnings
Point &	_p1
Point &	_p2

Detailed Description

Generic gap heat transfer model, with h_gap = h_conduction + h_contact + h_radiation.

Definition at line 24 of file GapHeatTransfer.h.

Constructor & Destructor Documentation

GapHeatTransfer()

GapHeatTransfer::GapHeatTransfer

(

const InputParameters &

parameters

)

Definition at line 90 of file GapHeatTransfer.C.

  : IntegratedBC(parameters),
    _gap_geometry_type(declareRestartableData<GapConductance::GAP_GEOMETRY>("gap_geometry_type",
                                                                            GapConductance::PLATE)),
    _quadrature(getParam<bool>("quadrature")),
    _slave_flux(!_quadrature ? &_sys.getVector("slave_flux") : NULL),
    _gap_conductance(getMaterialProperty<Real>("gap_conductance" +
                                               getParam<std::string>("appended_property_name"))),
    _gap_conductance_dT(getMaterialProperty<Real>(
        "gap_conductance" + getParam<std::string>("appended_property_name") + "_dT")),
    _min_gap(getParam<Real>("min_gap")),
    _min_gap_order(getParam<unsigned int>("min_gap_order")),
    _max_gap(getParam<Real>("max_gap")),
    _gap_temp(0),
    _gap_distance(std::numeric_limits<Real>::max()),
    _edge_multiplier(1.0),
    _has_info(false),
    _disp_vars(3, libMesh::invalid_uint),
    _gap_distance_value(_quadrature ? _zero : coupledValue("gap_distance")),
    _gap_temp_value(_quadrature ? _zero : coupledValue("gap_temp")),
    _penetration_locator(
        !_quadrature ? NULL
                     : &getQuadraturePenetrationLocator(
                           parameters.get<BoundaryName>("paired_boundary"),
                           getParam<std::vector<BoundaryName>>("boundary")[0],
                           Utility::string_to_enum<Order>(parameters.get<MooseEnum>("order")))),
    _warnings(getParam<bool>("warnings")),
    _p1(declareRestartableData<Point>("cylinder_axis_point_1", Point(0, 1, 0))),
    _p2(declareRestartableData<Point>("cylinder_axis_point_2", Point(0, 0, 0)))
{
  if (isParamValid("displacements"))
  {
    // modern parameter scheme for displacements
    for (unsigned int i = 0; i < coupledComponents("displacements"); ++i)
      _disp_vars[i] = coupled("displacements", i);
  }
  else
  {
    // Legacy parameter scheme for displacements
    if (isParamValid("disp_x"))
      _disp_vars[0] = coupled("disp_x");
    if (isParamValid("disp_y"))
      _disp_vars[1] = coupled("disp_y");
    if (isParamValid("disp_z"))
      _disp_vars[2] = coupled("disp_z");
 
    // TODO: these are only used in one Bison test. Deprecate soon!
  }
 
  if (_quadrature)
  {
    if (!parameters.isParamValid("paired_boundary"))
      mooseError(std::string("No 'paired_boundary' provided for ") + _name);
  }
  else
  {
    if (!isCoupled("gap_distance"))
      mooseError(std::string("No 'gap_distance' provided for ") + _name);
 
    if (!isCoupled("gap_temp"))
      mooseError(std::string("No 'gap_temp' provided for ") + _name);
  }
}

Member Function Documentation

computeGapValues()

void GapHeatTransfer::computeGapValues ( )

protectedvirtual

Definition at line 288 of file GapHeatTransfer.C.

{
  if (!_quadrature)
  {
    _has_info = true;
    _gap_temp = _gap_temp_value[_qp];
    _gap_distance = _gap_distance_value[_qp];
  }
  else
  {
    Node * qnode = _mesh.getQuadratureNode(_current_elem, _current_side, _qp);
    PenetrationInfo * pinfo = _penetration_locator->_penetration_info[qnode->id()];
 
    _gap_temp = 0.0;
    _gap_distance = std::numeric_limits<Real>::max();
    _has_info = false;
    _edge_multiplier = 1.0;
 
    if (pinfo)
    {
      _gap_distance = pinfo->_distance;
      _has_info = true;
 
      const Elem * slave_side = pinfo->_side;
      std::vector<std::vector<Real>> & slave_side_phi = pinfo->_side_phi;
      _gap_temp = _variable->getValue(slave_side, slave_side_phi);
 
      Real tangential_tolerance = _penetration_locator->getTangentialTolerance();
      if (tangential_tolerance != 0.0)
      {
        _edge_multiplier = 1.0 - pinfo->_tangential_distance / tangential_tolerance;
        if (_edge_multiplier < 0.0)
          _edge_multiplier = 0.0;
      }
    }
    else
    {
      if (_warnings)
        mooseWarning("No gap value information found for node ",
                     qnode->id(),
                     " on processor ",
                     processor_id());
    }
  }
 
  GapConductance::computeGapRadii(
      _gap_geometry_type, _q_point[_qp], _p1, _p2, _gap_distance, _normals[_qp], _r1, _r2, _radius);
}

Referenced by computeQpJacobian(), computeQpOffDiagJacobian(), and computeQpResidual().

computeQpJacobian()

Real GapHeatTransfer::computeQpJacobian ( )

overrideprotectedvirtual

Definition at line 194 of file GapHeatTransfer.C.

{
  computeGapValues();
 
  if (!_has_info)
    return 0.0;
 
  return _test[_i][_qp] *
         ((_u[_qp] - _gap_temp) * _edge_multiplier * _gap_conductance_dT[_qp] +
          _edge_multiplier * _gap_conductance[_qp]) *
         _phi[_j][_qp];
}

computeQpOffDiagJacobian()

Real GapHeatTransfer::computeQpOffDiagJacobian ( unsigned  jvar )

overrideprotectedvirtual

Definition at line 208 of file GapHeatTransfer.C.

{
  computeGapValues();
 
  if (!_has_info)
    return 0.0;
 
  unsigned int coupled_component;
  bool active = false;
  for (coupled_component = 0; coupled_component < _disp_vars.size(); ++coupled_component)
    if (jvar == _disp_vars[coupled_component])
    {
      active = true;
      break;
    }
 
  Real dRdx = 0.0;
  if (active)
  {
    // Compute dR/du_[xyz]
    // Residual is based on
    //   h_gap = h_conduction() + h_contact() + h_radiation();
    //   grad_t = (_u[_qp] - _gap_temp) * h_gap;
    // So we need
    //   (_u[_qp] - _gap_temp) * (dh_gap/du_[xyz]);
    // Assuming dh_contact/du_[xyz] = dh_radiation/du_[xyz] = 0,
    //   we need dh_conduction/du_[xyz]
    // Given
    //   h_conduction = gapK / gapLength, then
    //   dh_conduction/du_[xyz] = -gapK/gapLength^2 * dgapLength/du_[xyz]
    // Given
    //   gapLength = ((u_x-m_x)^2+(u_y-m_y)^2+(u_z-m_z)^2)^1/2
    // where m_[xyz] is the master coordinate, then
    //   dGapLength/du_[xyz] = 1/2*((u_x-m_x)^2+(u_y-m_y)^2+(u_z-m_z)^2)^(-1/2)*2*(u_[xyz]-m_[xyz])
    //                       = (u_[xyz]-m_[xyz])/gapLength
    // This is the normal vector.
 
    const Real gapL = gapLength();
 
    // THIS IS NOT THE NORMAL WE NEED.
    // WE NEED THE NORMAL FROM THE CONSTRAINT, THE NORMAL FROM THE
    // MASTER SURFACE.  HOWEVER, THIS IS TRICKY SINCE THE NORMAL
    // FROM THE MASTER SURFACE WAS COMPUTED FOR A POINT ASSOCIATED
    // WITH A SLAVE NODE.  NOW WE ARE AT A SLAVE INTEGRATION POINT.
    //
    // HOW DO WE GET THE NORMAL WE NEED?
    //
    // Until we have the normal we need,
    //   we'll hope that the one we have is close to the negative of the one we need.
    const Point & normal(_normals[_qp]);
 
    const Real dgap = dgapLength(-normal(coupled_component));
    dRdx = -(_u[_qp] - _gap_temp) * _edge_multiplier * _gap_conductance[_qp] *
           GapConductance::gapAttenuation(gapL, _min_gap, _min_gap_order) * dgap;
  }
  return _test[_i][_qp] * dRdx * _phi[_j][_qp];
}

computeQpResidual()

Real GapHeatTransfer::computeQpResidual ( )

overrideprotectedvirtual

Definition at line 166 of file GapHeatTransfer.C.

{
  computeGapValues();
 
  if (!_has_info)
    return 0.0;
 
  Real grad_t = (_u[_qp] - _gap_temp) * _edge_multiplier * _gap_conductance[_qp];
 
  // This is keeping track of this residual contribution so it can be used as the flux on the other
  // side of the gap.
  if (!_quadrature)
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mutex);
    const Real slave_flux = computeSlaveFluxContribution(grad_t);
    _slave_flux->add(_var.dofIndices()[_i], slave_flux);
  }
 
  return _test[_i][_qp] * grad_t;
}

computeSlaveFluxContribution()

Real GapHeatTransfer::computeSlaveFluxContribution ( Real  grad_t )

protectedvirtual

Definition at line 188 of file GapHeatTransfer.C.

{
  return _coord[_qp] * _JxW[_qp] * _test[_i][_qp] * grad_t;
}

Referenced by computeQpResidual().

dgapLength()

Real GapHeatTransfer::dgapLength ( Real  normalComponent ) const

protectedvirtual

Definition at line 276 of file GapHeatTransfer.C.

{
  const Real gap_L = gapLength();
  Real dgap = 0.0;
 
  if (_min_gap <= gap_L && gap_L <= _max_gap)
    dgap = normalComponent;
 
  return dgap;
}

Referenced by computeQpOffDiagJacobian().

gapLength()

Real GapHeatTransfer::gapLength ( ) const

protectedvirtual

Definition at line 267 of file GapHeatTransfer.C.

{
  if (_has_info)
    return GapConductance::gapLength(_gap_geometry_type, _radius, _r1, _r2, _max_gap);
 
  return 1.0;
}

Referenced by computeQpOffDiagJacobian(), and dgapLength().

initialSetup()

void GapHeatTransfer::initialSetup ( )

overridevirtual

Definition at line 155 of file GapHeatTransfer.C.

{
  GapConductance::setGapGeometryParameters(_pars,
                                           _assembly.coordSystem(),
                                           _fe_problem.getAxisymmetricRadialCoord(),
                                           _gap_geometry_type,
                                           _p1,
                                           _p2);
}

validParams()

InputParameters GapHeatTransfer::validParams ( )

static

Definition at line 27 of file GapHeatTransfer.C.

{
  InputParameters params = IntegratedBC::validParams();
  params.addClassDescription("Transfers heat across a gap between two "
                             "surfaces dependent on the gap geometry specified.");
  params.addParam<std::string>(
      "appended_property_name", "", "Name appended to material properties to make them unique");
 
  // Common
  params.addParam<Real>("min_gap", 1.0e-6, "A minimum gap size");
  params.addParam<Real>("max_gap", 1.0e6, "A maximum gap size");
  params.addRangeCheckedParam<unsigned int>(
      "min_gap_order", 0, "min_gap_order<=1", "Order of the Taylor expansion below min_gap");
 
  // Deprecated parameter
  MooseEnum coord_types("default XYZ cyl", "default");
  params.addDeprecatedParam<MooseEnum>(
      "coord_type",
      coord_types,
      "Gap calculation type (default or XYZ).",
      "The functionality of this parameter is replaced by 'gap_geometry_type'.");
 
  MooseEnum gap_geom_types("PLATE CYLINDER SPHERE");
  params.addParam<MooseEnum>("gap_geometry_type",
                             gap_geom_types,
                             "Gap calculation type. Choices are: " + gap_geom_types.getRawNames());
 
  params.addParam<RealVectorValue>("cylinder_axis_point_1",
                                   "Start point for line defining cylindrical axis");
  params.addParam<RealVectorValue>("cylinder_axis_point_2",
                                   "End point for line defining cylindrical axis");
  params.addParam<RealVectorValue>("sphere_origin", "Origin for sphere geometry");
 
  // Quadrature based
  params.addParam<bool>("quadrature",
                        false,
                        "Whether or not to do Quadrature point based gap heat "
                        "transfer.  If this is true then gap_distance and "
                        "gap_temp should NOT be provided (and will be "
                        "ignored) however paired_boundary IS then required.");
  params.addParam<BoundaryName>("paired_boundary", "The boundary to be penetrated");
 
  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.addCoupledVar("disp_x", "The x displacement");
  params.addCoupledVar("disp_y", "The y displacement");
  params.addCoupledVar("disp_z", "The z displacement");
 
  params.addCoupledVar(
      "displacements",
      "The displacements appropriate for the simulation geometry and coordinate system");
 
  // Node based options
  params.addCoupledVar("gap_distance", "Distance across the gap");
  params.addCoupledVar("gap_temp", "Temperature on the other side of the gap");
 
  return params;
}

Member Data Documentation

_disp_vars

std::vector<unsigned int> GapHeatTransfer::_disp_vars

protected

Definition at line 70 of file GapHeatTransfer.h.

Referenced by computeQpOffDiagJacobian(), and GapHeatTransfer().

_edge_multiplier

Real GapHeatTransfer::_edge_multiplier

protected

This is a factor that is used to gradually taper down the conductance if the contact point is off the face and tangential_tolerance is nonzero.

Definition at line 66 of file GapHeatTransfer.h.

Referenced by computeGapValues(), computeQpJacobian(), computeQpOffDiagJacobian(), and computeQpResidual().

_gap_conductance

const MaterialProperty<Real>& GapHeatTransfer::_gap_conductance

protected

Definition at line 49 of file GapHeatTransfer.h.

Referenced by computeQpJacobian(), computeQpOffDiagJacobian(), and computeQpResidual().

_gap_conductance_dT

const MaterialProperty<Real>& GapHeatTransfer::_gap_conductance_dT

protected

Definition at line 50 of file GapHeatTransfer.h.

Referenced by computeQpJacobian().

_gap_distance

Real GapHeatTransfer::_gap_distance

protected

Definition at line 57 of file GapHeatTransfer.h.

Referenced by computeGapValues().

_gap_distance_value

const VariableValue& GapHeatTransfer::_gap_distance_value

protected

Definition at line 72 of file GapHeatTransfer.h.

Referenced by computeGapValues().

_gap_geometry_type

GapConductance::GAP_GEOMETRY& GapHeatTransfer::_gap_geometry_type

protected

Definition at line 43 of file GapHeatTransfer.h.

Referenced by computeGapValues(), gapLength(), and initialSetup().

_gap_temp

Real GapHeatTransfer::_gap_temp

protected

Definition at line 56 of file GapHeatTransfer.h.

Referenced by computeGapValues(), computeQpJacobian(), computeQpOffDiagJacobian(), and computeQpResidual().

_gap_temp_value

const VariableValue& GapHeatTransfer::_gap_temp_value

protected

Definition at line 73 of file GapHeatTransfer.h.

Referenced by computeGapValues().

_has_info

bool GapHeatTransfer::_has_info

protected

Definition at line 68 of file GapHeatTransfer.h.

Referenced by computeGapValues(), computeQpJacobian(), computeQpOffDiagJacobian(), computeQpResidual(), and gapLength().

_max_gap

const Real GapHeatTransfer::_max_gap

protected

Definition at line 54 of file GapHeatTransfer.h.

Referenced by dgapLength(), and gapLength().

_min_gap

const Real GapHeatTransfer::_min_gap

protected

Definition at line 52 of file GapHeatTransfer.h.

Referenced by computeQpOffDiagJacobian(), and dgapLength().

_min_gap_order

const unsigned int GapHeatTransfer::_min_gap_order

protected

Definition at line 53 of file GapHeatTransfer.h.

Referenced by computeQpOffDiagJacobian().

_p1

Point& GapHeatTransfer::_p1

protected

Definition at line 78 of file GapHeatTransfer.h.

Referenced by computeGapValues(), and initialSetup().

_p2

Point& GapHeatTransfer::_p2

protected

Definition at line 79 of file GapHeatTransfer.h.

Referenced by computeGapValues(), and initialSetup().

_penetration_locator

PenetrationLocator* GapHeatTransfer::_penetration_locator

protected

Definition at line 75 of file GapHeatTransfer.h.

Referenced by computeGapValues().

_quadrature

const bool GapHeatTransfer::_quadrature

protected

Definition at line 45 of file GapHeatTransfer.h.

Referenced by computeGapValues(), computeQpResidual(), and GapHeatTransfer().

_r1

Real GapHeatTransfer::_r1

protected

Definition at line 59 of file GapHeatTransfer.h.

Referenced by computeGapValues(), and gapLength().

_r2

Real GapHeatTransfer::_r2

protected

Definition at line 60 of file GapHeatTransfer.h.

Referenced by computeGapValues(), and gapLength().

_radius

Real GapHeatTransfer::_radius

protected

Definition at line 58 of file GapHeatTransfer.h.

Referenced by computeGapValues(), and gapLength().

_slave_flux

NumericVector<Number>* GapHeatTransfer::_slave_flux

protected

Definition at line 47 of file GapHeatTransfer.h.

Referenced by computeQpResidual().

_warnings

const bool GapHeatTransfer::_warnings

protected

Definition at line 76 of file GapHeatTransfer.h.

Referenced by computeGapValues().

---

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

• heat_conduction/include/bcs/GapHeatTransfer.h
• heat_conduction/src/bcs/GapHeatTransfer.C