https://mooseframework.inl.gov
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 
22 
25 {
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 
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
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.
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 
99 std::unique_ptr<MooseMesh>
101 {
102  return _app.getFactory().copyConstruct(*this);
103 }
104 
105 void
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  {
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  {
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  {
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  {
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  {
460  mesh.prepare_for_use();
461  other_mesh.prepare_for_use();
462  mesh.stitch_meshes(other_mesh, 1, 1, TOLERANCE, true);
463 
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  {
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  {
499  mesh.prepare_for_use();
500  other_mesh.prepare_for_use();
501  mesh.stitch_meshes(other_mesh, 2, 2, TOLERANCE, true);
502 
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);
516  if (_has_outer_square)
517  {
518  // The other mesh is created by rotating the original mesh about 90 degrees.
526  // The original mesh is then rotated about 180 degrees.
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  {
547  mesh.prepare_for_use();
548  other_mesh.prepare_for_use();
549  mesh.stitch_meshes(other_mesh, 1, 1, TOLERANCE, true);
550 
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);
564  if (_has_outer_square)
565  {
566  // The other mesh is created by rotating the original mesh about 180 degrees.
574  // The original mesh is rotated about 270 degrees.
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  {
595  mesh.prepare_for_use();
596  other_mesh.prepare_for_use();
597  mesh.stitch_meshes(other_mesh, 1, 1, TOLERANCE, true);
598 
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
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);
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  {
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);
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 }
static InputParameters validParams()
Typical "Moose-style" constructor and copy constructor.
Definition: MooseMesh.C:83
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...
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sin(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tan
Real _inner_mesh_fraction
Size of inner square in relation to radius of the innermost concentric circle.
virtual void buildMesh() override
Must be overridden by child classes.
static InputParameters validParams()
unsigned int _num_sectors
Number of sectors in one quadrant.
MeshBase & mesh
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
std::vector< Real > _radii
Radii of concentric circles.
std::unique_ptr< T > copyConstruct(const T &object)
Copy constructs the object object.
Definition: Factory.h:310
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...
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition: MooseApp.h:424
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template cos(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(cos
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
Definition: MooseMesh.C:3443
void change_boundary_id(MeshBase &mesh, const boundary_id_type old_id, const boundary_id_type new_id)
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:88
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
ConcentricCircleMesh(const InputParameters &parameters)
RealTensorValue rotate(MeshBase &mesh, const Real phi, const Real theta=0., const Real psi=0.)
bool _has_outer_square
Adding the moderator is optional.
std::vector< unsigned int > _rings
Number of rings in each circle or in the moderator.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
registerMooseObject("MooseApp", ConcentricCircleMesh)
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sqrt(_arg)) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tanh
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
Mesh generated from parameters.
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...
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...
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
virtual Elem * elem(const dof_id_type i)
Various accessors (pointers/references) for Elem "i".
Definition: MooseMesh.C:3094
bool _preserve_volumes
Volume preserving function is optional.
void ErrorVector unsigned int
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template pow< 2 >(tan(_arg))+1.0) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(sqrt
MooseEnum _portion
Control of which portion of mesh will be developed.