Class for Subchannel mesh generation in the square lattice geometry. More...

#include <SCMQuadSubChannelMeshGenerator.h>

Inheritance diagram for SCMQuadSubChannelMeshGenerator:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	SCMQuadSubChannelMeshGenerator (const InputParameters &parameters)

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	haveParameter (const std::string &name) 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
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 More...

const Real	_heated_length
	heated length of the fuel Pin More...

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

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

std::vector< std::vector< Real > >	_k_grid
	axial form loss coefficient per computational cell More...

const std::vector< Real > &	_spacer_z
	axial location of the spacers More...

const std::vector< Real > &	_spacer_k
	form loss coefficient of the spacers More...

const std::vector< Real >	_z_blockage
	axial location of blockage (inlet, outlet) [m] More...

const std::vector< unsigned int >	_index_blockage
	index of subchannels affected by blockage More...

const std::vector< Real >	_reduction_blockage
	area reduction of subchannels affected by blockage More...

const std::vector< Real >	_k_blockage
	form loss coefficient of subchannels affected by blockage More...

const Real &	_kij
	Lateral form loss coefficient. More...

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

const Real	_pin_diameter
	fuel Pin diameter More...

const unsigned int	_n_cells
	number of axial cells More...

unsigned int	_n_blocks
	number of axial blocks More...

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

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

const unsigned int	_n_channels
	Total number of subchannels. More...

const unsigned int	_n_gaps
	Number of gaps per layer. More...

const unsigned int	_n_pins
	Number of pins. More...

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. More...

const unsigned int	_block_id
	block index More...

std::vector< std::vector< Node * > >	_nodes
	Channel nodes. More...

std::vector< std::vector< Node * > >	_gapnodes
	gap nodes More...

std::vector< std::pair< unsigned int, unsigned int > >	_gap_to_chan_map

std::vector< std::pair< unsigned int, unsigned int > >	_gap_to_pin_map

std::vector< std::vector< unsigned int > >	_chan_to_gap_map

std::vector< std::vector< unsigned int > >	_chan_to_pin_map

std::vector< std::vector< unsigned int > >	_pin_to_chan_map

std::vector< std::vector< double > >	_sign_id_crossflow_map
	Matrix used to give local sign to crossflow quantities. More...

std::vector< std::vector< Real > >	_gij_map
	Vector to store gap size. More...

std::vector< std::vector< Real > >	_subchannel_position
	x,y coordinates of the subchannel centroid More...

std::vector< EChannelType >	_subch_type
	Subchannel type. More...

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

Detailed Description

Class for Subchannel mesh generation in the square lattice geometry.

Definition at line 20 of file SCMQuadSubChannelMeshGenerator.h.

Constructor & Destructor Documentation

◆ SCMQuadSubChannelMeshGenerator()

SCMQuadSubChannelMeshGenerator::SCMQuadSubChannelMeshGenerator ( const InputParameters & parameters )

