www.mooseframework.org
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
GapConductance Class Reference

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

#include <GapConductance.h>

Inheritance diagram for GapConductance:
[legend]

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 actionParameters ()
 
static Real gapLength (const GAP_GEOMETRY &gap_geom, Real radius, Real r1, Real r2, Real min_gap, Real max_gap)
 
static Real gapRect (Real distance, Real min_gap, Real max_gap)
 
static Real gapCyl (Real radius, Real r1, Real r2, Real min_denom, Real max_denom)
 
static Real gapSphere (Real radius, Real r1, Real r2, Real min_denom, Real max_denom)
 
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)
 

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
 
Function *const _gap_conductivity_function
 
const VariableValue * _gap_conductivity_function_variable
 
const Real _stefan_boltzmann
 
Real _emissivity
 
Real _min_gap
 
Real _max_gap
 
MooseVariable * _temp_var
 
PenetrationLocator * _penetration_locator
 
const NumericVector< Number > ** _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 18 of file GapConductance.h.

Member Enumeration Documentation

◆ GAP_GEOMETRY

Enumerator
PLATE 
CYLINDER 
SPHERE 

Definition at line 21 of file GapConductance.h.

Constructor & Destructor Documentation

◆ GapConductance()

GapConductance::GapConductance ( const InputParameters &  parameters)

Definition at line 109 of file GapConductance.C.

