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

#include <GapConductance.h>

Inheritance diagram for GapConductance:

Public Types
enum	GAP_GEOMETRY { PLATE, CYLINDER, SPHERE }

Public Member Functions
	GapConductance (const InputParameters &parameters)

virtual void	initialSetup () override

Static Public Member Functions
static InputParameters	validParams ()

static InputParameters	actionParameters ()

static Real	gapLength (const GAP_GEOMETRY &gap_geom, Real radius, Real r1, Real r2, Real max_gap)

static Real	gapRect (Real distance, Real max_gap)

static Real	gapCyl (Real radius, Real r1, Real r2, Real max_denom)

static Real	gapSphere (Real radius, Real r1, Real r2, Real max_denom)

static Real	gapAttenuation (Real adjusted_length, Real min_gap, unsigned int min_gap_order)

static void	setGapGeometryParameters (const InputParameters &params, const Moose::CoordinateSystemType coord_sys, unsigned int axisymmetric_radial_coord, GAP_GEOMETRY &gap_geometry_type, Point &p1, Point &p2)

static void	computeGapRadii (const GAP_GEOMETRY gap_geometry_type, const Point &current_point, const Point &p1, const Point &p2, const Real &gap_distance, const Point &current_normal, Real &r1, Real &r2, Real &radius)

static Real	gapLength (const GAP_GEOMETRY &gap_geom, Real radius, Real r1, Real r2, Real min_gap, Real max_gap)
	Legacy method that clamps at min_gap. More...

Protected Member Functions
virtual void	computeQpProperties () override

virtual void	computeQpConductance ()
	Override this to compute the conductance at _qp. More...

virtual Real	h_conduction ()

virtual Real	h_radiation ()

virtual Real	dh_conduction ()

virtual Real	dh_radiation ()

virtual Real	gapK ()

virtual void	computeGapValues ()

Protected Attributes
const std::string	_appended_property_name

const VariableValue &	_temp

GAP_GEOMETRY &	_gap_geometry_type

bool	_quadrature

Real	_gap_temp

Real	_gap_distance

Real	_radius

Real	_r1

Real	_r2

bool	_has_info

const VariableValue &	_gap_distance_value

const VariableValue &	_gap_temp_value

MaterialProperty< Real > &	_gap_conductance

MaterialProperty< Real > &	_gap_conductance_dT

MaterialProperty< Real > &	_gap_thermal_conductivity

const Real	_gap_conductivity

const Function *const	_gap_conductivity_function

const VariableValue *	_gap_conductivity_function_variable

const Real	_stefan_boltzmann

Real	_emissivity

const Real	_min_gap

const unsigned int	_min_gap_order

const Real	_max_gap

MooseVariable *	_temp_var

PenetrationLocator *	_penetration_locator

const NumericVector< Number > const	_serialized_solution

DofMap *	_dof_map

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

Member Enumeration Documentation

◆ GAP_GEOMETRY

enum GapConductance::GAP_GEOMETRY

Enumerator
PLATE
CYLINDER
SPHERE

Definition at line 20 of file GapConductance.h.

   {
     PLATE,
     CYLINDER,
     SPHERE
   };

Constructor & Destructor Documentation

◆ GapConductance()

GapConductance::GapConductance ( const InputParameters & parameters )

Definition at line 108 of file GapConductance.C.

   : Material(parameters),
     _appended_property_name(getParam<std::string>("appended_property_name")),
     _temp(coupledValue("variable")),
     _gap_geometry_type(declareRestartableData<GapConductance::GAP_GEOMETRY>("gap_geometry_type",
                                                                             GapConductance::PLATE)),
     _quadrature(getParam<bool>("quadrature")),
     _gap_temp(0),
     _gap_distance(88888),
     _radius(0),
     _r1(0),
     _r2(0),
     _has_info(false),
     _gap_distance_value(_quadrature ? _zero : coupledValue("gap_distance")),
     _gap_temp_value(_quadrature ? _zero : coupledValue("gap_temp")),
     _gap_conductance(declareProperty<Real>("gap_conductance" + _appended_property_name)),
     _gap_conductance_dT(declareProperty<Real>("gap_conductance" + _appended_property_name + "_dT")),
     _gap_thermal_conductivity(declareProperty<Real>("gap_conductivity")),
     _gap_conductivity(getParam<Real>("gap_conductivity")),
     _gap_conductivity_function(isParamValid("gap_conductivity_function")
                                    ? &getFunction("gap_conductivity_function")
                                    : NULL),
     _gap_conductivity_function_variable(isCoupled("gap_conductivity_function_variable")
                                             ? &coupledValue("gap_conductivity_function_variable")
                                             : NULL),
     _stefan_boltzmann(getParam<Real>("stefan_boltzmann")),
     _emissivity(getParam<Real>("emissivity_1") != 0.0 && getParam<Real>("emissivity_2") != 0.0
                     ? 1.0 / getParam<Real>("emissivity_1") + 1.0 / getParam<Real>("emissivity_2") -
                           1
                     : 0.0),
     _min_gap(getParam<Real>("min_gap")),
     _min_gap_order(getParam<unsigned int>("min_gap_order")),
     _max_gap(getParam<Real>("max_gap")),
     _temp_var(_quadrature ? getVar("variable", 0) : NULL),
     _penetration_locator(NULL),
     _serialized_solution(_quadrature ? &_temp_var->sys().currentSolution() : NULL),
     _dof_map(_quadrature ? &_temp_var->sys().dofMap() : NULL),
     _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 (_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);
   }
  
   if (_quadrature)
   {
     _penetration_locator = &_subproblem.geomSearchData().getQuadraturePenetrationLocator(
         parameters.get<BoundaryName>("paired_boundary"),
         getParam<std::vector<BoundaryName>>("boundary")[0],
         Utility::string_to_enum<Order>(parameters.get<MooseEnum>("order")));
   }
  
   if (_mesh.uniformRefineLevel() != 0)
     mooseError("GapConductance does not work with uniform mesh refinement.");
 }

Member Function Documentation

◆ actionParameters()

InputParameters GapConductance::actionParameters ( )

static

Definition at line 74 of file GapConductance.C.

 {
   InputParameters params = emptyInputParameters();
   params.addParam<std::string>(
       "appended_property_name", "", "Name appended to material properties to make them unique");
   MooseEnum gap_geom_types("PLATE CYLINDER SPHERE");
   params.addParam<MooseEnum>("gap_geometry_type", gap_geom_types, "Gap calculation type.");
  
   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");
  
   params.addRangeCheckedParam<Real>("emissivity_1",
                                     0.0,
                                     "emissivity_1>=0 & emissivity_1<=1",
                                     "The emissivity of the fuel surface");
   params.addRangeCheckedParam<Real>("emissivity_2",
                                     0.0,
                                     "emissivity_2>=0 & emissivity_2<=1",
                                     "The emissivity of the cladding surface");
  
   // Common
   params.addRangeCheckedParam<Real>(
       "min_gap", 1e-6, "min_gap>0", "A minimum gap (denominator) size");
   params.addRangeCheckedParam<Real>(
       "max_gap", 1e6, "max_gap>=0", "A maximum gap (denominator) size");
   params.addRangeCheckedParam<unsigned int>(
       "min_gap_order", 0, "min_gap_order<=1", "Order of the Taylor expansion below min_gap");
  
   return params;
 }

Referenced by ThermalContactAction::validParams(), and validParams().

◆ computeGapRadii()

void GapConductance::computeGapRadii	(	const GAP_GEOMETRY	gap_geometry_type,
		const Point &	current_point,
		const Point &	p1,
		const Point &	p2,
		const Real &	gap_distance,
		const Point &	current_normal,
		Real &	r1,
		Real &	r2,
		Real &	radius
	)

static

