Mesh generator that builds a detailed 3D mesh representing quadrilateral subchannels and pins. More...

#include <SCMDetailedQuadAssemblyMeshGenerator.h>

Inheritance diagram for SCMDetailedQuadAssemblyMeshGenerator:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	SCMDetailedQuadAssemblyMeshGenerator (const InputParameters &parameters)

virtual std::unique_ptr< MeshBase >	generate () override

std::unique_ptr< CSG::CSGBase >	generateInternalCSG ()

std::unique_ptr< MeshBase >	generateInternal ()

const std::set< MeshGeneratorName > &	getRequestedMeshGenerators () const

const std::set< MeshGeneratorName > &	getRequestedMeshGeneratorsForSub () const

void	addParentMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

void	addChildMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

const std::set< const MeshGenerator *, Comparator > &	getParentMeshGenerators () const

const std::set< const MeshGenerator *, Comparator > &	getChildMeshGenerators () const

const std::set< const MeshGenerator *, Comparator > &	getSubMeshGenerators () const

bool	isParentMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const

bool	isChildMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const

bool	isNullMeshName (const MeshGeneratorName &name) const

bool	hasSaveMesh () const

bool	hasOutput () const

const std::string &	getSavedMeshName () const

bool	hasGenerateData () const

bool	hasGenerateCSG () const

bool	isDataOnly () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static bool	hasGenerateData (const InputParameters &params)

static bool	hasGenerateCSG (const InputParameters &params)

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

static void	setHasGenerateData (InputParameters &params)

static void	setHasGenerateCSG (InputParameters &params)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	data_only_param

static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
EChannelType	getSubchannelType (unsigned int index) const
	returns the type of the subchannel given the index

void	generatePin (std::unique_ptr< MeshBase > &mesh_base, const Point &center)
	Generate one detailed fuel pin volume centered at the supplied point.

virtual void	generateData ()

virtual std::unique_ptr< CSG::CSGBase >	generateCSG ()

T &	copyMeshProperty (const std::string &target_data_name, const std::string &source_data_name, const std::string &source_mesh)

T &	copyMeshProperty (const std::string &source_data_name, const std::string &source_mesh)

std::unique_ptr< MeshBase > &	getMesh (const std::string &param_name, const bool allow_invalid=false)

std::vector< std::unique_ptr< MeshBase > * >	getMeshes (const std::string &param_name)

std::unique_ptr< MeshBase > &	getMeshByName (const MeshGeneratorName &mesh_generator_name)

std::vector< std::unique_ptr< MeshBase > * >	getMeshesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)

std::unique_ptr< CSG::CSGBase > &	getCSGBase (const std::string &param_name)

std::unique_ptr< CSG::CSGBase > &	getCSGBaseByName (const MeshGeneratorName &mesh_generator_name)

std::vector< std::unique_ptr< CSG::CSGBase > * >	getCSGBases (const std::string &param_name)

std::vector< std::unique_ptr< CSG::CSGBase > * >	getCSGBasesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)

void	declareMeshForSub (const std::string &param_name)

void	declareMeshesForSub (const std::string &param_name)

void	declareMeshForSubByName (const MeshGeneratorName &mesh_generator_name)

void	declareMeshesForSubByName (const std::vector< MeshGeneratorName > &mesh_generator_names)

std::unique_ptr< MeshBase >	buildMeshBaseObject (unsigned int dim=libMesh::invalid_uint)

std::unique_ptr< ReplicatedMesh >	buildReplicatedMesh (unsigned int dim=libMesh::invalid_uint)

std::unique_ptr< DistributedMesh >	buildDistributedMesh (unsigned int dim=libMesh::invalid_uint)

void	addMeshSubgenerator (const std::string &type, const std::string &name, Ts... extra_input_parameters)

void	addMeshSubgenerator (const std::string &type, const std::string &name, InputParameters params)

void	declareNullMeshName (const MeshGeneratorName &name)

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)

const T &	getMeshProperty (const std::string &data_name)

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (const std::string &data_name) const

T &	declareMeshProperty (const std::string &data_name, Args &&... args)

T &	declareMeshProperty (const std::string &data_name, const T &data_value)

T &	declareMeshProperty (const std::string &data_name, Args &&... args)

T &	declareMeshProperty (const std::string &data_name, const T &data_value)

T &	setMeshProperty (const std::string &data_name, Args &&... args)

T &	setMeshProperty (const std::string &data_name, const T &data_value)

T &	setMeshProperty (const std::string &data_name, Args &&... args)

T &	setMeshProperty (const std::string &data_name, const T &data_value)

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
const Real	_unheated_length_entry
	unheated length of the fuel Pin at the entry of the assembly

const Real	_heated_length
	heated length of the fuel Pin

const Real	_unheated_length_exit
	unheated length of the fuel Pin at the exit of the assembly

std::vector< Real >	_z_grid
	axial location of nodes

const Real	_pitch
	Distance between the neighbor fuel pins, pitch.

const Real	_pin_diameter
	fuel Pin diameter

const unsigned int	_n_cells
	Number of cells in the axial direction.

const unsigned int	_nx
	Number of subchannels in the x direction.

const unsigned int	_ny
	Number of subchannels in the y direction.

unsigned int	_n_channels
	Total number of subchannels.

const Real	_side_gap
	The side gap, not to be confused with the gap between pins, this refers to the gap next to the duct or else the distance between the subchannel centroid to the duct wall.

const unsigned int	_num_sectors
	Number of azimuthal sectors used to discretize each circular pin cross section.