110  : Material(parameters),
111  _appended_property_name(getParam<std::string>("appended_property_name")),
112  _temp(coupledValue("variable")),
113  _gap_geometry_type(declareRestartableData<GapConductance::GAP_GEOMETRY>("gap_geometry_type",
115  _quadrature(getParam<bool>("quadrature")),
116  _gap_temp(0),
117  _gap_distance(88888),
118  _radius(0),
119  _r1(0),
120  _r2(0),
121  _has_info(false),
122  _gap_distance_value(_quadrature ? _zero : coupledValue("gap_distance")),
123  _gap_temp_value(_quadrature ? _zero : coupledValue("gap_temp")),
124  _gap_conductance(declareProperty<Real>("gap_conductance" + _appended_property_name)),
125  _gap_conductance_dT(declareProperty<Real>("gap_conductance" + _appended_property_name + "_dT")),
126  _gap_thermal_conductivity(declareProperty<Real>("gap_conductivity")),
127  _gap_conductivity(getParam<Real>("gap_conductivity")),
128  _gap_conductivity_function(isParamValid("gap_conductivity_function")
129  ? &getFunction("gap_conductivity_function")
130  : NULL),
131  _gap_conductivity_function_variable(isCoupled("gap_conductivity_function_variable")
132  ? &coupledValue("gap_conductivity_function_variable")
133  : NULL),
134  _stefan_boltzmann(getParam<Real>("stefan_boltzmann")),
135  _emissivity(getParam<Real>("emissivity_1") != 0.0 && getParam<Real>("emissivity_2") != 0.0
136  ? 1.0 / getParam<Real>("emissivity_1") + 1.0 / getParam<Real>("emissivity_2") -
137  1
138  : 0.0),
139  _min_gap(getParam<Real>("min_gap")),
140  _max_gap(getParam<Real>("max_gap")),
141  _temp_var(_quadrature ? getVar("variable", 0) : NULL),
142  _penetration_locator(NULL),
143  _serialized_solution(_quadrature ? &_temp_var->sys().currentSolution() : NULL),
144  _dof_map(_quadrature ? &_temp_var->sys().dofMap() : NULL),
145  _warnings(getParam<bool>("warnings")),
146  _p1(declareRestartableData<Point>("cylinder_axis_point_1", Point(0, 1, 0))),
147  _p2(declareRestartableData<Point>("cylinder_axis_point_2", Point(0, 0, 0)))
148 {
149  if (_quadrature)
150  {
151  if (!parameters.isParamValid("paired_boundary"))
152  mooseError(std::string("No 'paired_boundary' provided for ") + _name);
153  }
154  else
155  {
156  if (!isCoupled("gap_distance"))
157  mooseError(std::string("No 'gap_distance' provided for ") + _name);
158 
159  if (!isCoupled("gap_temp"))
160  mooseError(std::string("No 'gap_temp' provided for ") + _name);
161  }
162 
163  if (_quadrature)
164  {
165  _penetration_locator = &_subproblem.geomSearchData().getQuadraturePenetrationLocator(
166  parameters.get<BoundaryName>("paired_boundary"),
167  getParam<std::vector<BoundaryName>>("boundary")[0],
168  Utility::string_to_enum<Order>(parameters.get<MooseEnum>("order")));
169  }
170 }
MaterialProperty< Real > & _gap_conductance_dT
const VariableValue * _gap_conductivity_function_variable
const Real _stefan_boltzmann
MaterialProperty< Real > & _gap_thermal_conductivity
Function *const _gap_conductivity_function
const Real _gap_conductivity
const std::string _appended_property_name
const VariableValue & _gap_temp_value
const NumericVector< Number > ** _serialized_solution
const bool _warnings
const VariableValue & _gap_distance_value
GAP_GEOMETRY & _gap_geometry_type
const VariableValue & _temp
PenetrationLocator * _penetration_locator
MooseVariable * _temp_var
MaterialProperty< Real > & _gap_conductance

Member Function Documentation

◆ actionParameters()

InputParameters GapConductance::actionParameters ( )
static

Definition at line 71 of file GapConductance.C.

Referenced by validParams< GapConductance >(), validParams< ThermalContactBCsAction >(), and validParams< ThermalContactMaterialsAction >().

72 {
73  InputParameters params = emptyInputParameters();
74  params.addParam<std::string>(
75  "appended_property_name", "", "Name appended to material properties to make them unique");
76  MooseEnum gap_geom_types("PLATE CYLINDER SPHERE");
77  params.addParam<MooseEnum>("gap_geometry_type", gap_geom_types, "Gap calculation type.");
78 
79  params.addParam<RealVectorValue>("cylinder_axis_point_1",
80  "Start point for line defining cylindrical axis");
81  params.addParam<RealVectorValue>("cylinder_axis_point_2",
82  "End point for line defining cylindrical axis");
83  params.addParam<RealVectorValue>("sphere_origin", "Origin for sphere geometry");
84 
85  params.addRangeCheckedParam<Real>("emissivity_1",
86  0.0,
87  "emissivity_1>=0 & emissivity_1<=1",
88  "The emissivity of the fuel surface");
89  params.addRangeCheckedParam<Real>("emissivity_2",
90  0.0,
91  "emissivity_2>=0 & emissivity_2<=1",
92  "The emissivity of the cladding surface");
93 
94  params.addParam<bool>(
95  "warnings", false, "Whether to output warning messages concerning nodes not being found");
96 
97  MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
98  params.addParam<MooseEnum>("order", orders, "The finite element order");
99 
100  // Common
101  params.addRangeCheckedParam<Real>(
102  "min_gap", 1e-6, "min_gap>=0", "A minimum gap (denominator) size");
103  params.addRangeCheckedParam<Real>(
104  "max_gap", 1e6, "max_gap>=0", "A maximum gap (denominator) size");
105 
106  return params;
107 }

◆ 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 442 of file GapConductance.C.

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

451 {
452  if (gap_geometry_type == GapConductance::CYLINDER)
453  {
454  // The vector _p1 + t*(_p2-_p1) defines the cylindrical axis. The point along this
455  // axis closest to current_point is found by the following for t:
456  const Point p2p1(p2 - p1);
457  const Point p1pc(p1 - current_point);
458  const Real t = -(p1pc * p2p1) / p2p1.norm_sq();
459 
460  // The nearest point on the cylindrical axis to current_point is p.
461  const Point p(p1 + t * p2p1);
462  Point rad_vec(current_point - p);
463  Real rad = rad_vec.norm();
464  rad_vec /= rad;
465  Real rad_dot_norm = rad_vec * current_normal;
466 
467  if (rad_dot_norm > 0)
468  {
469  r1 = rad;
470  r2 = rad - gap_distance; // note, gap_distance is negative
471  radius = r1;
472  }
473  else if (rad_dot_norm < 0)
474  {
475  r1 = rad + gap_distance;
476  r2 = rad;
477  radius = r2;
478  }
479  else
480  ::mooseError("Issue with cylindrical flux calc. normals.\n");
481  }
482  else if (gap_geometry_type == GapConductance::SPHERE)
483  {
484  const Point origin_to_curr_point(current_point - p1);
485  const Real normal_dot = origin_to_curr_point * current_normal;
486  const Real curr_point_radius = origin_to_curr_point.norm();
487  if (normal_dot > 0) // on inside surface
488  {
489  r1 = curr_point_radius;
490  r2 = curr_point_radius - gap_distance; // gap_distance is negative
491  radius = r1;
492  }
493  else if (normal_dot < 0) // on outside surface
494  {
495  r1 = curr_point_radius + gap_distance; // gap_distance is negative
496  r2 = curr_point_radius;
497  radius = r2;
498  }
499  else
500  ::mooseError("Issue with spherical flux calc. normals. \n");
501  }
502  else
503  {
504  r2 = -gap_distance;
505  r1 = 0;
506  radius = 0;
507  }
508 }

◆ computeGapValues()

void GapConductance::computeGapValues ( )
protectedvirtual

Definition at line 390 of file GapConductance.C.

Referenced by computeQpProperties().

391 {
392  if (!_quadrature)
393  {
394  _has_info = true;
395  _gap_temp = _gap_temp_value[_qp];
397  }
398  else
399  {
400  Node * qnode = _mesh.getQuadratureNode(_current_elem, _current_side, _qp);
401  PenetrationInfo * pinfo = _penetration_locator->_penetration_info[qnode->id()];
402 
403  _gap_temp = 0.0;
404  _gap_distance = 88888;
405  _has_info = false;
406 
407  if (pinfo)
408  {
409  _gap_distance = pinfo->_distance;
410  _has_info = true;
411 
412  const Elem * slave_side = pinfo->_side;
413  std::vector<std::vector<Real>> & slave_side_phi = pinfo->_side_phi;
414  std::vector<dof_id_type> slave_side_dof_indices;
415 
416  _dof_map->dof_indices(slave_side, slave_side_dof_indices, _temp_var->number());
417 
418  for (unsigned int i = 0; i < slave_side_dof_indices.size(); ++i)
419  {
420  // The zero index is because we only have one point that the phis are evaluated at
421  _gap_temp += slave_side_phi[i][0] * (*(*_serialized_solution))(slave_side_dof_indices[i]);
422  }
423  }
424  else
425  {
426  if (_warnings)
427  mooseWarning("No gap value information found for node ",
428  qnode->id(),
429  " on processor ",
430  processor_id(),
431  " at coordinate ",
432  Point(*qnode));
433  }
434  }
435 
436  Point current_point(_q_point[_qp]);
438  _gap_geometry_type, current_point, _p1, _p2, _gap_distance, _normals[_qp], _r1, _r2, _radius);
439 }
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)
const VariableValue & _gap_temp_value
const bool _warnings
const VariableValue & _gap_distance_value
GAP_GEOMETRY & _gap_geometry_type
PenetrationLocator * _penetration_locator
MooseVariable * _temp_var

