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 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
 
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 > ** _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 107 of file GapConductance.C.

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

Referenced by validParams< GapConductance >(), and validParams< ThermalContactAction >().

74 {
75  InputParameters params = emptyInputParameters();
76  params.addParam<std::string>(
77  "appended_property_name", "", "Name appended to material properties to make them unique");
78  MooseEnum gap_geom_types("PLATE CYLINDER SPHERE");
79  params.addParam<MooseEnum>("gap_geometry_type", gap_geom_types, "Gap calculation type.");
80 
81  params.addParam<RealVectorValue>("cylinder_axis_point_1",
82  "Start point for line defining cylindrical axis");
83  params.addParam<RealVectorValue>("cylinder_axis_point_2",
84  "End point for line defining cylindrical axis");
85  params.addParam<RealVectorValue>("sphere_origin", "Origin for sphere geometry");
86 
87  params.addRangeCheckedParam<Real>("emissivity_1",
88  0.0,
89  "emissivity_1>=0 & emissivity_1<=1",
90  "The emissivity of the fuel surface");
91  params.addRangeCheckedParam<Real>("emissivity_2",
92  0.0,
93  "emissivity_2>=0 & emissivity_2<=1",
94  "The emissivity of the cladding surface");
95 
96  // Common
97  params.addRangeCheckedParam<Real>(
98  "min_gap", 1e-6, "min_gap>0", "A minimum gap (denominator) size");
99  params.addRangeCheckedParam<Real>(
100  "max_gap", 1e6, "max_gap>=0", "A maximum gap (denominator) size");
101  params.addRangeCheckedParam<unsigned int>(
102  "min_gap_order", 0, "min_gap_order<=1", "Order of the Taylor expansion below min_gap");
103 
104  return params;
105 }

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

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

467 {
468  if (gap_geometry_type == GapConductance::CYLINDER)
469  {
470  // The vector _p1 + t*(_p2-_p1) defines the cylindrical axis. The point along this
471  // axis closest to current_point is found by the following for t:
472  const Point p2p1(p2 - p1);
473  const Point p1pc(p1 - current_point);
474  const Real t = -(p1pc * p2p1) / p2p1.norm_sq();
475 
476  // The nearest point on the cylindrical axis to current_point is p.
477  const Point p(p1 + t * p2p1);
478  Point rad_vec(current_point - p);
479  Real rad = rad_vec.norm();
480  rad_vec /= rad;
481  Real rad_dot_norm = rad_vec * current_normal;
482 
483  if (rad_dot_norm > 0)
484  {
485  r1 = rad;
486  r2 = rad - gap_distance; // note, gap_distance is negative
487  radius = r1;
488  }
489  else if (rad_dot_norm < 0)
490  {
491  r1 = rad + gap_distance;
492  r2 = rad;
493  radius = r2;
494  }
495  else
496  ::mooseError("Issue with cylindrical flux calc. normals.\n");
497  }
498  else if (gap_geometry_type == GapConductance::SPHERE)
499  {
500  const Point origin_to_curr_point(current_point - p1);
501  const Real normal_dot = origin_to_curr_point * current_normal;
502  const Real curr_point_radius = origin_to_curr_point.norm();
503  if (normal_dot > 0) // on inside surface
504  {
505  r1 = curr_point_radius;
506  r2 = curr_point_radius - gap_distance; // gap_distance is negative
507  radius = r1;
508  }
509  else if (normal_dot < 0) // on outside surface
510  {
511  r1 = curr_point_radius + gap_distance; // gap_distance is negative
512  r2 = curr_point_radius;
513  radius = r2;
514  }
515  else
516  ::mooseError("Issue with spherical flux calc. normals. \n");
517  }
518  else
519  {
520  r2 = -gap_distance;
521  r1 = 0;
522  radius = 0;
523  }
524 }

◆ computeGapValues()

void GapConductance::computeGapValues ( )
protectedvirtual

Definition at line 406 of file GapConductance.C.

