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

Constructor & Destructor Documentation

◆ GapHeatTransfer()

GapHeatTransfer::GapHeatTransfer ( const InputParameters & parameters )

Definition at line 89 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 287 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 193 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 207 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 165 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 187 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 275 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 266 of file GapHeatTransfer.C.

Referenced by computeQpOffDiagJacobian(), and dgapLength().

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

◆ initialSetup()

void GapHeatTransfer::initialSetup ( )

overridevirtual

Definition at line 154 of file GapHeatTransfer.C.

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