◆ computeQpConductance()

void GapConductance::computeQpConductance ( )
protectedvirtual

Override this to compute the conductance at _qp.

Definition at line 269 of file GapConductance.C.

Referenced by computeQpProperties().

270 {
271  if (_has_info)
272  {
275  }
276  else
277  {
278  _gap_conductance[_qp] = 0;
279  _gap_conductance_dT[_qp] = 0;
280  }
281 }
MaterialProperty< Real > & _gap_conductance_dT
virtual Real h_radiation()
virtual Real h_conduction()
virtual Real dh_conduction()
MaterialProperty< Real > & _gap_conductance

◆ computeQpProperties()

void GapConductance::computeQpProperties ( )
overrideprotectedvirtual

Definition at line 262 of file GapConductance.C.

263 {
266 }
virtual void computeGapValues()
virtual void computeQpConductance()
Override this to compute the conductance at _qp.

◆ dh_conduction()

Real GapConductance::dh_conduction ( )
protectedvirtual

Definition at line 292 of file GapConductance.C.

Referenced by computeQpConductance().

293 {
294  return 0.0;
295 }

◆ dh_radiation()

Real GapConductance::dh_radiation ( )
protectedvirtual

Definition at line 327 of file GapConductance.C.

328 {
329  if (_emissivity == 0.0)
330  return 0.0;
331 
332  const Real temp_func = 3 * _temp[_qp] * _temp[_qp] + _gap_temp * (2 * _temp[_qp] + _gap_temp);
333  return _stefan_boltzmann * temp_func / _emissivity;
334 }
const Real _stefan_boltzmann
const VariableValue & _temp

