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 "DetailedPinMeshGeneratorBase.h"
      11             : #include "libmesh/cell_prism6.h"
      12             : 
      13             : InputParameters
      14          58 : DetailedPinMeshGeneratorBase::validParams()
      15             : {
      16          58 :   InputParameters params = MeshGenerator::validParams();
      17          58 :   params.addClassDescription(
      18             :       "Base Class used to create the detailed pin mesh in a square lattice arrangement");
      19         116 :   params.addRequiredParam<Real>("pitch", "Pitch [m]");
      20         116 :   params.addRequiredParam<Real>("pin_diameter", "Rod diameter [m]");
      21         116 :   params.addParam<Real>("unheated_length_entry", 0.0, "Unheated length at entry [m]");
      22         116 :   params.addRequiredParam<Real>("heated_length", "Heated length [m]");
      23         116 :   params.addParam<Real>("unheated_length_exit", 0.0, "Unheated length at exit [m]");
      24         116 :   params.addRequiredParam<unsigned int>("n_cells", "The number of cells in the axial direction");
      25         116 :   params.addParam<unsigned int>("block_id", 1, "Block ID used for the mesh subdomain.");
      26         174 :   params.addRangeCheckedParam<unsigned int>("num_radial_parts",
      27         116 :                                             16,
      28             :                                             "num_radial_parts>=4",
      29             :                                             "Number of radial parts (must be at least 4).");
      30          58 :   return params;
      31           0 : }
      32             : 
      33          29 : DetailedPinMeshGeneratorBase::DetailedPinMeshGeneratorBase(const InputParameters & parameters)
      34             :   : MeshGenerator(parameters),
      35          29 :     _unheated_length_entry(getParam<Real>("unheated_length_entry")),
      36          58 :     _heated_length(getParam<Real>("heated_length")),
      37          58 :     _unheated_length_exit(getParam<Real>("unheated_length_exit")),
      38          58 :     _pitch(getParam<Real>("pitch")),
      39          58 :     _pin_diameter(getParam<Real>("pin_diameter")),
      40          58 :     _n_cells(getParam<unsigned int>("n_cells")),
      41          58 :     _block_id(getParam<unsigned int>("block_id")),
      42          87 :     _num_radial_parts(getParam<unsigned int>("num_radial_parts"))
      43             : {
      44          29 :   Real L = _unheated_length_entry + _heated_length + _unheated_length_exit;
      45          29 :   Real dz = L / _n_cells;
      46         555 :   for (unsigned int i = 0; i < _n_cells + 1; i++)
      47         526 :     _z_grid.push_back(dz * i);
      48          29 : }
      49             : 
      50             : void
      51         257 : DetailedPinMeshGeneratorBase::generatePin(std::unique_ptr<MeshBase> & mesh_base,
      52             :                                           const Point & center)
      53             : {
      54         257 :   const Real dalpha = 360. / _num_radial_parts;
      55         257 :   Real radius = _pin_diameter / 2.;
      56             : 
      57             :   // nodes
      58             :   std::vector<std::vector<Node *>> nodes;
      59         257 :   nodes.resize(_n_cells + 1);
      60        6786 :   for (unsigned int k = 0; k < _n_cells + 1; k++)
      61             :   {
      62        6529 :     const Real elev = _z_grid[k];
      63             :     // center node
      64        6529 :     nodes[k].push_back(mesh_base->add_point(Point(center(0), center(1), elev)));
      65             :     // ring around the center
      66             :     Real alpha = 0.;
      67      110993 :     for (unsigned int i = 0; i < _num_radial_parts; i++, alpha += dalpha)
      68             :     {
      69      104464 :       const Real dx = radius * std::cos(alpha * M_PI / 180.);
      70      104464 :       const Real dy = radius * std::sin(alpha * M_PI / 180.);
      71      104464 :       Point pt(center(0) + dx, center(1) + dy, elev);
      72      104464 :       nodes[k].push_back(mesh_base->add_point(pt));
      73             :     }
      74             :   }
      75             : 
      76             :   // elements
      77        6529 :   for (unsigned int k = 0; k < _n_cells; k++)
      78             :   {
      79      106624 :     for (unsigned int i = 0; i < _num_radial_parts; i++)
      80             :     {
      81      100352 :       Elem * elem = new Prism6;
      82      100352 :       elem->subdomain_id() = _block_id;
      83      100352 :       elem->set_id(_elem_id++);
      84      100352 :       mesh_base->add_elem(elem);
      85             :       const unsigned int ctr_idx = 0;
      86      100352 :       const unsigned int idx1 = (i % _num_radial_parts) + 1;
      87      100352 :       const unsigned int idx2 = ((i + 1) % _num_radial_parts) + 1;
      88      100352 :       elem->set_node(0, nodes[k][ctr_idx]);
      89      100352 :       elem->set_node(1, nodes[k][idx1]);
      90      100352 :       elem->set_node(2, nodes[k][idx2]);
      91      100352 :       elem->set_node(3, nodes[k + 1][ctr_idx]);
      92      100352 :       elem->set_node(4, nodes[k + 1][idx1]);
      93      100352 :       elem->set_node(5, nodes[k + 1][idx2]);
      94             :     }
      95             :   }
      96         257 : }