Referenced by computeQpProperties().

407 {
408  if (!_quadrature)
409  {
410  _has_info = true;
411  _gap_temp = _gap_temp_value[_qp];
413  }
414  else
415  {
416  Node * qnode = _mesh.getQuadratureNode(_current_elem, _current_side, _qp);
417  PenetrationInfo * pinfo = _penetration_locator->_penetration_info[qnode->id()];
418 
419  _gap_temp = 0.0;
420  _gap_distance = 88888;
421  _has_info = false;
422 
423  if (pinfo)
424  {
425  _gap_distance = pinfo->_distance;
426  _has_info = true;
427 
428  const Elem * slave_side = pinfo->_side;
429  std::vector<std::vector<Real>> & slave_side_phi = pinfo->_side_phi;
430  std::vector<dof_id_type> slave_side_dof_indices;
431 
432  _dof_map->dof_indices(slave_side, slave_side_dof_indices, _temp_var->number());
433 
434  for (unsigned int i = 0; i < slave_side_dof_indices.size(); ++i)
435  {
436  // The zero index is because we only have one point that the phis are evaluated at
437  _gap_temp += slave_side_phi[i][0] * (*(*_serialized_solution))(slave_side_dof_indices[i]);
438  }
439  }
440  else
441  {
442  if (_warnings)
443  mooseWarning("No gap value information found for node ",
444  qnode->id(),
445  " on processor ",
446  processor_id(),
447  " at coordinate ",
448  Point(*qnode));
449  }
450  }
451 
452  Point current_point(_q_point[_qp]);
454  _gap_geometry_type, current_point, _p1, _p2, _gap_distance, _normals[_qp], _r1, _r2, _radius);
455 }
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 268 of file GapConductance.C.

Referenced by computeQpProperties().

269 {
270  if (_has_info)
271  {
274  }
275  else
276  {
277  _gap_conductance[_qp] = 0;
278  _gap_conductance_dT[_qp] = 0;
279  }
280 }
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 261 of file GapConductance.C.

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

◆ dh_conduction()

Real GapConductance::dh_conduction ( )
protectedvirtual

Definition at line 312 of file GapConductance.C.

Referenced by computeQpConductance().

313 {
314  return 0.0;
315 }

◆ dh_radiation()

Real GapConductance::dh_radiation ( )
protectedvirtual

Definition at line 347 of file GapConductance.C.

348 {
349  if (_emissivity == 0.0)
350  return 0.0;
351 
352  const Real temp_func = 3 * _temp[_qp] * _temp[_qp] + _gap_temp * (2 * _temp[_qp] + _gap_temp);
353  return _stefan_boltzmann * temp_func / _emissivity;
354 }
const Real _stefan_boltzmann
const VariableValue & _temp

◆ gapAttenuation()

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

Definition at line 283 of file GapConductance.C.

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

284 {
285  mooseAssert(min_gap > 0, "min_gap must be larger than zero.");
286 
287  if (adjusted_length > min_gap)
288  return 1.0 / adjusted_length;
289  else
290  switch (min_gap_order)
291  {
292  case 0:
293  return 1.0 / min_gap;
294 
295  case 1:
296  return 1.0 / min_gap - (adjusted_length - min_gap) / (min_gap * min_gap);
297 
298  default:
299  ::mooseError("Invalid Taylor expansion order");
300  }
301 }

◆ gapCyl()

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

Definition at line 375 of file GapConductance.C.

Referenced by gapLength().

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

◆ gapK()

Real GapConductance::gapK ( )
protectedvirtual

Definition at line 389 of file GapConductance.C.

Referenced by h_conduction().

390 {
391  Real gap_conductivity = _gap_conductivity;
392 
394  {
396  gap_conductivity *= _gap_conductivity_function->value(
397  (*_gap_conductivity_function_variable)[_qp], _q_point[_qp]);
398  else
399  gap_conductivity *= _gap_conductivity_function->value(_t, _q_point[_qp]);
400  }
401 
402  return gap_conductivity;
403 }
const VariableValue * _gap_conductivity_function_variable
Function *const _gap_conductivity_function
const Real _gap_conductivity

