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

Member Enumeration Documentation

Enumerator
PLATE 
CYLINDER 
SPHERE 

Definition at line 18 of file GapConductance.h.

Constructor & Destructor Documentation

GapConductance::GapConductance ( const InputParameters &  parameters)

Definition at line 101 of file GapConductance.C.

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

InputParameters GapConductance::actionParameters ( )
static

Definition at line 63 of file GapConductance.C.

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

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

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

432 {
433  if (gap_geometry_type == GapConductance::CYLINDER)
434  {
435  // The vector _p1 + t*(_p2-_p1) defines the cylindrical axis. The point along this
436  // axis closest to current_point is found by the following for t:
437  const Point p2p1(p2 - p1);
438  const Point p1pc(p1 - current_point);
439  const Real t = -(p1pc * p2p1) / p2p1.norm_sq();
440 
441  // The nearest point on the cylindrical axis to current_point is p.
442  const Point p(p1 + t * p2p1);
443  Point rad_vec(current_point - p);
444  Real rad = rad_vec.norm();
445  rad_vec /= rad;
446  Real rad_dot_norm = rad_vec * current_normal;
447 
448  if (rad_dot_norm > 0)
449  {
450  r1 = rad;
451  r2 = rad - gap_distance; // note, gap_distance is negative
452  radius = r1;
453  }
454  else if (rad_dot_norm < 0)
455  {
456  r1 = rad + gap_distance;
457  r2 = rad;
458  radius = r2;
459  }
460  else
461  ::mooseError("Issue with cylindrical flux calc. normals.\n");
462  }
463  else if (gap_geometry_type == GapConductance::SPHERE)
464  {
465  const Point origin_to_curr_point(current_point - p1);
466  const Real normal_dot = origin_to_curr_point * current_normal;
467  const Real curr_point_radius = origin_to_curr_point.norm();
468  if (normal_dot > 0) // on inside surface
469  {
470  r1 = curr_point_radius;
471  r2 = curr_point_radius - gap_distance; // gap_distance is negative
472  radius = r1;
473  }
474  else if (normal_dot < 0) // on outside surface
475  {
476  r1 = curr_point_radius + gap_distance; // gap_distance is negative
477  r2 = curr_point_radius;
478  radius = r2;
479  }
480  else
481  ::mooseError("Issue with spherical flux calc. normals. \n");
482  }
483  else
484  {
485  r2 = -gap_distance;
486  r1 = 0;
487  radius = 0;
488  }
489 }
void GapConductance::computeGapValues ( )
protectedvirtual

Definition at line 371 of file GapConductance.C.

Referenced by computeQpProperties().

372 {
373  if (!_quadrature)
374  {
375  _has_info = true;
376  _gap_temp = _gap_temp_value[_qp];
378  }
379  else
380  {
381  Node * qnode = _mesh.getQuadratureNode(_current_elem, _current_side, _qp);
382  PenetrationInfo * pinfo = _penetration_locator->_penetration_info[qnode->id()];
383 
384  _gap_temp = 0.0;
385  _gap_distance = 88888;
386  _has_info = false;
387 
388  if (pinfo)
389  {
390  _gap_distance = pinfo->_distance;
391  _has_info = true;
392 
393  const Elem * slave_side = pinfo->_side;
394  std::vector<std::vector<Real>> & slave_side_phi = pinfo->_side_phi;
395  std::vector<dof_id_type> slave_side_dof_indices;
396 
397  _dof_map->dof_indices(slave_side, slave_side_dof_indices, _temp_var->number());
398 
399  for (unsigned int i = 0; i < slave_side_dof_indices.size(); ++i)
400  {
401  // The zero index is because we only have one point that the phis are evaluated at
402  _gap_temp += slave_side_phi[i][0] * (*(*_serialized_solution))(slave_side_dof_indices[i]);
403  }
404  }
405  else
406  {
407  if (_warnings)
408  mooseWarning("No gap value information found for node ",
409  qnode->id(),
410  " on processor ",
411  processor_id(),
412  " at coordinate ",
413  Point(*qnode));
414  }
415  }
416 
417  Point current_point(_q_point[_qp]);
419  _gap_geometry_type, current_point, _p1, _p2, _gap_distance, _normals[_qp], _r1, _r2, _radius);
420 }
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
void GapConductance::computeQpConductance ( )
protectedvirtual

Override this to compute the conductance at _qp.

