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< 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	isDataOnly () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

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

void	callMooseError (std::string msg, const bool with_prefix) const

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

const InputParameters &	parameters () const

MooseObjectName	uniqueName () 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 &nm) const

void	paramError (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

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

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

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

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

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

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

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

void	mooseInfo (Args &&... args) 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 void	setHasGenerateData (InputParameters &params)

Public Attributes
const ConsoleStream	_console

Static Public Attributes
static const std::string	data_only_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
virtual void	generateData ()

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)

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)

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	_gap
	The gap, not to be confused with the gap between pins, this refers to the gap next to the duct. 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

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const Parallel::Communicator &	_communicator

Friends
class	SCMQuadPinMeshGenerator

Detailed Description

Class for Subchannel mesh generation in the square lattice geometry.

Definition at line 19 of file SCMQuadSubChannelMeshGenerator.h.

Constructor & Destructor Documentation

◆ SCMQuadSubChannelMeshGenerator()

SCMQuadSubChannelMeshGenerator::SCMQuadSubChannelMeshGenerator ( const InputParameters & parameters )

Definition at line 60 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)),
     _gap(getParam<Real>("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 + _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 + _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 389 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._gap = _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;
 
   return mesh_base;
 }

◆ validParams()

InputParameters SCMQuadSubChannelMeshGenerator::validParams ( )

static

Definition at line 22 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",
                                 "(Its an added distance between a perimetric pin and the duct: "
                                 "Edge Pitch W = (pitch/2 - pin_diameter/2 + gap) [m]");
   params.addParam<unsigned int>("block_id", 0, "Domain Index");
   return params;
 }