◆ gapCyl()

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

Definition at line 359 of file GapConductance.C.

Referenced by gapLength().

360 {
361  Real denominator = radius * std::log(r2 / r1);
362  return std::max(min_denom, std::min(denominator, max_denom));
363 }

◆ gapK()

Real GapConductance::gapK ( )
protectedvirtual

Definition at line 373 of file GapConductance.C.

Referenced by h_conduction().

374 {
375  Real gap_conductivity = _gap_conductivity;
376 
378  {
380  gap_conductivity *= _gap_conductivity_function->value(
381  (*_gap_conductivity_function_variable)[_qp], _q_point[_qp]);
382  else
383  gap_conductivity *= _gap_conductivity_function->value(_t, _q_point[_qp]);
384  }
385 
386  return gap_conductivity;
387 }
const VariableValue * _gap_conductivity_function_variable
Function *const _gap_conductivity_function
const Real _gap_conductivity

◆ gapLength()

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

Definition at line 337 of file GapConductance.C.

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

343 {
344  if (gap_geom == GapConductance::CYLINDER)
345  return gapCyl(radius, r1, r2, min_gap, max_gap);
346  else if (gap_geom == GapConductance::SPHERE)
347  return gapSphere(radius, r1, r2, min_gap, max_gap);
348  else
349  return gapRect(r2 - r1, min_gap, max_gap);
350 }
static Real gapRect(Real distance, Real min_gap, Real max_gap)
static Real gapCyl(Real radius, Real r1, Real r2, Real min_denom, Real max_denom)
static Real gapSphere(Real radius, Real r1, Real r2, Real min_denom, Real max_denom)

◆ gapRect()

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

Definition at line 353 of file GapConductance.C.

Referenced by gapLength().

354 {
355  return std::max(min_gap, std::min(distance, max_gap));
356 }

◆ gapSphere()

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

Definition at line 366 of file GapConductance.C.

Referenced by gapLength().

367 {
368  Real denominator = std::pow(radius, 2.0) * ((1.0 / r1) - (1.0 / r2));
369  return std::max(min_denom, std::min(denominator, max_denom));
370 }
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)

◆ h_conduction()

Real GapConductance::h_conduction ( )
protectedvirtual

Definition at line 284 of file GapConductance.C.

Referenced by computeQpConductance().

285 {
287  return _gap_thermal_conductivity[_qp] /
289 }
MaterialProperty< Real > & _gap_thermal_conductivity
static Real gapLength(const GAP_GEOMETRY &gap_geom, Real radius, Real r1, Real r2, Real min_gap, Real max_gap)
GAP_GEOMETRY & _gap_geometry_type
virtual Real gapK()

◆ h_radiation()

Real GapConductance::h_radiation ( )
protectedvirtual

Definition at line 298 of file GapConductance.C.

Referenced by computeQpConductance().

299 {
300  /*
301  Gap conductance due to radiation is based on the diffusion approximation:
302 
303  qr = sigma*Fe*(Tf^4 - Tc^4) ~ hr(Tf - Tc)
304  where sigma is the Stefan-Boltztmann constant, Fe is an emissivity function, Tf and Tc
305  are the fuel and clad absolute temperatures, respectively, and hr is the radiant gap
306  conductance. Solving for hr,
307 
308  hr = sigma*Fe*(Tf^4 - Tc^4) / (Tf - Tc)
309  which can be factored to give:
310 
311  hr = sigma*Fe*(Tf^2 + Tc^2) * (Tf + Tc)
312 
313  Approximating the fuel-clad gap as infinite parallel planes, the emissivity function is given by:
314 
315  Fe = 1 / (1/ef + 1/ec - 1)
316  */
317 
318  if (_emissivity == 0.0)
319  return 0.0;
320 
321  const Real temp_func =
322  (_temp[_qp] * _temp[_qp] + _gap_temp * _gap_temp) * (_temp[_qp] + _gap_temp);
323  return _stefan_boltzmann * temp_func / _emissivity;
324 }
const Real _stefan_boltzmann
const VariableValue & _temp

