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

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 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 25 of file GapHeatTransfer.h.

Constructor & Destructor Documentation

GapHeatTransfer()

GapHeatTransfer::GapHeatTransfer

(

const InputParameters &

parameters

)

Definition at line 87 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")),
    _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 282 of file GapHeatTransfer.C.

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

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

computeQpJacobian()

Real GapHeatTransfer::computeQpJacobian ( )

overrideprotectedvirtual

Definition at line 190 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 203 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] / gapL * dgap;
  }
  return _test[_i][_qp] * dRdx * _phi[_j][_qp];
}

computeQpResidual()

Real GapHeatTransfer::computeQpResidual ( )

overrideprotectedvirtual

Definition at line 162 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 184 of file GapHeatTransfer.C.

Referenced by computeQpResidual().

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

dgapLength()

Real GapHeatTransfer::dgapLength ( Real  normalComponent ) const

protectedvirtual

Definition at line 270 of file GapHeatTransfer.C.

Referenced by computeQpOffDiagJacobian().

{
  const Real gap_L = gapLength();
  Real dgap = 0.0;

  if (_min_gap <= gap_L && gap_L <= _max_gap)
    dgap = normalComponent;

  return dgap;
}

gapLength()

Real GapHeatTransfer::gapLength ( ) const

protectedvirtual

Definition at line 261 of file GapHeatTransfer.C.

Referenced by computeQpOffDiagJacobian(), and dgapLength().

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

  return 1.0;
}

initialSetup()

void GapHeatTransfer::initialSetup ( )

overridevirtual

Definition at line 151 of file GapHeatTransfer.C.

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

Member Data Documentation

_disp_vars

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

protected

Definition at line 68 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 64 of file GapHeatTransfer.h.

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

_gap_conductance

const MaterialProperty<Real>& GapHeatTransfer::_gap_conductance

protected

Definition at line 48 of file GapHeatTransfer.h.

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

_gap_conductance_dT

const MaterialProperty<Real>& GapHeatTransfer::_gap_conductance_dT

protected

Definition at line 49 of file GapHeatTransfer.h.

Referenced by computeQpJacobian().

_gap_distance

Real GapHeatTransfer::_gap_distance

protected

Definition at line 55 of file GapHeatTransfer.h.

Referenced by computeGapValues().

_gap_distance_value

const VariableValue& GapHeatTransfer::_gap_distance_value

protected

Definition at line 70 of file GapHeatTransfer.h.

Referenced by computeGapValues().

_gap_geometry_type

GapConductance::GAP_GEOMETRY& GapHeatTransfer::_gap_geometry_type

protected

Definition at line 42 of file GapHeatTransfer.h.

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

_gap_temp

Real GapHeatTransfer::_gap_temp

protected

Definition at line 54 of file GapHeatTransfer.h.

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

_gap_temp_value

const VariableValue& GapHeatTransfer::_gap_temp_value

protected

Definition at line 71 of file GapHeatTransfer.h.

Referenced by computeGapValues().

_has_info

bool GapHeatTransfer::_has_info

protected

Definition at line 66 of file GapHeatTransfer.h.

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

_max_gap

const Real GapHeatTransfer::_max_gap

protected

Definition at line 52 of file GapHeatTransfer.h.

Referenced by dgapLength(), and gapLength().

_min_gap

const Real GapHeatTransfer::_min_gap

protected

Definition at line 51 of file GapHeatTransfer.h.

Referenced by dgapLength(), and gapLength().

_p1

Point& GapHeatTransfer::_p1

protected

Definition at line 76 of file GapHeatTransfer.h.

Referenced by computeGapValues(), and initialSetup().

_p2

Point& GapHeatTransfer::_p2

protected

Definition at line 77 of file GapHeatTransfer.h.

Referenced by computeGapValues(), and initialSetup().

_penetration_locator

PenetrationLocator* GapHeatTransfer::_penetration_locator

protected

Definition at line 73 of file GapHeatTransfer.h.

Referenced by computeGapValues().

_quadrature

const bool GapHeatTransfer::_quadrature

protected

Definition at line 44 of file GapHeatTransfer.h.

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

_r1

Real GapHeatTransfer::_r1

protected

Definition at line 57 of file GapHeatTransfer.h.

Referenced by computeGapValues(), and gapLength().

_r2

Real GapHeatTransfer::_r2

protected

Definition at line 58 of file GapHeatTransfer.h.

Referenced by computeGapValues(), and gapLength().

_radius

Real GapHeatTransfer::_radius

protected

Definition at line 56 of file GapHeatTransfer.h.

Referenced by computeGapValues(), and gapLength().

_slave_flux

NumericVector<Number>* GapHeatTransfer::_slave_flux

protected

Definition at line 46 of file GapHeatTransfer.h.

Referenced by computeQpResidual().

_warnings

const bool GapHeatTransfer::_warnings

protected

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