Definition at line 59 of file SCMQuadSubChannelMeshGenerator.C.

   : MeshGenerator(params),
     _unheated_length_entry(getParam<Real>("unheated_length_entry")),
     _heated_length(getParam<Real>("heated_length")),
     _unheated_length_exit(getParam<Real>("unheated_length_exit")),
     _spacer_z(getParam<std::vector<Real>>("spacer_z")),
     _spacer_k(getParam<std::vector<Real>>("spacer_k")),
     _z_blockage(getParam<std::vector<Real>>("z_blockage")),
     _index_blockage(getParam<std::vector<unsigned int>>("index_blockage")),
     _reduction_blockage(getParam<std::vector<Real>>("reduction_blockage")),
     _k_blockage(getParam<std::vector<Real>>("k_blockage")),
     _kij(getParam<Real>("Kij")),
     _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(_nx * _ny),
     _n_gaps((_nx - 1) * _ny + (_ny - 1) * _nx),
     _n_pins((_nx - 1) * (_ny - 1)),
     _side_gap(getParam<Real>("side_gap")),
     _block_id(getParam<unsigned int>("block_id"))
 {
   if (_spacer_z.size() != _spacer_k.size())
     mooseError(name(), ": Size of vector spacer_z should be equal to size of vector spacer_k");
 
   if (_spacer_z.size() &&
       _spacer_z.back() > _unheated_length_entry + _heated_length + _unheated_length_exit)
     mooseError(name(), ": Location of spacers should be less than the total bundle length");
 
   if (_z_blockage.size() != 2)
     mooseError(name(), ": Size of vector z_blockage must be 2");
 
   if (*max_element(_index_blockage.begin(), _index_blockage.end()) > (_n_channels - 1))
     mooseError(name(),
                ": The index of the blocked subchannel cannot be more than the max index of the "
                "subchannels");
 
   if (*max_element(_reduction_blockage.begin(), _reduction_blockage.end()) > 1)
     mooseError(name(), ": The area reduction of the blocked subchannels cannot be more than 1");
 
   if ((_index_blockage.size() > _nx * _ny) || (_reduction_blockage.size() > _nx * _ny) ||
       (_k_blockage.size() > _nx * _ny))
     mooseError(name(),
                ": Size of vectors: index_blockage, reduction_blockage, k_blockage, cannot be more "
                "than the total number of subchannels");
 
   if ((_index_blockage.size() != _reduction_blockage.size()) ||
       (_index_blockage.size() != _k_blockage.size()) ||
       (_reduction_blockage.size() != _k_blockage.size()))
     mooseError(name(),
                ": Size of vectors: index_blockage, reduction_blockage, k_blockage, must be equal "
                "to eachother");
 
   if (_nx < 2 && _ny < 2)
     mooseError(name(),
                ": The number of subchannels cannot be less than 2 in both directions (x and y). "
                "Smallest assembly allowed is either 2X1 or 1X2. ");
 
   SubChannelMesh::generateZGrid(
       _unheated_length_entry, _heated_length, _unheated_length_exit, _n_cells, _z_grid);
 
   // Defining the total length from 3 axial sections
   Real L = _unheated_length_entry + _heated_length + _unheated_length_exit;
 
   // Defining the position of the spacer grid in the numerical solution array
   std::vector<int> spacer_cell;
   for (const auto & elem : _spacer_z)
     spacer_cell.emplace_back(std::round(elem * _n_cells / L));
 
   // Defining the arrays for axial resistances
   std::vector<Real> kgrid;
   kgrid.resize(_n_cells + 1, 0.0);
   _k_grid.resize(_n_channels, std::vector<Real>(_n_cells + 1));
 
   // Summing the spacer resistance to the 1D grid resistance array
   for (unsigned int index = 0; index < spacer_cell.size(); index++)
     kgrid[spacer_cell[index]] += _spacer_k[index];
 
   // Creating the 2D grid resistance array
   for (unsigned int i = 0; i < _n_channels; i++)
     _k_grid[i] = kgrid;
 
   // Add blockage resistance to the 2D grid resistane array
   Real dz = L / _n_cells;
   for (unsigned int i = 0; i < _n_cells + 1; i++)
   {
     if ((dz * i >= _z_blockage.front() && dz * i <= _z_blockage.back()))
     {
       unsigned int index(0);
       for (const auto & i_ch : _index_blockage)
       {
         _k_grid[i_ch][i] += _k_blockage[index];
         index++;
       }
     }
   }
 
   // Defining the size of the maps
   _gap_to_chan_map.resize(_n_gaps);
   _gap_to_pin_map.resize(_n_gaps);
   _gapnodes.resize(_n_gaps);
   _chan_to_gap_map.resize(_n_channels);
   _chan_to_pin_map.resize(_n_channels);
   _pin_to_chan_map.resize(_n_pins);
   _sign_id_crossflow_map.resize(_n_channels);
   _gij_map.resize(_n_cells + 1);
   _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);
     }
   }
 
   for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
   {
     _gij_map[iz].reserve(_n_gaps);
   }
 
   // Defining the signs for positive and negative flows
   Real positive_flow = 1.0;
   Real negative_flow = -1.0;
 
   // Defining the subchannel types
   _subch_type.resize(_n_channels);
   for (unsigned int iy = 0; iy < _ny; iy++)
   {
     for (unsigned int ix = 0; ix < _nx; ix++)
     {
       unsigned int i_ch = _nx * iy + ix;
       bool is_corner = (ix == 0 && iy == 0) || (ix == _nx - 1 && iy == 0) ||
                        (ix == 0 && iy == _ny - 1) || (ix == _nx - 1 && iy == _ny - 1);
       bool is_edge = (ix == 0 || iy == 0 || ix == _nx - 1 || iy == _ny - 1);
 
       if (_n_channels == 2)
       {
         _subch_type[i_ch] = EChannelType::CENTER;
       }
       else if (_n_channels == 4)
       {
         _subch_type[i_ch] = EChannelType::CORNER;
       }
       else
       {
         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;
       }
     }
   }
 
   // Index the east-west gaps.
   unsigned int i_gap = 0;
   for (unsigned int iy = 0; iy < _ny; iy++)
   {
     for (unsigned int ix = 0; ix < _nx - 1; ix++)
     {
       unsigned int i_ch = _nx * iy + ix;
       unsigned int j_ch = _nx * iy + (ix + 1);
       _gap_to_chan_map[i_gap] = {i_ch, j_ch};
       _chan_to_gap_map[i_ch].push_back(i_gap);
       _chan_to_gap_map[j_ch].push_back(i_gap);
       _sign_id_crossflow_map[i_ch].push_back(positive_flow);
       _sign_id_crossflow_map[j_ch].push_back(negative_flow);
 
       // make a gap size map
       if (iy == 0 || iy == _ny - 1)
         _gij_map[0].push_back((_pitch - _pin_diameter) / 2 + _side_gap);
       else
         _gij_map[0].push_back(_pitch - _pin_diameter);
       ++i_gap;
     }
   }
 
   // Index the north-south gaps.
   for (unsigned int iy = 0; iy < _ny - 1; iy++)
   {
     for (unsigned int ix = 0; ix < _nx; ix++)
     {
       unsigned int i_ch = _nx * iy + ix;
       unsigned int j_ch = _nx * (iy + 1) + ix;
       _gap_to_chan_map[i_gap] = {i_ch, j_ch};
       _chan_to_gap_map[i_ch].push_back(i_gap);
       _chan_to_gap_map[j_ch].push_back(i_gap);
       _sign_id_crossflow_map[i_ch].push_back(positive_flow);
       _sign_id_crossflow_map[j_ch].push_back(negative_flow);
 
       // make a gap size map
       if (ix == 0 || ix == _nx - 1)
         _gij_map[0].push_back((_pitch - _pin_diameter) / 2 + _side_gap);
       else
         _gij_map[0].push_back(_pitch - _pin_diameter);
       ++i_gap;
     }
   }
 
   for (unsigned int iz = 1; iz < _n_cells + 1; iz++)
   {
     _gij_map[iz] = _gij_map[0];
   }
 
   // Make pin to channel map
   for (unsigned int iy = 0; iy < _ny - 1; iy++)
   {
     for (unsigned int ix = 0; ix < _nx - 1; ix++)
     {
       unsigned int i_pin = (_nx - 1) * iy + ix;
       unsigned int i_chan_1 = _nx * iy + ix;
       unsigned int i_chan_2 = _nx * (iy + 1) + ix;
       unsigned int i_chan_3 = _nx * (iy + 1) + (ix + 1);
       unsigned int i_chan_4 = _nx * iy + (ix + 1);
       _pin_to_chan_map[i_pin].push_back(i_chan_1);
       _pin_to_chan_map[i_pin].push_back(i_chan_2);
       _pin_to_chan_map[i_pin].push_back(i_chan_3);
       _pin_to_chan_map[i_pin].push_back(i_chan_4);
     }
   }
 
   // Make channel to pin map
   for (unsigned int iy = 0; iy < _ny; iy++) // row
   {
     for (unsigned int ix = 0; ix < _nx; ix++) // column
     {
       unsigned int i_ch = _nx * iy + ix;
       // Corners contact 1/4 of one pin
       if (iy == 0 && ix == 0)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
       }
       else if (iy == _ny - 1 && ix == 0)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
       }
       else if (iy == 0 && ix == _nx - 1)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
       }
       else if (iy == _ny - 1 && ix == _nx - 1)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
       }
       // Sides contact 1/4 of two pins
       else if (iy == 0)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
       }
       else if (iy == _ny - 1)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
       }
       else if (ix == 0)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
       }
       else if (ix == _nx - 1)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
       }
       // interior contacts 1/4 of 4 pins
       else
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
       }
 
       // set the subchannel positions
       Real offset_x = (_nx - 1) * _pitch / 2.0;
       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;
     }
   }
 
   // Make gap to pin map
   for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
   {
     auto i_ch = _gap_to_chan_map[i_gap].first;
     auto j_ch = _gap_to_chan_map[i_gap].second;
     auto i_pins = _chan_to_pin_map[i_ch];
     auto j_pins = _chan_to_pin_map[j_ch];
     _gap_to_pin_map[i_gap] = {10000, 10000}; // Initialize with default values
 
     for (unsigned int i : i_pins)
     {
       for (unsigned int j : j_pins)
       {
         if (i == j)
         {
           if (_gap_to_pin_map[i_gap].first == 10000)
           {
             _gap_to_pin_map[i_gap].first = i;
             _gap_to_pin_map[i_gap].second = i;
           }
           else
           {
             _gap_to_pin_map[i_gap].second = i;
           }
         }
       }
     }
   }
 
   // Reduce reserved memory in the channel-to-gap map.
   for (auto & gap : _chan_to_gap_map)
     gap.shrink_to_fit();
 
   // Reduce reserved memory in the channel-to-pin map.
   for (auto & pin : _chan_to_pin_map)
     pin.shrink_to_fit();
 
   // Reduce reserved memory in the pin-to-channel map.
   for (auto & pin : _pin_to_chan_map)
     pin.shrink_to_fit();
 }

