https://mooseframework.inl.gov
SCMQuadSubChannelMeshGenerator.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
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 
11 #include "QuadSubChannelMesh.h"
12 #include "libmesh/edge_edge2.h"
13 #include <numeric>
14 
16 registerMooseObjectRenamed("SubChannelApp",
17  QuadSubChannelMeshGenerator,
18  "06/30/2025 24:00",
20 
23 {
25  params.addClassDescription("Creates a mesh of 1D subchannels in a square lattice arrangement");
26  params.addRequiredParam<Real>("pitch", "Pitch [m]");
27  params.addRequiredParam<Real>("pin_diameter", "Rod diameter [m]");
28  params.addParam<Real>("unheated_length_entry", 0.0, "Unheated length at entry [m]");
29  params.addRequiredParam<Real>("heated_length", "Heated length [m]");
30  params.addParam<Real>("unheated_length_exit", 0.0, "Unheated length at exit [m]");
31  params.addParam<std::vector<Real>>(
32  "spacer_z", {}, "Axial location of spacers/vanes/mixing_vanes [m]");
33  params.addParam<std::vector<Real>>(
34  "spacer_k", {}, "K-loss coefficient of spacers/vanes/mixing_vanes [-]");
35  params.addParam<std::vector<Real>>("z_blockage",
36  std::vector<Real>({0.0, 0.0}),
37  "axial location of blockage (inlet, outlet) [m]");
38  params.addParam<std::vector<unsigned int>>("index_blockage",
39  std::vector<unsigned int>({0}),
40  "index of subchannels affected by blockage");
41  params.addParam<std::vector<Real>>(
42  "reduction_blockage",
43  std::vector<Real>({1.0}),
44  "Area reduction of subchannels affected by blockage (number to muliply the area)");
45  params.addParam<std::vector<Real>>("k_blockage",
46  std::vector<Real>({0.0}),
47  "Form loss coefficient of subchannels affected by blockage");
48 
49  params.addParam<Real>("Kij", 0.5, "Lateral form loss coefficient [-]");
50  params.addRequiredParam<unsigned int>("n_cells", "The number of cells in the axial direction");
51  params.addRequiredParam<unsigned int>("nx", "Number of channels in the x direction [-]");
52  params.addRequiredParam<unsigned int>("ny", "Number of channels in the y direction [-]");
53  params.addRequiredParam<Real>(
54  "gap",
55  "The side gap, not to be confused with the gap between pins, this refers to the gap "
56  "next to the duct or else the distance between the subchannel centroid to the duct wall."
57  "distance(edge pin center, duct wall) = pitch / 2 + side_gap [m]");
58  params.deprecateParam("gap", "side_gap", "08/06/2026");
59  params.addParam<unsigned int>("block_id", 0, "Domain Index");
60  return params;
61 }
62 
64  : MeshGenerator(params),
65  _unheated_length_entry(getParam<Real>("unheated_length_entry")),
66  _heated_length(getParam<Real>("heated_length")),
67  _unheated_length_exit(getParam<Real>("unheated_length_exit")),
68  _spacer_z(getParam<std::vector<Real>>("spacer_z")),
69  _spacer_k(getParam<std::vector<Real>>("spacer_k")),
70  _z_blockage(getParam<std::vector<Real>>("z_blockage")),
71  _index_blockage(getParam<std::vector<unsigned int>>("index_blockage")),
72  _reduction_blockage(getParam<std::vector<Real>>("reduction_blockage")),
73  _k_blockage(getParam<std::vector<Real>>("k_blockage")),
74  _kij(getParam<Real>("Kij")),
75  _pitch(getParam<Real>("pitch")),
76  _pin_diameter(getParam<Real>("pin_diameter")),
77  _n_cells(getParam<unsigned int>("n_cells")),
78  _nx(getParam<unsigned int>("nx")),
79  _ny(getParam<unsigned int>("ny")),
80  _n_channels(_nx * _ny),
81  _n_gaps((_nx - 1) * _ny + (_ny - 1) * _nx),
82  _n_pins((_nx - 1) * (_ny - 1)),
83  _side_gap(getParam<Real>("side_gap")),
84  _block_id(getParam<unsigned int>("block_id"))
85 {
86  if (_spacer_z.size() != _spacer_k.size())
87  mooseError(name(), ": Size of vector spacer_z should be equal to size of vector spacer_k");
88 
89  if (_spacer_z.size() &&
91  mooseError(name(), ": Location of spacers should be less than the total bundle length");
92 
93  if (_z_blockage.size() != 2)
94  mooseError(name(), ": Size of vector z_blockage must be 2");
95 
96  if (*max_element(_index_blockage.begin(), _index_blockage.end()) > (_n_channels - 1))
97  mooseError(name(),
98  ": The index of the blocked subchannel cannot be more than the max index of the "
99  "subchannels");
100 
101  if (*max_element(_reduction_blockage.begin(), _reduction_blockage.end()) > 1)
102  mooseError(name(), ": The area reduction of the blocked subchannels cannot be more than 1");
103 
104  if ((_index_blockage.size() > _nx * _ny) || (_reduction_blockage.size() > _nx * _ny) ||
105  (_k_blockage.size() > _nx * _ny))
106  mooseError(name(),
107  ": Size of vectors: index_blockage, reduction_blockage, k_blockage, cannot be more "
108  "than the total number of subchannels");
109 
110  if ((_index_blockage.size() != _reduction_blockage.size()) ||
111  (_index_blockage.size() != _k_blockage.size()) ||
112  (_reduction_blockage.size() != _k_blockage.size()))
113  mooseError(name(),
114  ": Size of vectors: index_blockage, reduction_blockage, k_blockage, must be equal "
115  "to eachother");
116 
117  if (_nx < 2 && _ny < 2)
118  mooseError(name(),
119  ": The number of subchannels cannot be less than 2 in both directions (x and y). "
120  "Smallest assembly allowed is either 2X1 or 1X2. ");
121 
124 
125  // Defining the total length from 3 axial sections
127 
128  // Defining the position of the spacer grid in the numerical solution array
129  std::vector<int> spacer_cell;
130  for (const auto & elem : _spacer_z)
131  spacer_cell.emplace_back(std::round(elem * _n_cells / L));
132 
133  // Defining the arrays for axial resistances
134  std::vector<Real> kgrid;
135  kgrid.resize(_n_cells + 1, 0.0);
136  _k_grid.resize(_n_channels, std::vector<Real>(_n_cells + 1));
137 
138  // Summing the spacer resistance to the 1D grid resistance array
139  for (unsigned int index = 0; index < spacer_cell.size(); index++)
140  kgrid[spacer_cell[index]] += _spacer_k[index];
141 
142  // Creating the 2D grid resistance array
143  for (unsigned int i = 0; i < _n_channels; i++)
144  _k_grid[i] = kgrid;
145 
146  // Add blockage resistance to the 2D grid resistane array
147  Real dz = L / _n_cells;
148  for (unsigned int i = 0; i < _n_cells + 1; i++)
149  {
150  if ((dz * i >= _z_blockage.front() && dz * i <= _z_blockage.back()))
151  {
152  unsigned int index(0);
153  for (const auto & i_ch : _index_blockage)
154  {
155  _k_grid[i_ch][i] += _k_blockage[index];
156  index++;
157  }
158  }
159  }
160 
161  // Defining the size of the maps
162  _gap_to_chan_map.resize(_n_gaps);
163  _gap_to_pin_map.resize(_n_gaps);
164  _gapnodes.resize(_n_gaps);
167  _pin_to_chan_map.resize(_n_pins);
169  _gij_map.resize(_n_cells + 1);
171 
172  for (unsigned int i = 0; i < _n_channels; i++)
173  {
174  _subchannel_position[i].reserve(3);
175  for (unsigned int j = 0; j < 3; j++)
176  {
177  _subchannel_position.at(i).push_back(0.0);
178  }
179  }
180 
181  for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
182  {
183  _gij_map[iz].reserve(_n_gaps);
184  }
185 
186  // Defining the signs for positive and negative flows
187  Real positive_flow = 1.0;
188  Real negative_flow = -1.0;
189 
190  // Defining the subchannel types
191  _subch_type.resize(_n_channels);
192  for (unsigned int iy = 0; iy < _ny; iy++)
193  {
194  for (unsigned int ix = 0; ix < _nx; ix++)
195  {
196  unsigned int i_ch = _nx * iy + ix;
197  bool is_corner = (ix == 0 && iy == 0) || (ix == _nx - 1 && iy == 0) ||
198  (ix == 0 && iy == _ny - 1) || (ix == _nx - 1 && iy == _ny - 1);
199  bool is_edge = (ix == 0 || iy == 0 || ix == _nx - 1 || iy == _ny - 1);
200 
201  if (_n_channels == 2)
202  {
204  }
205  else if (_n_channels == 4)
206  {
208  }
209  else
210  {
211  if (is_corner)
213  else if (is_edge)
215  else
217  }
218  }
219  }
220 
221  // Index the east-west gaps.
222  unsigned int i_gap = 0;
223  for (unsigned int iy = 0; iy < _ny; iy++)
224  {
225  for (unsigned int ix = 0; ix < _nx - 1; ix++)
226  {
227  unsigned int i_ch = _nx * iy + ix;
228  unsigned int j_ch = _nx * iy + (ix + 1);
229  _gap_to_chan_map[i_gap] = {i_ch, j_ch};
230  _chan_to_gap_map[i_ch].push_back(i_gap);
231  _chan_to_gap_map[j_ch].push_back(i_gap);
232  _sign_id_crossflow_map[i_ch].push_back(positive_flow);
233  _sign_id_crossflow_map[j_ch].push_back(negative_flow);
234 
235  // make a gap size map
236  if (iy == 0 || iy == _ny - 1)
237  _gij_map[0].push_back((_pitch - _pin_diameter) / 2 + _side_gap);
238  else
239  _gij_map[0].push_back(_pitch - _pin_diameter);
240  ++i_gap;
241  }
242  }
243 
244  // Index the north-south gaps.
245  for (unsigned int iy = 0; iy < _ny - 1; iy++)
246  {
247  for (unsigned int ix = 0; ix < _nx; ix++)
248  {
249  unsigned int i_ch = _nx * iy + ix;
250  unsigned int j_ch = _nx * (iy + 1) + ix;
251  _gap_to_chan_map[i_gap] = {i_ch, j_ch};
252  _chan_to_gap_map[i_ch].push_back(i_gap);
253  _chan_to_gap_map[j_ch].push_back(i_gap);
254  _sign_id_crossflow_map[i_ch].push_back(positive_flow);
255  _sign_id_crossflow_map[j_ch].push_back(negative_flow);
256 
257  // make a gap size map
258  if (ix == 0 || ix == _nx - 1)
259  _gij_map[0].push_back((_pitch - _pin_diameter) / 2 + _side_gap);
260  else
261  _gij_map[0].push_back(_pitch - _pin_diameter);
262  ++i_gap;
263  }
264  }
265 
266  for (unsigned int iz = 1; iz < _n_cells + 1; iz++)
267  {
268  _gij_map[iz] = _gij_map[0];
269  }
270 
271  // Make pin to channel map
272  for (unsigned int iy = 0; iy < _ny - 1; iy++)
273  {
274  for (unsigned int ix = 0; ix < _nx - 1; ix++)
275  {
276  unsigned int i_pin = (_nx - 1) * iy + ix;
277  unsigned int i_chan_1 = _nx * iy + ix;
278  unsigned int i_chan_2 = _nx * (iy + 1) + ix;
279  unsigned int i_chan_3 = _nx * (iy + 1) + (ix + 1);
280  unsigned int i_chan_4 = _nx * iy + (ix + 1);
281  _pin_to_chan_map[i_pin].push_back(i_chan_1);
282  _pin_to_chan_map[i_pin].push_back(i_chan_2);
283  _pin_to_chan_map[i_pin].push_back(i_chan_3);
284  _pin_to_chan_map[i_pin].push_back(i_chan_4);
285  }
286  }
287 
288  // Make channel to pin map
289  for (unsigned int iy = 0; iy < _ny; iy++) // row
290  {
291  for (unsigned int ix = 0; ix < _nx; ix++) // column
292  {
293  unsigned int i_ch = _nx * iy + ix;
294  // Corners contact 1/4 of one pin
295  if (iy == 0 && ix == 0)
296  {
297  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
298  }
299  else if (iy == _ny - 1 && ix == 0)
300  {
301  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
302  }
303  else if (iy == 0 && ix == _nx - 1)
304  {
305  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
306  }
307  else if (iy == _ny - 1 && ix == _nx - 1)
308  {
309  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
310  }
311  // Sides contact 1/4 of two pins
312  else if (iy == 0)
313  {
314  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
315  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
316  }
317  else if (iy == _ny - 1)
318  {
319  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
320  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
321  }
322  else if (ix == 0)
323  {
324  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
325  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
326  }
327  else if (ix == _nx - 1)
328  {
329  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
330  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
331  }
332  // interior contacts 1/4 of 4 pins
333  else
334  {
335  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
336  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
337  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
338  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
339  }
340 
341  // set the subchannel positions
342  Real offset_x = (_nx - 1) * _pitch / 2.0;
343  Real offset_y = (_ny - 1) * _pitch / 2.0;
344  _subchannel_position[i_ch][0] = _pitch * ix - offset_x;
345  _subchannel_position[i_ch][1] = _pitch * iy - offset_y;
346  }
347  }
348 
349  // Make gap to pin map
350  for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
351  {
352  auto i_ch = _gap_to_chan_map[i_gap].first;
353  auto j_ch = _gap_to_chan_map[i_gap].second;
354  auto i_pins = _chan_to_pin_map[i_ch];
355  auto j_pins = _chan_to_pin_map[j_ch];
356  _gap_to_pin_map[i_gap] = {10000, 10000}; // Initialize with default values
357 
358  for (unsigned int i : i_pins)
359  {
360  for (unsigned int j : j_pins)
361  {
362  if (i == j)
363  {
364  if (_gap_to_pin_map[i_gap].first == 10000)
365  {
366  _gap_to_pin_map[i_gap].first = i;
367  _gap_to_pin_map[i_gap].second = i;
368  }
369  else
370  {
371  _gap_to_pin_map[i_gap].second = i;
372  }
373  }
374  }
375  }
376  }
377 
378  // Reduce reserved memory in the channel-to-gap map.
379  for (auto & gap : _chan_to_gap_map)
380  gap.shrink_to_fit();
381 
382  // Reduce reserved memory in the channel-to-pin map.
383  for (auto & pin : _chan_to_pin_map)
384  pin.shrink_to_fit();
385 
386  // Reduce reserved memory in the pin-to-channel map.
387  for (auto & pin : _pin_to_chan_map)
388  pin.shrink_to_fit();
389 }
390 
391 std::unique_ptr<MeshBase>
393 {
394  auto mesh_base = buildMeshBaseObject();
395  BoundaryInfo & boundary_info = mesh_base->get_boundary_info();
396  mesh_base->set_spatial_dimension(3);
397  mesh_base->reserve_elem(_n_cells * _ny * _nx);
398  mesh_base->reserve_nodes((_n_cells + 1) * _ny * _nx);
399  _nodes.resize(_nx * _ny);
400  // Add the points in the shape of a rectilinear grid. The grid is regular
401  // on the xy-plane with a spacing of `pitch` between points. The grid along
402  // z is irregular to account for Pin spacers. Store pointers in the _nodes
403  // array so we can keep track of which points are in which channels.
404  Real offset_x = (_nx - 1) * _pitch / 2.0;
405  Real offset_y = (_ny - 1) * _pitch / 2.0;
406  unsigned int node_id = 0;
407  for (unsigned int iy = 0; iy < _ny; iy++)
408  {
409  for (unsigned int ix = 0; ix < _nx; ix++)
410  {
411  int i_ch = _nx * iy + ix;
412  _nodes[i_ch].reserve(_n_cells);
413  for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
414  {
415  _nodes[i_ch].push_back(mesh_base->add_point(
416  Point(_pitch * ix - offset_x, _pitch * iy - offset_y, _z_grid[iz]), node_id++));
417  }
418  }
419  }
420 
421  // Add the elements which in this case are 2-node edges that link each
422  // subchannel's nodes vertically.
423  unsigned int elem_id = 0;
424  for (unsigned int iy = 0; iy < _ny; iy++)
425  {
426  for (unsigned int ix = 0; ix < _nx; ix++)
427  {
428  for (unsigned int iz = 0; iz < _n_cells; iz++)
429  {
430  Elem * elem = new Edge2;
431  elem->subdomain_id() = _block_id;
432  elem->set_id(elem_id++);
433  elem = mesh_base->add_elem(elem);
434  const int indx1 = ((_n_cells + 1) * _nx) * iy + (_n_cells + 1) * ix + iz;
435  const int indx2 = ((_n_cells + 1) * _nx) * iy + (_n_cells + 1) * ix + (iz + 1);
436  elem->set_node(0, mesh_base->node_ptr(indx1));
437  elem->set_node(1, mesh_base->node_ptr(indx2));
438 
439  if (iz == 0)
440  boundary_info.add_side(elem, 0, 0);
441  if (iz == _n_cells - 1)
442  boundary_info.add_side(elem, 1, 1);
443  }
444  }
445  }
446 
447  boundary_info.sideset_name(0) = "inlet";
448  boundary_info.sideset_name(1) = "outlet";
449  boundary_info.nodeset_name(0) = "inlet";
450  boundary_info.nodeset_name(1) = "outlet";
451  mesh_base->subdomain_name(_block_id) = name();
452  mesh_base->prepare_for_use();
453 
454  // move the meta data into QuadSubChannelMesh
455  auto & sch_mesh = static_cast<QuadSubChannelMesh &>(*_mesh);
457  sch_mesh._heated_length = _heated_length;
458  sch_mesh._unheated_length_exit = _unheated_length_exit;
459  sch_mesh._z_grid = _z_grid;
460  sch_mesh._k_grid = _k_grid;
461  sch_mesh._spacer_z = _spacer_z;
462  sch_mesh._spacer_k = _spacer_k;
463  sch_mesh._z_blockage = _z_blockage;
464  sch_mesh._index_blockage = _index_blockage;
465  sch_mesh._reduction_blockage = _reduction_blockage;
466  sch_mesh._kij = _kij;
467  sch_mesh._pitch = _pitch;
468  sch_mesh._pin_diameter = _pin_diameter;
469  sch_mesh._n_cells = _n_cells;
470  sch_mesh._nx = _nx;
471  sch_mesh._ny = _ny;
472  sch_mesh._n_channels = _n_channels;
473  sch_mesh._n_gaps = _n_gaps;
474  sch_mesh._n_pins = _n_pins;
475  sch_mesh._side_gap = _side_gap;
476  sch_mesh._nodes = _nodes;
477  sch_mesh._gapnodes = _gapnodes;
478  sch_mesh._gap_to_chan_map = _gap_to_chan_map;
479  sch_mesh._gap_to_pin_map = _gap_to_pin_map;
480  sch_mesh._chan_to_gap_map = _chan_to_gap_map;
481  sch_mesh._chan_to_pin_map = _chan_to_pin_map;
482  sch_mesh._pin_to_chan_map = _pin_to_chan_map;
483  sch_mesh._sign_id_crossflow_map = _sign_id_crossflow_map;
484  sch_mesh._gij_map = _gij_map;
485  sch_mesh._subchannel_position = _subchannel_position;
486  sch_mesh._subch_type = _subch_type;
487 
488  return mesh_base;
489 }
const unsigned int _n_gaps
Number of gaps per layer.
Class for Subchannel mesh generation in the square lattice geometry.
const std::vector< Real > & _spacer_k
form loss coefficient of the spacers
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
const Real _pitch
Distance between the neighbor fuel pins, pitch.
std::vector< std::pair< unsigned int, unsigned int > > _gap_to_chan_map
const std::vector< unsigned int > _index_blockage
index of subchannels affected by blockage
const std::vector< Real > _z_blockage
axial location of blockage (inlet, outlet) [m]
Real _unheated_length_entry
unheated length of the fuel Pin at the entry of the assembly
const Real _side_gap
The side gap, not to be confused with the gap between pins, this refers to the gap next to the duct o...
std::vector< std::vector< unsigned int > > _chan_to_pin_map
Creates the mesh of subchannels in a quadrilateral lattice.
const unsigned int _n_cells
number of axial cells
const unsigned int _ny
Number of subchannels in the y direction.
std::vector< std::vector< Real > > _subchannel_position
x,y coordinates of the subchannel centroid
const unsigned int _n_channels
Total number of subchannels.
void addRequiredParam(const std::string &name, const std::string &doc_string)
const Real _unheated_length_entry
unheated length of the fuel Pin at the entry of the assembly
registerMooseObject("SubChannelApp", SCMQuadSubChannelMeshGenerator)
const std::vector< Real > _k_blockage
form loss coefficient of subchannels affected by blockage
static void generateZGrid(Real unheated_length_entry, Real heated_length, Real unheated_length_exit, unsigned int n_cells, std::vector< Real > &z_grid)
Generate the spacing in z-direction using heated and unteaded lengths.
const std::string & name() const
registerMooseObjectRenamed("SubChannelApp", QuadSubChannelMeshGenerator, "06/30/2025 24:00", SCMQuadSubChannelMeshGenerator)
void deprecateParam(const std::string &old_name, const std::string &new_name, const std::string &removal_date)
std::vector< std::vector< Node * > > _nodes
Channel nodes.
const unsigned int _nx
Number of subchannels in the x direction.
const std::vector< Real > _reduction_blockage
area reduction of subchannels affected by blockage
static InputParameters validParams()
std::vector< EChannelType > _subch_type
Subchannel type.
std::unique_ptr< MeshBase > generate() override
std::vector< std::vector< Real > > _gij_map
Vector to store gap size.
SCMQuadSubChannelMeshGenerator(const InputParameters &parameters)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
std::vector< std::vector< Node * > > _gapnodes
gap nodes
const Real _pin_diameter
fuel Pin diameter
std::vector< std::vector< unsigned int > > _chan_to_gap_map
const Real _unheated_length_exit
unheated length of the fuel Pin at the exit of the assembly
const std::vector< Real > & _spacer_z
axial location of the spacers
void mooseError(Args &&... args) const
std::vector< std::vector< unsigned int > > _pin_to_chan_map
std::vector< std::vector< double > > _sign_id_crossflow_map
Matrix used to give local sign to crossflow quantities.
void addClassDescription(const std::string &doc_string)
const unsigned int _block_id
block index
static const std::complex< double > j(0, 1)
Complex number "j" (also known as "i")
const Real & _kij
Lateral form loss coefficient.
std::vector< std::vector< Real > > _k_grid
axial form loss coefficient per computational cell
std::unique_ptr< MeshBase > buildMeshBaseObject(unsigned int dim=libMesh::invalid_uint)
std::vector< std::pair< unsigned int, unsigned int > > _gap_to_pin_map
const Real _heated_length
heated length of the fuel Pin
std::vector< Real > _z_grid
axial location of nodes
void ErrorVector unsigned int
const unsigned int _n_pins
Number of pins.