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