Definition at line 250 of file GapConductance.C.

Referenced by computeQpProperties().

251 {
252  if (_has_info)
253  {
256  }
257  else
258  {
259  _gap_conductance[_qp] = 0;
260  _gap_conductance_dT[_qp] = 0;
261  }
262 }
MaterialProperty< Real > & _gap_conductance_dT
virtual Real h_radiation()
virtual Real h_conduction()
virtual Real dh_conduction()
MaterialProperty< Real > & _gap_conductance
void GapConductance::computeQpProperties ( )
overrideprotectedvirtual

Definition at line 243 of file GapConductance.C.

244 {
247 }
virtual void computeGapValues()
virtual void computeQpConductance()
Override this to compute the conductance at _qp.
Real GapConductance::dh_conduction ( )
protectedvirtual

Definition at line 273 of file GapConductance.C.

Referenced by computeQpConductance().

274 {
275  return 0.0;
276 }
Real GapConductance::dh_radiation ( )
protectedvirtual

Definition at line 308 of file GapConductance.C.

309 {
310  if (_emissivity == 0.0)
311  return 0.0;
312 
313  const Real temp_func = 3 * _temp[_qp] * _temp[_qp] + _gap_temp * (2 * _temp[_qp] + _gap_temp);
314  return _stefan_boltzmann * temp_func / _emissivity;
315 }
const Real _stefan_boltzmann
const VariableValue & _temp
Real GapConductance::gapCyl ( Real  radius,
Real  r1,
Real  r2,
Real  min_denom,
Real  max_denom 
)
static

Definition at line 340 of file GapConductance.C.

Referenced by gapLength().

341 {
342  Real denominator = radius * std::log(r2 / r1);
343  return std::max(min_denom, std::min(denominator, max_denom));
344 }
Real GapConductance::gapK ( )
protectedvirtual

Definition at line 354 of file GapConductance.C.

Referenced by h_conduction().

355 {
356  Real gap_conductivity = _gap_conductivity;
357 
359  {
361  gap_conductivity *= _gap_conductivity_function->value(
362  (*_gap_conductivity_function_variable)[_qp], _q_point[_qp]);
363  else
364  gap_conductivity *= _gap_conductivity_function->value(_t, _q_point[_qp]);
365  }
366 
367  return gap_conductivity;
368 }
const VariableValue * _gap_conductivity_function_variable
Function *const _gap_conductivity_function
const Real _gap_conductivity
Real GapConductance::gapLength ( const GAP_GEOMETRY gap_geom,
Real  radius,
Real  r1,
Real  r2,
Real  min_gap,
Real  max_gap 
)
static

Definition at line 318 of file GapConductance.C.

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

324 {
325  if (gap_geom == GapConductance::CYLINDER)
326  return gapCyl(radius, r1, r2, min_gap, max_gap);
327  else if (gap_geom == GapConductance::SPHERE)
328  return gapSphere(radius, r1, r2, min_gap, max_gap);
329  else
330  return gapRect(r2 - r1, min_gap, max_gap);
331 }
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)
Real GapConductance::gapRect ( Real  distance,
Real  min_gap,
Real  max_gap 
)
static

Definition at line 334 of file GapConductance.C.

Referenced by gapLength().

335 {
336  return std::max(min_gap, std::min(distance, max_gap));
337 }
Real GapConductance::gapSphere ( Real  radius,
Real  r1,
Real  r2,
Real  min_denom,
Real  max_denom 
)
static

Definition at line 347 of file GapConductance.C.

Referenced by gapLength().

348 {
349  Real denominator = std::pow(radius, 2.0) * ((1.0 / r1) - (1.0 / r2));
350  return std::max(min_denom, std::min(denominator, max_denom));
351 }
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)
Real GapConductance::h_conduction ( )
protectedvirtual

Definition at line 265 of file GapConductance.C.

Referenced by computeQpConductance().

266 {
268  return _gap_thermal_conductivity[_qp] /
270 }
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()
Real GapConductance::h_radiation ( )
protectedvirtual

Definition at line 279 of file GapConductance.C.

Referenced by computeQpConductance().

