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>("gap",
54  "(Its an added distance between a perimetric pin and the duct: "
55  "Edge Pitch W = (pitch/2 - pin_diameter/2 + gap) [m]");
56  params.addParam<unsigned int>("block_id", 0, "Domain Index");
57  return params;
58 }
59 
61  : MeshGenerator(params),
62  _unheated_length_entry(getParam<Real>("unheated_length_entry")),
63  _heated_length(getParam<Real>("heated_length")),
64  _unheated_length_exit(getParam<Real>("unheated_length_exit")),
65  _spacer_z(getParam<std::vector<Real>>("spacer_z")),
66  _spacer_k(getParam<std::vector<Real>>("spacer_k")),
67  _z_blockage(getParam<std::vector<Real>>("z_blockage")),
68  _index_blockage(getParam<std::vector<unsigned int>>("index_blockage")),
69  _reduction_blockage(getParam<std::vector<Real>>("reduction_blockage")),
70  _k_blockage(getParam<std::vector<Real>>("k_blockage")),
71  _kij(getParam<Real>("Kij")),
72  _pitch(getParam<Real>("pitch")),
73  _pin_diameter(getParam<Real>("pin_diameter")),
74  _n_cells(getParam<unsigned int>("n_cells")),
75  _nx(getParam<unsigned int>("nx")),
76  _ny(getParam<unsigned int>("ny")),
77  _n_channels(_nx * _ny),
78  _n_gaps((_nx - 1) * _ny + (_ny - 1) * _nx),
79  _n_pins((_nx - 1) * (_ny - 1)),
80  _gap(getParam<Real>("gap")),
81  _block_id(getParam<unsigned int>("block_id"))
82 {
83  if (_spacer_z.size() != _spacer_k.size())
84  mooseError(name(), ": Size of vector spacer_z should be equal to size of vector spacer_k");
85 
86  if (_spacer_z.size() &&
88  mooseError(name(), ": Location of spacers should be less than the total bundle length");
89 
90  if (_z_blockage.size() != 2)
91  mooseError(name(), ": Size of vector z_blockage must be 2");
92 
93  if (*max_element(_index_blockage.begin(), _index_blockage.end()) > (_n_channels - 1))
94  mooseError(name(),
95  ": The index of the blocked subchannel cannot be more than the max index of the "
96  "subchannels");
97 
98  if (*max_element(_reduction_blockage.begin(), _reduction_blockage.end()) > 1)
99  mooseError(name(), ": The area reduction of the blocked subchannels cannot be more than 1");
100 
101  if ((_index_blockage.size() > _nx * _ny) || (_reduction_blockage.size() > _nx * _ny) ||
102  (_k_blockage.size() > _nx * _ny))
103  mooseError(name(),
104  ": Size of vectors: index_blockage, reduction_blockage, k_blockage, cannot be more "
105  "than the total number of subchannels");
106 
107  if ((_index_blockage.size() != _reduction_blockage.size()) ||
108  (_index_blockage.size() != _k_blockage.size()) ||
109  (_reduction_blockage.size() != _k_blockage.size()))
110  mooseError(name(),
111  ": Size of vectors: index_blockage, reduction_blockage, k_blockage, must be equal "
112  "to eachother");
113 
114  if (_nx < 2 && _ny < 2)
115  mooseError(name(),
116  ": The number of subchannels cannot be less than 2 in both directions (x and y). "
117  "Smallest assembly allowed is either 2X1 or 1X2. ");
118 
121 
122  // Defining the total length from 3 axial sections
124 
125  // Defining the position of the spacer grid in the numerical solution array
126  std::vector<int> spacer_cell;
127  for (const auto & elem : _spacer_z)
128  spacer_cell.emplace_back(std::round(elem * _n_cells / L));
129 
130  // Defining the arrays for axial resistances
131  std::vector<Real> kgrid;
132  kgrid.resize(_n_cells + 1, 0.0);
133  _k_grid.resize(_n_channels, std::vector<Real>(_n_cells + 1));
134 
135  // Summing the spacer resistance to the 1D grid resistance array
136  for (unsigned int index = 0; index < spacer_cell.size(); index++)
137  kgrid[spacer_cell[index]] += _spacer_k[index];
138 
139  // Creating the 2D grid resistance array
140  for (unsigned int i = 0; i < _n_channels; i++)
141  _k_grid[i] = kgrid;
142 
143  // Add blockage resistance to the 2D grid resistane array
144  Real dz = L / _n_cells;
145  for (unsigned int i = 0; i < _n_cells + 1; i++)
146  {
147  if ((dz * i >= _z_blockage.front() && dz * i <= _z_blockage.back()))
148  {
149  unsigned int index(0);
150  for (const auto & i_ch : _index_blockage)
151  {
152  _k_grid[i_ch][i] += _k_blockage[index];
153  index++;
154  }
155  }
156  }
157 
158  // Defining the size of the maps
159  _gap_to_chan_map.resize(_n_gaps);
160  _gap_to_pin_map.resize(_n_gaps);
161  _gapnodes.resize(_n_gaps);
164  _pin_to_chan_map.resize(_n_pins);
166  _gij_map.resize(_n_cells + 1);
168 
169  for (unsigned int i = 0; i < _n_channels; i++)
170  {
171  _subchannel_position[i].reserve(3);
172  for (unsigned int j = 0; j < 3; j++)
173  {
174  _subchannel_position.at(i).push_back(0.0);
175  }
176  }
177 
178  for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
179  {
180  _gij_map[iz].reserve(_n_gaps);
181  }
182 
183  // Defining the signs for positive and negative flows
184  Real positive_flow = 1.0;
185  Real negative_flow = -1.0;
186 
187  // Defining the subchannel types
188  _subch_type.resize(_n_channels);
189  for (unsigned int iy = 0; iy < _ny; iy++)
190  {
191  for (unsigned int ix = 0; ix < _nx; ix++)
192  {
193  unsigned int i_ch = _nx * iy + ix;
194  bool is_corner = (ix == 0 && iy == 0) || (ix == _nx - 1 && iy == 0) ||
195  (ix == 0 && iy == _ny - 1) || (ix == _nx - 1 && iy == _ny - 1);
196  bool is_edge = (ix == 0 || iy == 0 || ix == _nx - 1 || iy == _ny - 1);
197 
198  if (_n_channels == 2)
199  {
201  }
202  else if (_n_channels == 4)
203  {
205  }
206  else
207  {
208  if (is_corner)
210  else if (is_edge)
212  else
214  }
215  }
216  }
217 
218  // Index the east-west gaps.
219  unsigned int i_gap = 0;
220  for (unsigned int iy = 0; iy < _ny; iy++)
221  {
222  for (unsigned int ix = 0; ix < _nx - 1; ix++)
223  {
224  unsigned int i_ch = _nx * iy + ix;
225  unsigned int j_ch = _nx * iy + (ix + 1);
226  _gap_to_chan_map[i_gap] = {i_ch, j_ch};
227  _chan_to_gap_map[i_ch].push_back(i_gap);
228  _chan_to_gap_map[j_ch].push_back(i_gap);
229  _sign_id_crossflow_map[i_ch].push_back(positive_flow);
230  _sign_id_crossflow_map[j_ch].push_back(negative_flow);
231 
232  // make a gap size map
233  if (iy == 0 || iy == _ny - 1)
234  _gij_map[0].push_back((_pitch - _pin_diameter) / 2 + _gap);
235  else
236  _gij_map[0].push_back(_pitch - _pin_diameter);
237  ++i_gap;
238  }
239  }
240 
241  // Index the north-south gaps.
242  for (unsigned int iy = 0; iy < _ny - 1; iy++)
243  {
244  for (unsigned int ix = 0; ix < _nx; ix++)
245  {
246  unsigned int i_ch = _nx * iy + ix;
247  unsigned int j_ch = _nx * (iy + 1) + ix;
248  _gap_to_chan_map[i_gap] = {i_ch, j_ch};
249  _chan_to_gap_map[i_ch].push_back(i_gap);
250  _chan_to_gap_map[j_ch].push_back(i_gap);
251  _sign_id_crossflow_map[i_ch].push_back(positive_flow);
252  _sign_id_crossflow_map[j_ch].push_back(negative_flow);
253 
254  // make a gap size map
255  if (ix == 0 || ix == _nx - 1)
256  _gij_map[0].push_back((_pitch - _pin_diameter) / 2 + _gap);
257  else
258  _gij_map[0].push_back(_pitch - _pin_diameter);
259  ++i_gap;
260  }
261  }
262 
263  for (unsigned int iz = 1; iz < _n_cells + 1; iz++)
264  {
265  _gij_map[iz] = _gij_map[0];
266  }
267 
268  // Make pin to channel map
269  for (unsigned int iy = 0; iy < _ny - 1; iy++)
270  {
271  for (unsigned int ix = 0; ix < _nx - 1; ix++)
272  {
273  unsigned int i_pin = (_nx - 1) * iy + ix;
274  unsigned int i_chan_1 = _nx * iy + ix;
275  unsigned int i_chan_2 = _nx * (iy + 1) + ix;
276  unsigned int i_chan_3 = _nx * (iy + 1) + (ix + 1);
277  unsigned int i_chan_4 = _nx * iy + (ix + 1);
278  _pin_to_chan_map[i_pin].push_back(i_chan_1);
279  _pin_to_chan_map[i_pin].push_back(i_chan_2);
280  _pin_to_chan_map[i_pin].push_back(i_chan_3);
281  _pin_to_chan_map[i_pin].push_back(i_chan_4);
282  }
283  }
284 
285  // Make channel to pin map
286  for (unsigned int iy = 0; iy < _ny; iy++) // row
287  {
288  for (unsigned int ix = 0; ix < _nx; ix++) // column
289  {
290  unsigned int i_ch = _nx * iy + ix;
291  // Corners contact 1/4 of one pin
292  if (iy == 0 && ix == 0)
293  {
294  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
295  }
296  else if (iy == _ny - 1 && ix == 0)
297  {
298  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
299  }
300  else if (iy == 0 && ix == _nx - 1)
301  {
302  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
303  }
304  else if (iy == _ny - 1 && ix == _nx - 1)
305  {
306  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
307  }
308  // Sides contact 1/4 of two pins
309  else if (iy == 0)
310  {
311  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
312  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
313  }
314  else if (iy == _ny - 1)
315  {
316  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
317  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
318  }
319  else if (ix == 0)
320  {
321  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
322  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
323  }
324  else if (ix == _nx - 1)
325  {
326  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
327  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
328  }
329  // interior contacts 1/4 of 4 pins
330  else
331  {
332  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
333  _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
334  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
335  _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
336  }
337 
338  // set the subchannel positions
339  Real offset_x = (_nx - 1) * _pitch / 2.0;
340  Real offset_y = (_ny - 1) * _pitch / 2.0;
341  _subchannel_position[i_ch][0] = _pitch * ix - offset_x;
342  _subchannel_position[i_ch][1] = _pitch * iy - offset_y;
343  }
344  }
345 
346  // Make gap to pin map
347  for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
348  {
349  auto i_ch = _gap_to_chan_map[i_gap].first;
350  auto j_ch = _gap_to_chan_map[i_gap].second;
351  auto i_pins = _chan_to_pin_map[i_ch];
352  auto j_pins = _chan_to_pin_map[j_ch];
353  _gap_to_pin_map[i_gap] = {10000, 10000}; // Initialize with default values
354 
355  for (unsigned int i : i_pins)
356  {
357  for (unsigned int j : j_pins)
358  {
359  if (i == j)
360  {
361  if (_gap_to_pin_map[i_gap].first == 10000)
362  {
363  _gap_to_pin_map[i_gap].first = i;
364  _gap_to_pin_map[i_gap].second = i;
365  }
366  else
367  {
368  _gap_to_pin_map[i_gap].second = i;
369  }
370  }
371  }
372  }
373  }
374 
375  // Reduce reserved memory in the channel-to-gap map.
376  for (auto & gap : _chan_to_gap_map)
377  gap.shrink_to_fit();
378 
379  // Reduce reserved memory in the channel-to-pin map.
380  for (auto & pin : _chan_to_pin_map)
381  pin.shrink_to_fit();
382 
383  // Reduce reserved memory in the pin-to-channel map.
384  for (auto & pin : _pin_to_chan_map)
385  pin.shrink_to_fit();
386 }
387 
388 std::unique_ptr<MeshBase>
390 {
391  auto mesh_base = buildMeshBaseObject();
392  BoundaryInfo & boundary_info = mesh_base->get_boundary_info();
393  mesh_base->set_spatial_dimension(3);
394  mesh_base->reserve_elem(_n_cells * _ny * _nx);
395  mesh_base->reserve_nodes((_n_cells + 1) * _ny * _nx);
396  _nodes.resize(_nx * _ny);
397  // Add the points in the shape of a rectilinear grid. The grid is regular
398  // on the xy-plane with a spacing of `pitch` between points. The grid along
399  // z is irregular to account for Pin spacers. Store pointers in the _nodes
400  // array so we can keep track of which points are in which channels.
401  Real offset_x = (_nx - 1) * _pitch / 2.0;
402  Real offset_y = (_ny - 1) * _pitch / 2.0;
403  unsigned int node_id = 0;
404  for (unsigned int iy = 0; iy < _ny; iy++)
405  {
406  for (unsigned int ix = 0; ix < _nx; ix++)
407  {
408  int i_ch = _nx * iy + ix;
409  _nodes[i_ch].reserve(_n_cells);
410  for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
411  {
412  _nodes[i_ch].push_back(mesh_base->add_point(
413  Point(_pitch * ix - offset_x, _pitch * iy - offset_y, _z_grid[iz]), node_id++));
414  }
415  }
416  }
417 
418  // Add the elements which in this case are 2-node edges that link each
419  // subchannel's nodes vertically.
420  unsigned int elem_id = 0;
421  for (unsigned int iy = 0; iy < _ny; iy++)
422  {
423  for (unsigned int ix = 0; ix < _nx; ix++)
424  {
425  for (unsigned int iz = 0; iz < _n_cells; iz++)
426  {
427  Elem * elem = new Edge2;
428  elem->subdomain_id() = _block_id;
429  elem->set_id(elem_id++);
430  elem = mesh_base->add_elem(elem);
431  const int indx1 = ((_n_cells + 1) * _nx) * iy + (_n_cells + 1) * ix + iz;
432  const int indx2 = ((_n_cells + 1) * _nx) * iy + (_n_cells + 1) * ix + (iz + 1);
433  elem->set_node(0, mesh_base->node_ptr(indx1));
434  elem->set_node(1, mesh_base->node_ptr(indx2));
435 
436  if (iz == 0)
437  boundary_info.add_side(elem, 0, 0);
438  if (iz == _n_cells - 1)
439  boundary_info.add_side(elem, 1, 1);
440  }
441  }
442  }
443 
444  boundary_info.sideset_name(0) = "inlet";
445  boundary_info.sideset_name(1) = "outlet";
446  boundary_info.nodeset_name(0) = "inlet";
447  boundary_info.nodeset_name(1) = "outlet";
448  mesh_base->subdomain_name(_block_id) = name();
449  mesh_base->prepare_for_use();
450 
451  // move the meta data into QuadSubChannelMesh
452  auto & sch_mesh = static_cast<QuadSubChannelMesh &>(*_mesh);
454  sch_mesh._heated_length = _heated_length;
455  sch_mesh._unheated_length_exit = _unheated_length_exit;
456  sch_mesh._z_grid = _z_grid;
457  sch_mesh._k_grid = _k_grid;
458  sch_mesh._spacer_z = _spacer_z;
459  sch_mesh._spacer_k = _spacer_k;
460  sch_mesh._z_blockage = _z_blockage;
461  sch_mesh._index_blockage = _index_blockage;
462  sch_mesh._reduction_blockage = _reduction_blockage;
463  sch_mesh._kij = _kij;
464  sch_mesh._pitch = _pitch;
465  sch_mesh._pin_diameter = _pin_diameter;
466  sch_mesh._n_cells = _n_cells;
467  sch_mesh._nx = _nx;
468  sch_mesh._ny = _ny;
469  sch_mesh._n_channels = _n_channels;
470  sch_mesh._n_gaps = _n_gaps;
471  sch_mesh._n_pins = _n_pins;
472  sch_mesh._gap = _gap;
473  sch_mesh._nodes = _nodes;
474  sch_mesh._gapnodes = _gapnodes;
475  sch_mesh._gap_to_chan_map = _gap_to_chan_map;
476  sch_mesh._gap_to_pin_map = _gap_to_pin_map;
477  sch_mesh._chan_to_gap_map = _chan_to_gap_map;
478  sch_mesh._chan_to_pin_map = _chan_to_pin_map;
479  sch_mesh._pin_to_chan_map = _pin_to_chan_map;
480  sch_mesh._sign_id_crossflow_map = _sign_id_crossflow_map;
481  sch_mesh._gij_map = _gij_map;
482  sch_mesh._subchannel_position = _subchannel_position;
483  sch_mesh._subch_type = _subch_type;
484 
485  return mesh_base;
486 }
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 Real _gap
The gap, not to be confused with the gap between pins, this refers to the gap next to the duct...
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
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.
virtual const std::string & name() const
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.
registerMooseObjectRenamed("SubChannelApp", QuadSubChannelMeshGenerator, "06/30/2025 24:00", SCMQuadSubChannelMeshGenerator)
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
std::vector< std::vector< unsigned int > > _pin_to_chan_map
void mooseError(Args &&... args) const
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.