const unsigned int	_subchannel_block_id
	Subchannel subdomain ID.

const unsigned int	_pin_block_id
	Pin subdomain ID.

std::vector< EChannelType >	_subch_type
	Subchannel type.

std::vector< std::vector< Real > >	_subchannel_position
	x,y coordinates of the subchannel centroids

dof_id_type	_elem_id
	Counter for element numbering.

MooseMesh *const	_mesh

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const Parallel::Communicator &	_communicator

Private Member Functions
virtual std::string	meshPropertyPrefix (const std::string &) const override final

void	checkGetMesh (const MeshGeneratorName &mesh_generator_name, const std::string &param_name) const

const MeshGeneratorName *	getMeshGeneratorNameFromParam (const std::string &param_name, const bool allow_invalid) const

const std::vector< MeshGeneratorName > &	getMeshGeneratorNamesFromParam (const std::string &param_name) const

RestartableDataValue &	setMeshPropertyHelper (const std::string &data_name)

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

void	mooseErrorInternal (Args &&... args) const

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
std::set< MeshGeneratorName >	_requested_mesh_generators

std::set< MeshGeneratorName >	_requested_mesh_generators_for_sub

std::vector< std::pair< std::string, std::unique_ptr< MeshBase > * > >	_requested_meshes

std::vector< std::pair< std::string, std::unique_ptr< CSG::CSGBase > * > >	_requested_csg_bases

std::unique_ptr< MeshBase >	_null_mesh

std::unique_ptr< CSG::CSGBase >	_null_csg_base

std::set< const MeshGenerator *, Comparator >	_parent_mesh_generators

std::set< const MeshGenerator *, Comparator >	_child_mesh_generators

std::set< const MeshGenerator *, Comparator >	_sub_mesh_generators

std::set< std::string >	_null_mesh_names

const std::string &	_save_with_name

const bool	_data_only

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

Detailed Description

Mesh generator that builds a detailed 3D mesh representing quadrilateral subchannels and pins.

Definition at line 18 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Constructor & Destructor Documentation

◆ SCMDetailedQuadAssemblyMeshGenerator()

SCMDetailedQuadAssemblyMeshGenerator::SCMDetailedQuadAssemblyMeshGenerator ( const InputParameters & parameters )

Definition at line 67 of file SCMDetailedQuadAssemblyMeshGenerator.C.

  : MeshGenerator(parameters),
    _unheated_length_entry(getParam<Real>("unheated_length_entry")),
    _heated_length(getParam<Real>("heated_length")),
    _unheated_length_exit(getParam<Real>("unheated_length_exit")),
    _pitch(getParam<Real>("pitch")),
    _pin_diameter(getParam<Real>("pin_diameter")),
    _n_cells(getParam<unsigned int>("n_cells")),
    _nx(getParam<unsigned int>("nx")),
    _ny(getParam<unsigned int>("ny")),
    _n_channels(0),
    _side_gap(getParam<Real>("side_gap")),
    _num_sectors(getParam<unsigned int>("num_sectors")),
    _subchannel_block_id(getParam<unsigned int>("subchannel_block_id")),
    _pin_block_id(getParam<unsigned int>("pin_block_id")),
    _elem_id(0)
{
  const Real L = _unheated_length_entry + _heated_length + _unheated_length_exit;
 
  if (_n_cells == 0)
    paramError("n_cells", "The number of axial cells must be greater than zero");
 
  if (L <= 0.0)
    mooseError("Total bundle length must be greater than zero");
 
  if (_nx == 0 || _ny == 0)
    mooseError("The number of subchannels must be greater than zero in each direction");
 
  if (_nx < 2 && _ny < 2)
    mooseError("The number of subchannels cannot be less than 2 in both directions. "
               "Smallest assembly allowed is either 2X1 or 1X2.");
 
  _n_channels = _nx * _ny;
 
  const Real dz = L / _n_cells;
  for (unsigned int i = 0; i < _n_cells + 1; i++)
    _z_grid.push_back(dz * i);
 
  _subchannel_position.resize(_n_channels);
  for (unsigned int i = 0; i < _n_channels; i++)
  {
    _subchannel_position[i].reserve(3);
    for (unsigned int j = 0; j < 3; j++)
      _subchannel_position.at(i).push_back(0.0);
  }
 
  _subch_type.resize(_n_channels);
  for (unsigned int iy = 0; iy < _ny; iy++)
    for (unsigned int ix = 0; ix < _nx; ix++)
    {
      const unsigned int i_ch = _nx * iy + ix;
      const bool is_corner = (ix == 0 && iy == 0) || (ix == _nx - 1 && iy == 0) ||
                             (ix == 0 && iy == _ny - 1) || (ix == _nx - 1 && iy == _ny - 1);
      const bool is_edge = (ix == 0 || iy == 0 || ix == _nx - 1 || iy == _ny - 1);
 
      if (is_corner)
        _subch_type[i_ch] = EChannelType::CORNER;
      else if (is_edge)
        _subch_type[i_ch] = EChannelType::EDGE;
      else
        _subch_type[i_ch] = EChannelType::CENTER;
 
      // Set the subchannel positions so that the center of the assembly is the zero point.
      const Real offset_x = (_nx - 1) * _pitch / 2.0;
      const Real offset_y = (_ny - 1) * _pitch / 2.0;
      _subchannel_position[i_ch][0] = _pitch * ix - offset_x;
      _subchannel_position[i_ch][1] = _pitch * iy - offset_y;
    }
}

Member Function Documentation

◆ generate()

std::unique_ptr< MeshBase > SCMDetailedQuadAssemblyMeshGenerator::generate ( )

overridevirtual

Implements MeshGenerator.

Definition at line 182 of file SCMDetailedQuadAssemblyMeshGenerator.C.

{
  auto mesh_base = buildMeshBaseObject();
  BoundaryInfo & boundary_info = mesh_base->get_boundary_info();
  mesh_base->set_spatial_dimension(3);
 
  // Define the resolution (the number of points used to represent a circle). This must be
  // divisible by 4.
  const unsigned int n_pins = (_nx - 1) * (_ny - 1);
 
  const unsigned int theta_res = 16;
  // Compute the number of points needed to represent one quarter of a circle.
  const unsigned int points_per_quad = theta_res / 4 + 1;
 
  // Compute the points needed to represent one axial cross-flow of a subchannel. For the center
  // subchannel there is one center point plus the points from 4 intersecting circles. For the
  // corner subchannel there is one center point plus the points from 1 intersecting circle plus 3
  // corners. For the side subchannel there is one center point plus the points from 2 intersecting
  // circles plus 2 corners.
  const unsigned int points_per_center = points_per_quad * 4 + 1;
  const unsigned int points_per_corner = points_per_quad * 1 + 1 + 3;
  const unsigned int points_per_side = points_per_quad * 2 + 1 + 2;
 
  // Compute the number of Prism6 elements which combine to create each subchannel cross-section.
  const unsigned int elems_per_center = theta_res + 4;
  const unsigned int elems_per_corner = theta_res / 4 + 4;
  const unsigned int elems_per_side = theta_res / 2 + 4;
 
  // Specify the number and type of subchannels.
  unsigned int n_center, n_side, n_corner;
  if (_n_channels == 2)
  {
    n_corner = 0;
    n_side = _n_channels;
    n_center = _n_channels - n_side - n_corner;
  }
  else if (_n_channels > 2 && (_ny == 1 || _nx == 1))
  {
    n_corner = 0;
    n_side = 2;
    n_center = _n_channels - n_side - n_corner;
  }
  else
  {
    n_corner = 4;
    n_side = 2 * (_ny - 2) + 2 * (_nx - 2);
    n_center = _n_channels - n_side - n_corner;
  }
 
  const unsigned int points_per_level =
      n_corner * points_per_corner + n_side * points_per_side + n_center * points_per_center;
  const unsigned int elems_per_level =
      n_corner * elems_per_corner + n_side * elems_per_side + n_center * elems_per_center;
 
  // Pin centers are generated for 2x2 and larger quad assemblies.
  std::vector<Point> pin_centers;
  if (n_pins > 0)
    QuadSubChannelMesh::generatePinCenters(_nx, _ny, _pitch, 0, pin_centers);
 
  const unsigned int pin_points =
      n_pins > 0 ? (_n_cells + 1) * (_num_sectors + 1) * pin_centers.size() : 0;
  const unsigned int pin_elems = n_pins > 0 ? _n_cells * _num_sectors * pin_centers.size() : 0;
 
  mesh_base->reserve_nodes(points_per_level * (_n_cells + 1) + pin_points);
  mesh_base->reserve_elem(elems_per_level * _n_cells + pin_elems);
 
  // Build an array of points arranged in a circle on the xy-plane. The last and first node overlap.
  const Real radius = _pin_diameter / 2.0;
  std::array<Point, theta_res + 1> circle_points;
  {
    Real theta = 0;
    for (unsigned int i = 0; i < theta_res + 1; i++)
    {
      circle_points[i](0) = radius * std::cos(theta);
      circle_points[i](1) = radius * std::sin(theta);
      theta += 2 * M_PI / theta_res;
    }
  }
 
  // Define "quadrant center" reference points. These will be the centers of the 4 circles that
  // represent the fuel pins. These centers are offset slightly so that in the final mesh, there is
  // a tiny gap between neighboring subchannel cells. That allows us to easily map a solution to
  // this detailed mesh with a nearest-neighbor search.
  const Real shrink_factor = 0.99999;
  std::array<Point, 4> quadrant_centers;
  quadrant_centers[0] = Point(_pitch * 0.5 * shrink_factor, _pitch * 0.5 * shrink_factor, 0);
  quadrant_centers[1] = Point(-_pitch * 0.5 * shrink_factor, _pitch * 0.5 * shrink_factor, 0);
  quadrant_centers[2] = Point(-_pitch * 0.5 * shrink_factor, -_pitch * 0.5 * shrink_factor, 0);
  quadrant_centers[3] = Point(_pitch * 0.5 * shrink_factor, -_pitch * 0.5 * shrink_factor, 0);
 
  const unsigned int m = theta_res / 4;
  // Build an array of points that represent a cross-section of a center subchannel cell. The points
  // are ordered in this fashion:
  //     4   3
  // 6 5       2 1
  //       0
  // 7 8       * *
  //     9   *
  std::array<Point, points_per_center> center_points;
  {
    unsigned int start;
    for (unsigned int i = 0; i < 4; i++)
    {
      if (i == 0)
        start = 3 * m;
      if (i == 1)
        start = 4 * m;
      if (i == 2)
        start = 1 * m;
      if (i == 3)
        start = 2 * m;
      for (unsigned int ii = 0; ii < points_per_quad; ii++)
      {
        auto c_pt = circle_points[start - ii];
        center_points[i * points_per_quad + ii + 1] = quadrant_centers[i] + c_pt;
      }
    }
  }
 
  // Build an array of points that represent a cross-section of a top left corner subchannel cell.
  // The points are ordered in this fashion:
  // 5            4
  //
  //       0
  //           2  3
  // 6       1
  std::array<Point, points_per_corner> tl_corner_points;
  {
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[2 * m - ii];
      tl_corner_points[ii + 1] = quadrant_centers[3] + c_pt;
    }
    tl_corner_points[points_per_quad + 1] = Point(_pitch * 0.5 * shrink_factor, _side_gap, 0);
    tl_corner_points[points_per_quad + 2] = Point(-_side_gap, _side_gap, 0);
    tl_corner_points[points_per_quad + 3] = Point(-_side_gap, -_pitch * 0.5 * shrink_factor, 0);
  }
 
  // Build an array of points that represent a cross-section of a top right corner subchannel cell.
  // The points are ordered in this fashion:
  // 6            5
  //
  //       0
  // 1 2
  //    3         4
  std::array<Point, points_per_corner> tr_corner_points;
  {
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[m - ii];
      tr_corner_points[ii + 1] = quadrant_centers[2] + c_pt;
    }
    tr_corner_points[points_per_quad + 1] = Point(_side_gap, -_pitch * 0.5 * shrink_factor, 0);
    tr_corner_points[points_per_quad + 2] = Point(_side_gap, _side_gap, 0);
    tr_corner_points[points_per_quad + 3] = Point(-_pitch * 0.5 * shrink_factor, _side_gap, 0);
  }
 
  // Build an array of points that represent a cross-section of a bottom left corner subchannel
  // cell. The points are ordered in this fashion:
  // 4       3
  //           2  1
  //       0
  //
  // 5            6
  std::array<Point, points_per_corner> bl_corner_points;
  {
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[3 * m - ii];
      bl_corner_points[ii + 1] = quadrant_centers[0] + c_pt;
    }
    bl_corner_points[points_per_quad + 1] = Point(-_side_gap, _pitch * 0.5 * shrink_factor, 0);
    bl_corner_points[points_per_quad + 2] = Point(-_side_gap, -_side_gap, 0);
    bl_corner_points[points_per_quad + 3] = Point(_pitch * 0.5 * shrink_factor, -_side_gap, 0);
  }
 
  // Build an array of points that represent a cross-section of a bottom right corner subchannel
  // cell. The points are ordered in this fashion:
  //    1        6
  // 3 2
  //       0
  //
  // 4           5
  std::array<Point, points_per_corner> br_corner_points;
  {
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[4 * m - ii];
      br_corner_points[ii + 1] = quadrant_centers[1] + c_pt;
    }
    br_corner_points[points_per_quad + 1] = Point(-_pitch * 0.5 * shrink_factor, -_side_gap, 0);
    br_corner_points[points_per_quad + 2] = Point(_side_gap, -_side_gap, 0);
    br_corner_points[points_per_quad + 3] = Point(_side_gap, _pitch * 0.5 * shrink_factor, 0);
  }
 
  // Build an array of points that represent a cross-section of a top side subchannel cell. The
  // points are ordered in this fashion:
  // 8            7
  //
  //       0
  // 1 2        5 6
  //    3     4
  std::array<Point, points_per_side> top_points;
  {
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[m - ii];
      top_points[ii + 1] = quadrant_centers[2] + c_pt;
    }
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[2 * m - ii];
      top_points[points_per_quad + ii + 1] = quadrant_centers[3] + c_pt;
    }
    top_points[2 * points_per_quad + 1] = Point(_pitch * 0.5 * shrink_factor, _side_gap, 0);
    top_points[2 * points_per_quad + 2] = Point(-_pitch * 0.5 * shrink_factor, _side_gap, 0);
  }
 
  // Build an array of points that represent a cross-section of a left side subchannel cell. The
  // points are ordered in this fashion:
  // 7        6
  //            5 4
  //      0
  //            2 3
  // 8        1
  std::array<Point, points_per_side> left_points;
  {
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[2 * m - ii];
      left_points[ii + 1] = quadrant_centers[3] + c_pt;
    }
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[3 * m - ii];
      left_points[points_per_quad + ii + 1] = quadrant_centers[0] + c_pt;
    }
    left_points[2 * points_per_quad + 1] = Point(-_side_gap, _pitch * 0.5 * shrink_factor, 0);
    left_points[2 * points_per_quad + 2] = Point(-_side_gap, -_pitch * 0.5 * shrink_factor, 0);
  }
 
  // Build an array of points that represent a cross-section of a bottom side subchannel cell. The
  // points are ordered in this fashion:
  //    4    3
  // 6 5       2 1
  //       0
  //
  // 7           8
  std::array<Point, points_per_side> bottom_points;
  {
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[3 * m - ii];
      bottom_points[ii + 1] = quadrant_centers[0] + c_pt;
    }
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[4 * m - ii];
      bottom_points[points_per_quad + ii + 1] = quadrant_centers[1] + c_pt;
    }
    bottom_points[2 * points_per_quad + 1] = Point(-_pitch * 0.5 * shrink_factor, -_side_gap, 0);
    bottom_points[2 * points_per_quad + 2] = Point(_pitch * 0.5 * shrink_factor, -_side_gap, 0);
  }
 
  // Build an array of points that represent a cross-section of a right side subchannel cell. The
  // points are ordered in this fashion:
  //    1        8
  // 3 2
  //       0
  // 4 5
  //   6         7
  std::array<Point, points_per_side> right_points;
  {
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[4 * m - ii];
      right_points[ii + 1] = quadrant_centers[1] + c_pt;
    }
    for (unsigned int ii = 0; ii < points_per_quad; ii++)
    {
      auto c_pt = circle_points[m - ii];
      right_points[points_per_quad + ii + 1] = quadrant_centers[2] + c_pt;
    }
    right_points[2 * points_per_quad + 1] = Point(_side_gap, -_pitch * 0.5 * shrink_factor, 0);
    right_points[2 * points_per_quad + 2] = Point(_side_gap, _pitch * 0.5 * shrink_factor, 0);
  }
 
  if (_n_channels == 2)
  {
    // Special handling for the smallest line meshes, which contain only side subchannels.
    unsigned int node_id = 0;
    const Real offset_x = (_nx - 1) * _pitch / 2.0;
    const Real offset_y = (_ny - 1) * _pitch / 2.0;
    for (unsigned int iy = 0; iy < _ny; iy++)
    {
      Point y0 = {0, _pitch * iy - offset_y, 0};
      for (unsigned int ix = 0; ix < _nx; ix++)
      {
        Point x0 = {_pitch * ix - offset_x, 0, 0};
        for (auto z : _z_grid)
        {
          Point z0{0, 0, z};
          if (_nx == 1 && iy == 0) // vertical orientation
            for (unsigned int i = 0; i < points_per_side; i++)
              mesh_base->add_point(bottom_points[i] + x0 + y0 + z0, node_id++);
          if (_nx == 1 && iy == 1) // vertical orientation
            for (unsigned int i = 0; i < points_per_side; i++)
              mesh_base->add_point(top_points[i] + x0 + y0 + z0, node_id++);
          if (_ny == 1 && ix == 0) // horizontal orientation
            for (unsigned int i = 0; i < points_per_side; i++)
              mesh_base->add_point(left_points[i] + x0 + y0 + z0, node_id++);
          if (_ny == 1 && ix == 1) // horizontal orientation
            for (unsigned int i = 0; i < points_per_side; i++)
              mesh_base->add_point(right_points[i] + x0 + y0 + z0, node_id++);
        }
      }
    }
  }
  else if (_n_channels > 2 && (_ny == 1 || _nx == 1))
  {
    // Line meshes larger than 2 channels have two side subchannels and center subchannels between
    // them.
    unsigned int node_id = 0;
    const Real offset_x = (_nx - 1) * _pitch / 2.0;
    const Real offset_y = (_ny - 1) * _pitch / 2.0;
    for (unsigned int iy = 0; iy < _ny; iy++)
    {
      Point y0 = {0, _pitch * iy - offset_y, 0};
      for (unsigned int ix = 0; ix < _nx; ix++)
      {
        Point x0 = {_pitch * ix - offset_x, 0, 0};
        for (auto z : _z_grid)
        {
          Point z0{0, 0, z};
          if (_nx == 1)
          {
            if (iy == 0)
              for (unsigned int i = 0; i < points_per_side; i++)
                mesh_base->add_point(bottom_points[i] + x0 + y0 + z0, node_id++);
            else if (iy == _ny - 1)
              for (unsigned int i = 0; i < points_per_side; i++)
                mesh_base->add_point(top_points[i] + x0 + y0 + z0, node_id++);
            else
              for (unsigned int i = 0; i < points_per_center; i++)
                mesh_base->add_point(center_points[i] + x0 + y0 + z0, node_id++);
          }
          else if (_ny == 1)
          {
            if (ix == 0)
              for (unsigned int i = 0; i < points_per_side; i++)
                mesh_base->add_point(left_points[i] + x0 + y0 + z0, node_id++);
            else if (ix == _nx - 1)
              for (unsigned int i = 0; i < points_per_side; i++)
                mesh_base->add_point(right_points[i] + x0 + y0 + z0, node_id++);
            else
              for (unsigned int i = 0; i < points_per_center; i++)
                mesh_base->add_point(center_points[i] + x0 + y0 + z0, node_id++);
          }
        }
      }
    }
  }
  else
  {
    // General 2D quad assemblies contain corner, side, and center subchannels.
    unsigned int node_id = 0;
    const Real offset_x = (_nx - 1) * _pitch / 2.0;
    const Real offset_y = (_ny - 1) * _pitch / 2.0;
    for (unsigned int iy = 0; iy < _ny; iy++)
    {
      Point y0 = {0, _pitch * iy - offset_y, 0};
      for (unsigned int ix = 0; ix < _nx; ix++)
      {
        Point x0 = {_pitch * ix - offset_x, 0, 0};
        if (ix == 0 && iy == 0) // Bottom Left corner
          for (auto z : _z_grid)
          {
            Point z0{0, 0, z};
            for (unsigned int i = 0; i < points_per_corner; i++)
              mesh_base->add_point(bl_corner_points[i] + x0 + y0 + z0, node_id++);
          }
        else if (ix == _nx - 1 && iy == 0) // Bottom right corner
          for (auto z : _z_grid)
          {
            Point z0{0, 0, z};
            for (unsigned int i = 0; i < points_per_corner; i++)
              mesh_base->add_point(br_corner_points[i] + x0 + y0 + z0, node_id++);
          }
        else if (ix == 0 && iy == _ny - 1) // top Left corner
          for (auto z : _z_grid)
          {
            Point z0{0, 0, z};
            for (unsigned int i = 0; i < points_per_corner; i++)
              mesh_base->add_point(tl_corner_points[i] + x0 + y0 + z0, node_id++);
          }
        else if (ix == _nx - 1 && iy == _ny - 1) // top right corner
          for (auto z : _z_grid)
          {
            Point z0{0, 0, z};
            for (unsigned int i = 0; i < points_per_corner; i++)
              mesh_base->add_point(tr_corner_points[i] + x0 + y0 + z0, node_id++);
          }
        else if (ix == 0 && (iy != _ny - 1 || iy != 0)) // left side
          for (auto z : _z_grid)
          {
            Point z0{0, 0, z};
            for (unsigned int i = 0; i < points_per_side; i++)
              mesh_base->add_point(left_points[i] + x0 + y0 + z0, node_id++);
          }
        else if (ix == _nx - 1 && (iy != _ny - 1 || iy != 0)) // right side
          for (auto z : _z_grid)
          {
            Point z0{0, 0, z};
            for (unsigned int i = 0; i < points_per_side; i++)
              mesh_base->add_point(right_points[i] + x0 + y0 + z0, node_id++);
          }
        else if (iy == 0 && (ix != _nx - 1 || ix != 0)) // bottom side
          for (auto z : _z_grid)
          {
            Point z0{0, 0, z};
            for (unsigned int i = 0; i < points_per_side; i++)
              mesh_base->add_point(bottom_points[i] + x0 + y0 + z0, node_id++);
          }
        else if (iy == _ny - 1 && (ix != _nx - 1 || ix != 0)) // top side
          for (auto z : _z_grid)
          {
            Point z0{0, 0, z};
            for (unsigned int i = 0; i < points_per_side; i++)
              mesh_base->add_point(top_points[i] + x0 + y0 + z0, node_id++);
          }
        else // center
          for (auto z : _z_grid)
          {
            Point z0{0, 0, z};
            for (unsigned int i = 0; i < points_per_center; i++)
              mesh_base->add_point(center_points[i] + x0 + y0 + z0, node_id++);
          }
      }
    }
  }
 
  if (_n_channels == 2)
  {
    // Build elements for the smallest line meshes.
    for (unsigned int iy = 0; iy < _ny; iy++)
      for (unsigned int ix = 0; ix < _nx; ix++)
      {
        const unsigned int i_ch = _nx * iy + ix;
        for (unsigned int iz = 0; iz < _n_cells; iz++)
          for (unsigned int i = 0; i < elems_per_side; i++)
          {
            Elem * elem = mesh_base->add_elem(std::make_unique<Prism6>());
            elem->subdomain_id() = _subchannel_block_id;
            elem->set_id(_elem_id++);
            // index of the central node at base of cell
            const unsigned int indx1 =
                iz * points_per_side + points_per_side * (_n_cells + 1) * i_ch;
            const unsigned int indx2 =
                (iz + 1) * points_per_side + points_per_side * (_n_cells + 1) * i_ch;
            const unsigned int elems_per_channel = elems_per_side;
            elem->set_node(0, mesh_base->node_ptr(indx1));
            elem->set_node(1, mesh_base->node_ptr(indx1 + i + 1));
            elem->set_node(2,
                           i != elems_per_channel - 1 ? mesh_base->node_ptr(indx1 + i + 2)
                                                      : mesh_base->node_ptr(indx1 + 1));
            elem->set_node(3, mesh_base->node_ptr(indx2));
            elem->set_node(4, mesh_base->node_ptr(indx2 + i + 1));
            elem->set_node(5,
                           i != elems_per_channel - 1 ? mesh_base->node_ptr(indx2 + i + 2)
                                                      : mesh_base->node_ptr(indx2 + 1));
 
            if (iz == 0)
              boundary_info.add_side(elem, 0, 0);
            if (iz == _n_cells - 1)
              boundary_info.add_side(elem, 4, 1);
          }
      }
  }
  else if (_n_channels > 2 && (_ny == 1 || _nx == 1))
  {
    // Build elements for 1xN and Nx1 line meshes.
    unsigned int number_of_corner = 0;
    unsigned int number_of_side = 0;
    unsigned int number_of_center = 0;
    unsigned int elems_per_channel = 0;
    unsigned int points_per_channel = 0;
    for (unsigned int iy = 0; iy < _ny; iy++)
      for (unsigned int ix = 0; ix < _nx; ix++)
      {
        const unsigned int i_ch = _nx * iy + ix;
        const auto subch_type = getSubchannelType(i_ch);
        if (subch_type == EChannelType::CORNER)
        {
          number_of_side++;
          elems_per_channel = elems_per_side;
          points_per_channel = points_per_side;
        }
        else if (subch_type == EChannelType::EDGE)
        {
          number_of_center++;
          elems_per_channel = elems_per_center;
          points_per_channel = points_per_center;
        }
 
        for (unsigned int iz = 0; iz < _n_cells; iz++)
        {
          const unsigned int elapsed_points =
              number_of_corner * points_per_corner * (_n_cells + 1) +
              number_of_side * points_per_side * (_n_cells + 1) +
              number_of_center * points_per_center * (_n_cells + 1) -
              points_per_channel * (_n_cells + 1);
          // index of the central node at base of cell
          const unsigned int indx1 = iz * points_per_channel + elapsed_points;
          const unsigned int indx2 = (iz + 1) * points_per_channel + elapsed_points;
 
          for (unsigned int i = 0; i < elems_per_channel; i++)
          {
            Elem * elem = mesh_base->add_elem(std::make_unique<Prism6>());
            elem->subdomain_id() = _subchannel_block_id;
            elem->set_id(_elem_id++);
            elem->set_node(0, mesh_base->node_ptr(indx1));
            elem->set_node(1, mesh_base->node_ptr(indx1 + i + 1));
            elem->set_node(2,
                           i != elems_per_channel - 1 ? mesh_base->node_ptr(indx1 + i + 2)
                                                      : mesh_base->node_ptr(indx1 + 1));
            elem->set_node(3, mesh_base->node_ptr(indx2));
            elem->set_node(4, mesh_base->node_ptr(indx2 + i + 1));
            elem->set_node(5,
                           i != elems_per_channel - 1 ? mesh_base->node_ptr(indx2 + i + 2)
                                                      : mesh_base->node_ptr(indx2 + 1));
 
            if (iz == 0)
              boundary_info.add_side(elem, 0, 0);
            if (iz == _n_cells - 1)
              boundary_info.add_side(elem, 4, 1);
          }
        }
      }
  }
  else
  {
    // Build elements for general 2D quad assemblies.
    unsigned int number_of_corner = 0;
    unsigned int number_of_side = 0;
    unsigned int number_of_center = 0;
    unsigned int elems_per_channel = 0;
    unsigned int points_per_channel = 0;
    for (unsigned int iy = 0; iy < _ny; iy++)
      for (unsigned int ix = 0; ix < _nx; ix++)
      {
        const unsigned int i_ch = _nx * iy + ix;
        const auto subch_type = getSubchannelType(i_ch);
        if (subch_type == EChannelType::CORNER)
        {
          number_of_corner++;
          elems_per_channel = elems_per_corner;
          points_per_channel = points_per_corner;
        }
        else if (subch_type == EChannelType::EDGE)
        {
          number_of_side++;
          elems_per_channel = elems_per_side;
          points_per_channel = points_per_side;
        }
        else
        {
          number_of_center++;
          elems_per_channel = elems_per_center;
          points_per_channel = points_per_center;
        }
 
        for (unsigned int iz = 0; iz < _n_cells; iz++)
        {
          const unsigned int elapsed_points =
              number_of_corner * points_per_corner * (_n_cells + 1) +
              number_of_side * points_per_side * (_n_cells + 1) +
              number_of_center * points_per_center * (_n_cells + 1) -
              points_per_channel * (_n_cells + 1);
          // index of the central node at base of cell
          const unsigned int indx1 = iz * points_per_channel + elapsed_points;
          const unsigned int indx2 = (iz + 1) * points_per_channel + elapsed_points;
 
          for (unsigned int i = 0; i < elems_per_channel; i++)
          {
            Elem * elem = mesh_base->add_elem(std::make_unique<Prism6>());
            elem->subdomain_id() = _subchannel_block_id;
            elem->set_id(_elem_id++);
            elem->set_node(0, mesh_base->node_ptr(indx1));
            elem->set_node(1, mesh_base->node_ptr(indx1 + i + 1));
            elem->set_node(2,
                           i != elems_per_channel - 1 ? mesh_base->node_ptr(indx1 + i + 2)
                                                      : mesh_base->node_ptr(indx1 + 1));
            elem->set_node(3, mesh_base->node_ptr(indx2));
            elem->set_node(4, mesh_base->node_ptr(indx2 + i + 1));
            elem->set_node(5,
                           i != elems_per_channel - 1 ? mesh_base->node_ptr(indx2 + i + 2)
                                                      : mesh_base->node_ptr(indx2 + 1));
 
            if (iz == 0)
              boundary_info.add_side(elem, 0, 0);
            if (iz == _n_cells - 1)
              boundary_info.add_side(elem, 4, 1);
          }
        }
      }
  }
 
  if (n_pins > 0)
    for (auto & ctr : pin_centers)
      generatePin(mesh_base, ctr);
 
  boundary_info.sideset_name(0) = "inlet";
  boundary_info.sideset_name(1) = "outlet";
  mesh_base->set_subdomain_name(_subchannel_block_id, "subchannel", true);
  if (n_pins > 0)
    mesh_base->set_subdomain_name(_pin_block_id, "fuel_pins", true);
  mesh_base->prepare_for_use();
 
  return mesh_base;
}

◆ generatePin()

void SCMDetailedQuadAssemblyMeshGenerator::generatePin	(	std::unique_ptr< MeshBase > &	mesh_base,
		const Point &	center
	)

protected

Generate one detailed fuel pin volume centered at the supplied point.

Definition at line 139 of file SCMDetailedQuadAssemblyMeshGenerator.C.

{
  const Real dalpha = 360. / _num_sectors;
  const Real radius = _pin_diameter / 2.;
 
  // Add a center node and radial boundary nodes on each axial level so each pin is discretized into
  // triangular prism sectors.
  std::vector<std::vector<Node *>> nodes;
  nodes.resize(_n_cells + 1);
  for (unsigned int k = 0; k < _n_cells + 1; k++)
  {
    const Real elev = _z_grid[k];
    nodes[k].push_back(mesh_base->add_point(Point(center(0), center(1), elev)));
    Real alpha = 0.;
    for (unsigned int i = 0; i < _num_sectors; i++, alpha += dalpha)
    {
      const Real dx = radius * std::cos(alpha * M_PI / 180.);
      const Real dy = radius * std::sin(alpha * M_PI / 180.);
      nodes[k].push_back(mesh_base->add_point(Point(center(0) + dx, center(1) + dy, elev)));
    }
  }
 
  // Add the pin volume elements, linking matching radial sectors between adjacent axial levels.
  for (unsigned int k = 0; k < _n_cells; k++)
    for (unsigned int i = 0; i < _num_sectors; i++)
    {
      Elem * elem = mesh_base->add_elem(std::make_unique<Prism6>());
      elem->subdomain_id() = _pin_block_id;
      elem->set_id(_elem_id++);
      const unsigned int ctr_idx = 0;
      const unsigned int idx1 = (i % _num_sectors) + 1;
      const unsigned int idx2 = ((i + 1) % _num_sectors) + 1;
      elem->set_node(0, nodes[k][ctr_idx]);
      elem->set_node(1, nodes[k][idx1]);
      elem->set_node(2, nodes[k][idx2]);
      elem->set_node(3, nodes[k + 1][ctr_idx]);
      elem->set_node(4, nodes[k + 1][idx1]);
      elem->set_node(5, nodes[k + 1][idx2]);
    }
}