◆ gapLength() [1/2]

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

Definition at line 357 of file GapConductance.C.

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

359 {
360  if (gap_geom == GapConductance::CYLINDER)
361  return gapCyl(radius, r1, r2, max_gap);
362  else if (gap_geom == GapConductance::SPHERE)
363  return gapSphere(radius, r1, r2, max_gap);
364  else
365  return gapRect(r2 - r1, max_gap);
366 }
static Real gapSphere(Real radius, Real r1, Real r2, Real max_denom)
static Real gapCyl(Real radius, Real r1, Real r2, Real max_denom)
static Real gapRect(Real distance, Real max_gap)

◆ 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.

62  {
63  return std::max(min_gap, gapLength(gap_geom, radius, r1, r2, max_gap));
64  }
static Real gapLength(const GAP_GEOMETRY &gap_geom, Real radius, Real r1, Real r2, Real max_gap)

◆ gapRect()

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

Definition at line 369 of file GapConductance.C.

Referenced by gapLength().

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

◆ gapSphere()

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

Definition at line 382 of file GapConductance.C.

Referenced by gapLength().

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

◆ h_conduction()

Real GapConductance::h_conduction ( )
protectedvirtual

Definition at line 304 of file GapConductance.C.

Referenced by computeQpConductance().

305 {
307  const Real adjusted_length = gapLength(_gap_geometry_type, _radius, _r1, _r2, _max_gap);
308  return _gap_thermal_conductivity[_qp] * gapAttenuation(adjusted_length, _min_gap, _min_gap_order);
309 }
MaterialProperty< Real > & _gap_thermal_conductivity
static Real gapAttenuation(Real adjusted_length, Real min_gap, unsigned int min_gap_order)
const unsigned int _min_gap_order
const Real _max_gap
const Real _min_gap
GAP_GEOMETRY & _gap_geometry_type
virtual Real gapK()
static Real gapLength(const GAP_GEOMETRY &gap_geom, Real radius, Real r1, Real r2, Real max_gap)

◆ h_radiation()

Real GapConductance::h_radiation ( )
protectedvirtual

Definition at line 318 of file GapConductance.C.

Referenced by computeQpConductance().

319 {
320  /*
321  Gap conductance due to radiation is based on the diffusion approximation:
322 
323  qr = sigma*Fe*(Tf^4 - Tc^4) ~ hr(Tf - Tc)
324  where sigma is the Stefan-Boltzmann constant, Fe is an emissivity function, Tf and Tc
325  are the fuel and clad absolute temperatures, respectively, and hr is the radiant gap
326  conductance. Solving for hr,
327 
328  hr = sigma*Fe*(Tf^4 - Tc^4) / (Tf - Tc)
329  which can be factored to give:
330 
331  hr = sigma*Fe*(Tf^2 + Tc^2) * (Tf + Tc)
332 
333  Approximating the fuel-clad gap as infinite parallel planes, the emissivity function is given by:
334 
335  Fe = 1 / (1/ef + 1/ec - 1)
336  */
337 
338  if (_emissivity == 0.0)
339  return 0.0;
340 
341  const Real temp_func =
342  (_temp[_qp] * _temp[_qp] + _gap_temp * _gap_temp) * (_temp[_qp] + _gap_temp);
343  return _stefan_boltzmann * temp_func / _emissivity;
344 }
const Real _stefan_boltzmann
const VariableValue & _temp

◆ initialSetup()

void GapConductance::initialSetup ( )
overridevirtual

Definition at line 172 of file GapConductance.C.

173 {
175  _pars, _coord_sys, _fe_problem.getAxisymmetricRadialCoord(), _gap_geometry_type, _p1, _p2);
176 }
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 179 of file GapConductance.C.

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

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

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

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>** 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: