https://mooseframework.inl.gov
Loading...
Searching...
No Matches
ConcentricCircleMesh.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
10#include "ConcentricCircleMesh.h"
11#include "libmesh/face_quad4.h"
12#include "MooseMesh.h"
13#include "MooseApp.h"
14#include "libmesh/mesh_modification.h"
15#include "libmesh/serial_mesh.h"
16#include "libmesh/boundary_info.h"
17#include "libmesh/utility.h"
18// C++ includes
19#include <cmath> // provides round, not std::round (see http://www.cplusplus.com/reference/cmath/round/)
20
21registerMooseObject("MooseApp", ConcentricCircleMesh);
22
23InputParameters
24ConcentricCircleMesh::validParams()
25{
26 InputParameters params = MooseMesh::validParams();
27 MooseEnum portion(
28 "full top_right top_left bottom_left bottom_right right_half left_half top_half bottom_half",
29 "full");
30 params.addRequiredParam<unsigned int>("num_sectors",
31 "num_sectors % 2 = 0, num_sectors > 0"
32 "Number of azimuthal sectors in each quadrant"
33 "'num_sectors' must be an even number.");
34 params.addRequiredParam<std::vector<Real>>("radii", "Radii of major concentric circles");
35 params.addRequiredParam<std::vector<unsigned int>>(
36 "rings", "Number of rings in each circle or in the moderator");
37 params.addRequiredParam<Real>("inner_mesh_fraction",
38 "Length of inner square / radius of the innermost circle");
39 params.addRequiredParam<bool>(
40 "has_outer_square",
41 "It determines if meshes for a outer square are added to concentric circle meshes.");
42 params.addRangeCheckedParam<Real>(
43 "pitch",
44 0.0,
45 "pitch>=0.0",
46 "The moderator can be added to complete meshes for one unit cell of fuel assembly."
47 "Elements are quad meshes.");
48 params.addParam<MooseEnum>("portion", portion, "Control of which part of mesh is created");
49 params.addRequiredParam<bool>(
50 "preserve_volumes", "Volume of concentric circles can be preserved using this function.");
51 params.addClassDescription("This ConcentricCircleMesh source code is to generate concentric "
52 "circle meshes.");
53 return params;
54}
55
56ConcentricCircleMesh::ConcentricCircleMesh(const InputParameters & parameters)
57 : MooseMesh(parameters),
58 _num_sectors(getParam<unsigned int>("num_sectors")),
59 _radii(getParam<std::vector<Real>>("radii")),
60 _rings(getParam<std::vector<unsigned int>>("rings")),
61 _inner_mesh_fraction(getParam<Real>("inner_mesh_fraction")),
62 _has_outer_square(getParam<bool>("has_outer_square")),
63 _pitch(getParam<Real>("pitch")),
64 _preserve_volumes(getParam<bool>("preserve_volumes")),
65 _portion(getParam<MooseEnum>("portion"))
66{
67
68 if (_num_sectors % 2 != 0)
69 mooseError("ConcentricCircleMesh: num_sectors must be an even number.");
70
71 // radii data check
72 for (unsigned i = 0; i < _radii.size() - 1; ++i)
73 if (_radii[i] > _radii[i + 1])
74 mooseError("Radii must be provided in order by starting with the smallest radius and "
75 "providing the following gradual radii.");
76
77 // condition for setting the size of inner squares.
78 if (_inner_mesh_fraction > std::cos(M_PI / 4))
79 mooseError("The aspect ratio can not be larger than cos(PI/4).");
80
81 // size of 'rings' check
82 if (_has_outer_square)
83 {
84 if (_rings.size() != _radii.size() + 1)
85 mooseError("The size of 'rings' must be equal to the size of 'radii' plus 1.");
86 }
87 else
88 {
89 if (_rings.size() != _radii.size())
90 mooseError("The size of 'rings' must be equal to the size of 'radii'.");
91 }
92 // pitch / 2 must be bigger than any raddi.
93 if (_has_outer_square)
94 for (unsigned i = 0; i < _radii.size(); ++i)
95 if (_pitch / 2 < _radii[i])
96 mooseError("The pitch / 2 must be larger than any radii.");
97}
98
99std::unique_ptr<MooseMesh>
100ConcentricCircleMesh::safeClone() const
101{
102 return _app.getFactory().copyConstruct(*this);
103}
104
105void
106ConcentricCircleMesh::buildMesh()
107{
108 // Get the actual libMesh mesh
109 ReplicatedMesh & mesh = cast_ref<ReplicatedMesh &>(getMesh());
110 // Set dimension of mesh
111 mesh.set_mesh_dimension(2);
112 mesh.set_spatial_dimension(2);
113 BoundaryInfo & boundary_info = mesh.get_boundary_info();
114
115 // Creating real mesh concentric circles
116 // i: index for _rings, j: index for _radii
117 std::vector<Real> total_concentric_circles;
118 unsigned int j = 0;
119 while (j < _radii.size())
120 {
121 unsigned int i = 0;
122 if (j == 0)
123 while (i < _rings[j])
124 {
125 total_concentric_circles.push_back(_inner_mesh_fraction * _radii[j] +
126 (_radii[j] - _inner_mesh_fraction * _radii[j]) /
127 _rings[j] * (i + 1));
128 ++i;
129 }
130 else
131 while (i < _rings[j])
132 {
133 total_concentric_circles.push_back(_radii[j - 1] +
134 (_radii[j] - _radii[j - 1]) / _rings[j] * (i + 1));
135 ++i;
136 }
137 ++j;
138 }
139
140 // volume preserving function is used to conserve volume.
141 const Real d_angle = M_PI / 2 / _num_sectors;
142
143 if (_preserve_volumes)
144 {
145 Real original_radius = 0.0;
146 for (unsigned i = 0; i < total_concentric_circles.size(); ++i)
147 {
148 // volume preserving function for the center circle
149 if (i == 0)
150 {
151 const Real target_area = M_PI * libMesh::Utility::pow<2>(total_concentric_circles[i]);
152 Real modified_radius = std::sqrt(2 * target_area / std::sin(d_angle) / _num_sectors / 4);
153 original_radius = total_concentric_circles[i];
154 total_concentric_circles[i] = modified_radius;
155 }
156 else
157 {
158 // volume preserving functions for outer circles
159 const Real target_area = M_PI * (libMesh::Utility::pow<2>(total_concentric_circles[i]) -
160 libMesh::Utility::pow<2>(original_radius));
161 Real modified_radius = std::sqrt(target_area / std::sin(d_angle) / _num_sectors / 2 +
162 libMesh::Utility::pow<2>(total_concentric_circles[i - 1]));
163 original_radius = total_concentric_circles[i];
164 total_concentric_circles[i] = modified_radius;
165 }
166 }
167 }
168
169 // number of total nodes
170 unsigned num_total_nodes = 0;
171 if (_has_outer_square)
172 num_total_nodes = libMesh::Utility::pow<2>(_num_sectors / 2 + 1) +
173 (_num_sectors + 1) * (total_concentric_circles.size() + _rings.back()) +
174 (_num_sectors + 1);
175 else
176 num_total_nodes = libMesh::Utility::pow<2>(_num_sectors / 2 + 1) +
177 (_num_sectors + 1) * total_concentric_circles.size();
178
179 std::vector<Node *> nodes(num_total_nodes);
180 unsigned node_id = 0;
181
182 // for adding nodes for the square at the center of the circle
183 for (unsigned i = 0; i <= _num_sectors / 2; ++i)
184 {
185 const Real x = i * _inner_mesh_fraction * total_concentric_circles[0] / (_num_sectors / 2);
186 for (unsigned j = 0; j <= _num_sectors / 2; ++j)
187 {
188 const Real y = j * _inner_mesh_fraction * total_concentric_circles[0] / (_num_sectors / 2);
189 nodes[node_id] = mesh.add_point(Point(x, y, 0.0), node_id);
190 ++node_id;
191 }
192 }
193
194 // for adding the outer nodes of the square
195 Real current_radius = 0.0;
196
197 for (unsigned layers = 0; layers < total_concentric_circles.size(); ++layers)
198 {
199 current_radius = total_concentric_circles[layers];
200 for (unsigned num_outer_nodes = 0; num_outer_nodes <= _num_sectors; ++num_outer_nodes)
201 {
202 const Real x = current_radius * std::cos(num_outer_nodes * d_angle);
203 const Real y = current_radius * std::sin(num_outer_nodes * d_angle);
204 nodes[node_id] = mesh.add_point(Point(x, y, 0.0), node_id);
205 ++node_id;
206 }
207 }
208
209 // adding nodes for the unit cell of fuel assembly.
210 if (_has_outer_square)
211 {
212 Real current_radius_moderator = 0.0;
213 for (unsigned i = 1; i <= _rings.back(); ++i)
214 {
215 current_radius_moderator =
216 _radii.back() + i * (_pitch / 2 - _radii.back()) / (_rings.back() + 1);
217 total_concentric_circles.push_back(current_radius_moderator);
218 for (unsigned num_outer_nodes = 0; num_outer_nodes <= _num_sectors; ++num_outer_nodes)
219 {
220 const Real x = current_radius_moderator * std::cos(num_outer_nodes * d_angle);
221 const Real y = current_radius_moderator * std::sin(num_outer_nodes * d_angle);
222 nodes[node_id] = mesh.add_point(Point(x, y, 0.0), node_id);
223 ++node_id;
224 }
225 }
226
227 for (unsigned j = 0; j < _num_sectors / 2 + 1; ++j)
228 {
229 const Real x = _pitch / 2;
230 const Real y = _pitch / 2 * std::tan(j * d_angle);
231 nodes[node_id] = mesh.add_point(Point(x, y, 0.0), node_id);
232 ++node_id;
233 }
234
235 for (unsigned i = 0; i < _num_sectors / 2; ++i)
236 {
237 const Real x = _pitch / 2 * std::cos((i + _num_sectors / 2 + 1) * d_angle) /
238 std::sin((i + _num_sectors / 2 + 1) * d_angle);
239 const Real y = _pitch / 2;
240 nodes[node_id] = mesh.add_point(Point(x, y, 0.0), node_id);
241 ++node_id;
242 }
243 }
244 // Currently, index, limit, counter variables use the int type because of the 'modulo' function.
245 // adding elements
246 int index = 0;
247 int limit = 0;
248 int standard = static_cast<int>(_num_sectors);
249
250 // This is to set the limit for the index
251 if (standard > 4)
252 {
253 int additional_term = 0;
254 int counter = standard;
255 while (counter > 4)
256 {
257 counter = counter - 2;
258 additional_term = additional_term + counter;
259 }
260 limit = standard + additional_term;
261 }
262 else if (standard == 4)
263 limit = standard;
264
265 // SubdomainIDs set up
266 std::vector<unsigned int> subdomainIDs;
267 for (unsigned int i = 0; i < _rings.size(); ++i)
268 for (unsigned int j = 0; j < _rings[i]; ++j)
269 subdomainIDs.push_back(i + 1);
270
271 if (_has_outer_square)
272 subdomainIDs.push_back(subdomainIDs.back());
273 // adding elements in the square
274 while (index <= limit)
275 {
276 Elem * elem = mesh.add_elem(new Quad4);
277 elem->set_node(0, nodes[index]);
278 elem->set_node(1, nodes[index + _num_sectors / 2 + 1]);
279 elem->set_node(2, nodes[index + _num_sectors / 2 + 2]);
280 elem->set_node(3, nodes[index + 1]);
281 elem->subdomain_id() = subdomainIDs[0];
282
283 if (index < standard / 2)
284 boundary_info.add_side(elem, 3, 1);
285 if (index % (standard / 2 + 1) == 0)
286 boundary_info.add_side(elem, 0, 2);
287
288 ++index;
289 if ((index - standard / 2) % (standard / 2 + 1) == 0)
290 ++index;
291 }
292
293 index = (_num_sectors / 2 + 1) * (_num_sectors / 2);
294 limit = (_num_sectors / 2) * (_num_sectors / 2 + 2);
295
296 // adding elements in one outer layer of the square (right side)
297 while (index < limit)
298 {
299 Elem * elem = mesh.add_elem(new Quad4);
300 elem->set_node(0, nodes[index]);
301 elem->set_node(1, nodes[index + _num_sectors / 2 + 1]);
302 elem->set_node(2, nodes[index + _num_sectors / 2 + 2]);
303 elem->set_node(3, nodes[index + 1]);
304 elem->subdomain_id() = subdomainIDs[0];
305
306 if (index == (standard / 2 + 1) * (standard / 2))
307 boundary_info.add_side(elem, 0, 2);
308
309 ++index;
310 }
311
312 // adding elements in one outer layer of the square (left side)
313 int counter = 0;
314 while (index != standard / 2)
315 {
316 Elem * elem = mesh.add_elem(new Quad4);
317 elem->set_node(0, nodes[index]);
318 elem->set_node(1, nodes[index + (_num_sectors / 2 + 1) + counter * (_num_sectors / 2 + 2)]);
319 elem->set_node(2, nodes[index + (_num_sectors / 2 + 1) + counter * (_num_sectors / 2 + 2) + 1]);
320 elem->set_node(3, nodes[index - _num_sectors / 2 - 1]);
321 elem->subdomain_id() = subdomainIDs[0];
322
323 if (index == standard + 1)
324 boundary_info.add_side(elem, 2, 1);
325
326 index = index - _num_sectors / 2 - 1;
327 ++counter;
328 }
329
330 // adding elements for other concentric circles
331 index = libMesh::Utility::pow<2>(_num_sectors / 2 + 1);
332 limit = static_cast<int>(num_total_nodes) - standard - 2;
333 int num_nodes_boundary = libMesh::Utility::pow<2>(_num_sectors / 2 + 1) + _num_sectors + 1;
334
335 counter = 0;
336 while (index < limit)
337 {
338
339 Elem * elem = mesh.add_elem(new Quad4);
340 elem->set_node(0, nodes[index]);
341 elem->set_node(1, nodes[index + _num_sectors + 1]);
342 elem->set_node(2, nodes[index + _num_sectors + 2]);
343 elem->set_node(3, nodes[index + 1]);
344
345 for (int i = 0; i < static_cast<int>(subdomainIDs.size()) - 1; ++i)
346 if (index < limit - (standard + 1) * i && index >= limit - (standard + 1) * (i + 1))
347 elem->subdomain_id() = subdomainIDs[subdomainIDs.size() - 1 - i];
348
349 int const initial = libMesh::Utility::pow<2>(standard / 2 + 1);
350 int const final = libMesh::Utility::pow<2>(standard / 2 + 1) + _num_sectors - 1;
351
352 if ((index - initial) % (standard + 1) == 0)
353 boundary_info.add_side(elem, 0, 2);
354 if ((index - final) % (standard + 1) == 0)
355 boundary_info.add_side(elem, 2, 1);
356 if (index > limit - (standard + 1))
357 {
358 if (_has_outer_square)
359 {
360 if (index < limit - standard + standard / 2)
361 boundary_info.add_side(elem, 1, 3);
362 else
363 boundary_info.add_side(elem, 1, 4);
364 }
365 else
366 {
367 boundary_info.add_side(elem, 1, 3);
368 }
369 }
370 ++index;
371 if (index == (num_nodes_boundary + counter * (standard + 1)) - 1)
372 {
373 ++index;
374 ++counter;
375 }
376 }
377
378 // This is to set boundary names.
379 boundary_info.sideset_name(1) = "left";
380 boundary_info.sideset_name(2) = "bottom";
381
382 if (!_has_outer_square)
383 boundary_info.sideset_name(3) = "outer";
384 else
385 {
386 boundary_info.sideset_name(3) = "right";
387 boundary_info.sideset_name(4) = "top";
388 }
389
390 if (_portion == "top_left")
391 {
392 libMesh::MeshTools::Modification::rotate(mesh, 90, 0, 0);
393 boundary_info.sideset_name(1) = "bottom";
394 boundary_info.sideset_name(2) = "right";
395
396 if (!_has_outer_square)
397 boundary_info.sideset_name(3) = "outer";
398 else
399 {
400 boundary_info.sideset_name(3) = "top";
401 boundary_info.sideset_name(4) = "left";
402 }
403 }
404 else if (_portion == "bottom_left")
405 {
406 libMesh::MeshTools::Modification::rotate(mesh, 180, 0, 0);
407 boundary_info.sideset_name(1) = "right";
408 boundary_info.sideset_name(2) = "top";
409
410 if (!_has_outer_square)
411 boundary_info.sideset_name(3) = "outer";
412 else
413 {
414 boundary_info.sideset_name(3) = "left";
415 boundary_info.sideset_name(4) = "bottom";
416 }
417 }
418 else if (_portion == "bottom_right")
419 {
420 libMesh::MeshTools::Modification::rotate(mesh, 270, 0, 0);
421 boundary_info.sideset_name(1) = "top";
422 boundary_info.sideset_name(2) = "left";
423
424 if (!_has_outer_square)
425 boundary_info.sideset_name(3) = "outer";
426 else
427 {
428 boundary_info.sideset_name(3) = "bottom";
429 boundary_info.sideset_name(4) = "right";
430 }
431 }
432
433 else if (_portion == "top_half")
434 {
435 ReplicatedMesh other_mesh(mesh);
436 // This is to rotate the mesh and also to reset boundary IDs.
437 libMesh::MeshTools::Modification::rotate(other_mesh, 90, 0, 0);
438 if (_has_outer_square)
439 {
440 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
441 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 2, 6);
442 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 3, 7);
443 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 4, 1);
444 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 5, 2);
445 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 6, 3);
446 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 7, 4);
447 mesh.prepare_for_use();
448 other_mesh.prepare_for_use();
449 mesh.stitch_meshes(other_mesh, 1, 3, TOLERANCE, true);
450 mesh.get_boundary_info().sideset_name(1) = "left";
451 mesh.get_boundary_info().sideset_name(2) = "bottom";
452 mesh.get_boundary_info().sideset_name(3) = "right";
453 mesh.get_boundary_info().sideset_name(4) = "top";
454 }
455 else
456 {
457 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
458 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 2, 1);
459 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 5, 2);
460 mesh.prepare_for_use();
461 other_mesh.prepare_for_use();
462 mesh.stitch_meshes(other_mesh, 1, 1, TOLERANCE, true);
463
464 libMesh::MeshTools::Modification::change_boundary_id(mesh, 2, 1);
465 libMesh::MeshTools::Modification::change_boundary_id(mesh, 3, 2);
466 mesh.get_boundary_info().sideset_name(1) = "bottom";
467 mesh.get_boundary_info().sideset_name(2) = "outer";
468 }
469 other_mesh.clear();
470 }
471
472 else if (_portion == "right_half")
473 {
474 ReplicatedMesh other_mesh(mesh);
475 // This is to rotate the mesh and also to reset boundary IDs.
476 libMesh::MeshTools::Modification::rotate(other_mesh, 270, 0, 0);
477 if (_has_outer_square)
478 {
479 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
480 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 2, 6);
481 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 3, 7);
482 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 4, 3);
483 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 5, 4);
484 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 6, 1);
485 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 7, 2);
486 mesh.prepare_for_use();
487 other_mesh.prepare_for_use();
488 mesh.stitch_meshes(other_mesh, 2, 4, TOLERANCE, true);
489 mesh.get_boundary_info().sideset_name(1) = "left";
490 mesh.get_boundary_info().sideset_name(2) = "bottom";
491 mesh.get_boundary_info().sideset_name(3) = "right";
492 mesh.get_boundary_info().sideset_name(4) = "top";
493 }
494 else
495 {
496 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
497 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 2, 1);
498 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 5, 2);
499 mesh.prepare_for_use();
500 other_mesh.prepare_for_use();
501 mesh.stitch_meshes(other_mesh, 2, 2, TOLERANCE, true);
502
503 libMesh::MeshTools::Modification::change_boundary_id(mesh, 3, 2);
504 mesh.get_boundary_info().sideset_name(1) = "left";
505 mesh.get_boundary_info().sideset_name(2) = "outer";
506 }
507 other_mesh.clear();
508 }
509 else if (_portion == "left_half")
510 {
511 ReplicatedMesh other_mesh(mesh);
512
513 // This is to rotate the mesh and to reset boundary IDs.
514 libMesh::MeshTools::Modification::rotate(other_mesh, 90, 0, 0);
515 libMesh::MeshTools::Modification::rotate(mesh, 180, 0, 0);
516 if (_has_outer_square)
517 {
518 // The other mesh is created by rotating the original mesh about 90 degrees.
519 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
520 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 2, 6);
521 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 3, 7);
522 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 4, 1);
523 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 5, 2);
524 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 6, 3);
525 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 7, 4);
526 // The original mesh is then rotated about 180 degrees.
527 libMesh::MeshTools::Modification::change_boundary_id(mesh, 1, 5);
528 libMesh::MeshTools::Modification::change_boundary_id(mesh, 2, 6);
529 libMesh::MeshTools::Modification::change_boundary_id(mesh, 3, 7);
530 libMesh::MeshTools::Modification::change_boundary_id(mesh, 4, 2);
531 libMesh::MeshTools::Modification::change_boundary_id(mesh, 5, 3);
532 libMesh::MeshTools::Modification::change_boundary_id(mesh, 6, 4);
533 libMesh::MeshTools::Modification::change_boundary_id(mesh, 7, 1);
534 mesh.prepare_for_use();
535 other_mesh.prepare_for_use();
536 mesh.stitch_meshes(other_mesh, 4, 2, TOLERANCE, true);
537 mesh.get_boundary_info().sideset_name(1) = "left";
538 mesh.get_boundary_info().sideset_name(2) = "bottom";
539 mesh.get_boundary_info().sideset_name(3) = "right";
540 mesh.get_boundary_info().sideset_name(4) = "top";
541 }
542 else
543 {
544 libMesh::MeshTools::Modification::change_boundary_id(mesh, 1, 5);
545 libMesh::MeshTools::Modification::change_boundary_id(mesh, 2, 1);
546 libMesh::MeshTools::Modification::change_boundary_id(mesh, 5, 2);
547 mesh.prepare_for_use();
548 other_mesh.prepare_for_use();
549 mesh.stitch_meshes(other_mesh, 1, 1, TOLERANCE, true);
550
551 libMesh::MeshTools::Modification::change_boundary_id(mesh, 2, 1);
552 libMesh::MeshTools::Modification::change_boundary_id(mesh, 3, 2);
553 mesh.get_boundary_info().sideset_name(1) = "right";
554 mesh.get_boundary_info().sideset_name(2) = "outer";
555 }
556 other_mesh.clear();
557 }
558 else if (_portion == "bottom_half")
559 {
560 ReplicatedMesh other_mesh(mesh);
561 // This is to rotate the mesh and also to reset boundary IDs.
562 libMesh::MeshTools::Modification::rotate(other_mesh, 180, 0, 0);
563 libMesh::MeshTools::Modification::rotate(mesh, 270, 0, 0);
564 if (_has_outer_square)
565 {
566 // The other mesh is created by rotating the original mesh about 180 degrees.
567 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
568 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 2, 6);
569 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 3, 7);
570 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 4, 2);
571 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 5, 3);
572 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 6, 4);
573 libMesh::MeshTools::Modification::change_boundary_id(other_mesh, 7, 1);
574 // The original mesh is rotated about 270 degrees.
575 libMesh::MeshTools::Modification::change_boundary_id(mesh, 1, 5);
576 libMesh::MeshTools::Modification::change_boundary_id(mesh, 2, 6);
577 libMesh::MeshTools::Modification::change_boundary_id(mesh, 3, 7);
578 libMesh::MeshTools::Modification::change_boundary_id(mesh, 4, 3);
579 libMesh::MeshTools::Modification::change_boundary_id(mesh, 5, 4);
580 libMesh::MeshTools::Modification::change_boundary_id(mesh, 6, 1);
581 libMesh::MeshTools::Modification::change_boundary_id(mesh, 7, 2);
582 mesh.prepare_for_use();
583 other_mesh.prepare_for_use();
584 mesh.stitch_meshes(other_mesh, 1, 3, TOLERANCE, true);
585 mesh.get_boundary_info().sideset_name(1) = "left";
586 mesh.get_boundary_info().sideset_name(2) = "bottom";
587 mesh.get_boundary_info().sideset_name(3) = "right";
588 mesh.get_boundary_info().sideset_name(4) = "top";
589 }
590 else
591 {
592 libMesh::MeshTools::Modification::change_boundary_id(mesh, 1, 5);
593 libMesh::MeshTools::Modification::change_boundary_id(mesh, 2, 1);
594 libMesh::MeshTools::Modification::change_boundary_id(mesh, 5, 2);
595 mesh.prepare_for_use();
596 other_mesh.prepare_for_use();
597 mesh.stitch_meshes(other_mesh, 1, 1, TOLERANCE, true);
598
599 libMesh::MeshTools::Modification::change_boundary_id(mesh, 2, 1);
600 libMesh::MeshTools::Modification::change_boundary_id(mesh, 3, 2);
601 mesh.get_boundary_info().sideset_name(1) = "top";
602 mesh.get_boundary_info().sideset_name(2) = "outer";
603 }
604 other_mesh.clear();
605 }
606 else if (_portion == "full")
607 {
608 ReplicatedMesh portion_two(mesh);
609
610 // This is to rotate the mesh and also to reset boundary IDs.
611 libMesh::MeshTools::Modification::rotate(portion_two, 90, 0, 0);
612
613 if (_has_outer_square)
614 {
615 // Portion 2: 2nd quadrant
616 libMesh::MeshTools::Modification::change_boundary_id(portion_two, 1, 5);
617 libMesh::MeshTools::Modification::change_boundary_id(portion_two, 2, 6);
618 libMesh::MeshTools::Modification::change_boundary_id(portion_two, 3, 7);
619 libMesh::MeshTools::Modification::change_boundary_id(portion_two, 4, 1);
620 libMesh::MeshTools::Modification::change_boundary_id(portion_two, 5, 2);
621 libMesh::MeshTools::Modification::change_boundary_id(portion_two, 6, 3);
622 libMesh::MeshTools::Modification::change_boundary_id(portion_two, 7, 4);
623 mesh.prepare_for_use();
624 portion_two.prepare_for_use();
625 // 'top_half'
626 mesh.stitch_meshes(portion_two, 1, 3, TOLERANCE, true);
627
628 // 'bottom_half'
629 ReplicatedMesh portion_bottom(mesh);
630 libMesh::MeshTools::Modification::rotate(portion_bottom, 180, 0, 0);
631 libMesh::MeshTools::Modification::change_boundary_id(portion_bottom, 1, 5);
632 libMesh::MeshTools::Modification::change_boundary_id(portion_bottom, 2, 6);
633 libMesh::MeshTools::Modification::change_boundary_id(portion_bottom, 3, 7);
634 libMesh::MeshTools::Modification::change_boundary_id(portion_bottom, 4, 2);
635 libMesh::MeshTools::Modification::change_boundary_id(portion_bottom, 5, 3);
636 libMesh::MeshTools::Modification::change_boundary_id(portion_bottom, 6, 4);
637 libMesh::MeshTools::Modification::change_boundary_id(portion_bottom, 7, 1);
638 mesh.prepare_for_use();
639 portion_bottom.prepare_for_use();
640 // 'full'
641 mesh.stitch_meshes(portion_bottom, 2, 4, TOLERANCE, true);
642
643 mesh.get_boundary_info().sideset_name(1) = "left";
644 mesh.get_boundary_info().sideset_name(2) = "bottom";
645 mesh.get_boundary_info().sideset_name(3) = "right";
646 mesh.get_boundary_info().sideset_name(4) = "top";
647 portion_bottom.clear();
648 }
649 else
650 {
651 libMesh::MeshTools::Modification::change_boundary_id(portion_two, 1, 5);
652 libMesh::MeshTools::Modification::change_boundary_id(portion_two, 2, 1);
653 libMesh::MeshTools::Modification::change_boundary_id(portion_two, 5, 2);
654 // 'top half'
655 mesh.prepare_for_use();
656 portion_two.prepare_for_use();
657 mesh.stitch_meshes(portion_two, 1, 1, TOLERANCE, true);
658 // 'bottom half'
659 ReplicatedMesh portion_bottom(mesh);
660 libMesh::MeshTools::Modification::rotate(portion_bottom, 180, 0, 0);
661 // 'full'
662 mesh.prepare_for_use();
663 portion_bottom.prepare_for_use();
664 mesh.stitch_meshes(portion_bottom, 2, 2, TOLERANCE, true);
665 libMesh::MeshTools::Modification::change_boundary_id(mesh, 3, 1);
666 mesh.get_boundary_info().sideset_name(1) = "outer";
667 portion_bottom.clear();
668 }
669 portion_two.clear();
670 }
671 if (_portion != "top_half" && _portion != "right_half" && _portion != "left_half" &&
672 _portion != "bottom_half" && _portion != "full")
673 mesh.prepare_for_use();
674}
registerMooseObject
registerMooseObject("MooseApp", ConcentricCircleMesh)
int
void ErrorVector unsigned int
ConcentricCircleMesh
Mesh generated from parameters.
Definition ConcentricCircleMesh.h:19
ConcentricCircleMesh::_rings
std::vector< unsigned int > _rings
Number of rings in each circle or in the moderator.
Definition ConcentricCircleMesh.h:38
ConcentricCircleMesh::_radii
std::vector< Real > _radii
Radii of concentric circles.
Definition ConcentricCircleMesh.h:36
ConcentricCircleMesh::_portion
MooseEnum _portion
Control of which portion of mesh will be developed.
Definition ConcentricCircleMesh.h:47
ConcentricCircleMesh::_inner_mesh_fraction
Real _inner_mesh_fraction
Size of inner square in relation to radius of the innermost concentric circle.
Definition ConcentricCircleMesh.h:40
ConcentricCircleMesh::_preserve_volumes
bool _preserve_volumes
Volume preserving function is optional.
Definition ConcentricCircleMesh.h:45
ConcentricCircleMesh::_has_outer_square
bool _has_outer_square
Adding the moderator is optional.
Definition ConcentricCircleMesh.h:42
ConcentricCircleMesh::validParams
static InputParameters validParams()
Definition ConcentricCircleMesh.C:24
ConcentricCircleMesh::_num_sectors
unsigned int _num_sectors
Number of sectors in one quadrant.
Definition ConcentricCircleMesh.h:34
ConcentricCircleMesh::buildMesh
virtual void buildMesh() override
Must be overridden by child classes.
Definition ConcentricCircleMesh.C:106
ConcentricCircleMesh::ConcentricCircleMesh
ConcentricCircleMesh(const InputParameters &parameters)
Definition ConcentricCircleMesh.C:56
ConcentricCircleMesh::safeClone
virtual std::unique_ptr< MooseMesh > safeClone() const override
A safer version of the clone() method that hands back an allocated object wrapped in a smart pointer.
Definition ConcentricCircleMesh.C:100
Factory::copyConstruct
std::unique_ptr< T > copyConstruct(const T &object)
Copy constructs the object object.
Definition Factory.h:358
InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system.
Definition InputParameters.h:68
InputParameters::addParam
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object.
Definition InputParameters.h:1832
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
This method adds a parameter and documentation string to the InputParameters object that will be extr...
Definition InputParameters.h:1806
InputParameters::addClassDescription
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump.
Definition InputParameters.C:81
InputParameters::addRangeCheckedParam
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
Definition InputParameters.h:1947
MooseApp::getFactory
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition MooseApp.h:407
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition MooseBase.h:271
MooseEnum
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition MooseEnum.h:55
MooseMesh
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition MooseMesh.h:95
MooseMesh::elem
virtual Elem * elem(const dof_id_type i)
Various accessors (pointers/references) for Elem "i".
Definition MooseMesh.C:3200
MooseMesh::getMesh
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
Definition MooseMesh.C:3549
MooseMesh::validParams
static InputParameters validParams()
Typical "Moose-style" constructor and copy constructor.
Definition MooseMesh.C:83
MooseObject::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition MooseBase.h:375
mesh
MeshBase & mesh
libMesh::MeshTools::Modification::change_boundary_id
void change_boundary_id(MeshBase &mesh, const boundary_id_type old_id, const boundary_id_type new_id)
libMesh::MeshTools::Modification::rotate
RealTensorValue rotate(MeshBase &mesh, const Real phi, const Real theta=0., const Real psi=0.)
Generated on Mon Aug 24 2026 19:02:10 for https://mooseframework.inl.gov by doxygen 1.9.8