Referenced by generate().

◆ getSubchannelType()

EChannelType SCMDetailedQuadAssemblyMeshGenerator::getSubchannelType ( unsigned int index ) const

inlineprotected

returns the type of the subchannel given the index

Definition at line 26 of file SCMDetailedQuadAssemblyMeshGenerator.h.

26{ return _subch_type[index]; }

Referenced by generate().

◆ validParams()

InputParameters SCMDetailedQuadAssemblyMeshGenerator::validParams ( )

static

Definition at line 39 of file SCMDetailedQuadAssemblyMeshGenerator.C.

{
  InputParameters params = MeshGenerator::validParams();
  params.addClassDescription(
      "Creates a detailed mesh of subchannels and fuel pins in a square lattice arrangement");
  params.addRequiredParam<Real>("pitch", "Pitch [m]");
  params.addRequiredParam<Real>("pin_diameter", "Rod diameter [m]");
  params.addParam<Real>("unheated_length_entry", 0.0, "Unheated length at entry [m]");
  params.addRequiredParam<Real>("heated_length", "Heated length [m]");
  params.addParam<Real>("unheated_length_exit", 0.0, "Unheated length at exit [m]");
  params.addRequiredParam<unsigned int>("n_cells", "The number of cells in the axial direction");
  params.addRequiredParam<unsigned int>("nx", "Number of channels in the x direction [-]");
  params.addRequiredParam<unsigned int>("ny", "Number of channels in the y direction [-]");
  params.addRequiredParam<Real>(
      "side_gap",
      "The side gap, not to be confused with the gap between pins, this refers to the gap "
      "next to the duct or else the distance between the subchannel centroid to the duct wall."
      "distance(edge pin center, duct wall) = pitch / 2 + side_gap [m]");
  params.addRangeCheckedParam<unsigned int>("num_sectors",
                                            16,
                                            "num_sectors>=4",
                                            "Number of azimuthal sectors used to discretize each "
                                            "circular pin cross section.");
  params.addParam<unsigned int>("subchannel_block_id", 0, "Subchannel block id.");
  params.addParam<unsigned int>("pin_block_id", 1, "Fuel pin block id.");
  return params;
}

Member Data Documentation

◆ _elem_id

dof_id_type SCMDetailedQuadAssemblyMeshGenerator::_elem_id

protected

Counter for element numbering.

Definition at line 68 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Referenced by generate(), and generatePin().

◆ _heated_length

const Real SCMDetailedQuadAssemblyMeshGenerator::_heated_length

protected

heated length of the fuel Pin

Definition at line 34 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Referenced by SCMDetailedQuadAssemblyMeshGenerator().

◆ _n_cells

const unsigned int SCMDetailedQuadAssemblyMeshGenerator::_n_cells

protected

Number of cells in the axial direction.

Definition at line 44 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Referenced by generate(), generatePin(), and SCMDetailedQuadAssemblyMeshGenerator().

◆ _n_channels

unsigned int SCMDetailedQuadAssemblyMeshGenerator::_n_channels

protected

Total number of subchannels.

Definition at line 50 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Referenced by generate(), and SCMDetailedQuadAssemblyMeshGenerator().

◆ _num_sectors

const unsigned int SCMDetailedQuadAssemblyMeshGenerator::_num_sectors

protected

Number of azimuthal sectors used to discretize each circular pin cross section.

Definition at line 58 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Referenced by generate(), and generatePin().

◆ _nx

const unsigned int SCMDetailedQuadAssemblyMeshGenerator::_nx