Member Function Documentation

◆ generate()

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

overridevirtual

Implements MeshGenerator.

Definition at line 388 of file SCMQuadSubChannelMeshGenerator.C.

 {
   auto mesh_base = buildMeshBaseObject();
   BoundaryInfo & boundary_info = mesh_base->get_boundary_info();
   mesh_base->set_spatial_dimension(3);
   mesh_base->reserve_elem(_n_cells * _ny * _nx);
   mesh_base->reserve_nodes((_n_cells + 1) * _ny * _nx);
   _nodes.resize(_nx * _ny);
   // Add the points in the shape of a rectilinear grid.  The grid is regular
   // on the xy-plane with a spacing of `pitch` between points.  The grid along
   // z is irregular to account for Pin spacers.  Store pointers in the _nodes
   // array so we can keep track of which points are in which channels.
   Real offset_x = (_nx - 1) * _pitch / 2.0;
   Real offset_y = (_ny - 1) * _pitch / 2.0;
   unsigned int node_id = 0;
   for (unsigned int iy = 0; iy < _ny; iy++)
   {
     for (unsigned int ix = 0; ix < _nx; ix++)
     {
       int i_ch = _nx * iy + ix;
       _nodes[i_ch].reserve(_n_cells);
       for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
       {
         _nodes[i_ch].push_back(mesh_base->add_point(
             Point(_pitch * ix - offset_x, _pitch * iy - offset_y, _z_grid[iz]), node_id++));
       }
     }
   }
 
   // Add the elements which in this case are 2-node edges that link each
   // subchannel's nodes vertically.
   unsigned int elem_id = 0;
   for (unsigned int iy = 0; iy < _ny; iy++)
   {
     for (unsigned int ix = 0; ix < _nx; ix++)
     {
       for (unsigned int iz = 0; iz < _n_cells; iz++)
       {
         Elem * elem = new Edge2;
         elem->subdomain_id() = _block_id;
         elem->set_id(elem_id++);
         elem = mesh_base->add_elem(elem);
         const int indx1 = ((_n_cells + 1) * _nx) * iy + (_n_cells + 1) * ix + iz;
         const int indx2 = ((_n_cells + 1) * _nx) * iy + (_n_cells + 1) * ix + (iz + 1);
         elem->set_node(0, mesh_base->node_ptr(indx1));
         elem->set_node(1, mesh_base->node_ptr(indx2));
 
         if (iz == 0)
           boundary_info.add_side(elem, 0, 0);
         if (iz == _n_cells - 1)
           boundary_info.add_side(elem, 1, 1);
       }
     }
   }
 
   boundary_info.sideset_name(0) = "inlet";
   boundary_info.sideset_name(1) = "outlet";
   boundary_info.nodeset_name(0) = "inlet";
   boundary_info.nodeset_name(1) = "outlet";
   mesh_base->subdomain_name(_block_id) = name();
   mesh_base->prepare_for_use();
 
   // move the meta data into QuadSubChannelMesh
   auto & sch_mesh = static_cast<QuadSubChannelMesh &>(*_mesh);
   sch_mesh._unheated_length_entry = _unheated_length_entry;
   sch_mesh._heated_length = _heated_length;
   sch_mesh._unheated_length_exit = _unheated_length_exit;
   sch_mesh._z_grid = _z_grid;
   sch_mesh._k_grid = _k_grid;
   sch_mesh._spacer_z = _spacer_z;
   sch_mesh._spacer_k = _spacer_k;
   sch_mesh._z_blockage = _z_blockage;
   sch_mesh._index_blockage = _index_blockage;
   sch_mesh._reduction_blockage = _reduction_blockage;
   sch_mesh._kij = _kij;
   sch_mesh._pitch = _pitch;
   sch_mesh._pin_diameter = _pin_diameter;
   sch_mesh._n_cells = _n_cells;
   sch_mesh._nx = _nx;
   sch_mesh._ny = _ny;
   sch_mesh._n_channels = _n_channels;
   sch_mesh._n_gaps = _n_gaps;
   sch_mesh._n_pins = _n_pins;
   sch_mesh._side_gap = _side_gap;
   sch_mesh._nodes = _nodes;
   sch_mesh._gapnodes = _gapnodes;
   sch_mesh._gap_to_chan_map = _gap_to_chan_map;
   sch_mesh._gap_to_pin_map = _gap_to_pin_map;
   sch_mesh._chan_to_gap_map = _chan_to_gap_map;
   sch_mesh._chan_to_pin_map = _chan_to_pin_map;
   sch_mesh._pin_to_chan_map = _pin_to_chan_map;
   sch_mesh._sign_id_crossflow_map = _sign_id_crossflow_map;
   sch_mesh._gij_map = _gij_map;
   sch_mesh._subchannel_position = _subchannel_position;
   sch_mesh._subch_type = _subch_type;
   sch_mesh.computeAssemblyHydraulicParameters();
 
   return mesh_base;
 }

◆ validParams()

InputParameters SCMQuadSubChannelMeshGenerator::validParams ( )

static

Definition at line 18 of file SCMQuadSubChannelMeshGenerator.C.

 {
   InputParameters params = MeshGenerator::validParams();
   params.addClassDescription("Creates a mesh of 1D subchannels 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.addParam<std::vector<Real>>(
       "spacer_z", {}, "Axial location of spacers/vanes/mixing_vanes [m]");
   params.addParam<std::vector<Real>>(
       "spacer_k", {}, "K-loss coefficient of spacers/vanes/mixing_vanes [-]");
   params.addParam<std::vector<Real>>("z_blockage",
                                      std::vector<Real>({0.0, 0.0}),
                                      "axial location of blockage (inlet, outlet) [m]");
   params.addParam<std::vector<unsigned int>>("index_blockage",
                                              std::vector<unsigned int>({0}),
                                              "index of subchannels affected by blockage");
   params.addParam<std::vector<Real>>(
       "reduction_blockage",
       std::vector<Real>({1.0}),
       "Area reduction of subchannels affected by blockage (number to muliply the area)");
   params.addParam<std::vector<Real>>("k_blockage",
                                      std::vector<Real>({0.0}),
                                      "Form loss coefficient of subchannels affected by blockage");
 
   params.addParam<Real>("Kij", 0.5, "Lateral form loss coefficient [-]");
   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>(
       "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.deprecateParam("gap", "side_gap", "08/06/2026");
   params.addParam<unsigned int>("block_id", 0, "Domain Index");
   return params;
 }

Member Data Documentation

◆ _block_id

const unsigned int SCMQuadSubChannelMeshGenerator::_block_id

protected

block index

Definition at line 76 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate().

◆ _chan_to_gap_map

std::vector<std::vector<unsigned int> > SCMQuadSubChannelMeshGenerator::_chan_to_gap_map

protected

Definition at line 83 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _chan_to_pin_map

std::vector<std::vector<unsigned int> > SCMQuadSubChannelMeshGenerator::_chan_to_pin_map

protected

Definition at line 84 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _gap_to_chan_map

std::vector<std::pair<unsigned int, unsigned int> > SCMQuadSubChannelMeshGenerator::_gap_to_chan_map

protected

Definition at line 81 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _gap_to_pin_map

std::vector<std::pair<unsigned int, unsigned int> > SCMQuadSubChannelMeshGenerator::_gap_to_pin_map

protected

Definition at line 82 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _gapnodes

std::vector<std::vector<Node *> > SCMQuadSubChannelMeshGenerator::_gapnodes

protected

gap nodes

Definition at line 80 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _gij_map

std::vector<std::vector<Real> > SCMQuadSubChannelMeshGenerator::_gij_map

protected

Vector to store gap size.

Definition at line 89 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _heated_length

const Real SCMQuadSubChannelMeshGenerator::_heated_length

protected

heated length of the fuel Pin

Definition at line 30 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _index_blockage

const std::vector<unsigned int> SCMQuadSubChannelMeshGenerator::_index_blockage

protected

index of subchannels affected by blockage

Definition at line 44 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _k_blockage

const std::vector<Real> SCMQuadSubChannelMeshGenerator::_k_blockage

protected

form loss coefficient of subchannels affected by blockage

Definition at line 48 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by SCMQuadSubChannelMeshGenerator().

◆ _k_grid

std::vector<std::vector<Real> > SCMQuadSubChannelMeshGenerator::_k_grid

protected

axial form loss coefficient per computational cell

Definition at line 36 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _kij

const Real& SCMQuadSubChannelMeshGenerator::_kij

protected

Lateral form loss coefficient.

Definition at line 50 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate().

◆ _n_blocks

unsigned int SCMQuadSubChannelMeshGenerator::_n_blocks

protected

number of axial blocks

Definition at line 58 of file SCMQuadSubChannelMeshGenerator.h.

◆ _n_cells

const unsigned int SCMQuadSubChannelMeshGenerator::_n_cells

protected

number of axial cells

Definition at line 56 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _n_channels

const unsigned int SCMQuadSubChannelMeshGenerator::_n_channels

protected

Total number of subchannels.

Definition at line 64 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _n_gaps

const unsigned int SCMQuadSubChannelMeshGenerator::_n_gaps

protected

Number of gaps per layer.

Definition at line 66 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _n_pins

const unsigned int SCMQuadSubChannelMeshGenerator::_n_pins

protected

Number of pins.

Definition at line 68 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _nodes

std::vector<std::vector<Node *> > SCMQuadSubChannelMeshGenerator::_nodes

protected

Channel nodes.

Definition at line 78 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate().

◆ _nx

const unsigned int SCMQuadSubChannelMeshGenerator::_nx

protected

Number of subchannels in the x direction.

Definition at line 60 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _ny

const unsigned int SCMQuadSubChannelMeshGenerator::_ny

protected

Number of subchannels in the y direction.

Definition at line 62 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _pin_diameter

const Real SCMQuadSubChannelMeshGenerator::_pin_diameter

protected

fuel Pin diameter

Definition at line 54 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _pin_to_chan_map

std::vector<std::vector<unsigned int> > SCMQuadSubChannelMeshGenerator::_pin_to_chan_map

protected

Definition at line 85 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _pitch

const Real SCMQuadSubChannelMeshGenerator::_pitch

protected

Distance between the neighbor fuel pins, pitch.

Definition at line 52 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _reduction_blockage

const std::vector<Real> SCMQuadSubChannelMeshGenerator::_reduction_blockage

protected

area reduction of subchannels affected by blockage

Definition at line 46 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().

◆ _side_gap

const Real SCMQuadSubChannelMeshGenerator::_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 74 of file SCMQuadSubChannelMeshGenerator.h.

Referenced by generate(), and SCMQuadSubChannelMeshGenerator().