◆ initialSetup()

void GapConductance::initialSetup ( )
overridevirtual

Definition at line 173 of file GapConductance.C.

174 {
176  _pars, _coord_sys, _fe_problem.getAxisymmetricRadialCoord(), _gap_geometry_type, _p1, _p2);
177 }
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)
GAP_GEOMETRY & _gap_geometry_type

◆ 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 180 of file GapConductance.C.

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

186 {
187  if (params.isParamSetByUser("gap_geometry_type"))
188  {
189  gap_geometry_type =
190  GapConductance::GAP_GEOMETRY(int(params.get<MooseEnum>("gap_geometry_type")));
191  }
192  else
193  {
194  if (coord_sys == Moose::COORD_XYZ)
195  gap_geometry_type = GapConductance::PLATE;
196  else if (coord_sys == Moose::COORD_RZ)
197  gap_geometry_type = GapConductance::CYLINDER;
198  else if (coord_sys == Moose::COORD_RSPHERICAL)
199  gap_geometry_type = GapConductance::SPHERE;
200  }
201 
202  if (gap_geometry_type == GapConductance::PLATE)
203  {
204  if (coord_sys == Moose::COORD_RSPHERICAL)
205  ::mooseError("'gap_geometry_type = PLATE' cannot be used with models having a spherical "
206  "coordinate system.");
207  }
208  else if (gap_geometry_type == GapConductance::CYLINDER)
209  {
210  if (coord_sys == Moose::COORD_XYZ)
211  {
212  if (!params.isParamValid("cylinder_axis_point_1") ||
213  !params.isParamValid("cylinder_axis_point_2"))
214  ::mooseError("For 'gap_geometry_type = CYLINDER' to be used with a Cartesian model, "
215  "'cylinder_axis_point_1' and 'cylinder_axis_point_2' must be specified.");
216  p1 = params.get<RealVectorValue>("cylinder_axis_point_1");
217  p2 = params.get<RealVectorValue>("cylinder_axis_point_2");
218  }
219  else if (coord_sys == Moose::COORD_RZ)
220  {
221  if (params.isParamValid("cylinder_axis_point_1") ||
222  params.isParamValid("cylinder_axis_point_2"))
223  ::mooseError("The 'cylinder_axis_point_1' and 'cylinder_axis_point_2' cannot be specified "
224  "with axisymmetric models. The y-axis is used as the cylindrical axis of "
225  "symmetry.");
226 
227  if (axisymmetric_radial_coord == 0) // R-Z problem
228  {
229  p1 = Point(0, 0, 0);
230  p2 = Point(0, 1, 0);
231  }
232  else // Z-R problem
233  {
234  p1 = Point(0, 0, 0);
235  p2 = Point(1, 0, 0);
236  }
237  }
238  else if (coord_sys == Moose::COORD_RSPHERICAL)
239  ::mooseError("'gap_geometry_type = CYLINDER' cannot be used with models having a spherical "
240  "coordinate system.");
241  }
242  else if (gap_geometry_type == GapConductance::SPHERE)
243  {
244  if (coord_sys == Moose::COORD_XYZ || coord_sys == Moose::COORD_RZ)
245  {
246  if (!params.isParamValid("sphere_origin"))
247  ::mooseError("For 'gap_geometry_type = SPHERE' to be used with a Cartesian or axisymmetric "
248  "model, 'sphere_origin' must be specified.");
249  p1 = params.get<RealVectorValue>("sphere_origin");
250  }
251  else if (coord_sys == Moose::COORD_RSPHERICAL)
252  {
253  if (params.isParamValid("sphere_origin"))
254  ::mooseError("The 'sphere_origin' cannot be specified with spherical models. x=0 is used "
255  "as the spherical origin.");
256  p1 = Point(0, 0, 0);
257  }
258  }
259 }

Member Data Documentation

◆ _appended_property_name

const std::string GapConductance::_appended_property_name
protected

Definition at line 74 of file GapConductance.h.

◆ _dof_map

DofMap* GapConductance::_dof_map
protected

Definition at line 109 of file GapConductance.h.

Referenced by computeGapValues().

◆ _emissivity