protected

Number of subchannels in the x direction.

Definition at line 46 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Referenced by generate(), and SCMDetailedQuadAssemblyMeshGenerator().

◆ _ny

const unsigned int SCMDetailedQuadAssemblyMeshGenerator::_ny

protected

Number of subchannels in the y direction.

Definition at line 48 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Referenced by generate(), and SCMDetailedQuadAssemblyMeshGenerator().

◆ _pin_block_id

const unsigned int SCMDetailedQuadAssemblyMeshGenerator::_pin_block_id

protected

Pin subdomain ID.

Definition at line 62 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Referenced by generate(), and generatePin().

◆ _pin_diameter

const Real SCMDetailedQuadAssemblyMeshGenerator::_pin_diameter

protected

fuel Pin diameter

Definition at line 42 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Referenced by generate(), and generatePin().

◆ _pitch

const Real SCMDetailedQuadAssemblyMeshGenerator::_pitch

protected

Distance between the neighbor fuel pins, pitch.

Definition at line 40 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Referenced by generate(), and SCMDetailedQuadAssemblyMeshGenerator().

◆ _side_gap

const Real SCMDetailedQuadAssemblyMeshGenerator::_side_gap

protected

The side gap, not to be confused with the gap between pins, this refers to the gap next to the duct or else the distance between the subchannel centroid to the duct wall.

distance(edge pin center, duct wall) = pitch / 2 + side_gap [m].

Definition at line 56 of file SCMDetailedQuadAssemblyMeshGenerator.h.

Referenced by generate().