Definition at line 462 of file GapConductance.C.

 {
   if (gap_geometry_type == GapConductance::CYLINDER)
   {
     // The vector _p1 + t*(_p2-_p1) defines the cylindrical axis.  The point along this
     // axis closest to current_point is found by the following for t:
     const Point p2p1(p2 - p1);
     const Point p1pc(p1 - current_point);
     const Real t = -(p1pc * p2p1) / p2p1.norm_sq();
  
     // The nearest point on the cylindrical axis to current_point is p.
     const Point p(p1 + t * p2p1);
     Point rad_vec(current_point - p);
     Real rad = rad_vec.norm();
     rad_vec /= rad;
     Real rad_dot_norm = rad_vec * current_normal;
  
     if (rad_dot_norm > 0)
     {
       r1 = rad;
       r2 = rad - gap_distance; // note, gap_distance is negative
       radius = r1;
     }
     else if (rad_dot_norm < 0)
     {
       r1 = rad + gap_distance;
       r2 = rad;
       radius = r2;
     }
     else
       ::mooseError("Issue with cylindrical flux calc. normals.\n");
   }
   else if (gap_geometry_type == GapConductance::SPHERE)
   {
     const Point origin_to_curr_point(current_point - p1);
     const Real normal_dot = origin_to_curr_point * current_normal;
     const Real curr_point_radius = origin_to_curr_point.norm();
     if (normal_dot > 0) // on inside surface
     {
       r1 = curr_point_radius;
       r2 = curr_point_radius - gap_distance; // gap_distance is negative
       radius = r1;
     }
     else if (normal_dot < 0) // on outside surface
     {
       r1 = curr_point_radius + gap_distance; // gap_distance is negative
       r2 = curr_point_radius;
       radius = r2;
     }
     else
       ::mooseError("Issue with spherical flux calc. normals. \n");
   }
   else
   {
     r2 = -gap_distance;
     r1 = 0;
     radius = 0;
   }
 }

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

◆ computeGapValues()

void GapConductance::computeGapValues ( )

protectedvirtual

Definition at line 410 of file GapConductance.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 = 88888;
     _has_info = false;
  
     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;
       std::vector<dof_id_type> slave_side_dof_indices;
  
       _dof_map->dof_indices(slave_side, slave_side_dof_indices, _temp_var->number());
  
       for (unsigned int i = 0; i < slave_side_dof_indices.size(); ++i)
       {
         // The zero index is because we only have one point that the phis are evaluated at
         _gap_temp += slave_side_phi[i][0] * (*(*_serialized_solution))(slave_side_dof_indices[i]);
       }
     }
     else
     {
       if (_warnings)
         mooseWarning("No gap value information found for node ",
                      qnode->id(),
                      " on processor ",
                      processor_id(),
                      " at coordinate ",
                      Point(*qnode));
     }
   }
  
   Point current_point(_q_point[_qp]);
   computeGapRadii(
       _gap_geometry_type, current_point, _p1, _p2, _gap_distance, _normals[_qp], _r1, _r2, _radius);
 }

Referenced by computeQpProperties().

◆ computeQpConductance()

void GapConductance::computeQpConductance ( )

protectedvirtual

Override this to compute the conductance at _qp.

Definition at line 272 of file GapConductance.C.

 {
   if (_has_info)
   {
     _gap_conductance[_qp] = h_conduction() + h_radiation();
     _gap_conductance_dT[_qp] = dh_conduction();
   }
   else
   {
     _gap_conductance[_qp] = 0;
     _gap_conductance_dT[_qp] = 0;
   }
 }

Referenced by computeQpProperties().

◆ computeQpProperties()

void GapConductance::computeQpProperties ( )

overrideprotectedvirtual

Definition at line 265 of file GapConductance.C.

 {
   computeGapValues();
   computeQpConductance();
 }

◆ dh_conduction()

Real GapConductance::dh_conduction ( )

protectedvirtual

Definition at line 316 of file GapConductance.C.

 {
   return 0.0;
 }

Referenced by computeQpConductance().

◆ dh_radiation()

Real GapConductance::dh_radiation ( )

protectedvirtual

Definition at line 351 of file GapConductance.C.

 {
   if (_emissivity == 0.0)
     return 0.0;
  
   const Real temp_func = 3 * _temp[_qp] * _temp[_qp] + _gap_temp * (2 * _temp[_qp] + _gap_temp);
   return _stefan_boltzmann * temp_func / _emissivity;
 }

◆ gapAttenuation()

Real GapConductance::gapAttenuation	(	Real	adjusted_length,
		Real	min_gap,
		unsigned int	min_gap_order
	)

static

Definition at line 287 of file GapConductance.C.

 {
   mooseAssert(min_gap > 0, "min_gap must be larger than zero.");
  
   if (adjusted_length > min_gap)
     return 1.0 / adjusted_length;
   else
     switch (min_gap_order)
     {
       case 0:
         return 1.0 / min_gap;
  
       case 1:
         return 1.0 / min_gap - (adjusted_length - min_gap) / (min_gap * min_gap);
  
       default:
         ::mooseError("Invalid Taylor expansion order");
     }
 }

Referenced by GapHeatTransfer::computeQpOffDiagJacobian(), and h_conduction().

◆ gapCyl()

Real GapConductance::gapCyl	(	Real	radius,
		Real	r1,
		Real	r2,
		Real	max_denom
	)

static

Definition at line 379 of file GapConductance.C.

 {
   const Real denominator = radius * std::log(r2 / r1);
   return std::min(denominator, max_denom);
 }

Referenced by gapLength().

◆ gapK()

Real GapConductance::gapK ( )

protectedvirtual

Definition at line 393 of file GapConductance.C.

 {
   Real gap_conductivity = _gap_conductivity;
  
   if (_gap_conductivity_function)
   {
     if (_gap_conductivity_function_variable)
       gap_conductivity *= _gap_conductivity_function->value(
           (*_gap_conductivity_function_variable)[_qp], _q_point[_qp]);
     else
       gap_conductivity *= _gap_conductivity_function->value(_t, _q_point[_qp]);
   }
  
   return gap_conductivity;
 }

Referenced by h_conduction().

◆ gapLength() [1/2]

Real GapConductance::gapLength	(	const GAP_GEOMETRY &	gap_geom,
		Real	radius,
		Real	r1,
		Real	r2,
		Real	max_gap
	)

static

Definition at line 361 of file GapConductance.C.

 {
   if (gap_geom == GapConductance::CYLINDER)
     return gapCyl(radius, r1, r2, max_gap);
   else if (gap_geom == GapConductance::SPHERE)
     return gapSphere(radius, r1, r2, max_gap);
   else
     return gapRect(r2 - r1, max_gap);
 }

Referenced by GapHeatTransfer::gapLength(), gapLength(), and h_conduction().

◆ gapLength() [2/2]

static Real GapConductance::gapLength	(	const GAP_GEOMETRY &	gap_geom,
		Real	radius,
		Real	r1,
		Real	r2,
		Real	min_gap,
		Real	max_gap
	)

inlinestatic

Legacy method that clamps at min_gap.

Definition at line 60 of file GapConductance.h.

   {
     return std::max(min_gap, gapLength(gap_geom, radius, r1, r2, max_gap));
   }

◆ gapRect()

Real GapConductance::gapRect	(	Real	distance,
		Real	max_gap
	)

static

Definition at line 373 of file GapConductance.C.

 {
   return std::min(distance, max_gap);
 }

Referenced by gapLength().

◆ gapSphere()

Real GapConductance::gapSphere	(	Real	radius,
		Real	r1,
		Real	r2,
		Real	max_denom
	)

static

Definition at line 386 of file GapConductance.C.

 {
   const Real denominator = radius * radius * ((1.0 / r1) - (1.0 / r2));
   return std::min(denominator, max_denom);
 }

Referenced by gapLength().

◆ h_conduction()

Real GapConductance::h_conduction ( )

protectedvirtual

Definition at line 308 of file GapConductance.C.

 {
   _gap_thermal_conductivity[_qp] = gapK();
   const Real adjusted_length = gapLength(_gap_geometry_type, _radius, _r1, _r2, _max_gap);
   return _gap_thermal_conductivity[_qp] * gapAttenuation(adjusted_length, _min_gap, _min_gap_order);
 }

Referenced by computeQpConductance().

◆ h_radiation()

Real GapConductance::h_radiation ( )

protectedvirtual

Definition at line 322 of file GapConductance.C.

 {
   /*
    Gap conductance due to radiation is based on the diffusion approximation:
  
       qr = sigma*Fe*(Tf^4 - Tc^4) ~ hr(Tf - Tc)
          where sigma is the Stefan-Boltzmann constant, Fe is an emissivity function, Tf and Tc
          are the fuel and clad absolute temperatures, respectively, and hr is the radiant gap
          conductance. Solving for hr,
  
       hr = sigma*Fe*(Tf^4 - Tc^4) / (Tf - Tc)
          which can be factored to give:
  
       hr = sigma*Fe*(Tf^2 + Tc^2) * (Tf + Tc)
  
    Approximating the fuel-clad gap as infinite parallel planes, the emissivity function is given by:
  
       Fe = 1 / (1/ef + 1/ec - 1)
   */
  
   if (_emissivity == 0.0)
     return 0.0;
  
   const Real temp_func =
       (_temp[_qp] * _temp[_qp] + _gap_temp * _gap_temp) * (_temp[_qp] + _gap_temp);
   return _stefan_boltzmann * temp_func / _emissivity;
 }

Referenced by computeQpConductance().

◆ initialSetup()

void GapConductance::initialSetup ( )

overridevirtual

Definition at line 176 of file GapConductance.C.

 {
   setGapGeometryParameters(
       _pars, _coord_sys, _fe_problem.getAxisymmetricRadialCoord(), _gap_geometry_type, _p1, _p2);
 }

◆ setGapGeometryParameters()

void GapConductance::setGapGeometryParameters	(	const InputParameters &	params,
		const Moose::CoordinateSystemType	coord_sys,
		unsigned int	axisymmetric_radial_coord,
		GAP_GEOMETRY &	gap_geometry_type,
		Point &	p1,
		Point &	p2
	)

static

Definition at line 183 of file GapConductance.C.

 {
   if (params.isParamSetByUser("gap_geometry_type"))
   {
     gap_geometry_type =
         GapConductance::GAP_GEOMETRY(int(params.get<MooseEnum>("gap_geometry_type")));
   }
   else
   {
     if (coord_sys == Moose::COORD_XYZ)
       gap_geometry_type = GapConductance::PLATE;
     else if (coord_sys == Moose::COORD_RZ)
       gap_geometry_type = GapConductance::CYLINDER;
     else if (coord_sys == Moose::COORD_RSPHERICAL)
       gap_geometry_type = GapConductance::SPHERE;
   }
  
   if (gap_geometry_type == GapConductance::PLATE)
   {
     if (coord_sys == Moose::COORD_RSPHERICAL)
       ::mooseError("'gap_geometry_type = PLATE' cannot be used with models having a spherical "
                    "coordinate system.");
   }
   else if (gap_geometry_type == GapConductance::CYLINDER)
   {
     if (coord_sys == Moose::COORD_XYZ)
     {
       if (!params.isParamValid("cylinder_axis_point_1") ||
           !params.isParamValid("cylinder_axis_point_2"))
         ::mooseError("For 'gap_geometry_type = CYLINDER' to be used with a Cartesian model, "
                      "'cylinder_axis_point_1' and 'cylinder_axis_point_2' must be specified.");
       p1 = params.get<RealVectorValue>("cylinder_axis_point_1");
       p2 = params.get<RealVectorValue>("cylinder_axis_point_2");
     }
     else if (coord_sys == Moose::COORD_RZ)
     {
       if (params.isParamValid("cylinder_axis_point_1") ||
           params.isParamValid("cylinder_axis_point_2"))
         ::mooseError("The 'cylinder_axis_point_1' and 'cylinder_axis_point_2' cannot be specified "
                      "with axisymmetric models.  The y-axis is used as the cylindrical axis of "
                      "symmetry.");
  
       if (axisymmetric_radial_coord == 0) // R-Z problem
       {
         p1 = Point(0, 0, 0);
         p2 = Point(0, 1, 0);
       }
       else // Z-R problem
       {
         p1 = Point(0, 0, 0);
         p2 = Point(1, 0, 0);
       }
     }
     else if (coord_sys == Moose::COORD_RSPHERICAL)
       ::mooseError("'gap_geometry_type = CYLINDER' cannot be used with models having a spherical "
                    "coordinate system.");
   }
   else if (gap_geometry_type == GapConductance::SPHERE)
   {
     if (coord_sys == Moose::COORD_XYZ || coord_sys == Moose::COORD_RZ)
     {
       if (!params.isParamValid("sphere_origin"))
         ::mooseError("For 'gap_geometry_type = SPHERE' to be used with a Cartesian or axisymmetric "
                      "model, 'sphere_origin' must be specified.");
       p1 = params.get<RealVectorValue>("sphere_origin");
     }
     else if (coord_sys == Moose::COORD_RSPHERICAL)
     {
       if (params.isParamValid("sphere_origin"))
         ::mooseError("The 'sphere_origin' cannot be specified with spherical models.  x=0 is used "
                      "as the spherical origin.");
       p1 = Point(0, 0, 0);
     }
   }
 }

Referenced by GapHeatTransfer::initialSetup(), and initialSetup().

◆ validParams()

InputParameters GapConductance::validParams ( )

static

Definition at line 27 of file GapConductance.C.

 {
   InputParameters params = Material::validParams();
   params += GapConductance::actionParameters();
  
   params.addRequiredCoupledVar("variable", "Temperature variable");
  
   // Node based
   params.addCoupledVar("gap_distance", "Distance across the gap");
   params.addCoupledVar("gap_temp", "Temperature on the other side of the gap");
   params.addParam<Real>("gap_conductivity", 1.0, "The thermal conductivity of the gap material");
   params.addParam<FunctionName>(
       "gap_conductivity_function",
       "Thermal conductivity of the gap material as a function.  Multiplied by gap_conductivity.");
   params.addCoupledVar("gap_conductivity_function_variable",
                        "Variable to be used in the gap_conductivity_function in place of time");
  
   // 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 and variable are "
                         "then required.");
   params.addParam<BoundaryName>("paired_boundary", "The boundary to be penetrated");
  
   params.addParam<Real>("stefan_boltzmann", 5.669e-8, "The Stefan-Boltzmann constant");
  
   params.addParam<bool>("use_displaced_mesh",
                         true,
                         "Whether or not this object should use the "
                         "displaced mesh for computation.  Note that in "
                         "the case this is true but no displacements "
                         "are provided in the Mesh block the "
                         "undisplaced mesh will still be used.");
  
   params.addParam<bool>(
       "warnings", false, "Whether to output warning messages concerning nodes not being found");
  
   MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
   params.addParam<MooseEnum>("order", orders, "The finite element order");
  
   return params;
 }

Member Data Documentation

◆ _appended_property_name

const std::string GapConductance::_appended_property_name

protected

Definition at line 82 of file GapConductance.h.

◆ _dof_map

DofMap* GapConductance::_dof_map

protected

Definition at line 118 of file GapConductance.h.

Referenced by computeGapValues().

◆ _emissivity

Real GapConductance::_emissivity

protected

Definition at line 109 of file GapConductance.h.

Referenced by dh_radiation(), and h_radiation().

◆ _gap_conductance

MaterialProperty<Real>& GapConductance::_gap_conductance

protected

Definition at line 100 of file GapConductance.h.

Referenced by computeQpConductance().

◆ _gap_conductance_dT

MaterialProperty<Real>& GapConductance::_gap_conductance_dT

protected

Definition at line 101 of file GapConductance.h.

Referenced by computeQpConductance().

◆ _gap_conductivity

const Real GapConductance::_gap_conductivity

protected

Definition at line 104 of file GapConductance.h.

Referenced by gapK().

◆ _gap_conductivity_function

const Function* const GapConductance::_gap_conductivity_function

protected

Definition at line 105 of file GapConductance.h.

Referenced by gapK().

◆ _gap_conductivity_function_variable

const VariableValue* GapConductance::_gap_conductivity_function_variable

protected

Definition at line 106 of file GapConductance.h.

Referenced by gapK().

◆ _gap_distance

Real GapConductance::_gap_distance

protected

Definition at line 91 of file GapConductance.h.

Referenced by computeGapValues().

◆ _gap_distance_value

const VariableValue& GapConductance::_gap_distance_value

protected

Definition at line 98 of file GapConductance.h.

Referenced by computeGapValues().

◆ _gap_geometry_type

GAP_GEOMETRY& GapConductance::_gap_geometry_type

protected

Definition at line 86 of file GapConductance.h.

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

◆ _gap_temp

Real GapConductance::_gap_temp

protected

Definition at line 90 of file GapConductance.h.

Referenced by computeGapValues(), dh_radiation(), and h_radiation().

◆ _gap_temp_value

const VariableValue& GapConductance::_gap_temp_value

protected

Definition at line 99 of file GapConductance.h.

Referenced by computeGapValues().

◆ _gap_thermal_conductivity

MaterialProperty<Real>& GapConductance::_gap_thermal_conductivity