280 {
281  /*
282  Gap conductance due to radiation is based on the diffusion approximation:
283 
284  qr = sigma*Fe*(Tf^4 - Tc^4) ~ hr(Tf - Tc)
285  where sigma is the Stefan-Boltztmann constant, Fe is an emissivity function, Tf and Tc
286  are the fuel and clad absolute temperatures, respectively, and hr is the radiant gap
287  conductance. Solving for hr,
288 
289  hr = sigma*Fe*(Tf^4 - Tc^4) / (Tf - Tc)
290  which can be factored to give:
291 
292  hr = sigma*Fe*(Tf^2 + Tc^2) * (Tf + Tc)
293 
294  Approximating the fuel-clad gap as infinite parallel planes, the emissivity function is given by:
295 
296  Fe = 1 / (1/ef + 1/ec - 1)
297  */
298 
299  if (_emissivity == 0.0)
300  return 0.0;
301 
302  const Real temp_func =
303  (_temp[_qp] * _temp[_qp] + _gap_temp * _gap_temp) * (_temp[_qp] + _gap_temp);
304  return _stefan_boltzmann * temp_func / _emissivity;
305 }
const Real _stefan_boltzmann
const VariableValue & _temp
void GapConductance::initialSetup ( )
overridevirtual

Definition at line 165 of file GapConductance.C.

166 {
167  setGapGeometryParameters(_pars, _coord_sys, _gap_geometry_type, _p1, _p2);
168 }
GAP_GEOMETRY & _gap_geometry_type
static void setGapGeometryParameters(const InputParameters &params, const Moose::CoordinateSystemType coord_sys, GAP_GEOMETRY &gap_geometry_type, Point &p1, Point &p2)
void GapConductance::setGapGeometryParameters ( const InputParameters &  params,
const Moose::CoordinateSystemType  coord_sys,
GAP_GEOMETRY gap_geometry_type,
Point &  p1,
Point &  p2 
)
static

Definition at line 171 of file GapConductance.C.

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

176 {
177  if (params.isParamSetByUser("gap_geometry_type"))
178  {
179  gap_geometry_type =
180  GapConductance::GAP_GEOMETRY(int(params.get<MooseEnum>("gap_geometry_type")));
181  }
182  else
183  {
184  if (coord_sys == Moose::COORD_XYZ)
185  gap_geometry_type = GapConductance::PLATE;
186  else if (coord_sys == Moose::COORD_RZ)
187  gap_geometry_type = GapConductance::CYLINDER;
188  else if (coord_sys == Moose::COORD_RSPHERICAL)
189  gap_geometry_type = GapConductance::SPHERE;
190  }
191 
192  if (gap_geometry_type == GapConductance::PLATE)
193  {
194  if (coord_sys == Moose::COORD_RSPHERICAL)
195  ::mooseError("'gap_geometry_type = PLATE' cannot be used with models having a spherical "
196  "coordinate system.");
197  }
198  else if (gap_geometry_type == GapConductance::CYLINDER)
199  {
200  if (coord_sys == Moose::COORD_XYZ)
201  {
202  if (!params.isParamValid("cylinder_axis_point_1") ||
203  !params.isParamValid("cylinder_axis_point_2"))
204  ::mooseError("For 'gap_geometry_type = CYLINDER' to be used with a Cartesian model, "
205  "'cylinder_axis_point_1' and 'cylinder_axis_point_2' must be specified.");
206  p1 = params.get<RealVectorValue>("cylinder_axis_point_1");
207  p2 = params.get<RealVectorValue>("cylinder_axis_point_2");
208  }
209  else if (coord_sys == Moose::COORD_RZ)
210  {
211  if (params.isParamValid("cylinder_axis_point_1") ||
212  params.isParamValid("cylinder_axis_point_2"))
213  ::mooseError("The 'cylinder_axis_point_1' and 'cylinder_axis_point_2' cannot be specified "
214  "with axisymmetric models. The y-axis is used as the cylindrical axis of "
215  "symmetry.");
216  p1 = Point(0, 0, 0);
217  p2 = Point(0, 1, 0);
218  }
219  else if (coord_sys == Moose::COORD_RSPHERICAL)
220  ::mooseError("'gap_geometry_type = CYLINDER' cannot be used with models having a spherical "
221  "coordinate system.");
222  }
223  else if (gap_geometry_type == GapConductance::SPHERE)
224  {
225  if (coord_sys == Moose::COORD_XYZ || coord_sys == Moose::COORD_RZ)
226  {
227  if (!params.isParamValid("sphere_origin"))
228  ::mooseError("For 'gap_geometry_type = SPHERE' to be used with a Cartesian or axisymmetric "
229  "model, 'sphere_origin' must be specified.");
230  p1 = params.get<RealVectorValue>("sphere_origin");
231  }
232  else if (coord_sys == Moose::COORD_RSPHERICAL)
233  {
234  if (params.isParamValid("sphere_origin"))
235  ::mooseError("The 'sphere_origin' cannot be specified with spherical models. x=0 is used "
236  "as the spherical origin.");
237  p1 = Point(0, 0, 0);
238  }
239  }
240 }

