www.mooseframework.org
GapConductance.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #include "GapConductance.h"
11 
12 // MOOSE includes
13 #include "Function.h"
14 #include "MooseMesh.h"
15 #include "MooseVariable.h"
16 #include "PenetrationLocator.h"
17 #include "SystemBase.h"
18 #include "AddVariableAction.h"
19 
20 #include "libmesh/string_to_enum.h"
21 
22 registerMooseObject("HeatConductionApp", GapConductance);
23 
25 
26 InputParameters
28 {
29  InputParameters params = Material::validParams();
31 
32  params.addRequiredCoupledVar("variable", "Temperature variable");
33 
34  // Node based
35  params.addCoupledVar("gap_distance", "Distance across the gap");
36  params.addCoupledVar("gap_temp", "Temperature on the other side of the gap");
37  params.addParam<Real>("gap_conductivity", 1.0, "The thermal conductivity of the gap material");
38  params.addParam<FunctionName>(
39  "gap_conductivity_function",
40  "Thermal conductivity of the gap material as a function. Multiplied by gap_conductivity.");
41  params.addCoupledVar("gap_conductivity_function_variable",
42  "Variable to be used in the gap_conductivity_function in place of time");
43 
44  // Quadrature based
45  params.addParam<bool>("quadrature",
46  false,
47  "Whether or not to do quadrature point based gap heat "
48  "transfer. If this is true then gap_distance and "
49  "gap_temp should NOT be provided (and will be "
50  "ignored); however, paired_boundary and variable are "
51  "then required.");
52  params.addParam<BoundaryName>("paired_boundary", "The boundary to be penetrated");
53 
54  params.addParam<Real>("stefan_boltzmann", 5.669e-8, "The Stefan-Boltzmann constant");
55 
56  params.addParam<bool>("use_displaced_mesh",
57  true,
58  "Whether or not this object should use the "
59  "displaced mesh for computation. Note that in "
60  "the case this is true but no displacements "
61  "are provided in the Mesh block the "
62  "undisplaced mesh will still be used.");
63 
64  params.addParam<bool>(
65  "warnings", false, "Whether to output warning messages concerning nodes not being found");
66 
67  MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
68  params.addParam<MooseEnum>("order", orders, "The finite element order");
69 
70  return params;
71 }
72 
73 InputParameters
75 {
76  InputParameters params = emptyInputParameters();
77  params.addParam<std::string>(
78  "appended_property_name", "", "Name appended to material properties to make them unique");
79  MooseEnum gap_geom_types("PLATE CYLINDER SPHERE");
80  params.addParam<MooseEnum>("gap_geometry_type", gap_geom_types, "Gap calculation type.");
81 
82  params.addParam<RealVectorValue>("cylinder_axis_point_1",
83  "Start point for line defining cylindrical axis");
84  params.addParam<RealVectorValue>("cylinder_axis_point_2",
85  "End point for line defining cylindrical axis");
86  params.addParam<RealVectorValue>("sphere_origin", "Origin for sphere geometry");
87 
88  params.addRangeCheckedParam<Real>("emissivity_1",
89  0.0,
90  "emissivity_1>=0 & emissivity_1<=1",
91  "The emissivity of the fuel surface");
92  params.addRangeCheckedParam<Real>("emissivity_2",
93  0.0,
94  "emissivity_2>=0 & emissivity_2<=1",
95  "The emissivity of the cladding surface");
96 
97  // Common
98  params.addRangeCheckedParam<Real>(
99  "min_gap", 1e-6, "min_gap>0", "A minimum gap (denominator) size");
100  params.addRangeCheckedParam<Real>(
101  "max_gap", 1e6, "max_gap>=0", "A maximum gap (denominator) size");
102  params.addRangeCheckedParam<unsigned int>(
103  "min_gap_order", 0, "min_gap_order<=1", "Order of the Taylor expansion below min_gap");
104 
105  return params;
106 }
107 
108 GapConductance::GapConductance(const InputParameters & parameters)
109  : Material(parameters),
110  _appended_property_name(getParam<std::string>("appended_property_name")),
111  _temp(coupledValue("variable")),
112  _gap_geometry_type(declareRestartableData<GapConductance::GAP_GEOMETRY>("gap_geometry_type",
113  GapConductance::PLATE)),
114  _quadrature(getParam<bool>("quadrature")),
115  _gap_temp(0),
116  _gap_distance(88888),
117  _radius(0),
118  _r1(0),
119  _r2(0),
120  _has_info(false),
121  _gap_distance_value(_quadrature ? _zero : coupledValue("gap_distance")),
122  _gap_temp_value(_quadrature ? _zero : coupledValue("gap_temp")),
123  _gap_conductance(declareProperty<Real>("gap_conductance" + _appended_property_name)),
124  _gap_conductance_dT(declareProperty<Real>("gap_conductance" + _appended_property_name + "_dT")),
125  _gap_thermal_conductivity(declareProperty<Real>("gap_conductivity")),
126  _gap_conductivity(getParam<Real>("gap_conductivity")),
127  _gap_conductivity_function(isParamValid("gap_conductivity_function")
128  ? &getFunction("gap_conductivity_function")
129  : NULL),
130  _gap_conductivity_function_variable(isCoupled("gap_conductivity_function_variable")
131  ? &coupledValue("gap_conductivity_function_variable")
132  : NULL),
133  _stefan_boltzmann(getParam<Real>("stefan_boltzmann")),
134  _emissivity(getParam<Real>("emissivity_1") != 0.0 && getParam<Real>("emissivity_2") != 0.0
135  ? 1.0 / getParam<Real>("emissivity_1") + 1.0 / getParam<Real>("emissivity_2") -
136  1
137  : 0.0),
138  _min_gap(getParam<Real>("min_gap")),
139  _min_gap_order(getParam<unsigned int>("min_gap_order")),
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 
171  if (_mesh.uniformRefineLevel() != 0)
172  mooseError("GapConductance does not work with uniform mesh refinement.");
173 }
174 
175 void
177 {
179  _pars, _coord_sys, _fe_problem.getAxisymmetricRadialCoord(), _gap_geometry_type, _p1, _p2);
180 }
181 
182 void
183 GapConductance::setGapGeometryParameters(const InputParameters & params,
184  const Moose::CoordinateSystemType coord_sys,
185  unsigned int axisymmetric_radial_coord,
186  GAP_GEOMETRY & gap_geometry_type,
187  Point & p1,
188  Point & p2)
189 {
190  if (params.isParamSetByUser("gap_geometry_type"))
191  {
192  gap_geometry_type =
193  GapConductance::GAP_GEOMETRY(int(params.get<MooseEnum>("gap_geometry_type")));
194  }
195  else
196  {
197  if (coord_sys == Moose::COORD_XYZ)
198  gap_geometry_type = GapConductance::PLATE;
199  else if (coord_sys == Moose::COORD_RZ)
200  gap_geometry_type = GapConductance::CYLINDER;
201  else if (coord_sys == Moose::COORD_RSPHERICAL)
202  gap_geometry_type = GapConductance::SPHERE;
203  }
204 
205  if (gap_geometry_type == GapConductance::PLATE)
206  {
207  if (coord_sys == Moose::COORD_RSPHERICAL)
208  ::mooseError("'gap_geometry_type = PLATE' cannot be used with models having a spherical "
209  "coordinate system.");
210  }
211  else if (gap_geometry_type == GapConductance::CYLINDER)
212  {
213  if (coord_sys == Moose::COORD_XYZ)
214  {
215  if (!params.isParamValid("cylinder_axis_point_1") ||
216  !params.isParamValid("cylinder_axis_point_2"))
217  ::mooseError("For 'gap_geometry_type = CYLINDER' to be used with a Cartesian model, "
218  "'cylinder_axis_point_1' and 'cylinder_axis_point_2' must be specified.");
219  p1 = params.get<RealVectorValue>("cylinder_axis_point_1");
220  p2 = params.get<RealVectorValue>("cylinder_axis_point_2");
221  }
222  else if (coord_sys == Moose::COORD_RZ)
223  {
224  if (params.isParamValid("cylinder_axis_point_1") ||
225  params.isParamValid("cylinder_axis_point_2"))
226  ::mooseError("The 'cylinder_axis_point_1' and 'cylinder_axis_point_2' cannot be specified "
227  "with axisymmetric models. The y-axis is used as the cylindrical axis of "
228  "symmetry.");
229 
230  if (axisymmetric_radial_coord == 0) // R-Z problem
231  {
232  p1 = Point(0, 0, 0);
233  p2 = Point(0, 1, 0);
234  }
235  else // Z-R problem
236  {
237  p1 = Point(0, 0, 0);
238  p2 = Point(1, 0, 0);
239  }
240  }
241  else if (coord_sys == Moose::COORD_RSPHERICAL)
242  ::mooseError("'gap_geometry_type = CYLINDER' cannot be used with models having a spherical "
243  "coordinate system.");
244  }
245  else if (gap_geometry_type == GapConductance::SPHERE)
246  {
247  if (coord_sys == Moose::COORD_XYZ || coord_sys == Moose::COORD_RZ)
248  {
249  if (!params.isParamValid("sphere_origin"))
250  ::mooseError("For 'gap_geometry_type = SPHERE' to be used with a Cartesian or axisymmetric "
251  "model, 'sphere_origin' must be specified.");
252  p1 = params.get<RealVectorValue>("sphere_origin");
253  }
254  else if (coord_sys == Moose::COORD_RSPHERICAL)
255  {
256  if (params.isParamValid("sphere_origin"))
257  ::mooseError("The 'sphere_origin' cannot be specified with spherical models. x=0 is used "
258  "as the spherical origin.");
259  p1 = Point(0, 0, 0);
260  }
261  }
262 }
263 
264 void
266 {
269 }
270 
271 void
273 {
274  if (_has_info)
275  {
278  }
279  else
280  {
281  _gap_conductance[_qp] = 0;
282  _gap_conductance_dT[_qp] = 0;
283  }
284 }
285 
286 Real
287 GapConductance::gapAttenuation(Real adjusted_length, Real min_gap, unsigned int min_gap_order)
288 {
289  mooseAssert(min_gap > 0, "min_gap must be larger than zero.");
290 
291  if (adjusted_length > min_gap)
292  return 1.0 / adjusted_length;
293  else
294  switch (min_gap_order)
295  {
296  case 0:
297  return 1.0 / min_gap;
298 
299  case 1:
300  return 1.0 / min_gap - (adjusted_length - min_gap) / (min_gap * min_gap);
301 
302  default:
303  ::mooseError("Invalid Taylor expansion order");
304  }
305 }
306 
307 Real
309 {
311  const Real adjusted_length = gapLength(_gap_geometry_type, _radius, _r1, _r2, _max_gap);
312  return _gap_thermal_conductivity[_qp] * gapAttenuation(adjusted_length, _min_gap, _min_gap_order);
313 }
314 
315 Real
317 {
318  return 0.0;
319 }
320 
321 Real
323 {
324  /*
325  Gap conductance due to radiation is based on the diffusion approximation:
326 
327  qr = sigma*Fe*(Tf^4 - Tc^4) ~ hr(Tf - Tc)
328  where sigma is the Stefan-Boltzmann constant, Fe is an emissivity function, Tf and Tc
329  are the fuel and clad absolute temperatures, respectively, and hr is the radiant gap
330  conductance. Solving for hr,
331 
332  hr = sigma*Fe*(Tf^4 - Tc^4) / (Tf - Tc)
333  which can be factored to give:
334 
335  hr = sigma*Fe*(Tf^2 + Tc^2) * (Tf + Tc)
336 
337  Approximating the fuel-clad gap as infinite parallel planes, the emissivity function is given by:
338 
339  Fe = 1 / (1/ef + 1/ec - 1)
340  */
341 
342  if (_emissivity == 0.0)
343  return 0.0;
344 
345  const Real temp_func =
346  (_temp[_qp] * _temp[_qp] + _gap_temp * _gap_temp) * (_temp[_qp] + _gap_temp);
347  return _stefan_boltzmann * temp_func / _emissivity;
348 }
349 
350 Real
352 {
353  if (_emissivity == 0.0)
354  return 0.0;
355 
356  const Real temp_func = 3 * _temp[_qp] * _temp[_qp] + _gap_temp * (2 * _temp[_qp] + _gap_temp);
357  return _stefan_boltzmann * temp_func / _emissivity;
358 }
359 
360 Real
362  const GapConductance::GAP_GEOMETRY & gap_geom, Real radius, Real r1, Real r2, Real max_gap)
363 {
364  if (gap_geom == GapConductance::CYLINDER)
365  return gapCyl(radius, r1, r2, max_gap);
366  else if (gap_geom == GapConductance::SPHERE)
367  return gapSphere(radius, r1, r2, max_gap);
368  else
369  return gapRect(r2 - r1, max_gap);
370 }
371 
372 Real
373 GapConductance::gapRect(Real distance, Real max_gap)
374 {
375  return std::min(distance, max_gap);
376 }
377 
378 Real
379 GapConductance::gapCyl(Real radius, Real r1, Real r2, Real max_denom)
380 {
381  const Real denominator = radius * std::log(r2 / r1);
382  return std::min(denominator, max_denom);
383 }
384 
385 Real
386 GapConductance::gapSphere(Real radius, Real r1, Real r2, Real max_denom)
387 {
388  const Real denominator = radius * radius * ((1.0 / r1) - (1.0 / r2));
389  return std::min(denominator, max_denom);
390 }
391 
392 Real
394 {
395  Real gap_conductivity = _gap_conductivity;
396 
398  {
400  gap_conductivity *= _gap_conductivity_function->value(
401  (*_gap_conductivity_function_variable)[_qp], _q_point[_qp]);
402  else
403  gap_conductivity *= _gap_conductivity_function->value(_t, _q_point[_qp]);
404  }
405 
406  return gap_conductivity;
407 }
408 
409 void
411 {
412  if (!_quadrature)
413  {
414  _has_info = true;
415  _gap_temp = _gap_temp_value[_qp];
417  }
418  else
419  {
420  Node * qnode = _mesh.getQuadratureNode(_current_elem, _current_side, _qp);
421  PenetrationInfo * pinfo = _penetration_locator->_penetration_info[qnode->id()];
422 
423  _gap_temp = 0.0;
424  _gap_distance = 88888;
425  _has_info = false;
426 
427  if (pinfo)
428  {
429  _gap_distance = pinfo->_distance;
430  _has_info = true;
431 
432  const Elem * slave_side = pinfo->_side;
433  std::vector<std::vector<Real>> & slave_side_phi = pinfo->_side_phi;
434  std::vector<dof_id_type> slave_side_dof_indices;
435 
436  _dof_map->dof_indices(slave_side, slave_side_dof_indices, _temp_var->number());
437 
438  for (unsigned int i = 0; i < slave_side_dof_indices.size(); ++i)
439  {
440  // The zero index is because we only have one point that the phis are evaluated at
441  _gap_temp += slave_side_phi[i][0] * (*(*_serialized_solution))(slave_side_dof_indices[i]);
442  }
443  }
444  else
445  {
446  if (_warnings)
447  mooseWarning("No gap value information found for node ",
448  qnode->id(),
449  " on processor ",
450  processor_id(),
451  " at coordinate ",
452  Point(*qnode));
453  }
454  }
455 
456  Point current_point(_q_point[_qp]);
458  _gap_geometry_type, current_point, _p1, _p2, _gap_distance, _normals[_qp], _r1, _r2, _radius);
459 }
460 
461 void
463  const Point & current_point,
464  const Point & p1,
465  const Point & p2,
466  const Real & gap_distance,
467  const Point & current_normal,
468  Real & r1,
469  Real & r2,
470  Real & radius)
471 {
472  if (gap_geometry_type == GapConductance::CYLINDER)
473  {
474  // The vector _p1 + t*(_p2-_p1) defines the cylindrical axis. The point along this
475  // axis closest to current_point is found by the following for t:
476  const Point p2p1(p2 - p1);
477  const Point p1pc(p1 - current_point);
478  const Real t = -(p1pc * p2p1) / p2p1.norm_sq();
479 
480  // The nearest point on the cylindrical axis to current_point is p.
481  const Point p(p1 + t * p2p1);
482  Point rad_vec(current_point - p);
483  Real rad = rad_vec.norm();
484  rad_vec /= rad;
485  Real rad_dot_norm = rad_vec * current_normal;
486 
487  if (rad_dot_norm > 0)
488  {
489  r1 = rad;
490  r2 = rad - gap_distance; // note, gap_distance is negative
491  radius = r1;
492  }
493  else if (rad_dot_norm < 0)
494  {
495  r1 = rad + gap_distance;
496  r2 = rad;
497  radius = r2;
498  }
499  else
500  ::mooseError("Issue with cylindrical flux calc. normals.\n");
501  }
502  else if (gap_geometry_type == GapConductance::SPHERE)
503  {
504  const Point origin_to_curr_point(current_point - p1);
505  const Real normal_dot = origin_to_curr_point * current_normal;
506  const Real curr_point_radius = origin_to_curr_point.norm();
507  if (normal_dot > 0) // on inside surface
508  {
509  r1 = curr_point_radius;
510  r2 = curr_point_radius - gap_distance; // gap_distance is negative
511  radius = r1;
512  }
513  else if (normal_dot < 0) // on outside surface
514  {
515  r1 = curr_point_radius + gap_distance; // gap_distance is negative
516  r2 = curr_point_radius;
517  radius = r2;
518  }
519  else
520  ::mooseError("Issue with spherical flux calc. normals. \n");
521  }
522  else
523  {
524  r2 = -gap_distance;
525  r1 = 0;
526  radius = 0;
527  }
528 }
GapConductance::_gap_conductance_dT
MaterialProperty< Real > & _gap_conductance_dT
Definition: GapConductance.h:101
GapConductance::_gap_thermal_conductivity
MaterialProperty< Real > & _gap_thermal_conductivity
Definition: GapConductance.h:102
GapConductance::_gap_conductivity
const Real _gap_conductivity
Definition: GapConductance.h:104
GapConductance::_temp_var
MooseVariable * _temp_var
Definition: GapConductance.h:115
GapConductance::_gap_conductance
MaterialProperty< Real > & _gap_conductance
Definition: GapConductance.h:100
GapConductance::initialSetup
virtual void initialSetup() override
Definition: GapConductance.C:176
GapConductance::_dof_map
DofMap * _dof_map
Definition: GapConductance.h:118
GapConductance::validParams
static InputParameters validParams()
Definition: GapConductance.C:27
GapConductance::CYLINDER
Definition: GapConductance.h:23
GapConductance::_gap_conductivity_function
const Function *const _gap_conductivity_function
Definition: GapConductance.h:105
GapConductance::_gap_conductivity_function_variable
const VariableValue * _gap_conductivity_function_variable
Definition: GapConductance.h:106
GapConductance::_r1
Real _r1
Definition: GapConductance.h:93
GapConductance::_quadrature
bool _quadrature
Definition: GapConductance.h:88
GapConductance::gapAttenuation
static Real gapAttenuation(Real adjusted_length, Real min_gap, unsigned int min_gap_order)
Definition: GapConductance.C:287
GapConductance::_gap_distance
Real _gap_distance
Definition: GapConductance.h:91
GapConductance::_gap_temp_value
const VariableValue & _gap_temp_value
Definition: GapConductance.h:99
GapConductance::_radius
Real _radius
Definition: GapConductance.h:92
GapConductance::gapLength
static Real gapLength(const GAP_GEOMETRY &gap_geom, Real radius, Real r1, Real r2, Real max_gap)
Definition: GapConductance.C:361
GapConductance::dh_radiation
virtual Real dh_radiation()
Definition: GapConductance.C:351
GapConductance::setGapGeometryParameters
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)
Definition: GapConductance.C:183
GapConductance::_p2
Point & _p2
Definition: GapConductance.h:122
GapConductance::_r2
Real _r2
Definition: GapConductance.h:94
GapConductance::_has_info
bool _has_info
Definition: GapConductance.h:96
GapConductance::_max_gap
const Real _max_gap
Definition: GapConductance.h:113
GapConductance::_min_gap_order
const unsigned int _min_gap_order
Definition: GapConductance.h:112
GapConductance::gapCyl
static Real gapCyl(Real radius, Real r1, Real r2, Real max_denom)
Definition: GapConductance.C:379
GapConductance::h_radiation
virtual Real h_radiation()
Definition: GapConductance.C:322
GapConductance::gapSphere
static Real gapSphere(Real radius, Real r1, Real r2, Real max_denom)
Definition: GapConductance.C:386
GapConductance::gapRect
static Real gapRect(Real distance, Real max_gap)
Definition: GapConductance.C:373
GapConductance::_min_gap
const Real _min_gap
Definition: GapConductance.h:111
GapConductance::computeGapValues
virtual void computeGapValues()
Definition: GapConductance.C:410
GapConductance::h_conduction
virtual Real h_conduction()
Definition: GapConductance.C:308
GapConductance::SPHERE
Definition: GapConductance.h:24
GapConductance::_gap_temp
Real _gap_temp
Definition: GapConductance.h:90
GapConductance::GAP_GEOMETRY
GAP_GEOMETRY
Definition: GapConductance.h:20
GapConductance.h
GapConductance::_gap_distance_value
const VariableValue & _gap_distance_value
Definition: GapConductance.h:98
validParams
InputParameters validParams()
GapConductance::dh_conduction
virtual Real dh_conduction()
Definition: GapConductance.C:316
GapConductance::_warnings
const bool _warnings
Definition: GapConductance.h:119
GapConductance::_emissivity
Real _emissivity
Definition: GapConductance.h:109
GapConductance::_p1
Point & _p1
Definition: GapConductance.h:121
GapConductance::PLATE
Definition: GapConductance.h:22
GapConductance::computeQpProperties
virtual void computeQpProperties() override
Definition: GapConductance.C:265
GapConductance::_gap_geometry_type
GAP_GEOMETRY & _gap_geometry_type
Definition: GapConductance.h:86
registerMooseObject
registerMooseObject("HeatConductionApp", GapConductance)
GapConductance::_penetration_locator
PenetrationLocator * _penetration_locator
Definition: GapConductance.h:116
GapConductance::_stefan_boltzmann
const Real _stefan_boltzmann
Definition: GapConductance.h:108
GapConductance::GapConductance
GapConductance(const InputParameters &parameters)
Definition: GapConductance.C:108
GapConductance::computeQpConductance
virtual void computeQpConductance()
Override this to compute the conductance at _qp.
Definition: GapConductance.C:272
GapConductance::_temp
const VariableValue & _temp
Definition: GapConductance.h:84
GapConductance::gapK
virtual Real gapK()
Definition: GapConductance.C:393
GapConductance::actionParameters
static InputParameters actionParameters()
Definition: GapConductance.C:74
defineLegacyParams
defineLegacyParams(GapConductance)
GapConductance::computeGapRadii
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)
Definition: GapConductance.C:462
GapConductance
Generic gap heat transfer model, with h_gap = h_conduction + h_contact + h_radiation.
Definition: GapConductance.h:17