Real GapConductance::_emissivity
protected

Definition at line 101 of file GapConductance.h.

Referenced by dh_radiation(), and h_radiation().

◆ _gap_conductance

MaterialProperty<Real>& GapConductance::_gap_conductance
protected

Definition at line 92 of file GapConductance.h.

Referenced by computeQpConductance().

◆ _gap_conductance_dT

MaterialProperty<Real>& GapConductance::_gap_conductance_dT
protected

Definition at line 93 of file GapConductance.h.

Referenced by computeQpConductance().

◆ _gap_conductivity

const Real GapConductance::_gap_conductivity
protected

Definition at line 96 of file GapConductance.h.

Referenced by gapK().

◆ _gap_conductivity_function

Function* const GapConductance::_gap_conductivity_function
protected

Definition at line 97 of file GapConductance.h.

Referenced by gapK().

◆ _gap_conductivity_function_variable

const VariableValue* GapConductance::_gap_conductivity_function_variable
protected

Definition at line 98 of file GapConductance.h.

Referenced by gapK().

◆ _gap_distance

Real GapConductance::_gap_distance
protected

Definition at line 83 of file GapConductance.h.

Referenced by computeGapValues().

◆ _gap_distance_value

const VariableValue& GapConductance::_gap_distance_value
protected

Definition at line 90 of file GapConductance.h.

Referenced by computeGapValues().

◆ _gap_geometry_type

GAP_GEOMETRY& GapConductance::_gap_geometry_type
protected

Definition at line 78 of file GapConductance.h.

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

◆ _gap_temp

Real GapConductance::_gap_temp
protected

Definition at line 82 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 91 of file GapConductance.h.

Referenced by computeGapValues().

◆ _gap_thermal_conductivity

MaterialProperty<Real>& GapConductance::_gap_thermal_conductivity
protected

Definition at line 94 of file GapConductance.h.

Referenced by h_conduction().

◆ _has_info

bool GapConductance::_has_info
protected

Definition at line 88 of file GapConductance.h.

Referenced by computeGapValues(), and computeQpConductance().

◆ _max_gap

Real GapConductance::_max_gap
protected

Definition at line 104 of file GapConductance.h.

Referenced by h_conduction().

◆ _min_gap

Real GapConductance::_min_gap
protected

Definition at line 103 of file GapConductance.h.

Referenced by h_conduction().

◆ _p1

Point& GapConductance::_p1
protected

Definition at line 112 of file GapConductance.h.

Referenced by computeGapValues(), and initialSetup().

◆ _p2

Point& GapConductance::_p2
protected

Definition at line 113 of file GapConductance.h.

Referenced by computeGapValues(), and initialSetup().

◆ _penetration_locator

PenetrationLocator* GapConductance::_penetration_locator
protected

Definition at line 107 of file GapConductance.h.

Referenced by computeGapValues(), and GapConductance().

◆ _quadrature

bool GapConductance::_quadrature
protected

Definition at line 80 of file GapConductance.h.

Referenced by computeGapValues(), and GapConductance().

◆ _r1

Real GapConductance::_r1
protected

Definition at line 85 of file GapConductance.h.

Referenced by computeGapValues(), and h_conduction().

◆ _r2

Real GapConductance::_r2
protected

Definition at line 86 of file GapConductance.h.

Referenced by computeGapValues(), and h_conduction().

◆ _radius

Real GapConductance::_radius
protected

Definition at line 84 of file GapConductance.h.

Referenced by computeGapValues(), and h_conduction().

◆ _serialized_solution

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

Definition at line 108 of file GapConductance.h.

◆ _stefan_boltzmann

const Real GapConductance::_stefan_boltzmann
protected

Definition at line 100 of file GapConductance.h.

Referenced by dh_radiation(), and h_radiation().

◆ _temp

const VariableValue& GapConductance::_temp
protected

Definition at line 76 of file GapConductance.h.

Referenced by dh_radiation(), and h_radiation().

◆ _temp_var

MooseVariable* GapConductance::_temp_var
protected

Definition at line 106 of file GapConductance.h.

Referenced by computeGapValues().

◆ _warnings

const bool GapConductance::_warnings
protected

Definition at line 110 of file GapConductance.h.

Referenced by computeGapValues().


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