Member Data Documentation

const std::string GapConductance::_appended_property_name
protected

Definition at line 70 of file GapConductance.h.

DofMap* GapConductance::_dof_map
protected

Definition at line 105 of file GapConductance.h.

Referenced by computeGapValues().

Real GapConductance::_emissivity
protected

Definition at line 97 of file GapConductance.h.

Referenced by dh_radiation(), and h_radiation().

MaterialProperty<Real>& GapConductance::_gap_conductance
protected

Definition at line 88 of file GapConductance.h.

Referenced by computeQpConductance().

MaterialProperty<Real>& GapConductance::_gap_conductance_dT
protected

Definition at line 89 of file GapConductance.h.

Referenced by computeQpConductance().

const Real GapConductance::_gap_conductivity
protected

Definition at line 92 of file GapConductance.h.

Referenced by gapK().

Function* const GapConductance::_gap_conductivity_function
protected

Definition at line 93 of file GapConductance.h.

Referenced by gapK().

const VariableValue* GapConductance::_gap_conductivity_function_variable
protected

Definition at line 94 of file GapConductance.h.

Referenced by gapK().

Real GapConductance::_gap_distance
protected

Definition at line 79 of file GapConductance.h.

Referenced by computeGapValues().

const VariableValue& GapConductance::_gap_distance_value
protected

Definition at line 86 of file GapConductance.h.

Referenced by computeGapValues().

GAP_GEOMETRY& GapConductance::_gap_geometry_type
protected

Definition at line 74 of file GapConductance.h.

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

Real GapConductance::_gap_temp
protected

Definition at line 78 of file GapConductance.h.

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

const VariableValue& GapConductance::_gap_temp_value
protected

Definition at line 87 of file GapConductance.h.

Referenced by computeGapValues().

MaterialProperty<Real>& GapConductance::_gap_thermal_conductivity
protected

Definition at line 90 of file GapConductance.h.

Referenced by h_conduction().

bool GapConductance::_has_info
protected

Definition at line 84 of file GapConductance.h.

Referenced by computeGapValues(), and computeQpConductance().

Real GapConductance::_max_gap
protected

Definition at line 100 of file GapConductance.h.

Referenced by h_conduction().

Real GapConductance::_min_gap
protected

Definition at line 99 of file GapConductance.h.

Referenced by h_conduction().

Point& GapConductance::_p1
protected

Definition at line 108 of file GapConductance.h.

Referenced by computeGapValues(), and initialSetup().

Point& GapConductance::_p2
protected

Definition at line 109 of file GapConductance.h.

Referenced by computeGapValues(), and initialSetup().

PenetrationLocator* GapConductance::_penetration_locator
protected

Definition at line 103 of file GapConductance.h.

Referenced by computeGapValues(), and GapConductance().

bool GapConductance::_quadrature
protected

Definition at line 76 of file GapConductance.h.

Referenced by computeGapValues(), and GapConductance().

Real GapConductance::_r1
protected

Definition at line 81 of file GapConductance.h.

Referenced by computeGapValues(), and h_conduction().

Real GapConductance::_r2
protected

Definition at line 82 of file GapConductance.h.

Referenced by computeGapValues(), and h_conduction().

Real GapConductance::_radius
protected

Definition at line 80 of file GapConductance.h.

Referenced by computeGapValues(), and h_conduction().

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

Definition at line 104 of file GapConductance.h.

const Real GapConductance::_stefan_boltzmann
protected

Definition at line 96 of file GapConductance.h.

Referenced by dh_radiation(), and h_radiation().

const VariableValue& GapConductance::_temp
protected

Definition at line 72 of file GapConductance.h.

Referenced by dh_radiation(), and h_radiation().

MooseVariable* GapConductance::_temp_var
protected

Definition at line 102 of file GapConductance.h.

Referenced by computeGapValues().

const bool GapConductance::_warnings
protected

Definition at line 106 of file GapConductance.h.

Referenced by computeGapValues().


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