protected

Definition at line 102 of file GapConductance.h.

Referenced by h_conduction().

◆ _has_info

bool GapConductance::_has_info

protected

Definition at line 96 of file GapConductance.h.

Referenced by computeGapValues(), and computeQpConductance().

◆ _max_gap

const Real GapConductance::_max_gap

protected

Definition at line 113 of file GapConductance.h.

Referenced by h_conduction().

◆ _min_gap

const Real GapConductance::_min_gap

protected

Definition at line 111 of file GapConductance.h.

Referenced by h_conduction().

◆ _min_gap_order

const unsigned int GapConductance::_min_gap_order

protected

Definition at line 112 of file GapConductance.h.

Referenced by h_conduction().

◆ _p1

Point& GapConductance::_p1

protected

Definition at line 121 of file GapConductance.h.

Referenced by computeGapValues(), and initialSetup().

◆ _p2

Point& GapConductance::_p2

protected

Definition at line 122 of file GapConductance.h.

Referenced by computeGapValues(), and initialSetup().

◆ _penetration_locator

PenetrationLocator* GapConductance::_penetration_locator

protected

Definition at line 116 of file GapConductance.h.

Referenced by computeGapValues(), and GapConductance().

◆ _quadrature

bool GapConductance::_quadrature

protected

Definition at line 88 of file GapConductance.h.

Referenced by computeGapValues(), and GapConductance().

◆ _r1

Real GapConductance::_r1

protected

Definition at line 93 of file GapConductance.h.

Referenced by computeGapValues(), and h_conduction().

◆ _r2

Real GapConductance::_r2

protected

Definition at line 94 of file GapConductance.h.

Referenced by computeGapValues(), and h_conduction().

◆ _radius

Real GapConductance::_radius

protected

Definition at line 92 of file GapConductance.h.

Referenced by computeGapValues(), and h_conduction().

◆ _serialized_solution

const NumericVector<Number>* const * GapConductance::_serialized_solution

protected

Definition at line 117 of file GapConductance.h.

◆ _stefan_boltzmann

const Real GapConductance::_stefan_boltzmann

protected

Definition at line 108 of file GapConductance.h.

Referenced by dh_radiation(), and h_radiation().

◆ _temp

const VariableValue& GapConductance::_temp

protected

Definition at line 84 of file GapConductance.h.

Referenced by dh_radiation(), and h_radiation().

◆ _temp_var

MooseVariable* GapConductance::_temp_var

protected

Definition at line 115 of file GapConductance.h.

Referenced by computeGapValues().

◆ _warnings

const bool GapConductance::_warnings

protected

Definition at line 119 of file GapConductance.h.

Referenced by computeGapValues().

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

heat_conduction/include/materials/GapConductance.h
heat_conduction/src/materials/GapConductance.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ GAP_GEOMETRY

Constructor & Destructor Documentation

◆ GapConductance()

Member Function Documentation

◆ actionParameters()

◆ computeGapRadii()

◆ computeGapValues()

◆ computeQpConductance()

◆ computeQpProperties()

◆ dh_conduction()

◆ dh_radiation()

◆ gapAttenuation()

◆ gapCyl()

◆ gapK()

◆ gapLength() [1/2]

◆ gapLength() [2/2]

◆ gapRect()

◆ gapSphere()

◆ h_conduction()

◆ h_radiation()

◆ initialSetup()

◆ setGapGeometryParameters()

◆ validParams()

Member Data Documentation

◆ _appended_property_name

◆ _dof_map

◆ _emissivity

◆ _gap_conductance

◆ _gap_conductance_dT

◆ _gap_conductivity

◆ _gap_conductivity_function

◆ _gap_conductivity_function_variable

◆ _gap_distance

◆ _gap_distance_value

◆ _gap_geometry_type

◆ _gap_temp

◆ _gap_temp_value

◆ _gap_thermal_conductivity

◆ _has_info

◆ _max_gap

◆ _min_gap

◆ _min_gap_order

◆ _p1

◆ _p2

◆ _penetration_locator

◆ _quadrature

◆ _r1

◆ _r2

◆ _radius

◆ _serialized_solution

◆ _stefan_boltzmann

◆ _temp

◆ _temp_var

◆ _warnings