Mesh generator that builds a mesh of 1D lines representing subchannels and pins in a triangular assembly. More...

#include <SCMTriAssemblyMeshGenerator.h>

Inheritance diagram for SCMTriAssemblyMeshGenerator:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	SCMTriAssemblyMeshGenerator (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
void	buildPinMesh (MeshBase &mesh_base)
	Build the 1D pin elements and append them to the subchannel mesh. More...

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

const unsigned int	_subchannel_block_id
	subchannel block index More...

const unsigned int	_pin_block_id
	pin block index 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	_pitch
	Distance between the neighbor fuel pins, pitch. More...

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

const Real	_pin_diameter
	fuel Pin diameter More...

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

const unsigned int	_n_rings
	number of rings of fuel pins More...

unsigned int	_n_channels
	number of subchannels More...

const Real	_flat_to_flat
	the distance between flat surfaces of the duct facing each other More...

const Real	_dwire
	wire diameter More...

const Real	_hwire
	wire lead length More...

const Real	_duct_to_pin_gap
	the gap thickness between the duct and peripheral fuel pins More...

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

std::vector< std::vector< Node * > >	_pin_nodes
	pin nodes More...

std::vector< std::pair< unsigned int, unsigned int > >	_gap_to_chan_map
	stores the channel pairs for each gap More...

std::vector< std::pair< unsigned int, unsigned int > >	_gap_to_pin_map
	stores the fuel pin pairs for each gap each gap More...

std::vector< std::vector< unsigned int > >	_chan_to_gap_map
	stores the gaps that forms each subchannel More...

std::vector< std::vector< Real > >	_sign_id_crossflow_map
	Defines the global cross-flow direction -1 or 1 for each subchannel and for all gaps that are belonging to the corresponding subchannel. More...

std::vector< std::vector< Real > >	_gij_map
	gap size More...

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

std::vector< Point >	_pin_position
	x,y coordinates of the fuel pins More...

std::vector< std::vector< Real > >	_pins_in_rings
	fuel pins that are belonging to each ring More...

std::vector< std::vector< unsigned int > >	_chan_to_pin_map
	stores the fuel pins belonging to each subchannel More...

std::vector< std::vector< unsigned int > >	_pin_to_chan_map
	stores the map from pins to channels More...

unsigned int	_npins
	number of fuel pins More...

unsigned int	_n_gaps
	number of gaps More...

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

std::vector< EChannelType >	_gap_type
	gap type More...

std::vector< std::pair< unsigned int, unsigned int > >	_gap_pairs_sf
	sweeping flow model gap pairs per channel to specify directional edge flow More...

std::vector< std::pair< unsigned int, unsigned int > >	_chan_pairs_sf
	sweeping flow model channel pairs to specify directional edge flow 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

Mesh generator that builds a mesh of 1D lines representing subchannels and pins in a triangular assembly.

Definition at line 19 of file SCMTriAssemblyMeshGenerator.h.

Constructor & Destructor Documentation

◆ SCMTriAssemblyMeshGenerator()

SCMTriAssemblyMeshGenerator::SCMTriAssemblyMeshGenerator ( const InputParameters & parameters )

initial assignment

Definition at line 78 of file SCMTriAssemblyMeshGenerator.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")),
     _subchannel_block_id(getParam<unsigned int>("subchannel_block_id")),
     _pin_block_id(getParam<unsigned int>("pin_block_id")),
     _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")),
     _pitch(getParam<Real>("pitch")),
     _kij(getParam<Real>("Kij")),
     _pin_diameter(getParam<Real>("pin_diameter")),
     _n_cells(getParam<unsigned int>("n_cells")),
     _n_rings(getParam<unsigned int>("nrings")),
     _n_channels(0),
     _flat_to_flat(getParam<Real>("flat_to_flat")),
     _dwire(getParam<Real>("dwire")),
     _hwire(getParam<Real>("hwire")),
     _duct_to_pin_gap(0.5 *
                      (_flat_to_flat - (_n_rings - 1) * _pitch * std::sqrt(3.0) - _pin_diameter)),
     _npins(0),
     _n_gaps(0)
 {
   const Real total_length = _unheated_length_entry + _heated_length + _unheated_length_exit;
 
   if (_n_rings < 2)
     paramError("nrings",
                "'nrings' must be at least 2. In this mesh generator, the center pin counts as "
                "the first ring, so a 7-pin bundle uses nrings = 2.");
 
   if (_n_cells == 0)
     paramError("n_cells", "The number of axial cells must be greater than zero");
 
   if (total_length <= 0.0)
     mooseError("Total bundle length must be greater than zero");
 
   if (_spacer_z.size() != _spacer_k.size())
     mooseError("Size of vector spacer_z should be equal to size of vector spacer_k");
 
   for (const auto spacer_z : _spacer_z)
     if (spacer_z < 0.0 || spacer_z > total_length)
       paramError("spacer_z", "Location of spacers should be between zero and total bundle length");
 
   if (_z_blockage.size() != 2)
     paramError("z_blockage", "Size of vector z_blockage must be 2");
 
   if (_z_blockage.front() > _z_blockage.back())
     paramError("z_blockage", "z_blockage inlet location must not exceed outlet location");
 
   if (*max_element(_reduction_blockage.begin(), _reduction_blockage.end()) > 1)
     paramError("reduction_blockage",
                "The area reduction of the blocked subchannels cannot be more than 1");
 
   if ((_index_blockage.size() != _reduction_blockage.size()) ||
       (_index_blockage.size() != _k_blockage.size()) ||
       (_reduction_blockage.size() != _k_blockage.size()))
     mooseError("Size of vectors: index_blockage, reduction_blockage, k_blockage, must be equal "
                "to eachother");
 
   SubChannelMesh::generateZGrid(
       _unheated_length_entry, _heated_length, _unheated_length_exit, _n_cells, _z_grid);
 
   // Defining the total length from 3 axial sections
   Real L = total_length;
 
   // 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 array for axial resistances
   std::vector<Real> kgrid;
   kgrid.resize(_n_cells + 1, 0.0);
 
   // Summing the spacer resistance to the grid resistance array
   for (unsigned int index = 0; index < spacer_cell.size(); index++)
     kgrid[spacer_cell[index]] += _spacer_k[index];
 
   //  compute the hex mesh variables
   // -------------------------------------------
 
   // x coordinate for the first position
   Real x0 = 0.0;
   // y coordinate for the first position
   Real y0 = 0.0;
   // x coordinate for the second position
   Real x1 = 0.0;
   // y coordinate for the second position dummy variable
   Real y1 = 0.0;
   // dummy variable
   Real a1 = 0.0;
   // dummy variable
   Real a2 = 0.0;
   // average x coordinate
   Real avg_coor_x = 0.0;
   // average y coordinate
   Real avg_coor_y = 0.0;
   // distance between two points
   Real dist = 0.0;
   // distance between two points
   Real dist0 = 0.0;
   // integer counter
   unsigned int kgap = 0;
   // dummy integer
   unsigned int icorner = 0;
   // used to defined global direction of the cross_flow_map coefficients for each subchannel and gap
   const Real positive_flow = 1.0;
   // used to defined global direction of the cross_flow_map coefficients for each subchannel and gap
   const Real negative_flow = -1.0;
   // the indicator used while setting _gap_to_chan_map array
   std::vector<std::pair<unsigned int, unsigned int>> gap_fill;
   TriSubChannelMesh::pinPositions(_pin_position, _n_rings, _pitch, Point(0, 0));
   _npins = _pin_position.size();
   // assign the pins to the corresponding rings
   unsigned int k = 0; // initialize the fuel Pin counter index
   _pins_in_rings.resize(_n_rings);
   _pins_in_rings[0].push_back(k++);
   for (unsigned int i = 1; i < _n_rings; i++)
     for (unsigned int j = 0; j < i * 6; j++)
       _pins_in_rings[i].push_back(k++);
   //  Given the number of pins and number of fuel Pin rings, the number of subchannels can be
   //  computed as follows:
   unsigned int chancount = 0.0;
   // Summing internal channels
   for (unsigned int j = 0; j < _n_rings - 1; j++)
     chancount += j * 6;
   // Adding external channels to the total count
   _n_channels = chancount + _npins - 1 + (_n_rings - 1) * 6 + 6;
 
   if (*max_element(_index_blockage.begin(), _index_blockage.end()) > (_n_channels - 1))
     paramError("index_blockage",
                "The index of the blocked subchannel cannot be more than the max index of the "
                "subchannels");
 
   if ((_index_blockage.size() > _n_channels) || (_reduction_blockage.size() > _n_channels) ||
       (_k_blockage.size() > _n_channels))
     mooseError("Size of vectors: index_blockage, reduction_blockage, k_blockage, cannot be more "
                "than the total number of subchannels");
 
   // Defining the 2D array for axial resistances
   _k_grid.resize(_n_channels, std::vector<Real>(_n_cells + 1));
   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++;
       }
     }
   }
 
   _chan_to_pin_map.resize(_n_channels);
   _pin_to_chan_map.resize(_npins);
   _subch_type.resize(_n_channels);
   _n_gaps = _n_channels + _npins - 1; 
   _gap_to_chan_map.resize(_n_gaps);
   _gap_to_pin_map.resize(_n_gaps);
   gap_fill.resize(_n_gaps);
   _chan_to_gap_map.resize(_n_channels);
   _gap_pairs_sf.resize(_n_channels);
   _chan_pairs_sf.resize(_n_channels);
   _gij_map.resize(_n_cells + 1);
   _sign_id_crossflow_map.resize(_n_channels);
   _gap_type.resize(_n_gaps);
   _subchannel_position.resize(_n_channels);
 
   for (unsigned int i = 0; i < _n_channels; i++)
   {
     _chan_to_pin_map[i].reserve(3);
     _chan_to_gap_map[i].reserve(3);
     _sign_id_crossflow_map[i].reserve(3);
     _subchannel_position[i].reserve(3);
     for (unsigned int j = 0; j < 3; j++)
     {
       _sign_id_crossflow_map.at(i).push_back(positive_flow);
       _subchannel_position.at(i).push_back(0.0);
     }
   }
 
   for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
   {
     _gij_map[iz].reserve(_n_gaps);
   }
 
   for (unsigned int i = 0; i < _npins; i++)
     _pin_to_chan_map[i].reserve(6);
 
   // create the subchannels
   k = 0; // initialize the subchannel counter index
   kgap = 0;
   // for each ring we trace the subchannels by pairing up to neighbor pins and looking for the third
   // Pin at inner or outer ring compared to the current ring.
   for (unsigned int i = 1; i < _n_rings; i++)
   {
     // find the closest Pin at back ring
     for (unsigned int j = 0; j < _pins_in_rings[i].size(); j++)
     {
       if (j == _pins_in_rings[i].size() - 1)
       {
         _chan_to_pin_map[k].push_back(_pins_in_rings[i][j]);
         _chan_to_pin_map[k].push_back(_pins_in_rings[i][0]);
         avg_coor_x =
             0.5 * (_pin_position[_pins_in_rings[i][j]](0) + _pin_position[_pins_in_rings[i][0]](0));
         avg_coor_y =
             0.5 * (_pin_position[_pins_in_rings[i][j]](1) + _pin_position[_pins_in_rings[i][0]](1));
         _gap_to_pin_map[kgap].first = _pins_in_rings[i][0];
         _gap_to_pin_map[kgap].second = _pins_in_rings[i][j];
         _gap_type[kgap] = EChannelType::CENTER;
         kgap = kgap + 1;
       }
       else
       {
         _chan_to_pin_map[k].push_back(_pins_in_rings[i][j]);
         _chan_to_pin_map[k].push_back(_pins_in_rings[i][j + 1]);
         avg_coor_x = 0.5 * (_pin_position[_pins_in_rings[i][j]](0) +
                             _pin_position[_pins_in_rings[i][j + 1]](0));
         avg_coor_y = 0.5 * (_pin_position[_pins_in_rings[i][j]](1) +
                             _pin_position[_pins_in_rings[i][j + 1]](1));
         _gap_to_pin_map[kgap].first = _pins_in_rings[i][j];
         _gap_to_pin_map[kgap].second = _pins_in_rings[i][j + 1];
         _gap_type[kgap] = EChannelType::CENTER;
         kgap = kgap + 1;
       }
 
       dist0 = 1.0e+5;
 
       _chan_to_pin_map[k].push_back(_pins_in_rings[i - 1][0]);
       unsigned int l0 = 0;
 
       for (unsigned int l = 0; l < _pins_in_rings[i - 1].size(); l++)
       {
         dist = std::sqrt(pow(_pin_position[_pins_in_rings[i - 1][l]](0) - avg_coor_x, 2) +
                          pow(_pin_position[_pins_in_rings[i - 1][l]](1) - avg_coor_y, 2));
 
         if (dist < dist0)
         {
           _chan_to_pin_map[k][2] = _pins_in_rings[i - 1][l];
           l0 = l;
           dist0 = dist;
         } // if
       } // l
 
       _gap_to_pin_map[kgap].first = _pins_in_rings[i][j];
       _gap_to_pin_map[kgap].second = _pins_in_rings[i - 1][l0];
       _gap_type[kgap] = EChannelType::CENTER;
       kgap = kgap + 1;
       _subch_type[k] = EChannelType::CENTER;
       k = k + 1;
 
     } // for j
 
     // find the closest Pin at front ring
 
     for (unsigned int j = 0; j < _pins_in_rings[i].size(); j++)
     {
       if (j == _pins_in_rings[i].size() - 1)
       {
         _chan_to_pin_map[k].push_back(_pins_in_rings[i][j]);
         _chan_to_pin_map[k].push_back(_pins_in_rings[i][0]);
         avg_coor_x =
             0.5 * (_pin_position[_pins_in_rings[i][j]](0) + _pin_position[_pins_in_rings[i][0]](0));
         avg_coor_y =
             0.5 * (_pin_position[_pins_in_rings[i][j]](1) + _pin_position[_pins_in_rings[i][0]](1));
       }
       else
       {
         _chan_to_pin_map[k].push_back(_pins_in_rings[i][j]);
         _chan_to_pin_map[k].push_back(_pins_in_rings[i][j + 1]);
         avg_coor_x = 0.5 * (_pin_position[_pins_in_rings[i][j]](0) +
                             _pin_position[_pins_in_rings[i][j + 1]](0));
         avg_coor_y = 0.5 * (_pin_position[_pins_in_rings[i][j]](1) +
                             _pin_position[_pins_in_rings[i][j + 1]](1));
       }
 
       // if the outermost ring, set the edge subchannels first... then the corner subchannels
       if (i == _n_rings - 1)
       {
         // add  edges
         _subch_type[k] = EChannelType::EDGE; // an edge subchannel is created
         _gap_to_pin_map[kgap].first = _pins_in_rings[i][j];
         _gap_to_pin_map[kgap].second = _pins_in_rings[i][j];
         _gap_type[kgap] = EChannelType::EDGE;
         _chan_to_gap_map[k].push_back(kgap);
         kgap = kgap + 1;
         k = k + 1;
 
         if (j % i == 0)
         {
           // generate a corner subchannel, generate the additional gap and fix chan_to_gap_map
           _gap_to_pin_map[kgap].first = _pins_in_rings[i][j];
           _gap_to_pin_map[kgap].second = _pins_in_rings[i][j];
           _gap_type[kgap] = EChannelType::CORNER;
 
           // corner subchannel
           _chan_to_pin_map[k].push_back(_pins_in_rings[i][j]);
           _chan_to_gap_map[k].push_back(kgap - 1);
           _chan_to_gap_map[k].push_back(kgap);
           _subch_type[k] = EChannelType::CORNER;
 
           kgap = kgap + 1;
           k = k + 1;
         }
         // if not the outer most ring
       }
       else
       {
         dist0 = 1.0e+5;
         unsigned int l0 = 0;
         _chan_to_pin_map[k].push_back(_pins_in_rings[i + 1][0]);
         for (unsigned int l = 0; l < _pins_in_rings[i + 1].size(); l++)
         {
           dist = std::sqrt(pow(_pin_position[_pins_in_rings[i + 1][l]](0) - avg_coor_x, 2) +
                            pow(_pin_position[_pins_in_rings[i + 1][l]](1) - avg_coor_y, 2));
           if (dist < dist0)
           {
             _chan_to_pin_map[k][2] = _pins_in_rings[i + 1][l];
             dist0 = dist;
             l0 = l;
           } // if
         } // l
 
         _gap_to_pin_map[kgap].first = _pins_in_rings[i][j];
         _gap_to_pin_map[kgap].second = _pins_in_rings[i + 1][l0];
         _gap_type[kgap] = EChannelType::CENTER;
         kgap = kgap + 1;
         _subch_type[k] = EChannelType::CENTER;
         k = k + 1;
       } // if
     } // for j
   } // for i
 
   // Constructing pins to channels mao
   for (unsigned int loc_rod = 0; loc_rod < _npins; loc_rod++)
   {
     for (unsigned int i = 0; i < _n_channels; i++)
     {
       bool rod_in_sc = false;
       for (unsigned int j : _chan_to_pin_map[i])
       {
         if (j == loc_rod)
           rod_in_sc = true;
       }
       if (rod_in_sc)
       {
         _pin_to_chan_map[loc_rod].push_back(i);
       }
     }
   }
 
   // find the _gap_to_chan_map and _chan_to_gap_map using the gap_to_rod and subchannel_to_rod_maps
 
   for (unsigned int i = 0; i < _n_channels; i++)
   {
     if (_subch_type[i] == EChannelType::CENTER)
     {
       for (unsigned int j = 0; j < _n_gaps; j++)
       {
         if (_gap_type[j] == EChannelType::CENTER)
         {
           if (((_chan_to_pin_map[i][0] == _gap_to_pin_map[j].first) &&
                (_chan_to_pin_map[i][1] == _gap_to_pin_map[j].second)) ||
               ((_chan_to_pin_map[i][0] == _gap_to_pin_map[j].second) &&
                (_chan_to_pin_map[i][1] == _gap_to_pin_map[j].first)))
           {
             _chan_to_gap_map[i].push_back(j);
           }
 
           if (((_chan_to_pin_map[i][0] == _gap_to_pin_map[j].first) &&
                (_chan_to_pin_map[i][2] == _gap_to_pin_map[j].second)) ||
               ((_chan_to_pin_map[i][0] == _gap_to_pin_map[j].second) &&
                (_chan_to_pin_map[i][2] == _gap_to_pin_map[j].first)))
           {
             _chan_to_gap_map[i].push_back(j);
           }
 
           if (((_chan_to_pin_map[i][1] == _gap_to_pin_map[j].first) &&
                (_chan_to_pin_map[i][2] == _gap_to_pin_map[j].second)) ||
               ((_chan_to_pin_map[i][1] == _gap_to_pin_map[j].second) &&
                (_chan_to_pin_map[i][2] == _gap_to_pin_map[j].first)))
           {
             _chan_to_gap_map[i].push_back(j);
           }
         }
       } // for j
     }
     else if (_subch_type[i] == EChannelType::EDGE)
     {
       for (unsigned int j = 0; j < _n_gaps; j++)
       {
         if (_gap_type[j] == EChannelType::CENTER)
         {
           if (((_chan_to_pin_map[i][0] == _gap_to_pin_map[j].first) &&
                (_chan_to_pin_map[i][1] == _gap_to_pin_map[j].second)) ||
               ((_chan_to_pin_map[i][0] == _gap_to_pin_map[j].second) &&
                (_chan_to_pin_map[i][1] == _gap_to_pin_map[j].first)))
           {
             _chan_to_gap_map[i].push_back(j);
           }
         }
       }
 
       icorner = 0;
       for (unsigned int k = 0; k < _n_channels; k++)
       {
         if (_subch_type[k] == EChannelType::CORNER &&
             _chan_to_pin_map[i][1] == _chan_to_pin_map[k][0])
         {
           _chan_to_gap_map[i].push_back(_chan_to_gap_map[k][1]);
           icorner = 1;
           break;
         } // if
       } // for
 
       for (unsigned int k = 0; k < _n_channels; k++)
       {
         if (_subch_type[k] == EChannelType::CORNER &&
             _chan_to_pin_map[i][0] == _chan_to_pin_map[k][0])
         {
           _chan_to_gap_map[i].push_back(_chan_to_gap_map[k][1] + 1);
           icorner = 1;
           break;
         }
       }
 
       if (icorner == 0)
       {
         _chan_to_gap_map[i].push_back(_chan_to_gap_map[i][0] + 1);
       }
     }
   }
 
   // find gap_to_chan_map pair
 
   for (unsigned int j = 0; j < _n_gaps; j++)
   {
     for (unsigned int i = 0; i < _n_channels; i++)
     {
       if (_subch_type[i] == EChannelType::CENTER || _subch_type[i] == EChannelType::EDGE)
       {
         if ((j == _chan_to_gap_map[i][0]) || (j == _chan_to_gap_map[i][1]) ||
             (j == _chan_to_gap_map[i][2]))
         {
           if (_gap_to_chan_map[j].first == 0 && gap_fill[j].first == 0)
           {
             _gap_to_chan_map[j].first = i;
             gap_fill[j].first = 1;
           }
           else if (_gap_to_chan_map[j].second == 0 && gap_fill[j].second == 0)
           {
             _gap_to_chan_map[j].second = i;
             gap_fill[j].second = 1;
           }
           else
           {
           }
         }
       }
       else if (_subch_type[i] == EChannelType::CORNER)
       {
         if ((j == _chan_to_gap_map[i][0]) || (j == _chan_to_gap_map[i][1]))
         {
           if (_gap_to_chan_map[j].first == 0 && gap_fill[j].first == 0)
           {
             _gap_to_chan_map[j].first = i;
             gap_fill[j].first = 1;
           }
           else if (_gap_to_chan_map[j].second == 0 && gap_fill[j].second == 0)
           {
             _gap_to_chan_map[j].second = i;
             gap_fill[j].second = 1;
           }
           else
           {
           }
         }
       }
     } // i
   } // j
 
   for (unsigned int k = 0; k < _n_channels; k++)
   {
     if (_subch_type[k] == EChannelType::EDGE)
     {
       _gap_pairs_sf[k].first = _chan_to_gap_map[k][0];
       _gap_pairs_sf[k].second = _chan_to_gap_map[k][2];
       auto k1 = _gap_pairs_sf[k].first;
       auto k2 = _gap_pairs_sf[k].second;
       if (_gap_to_chan_map[k1].first == k)
       {
         _chan_pairs_sf[k].first = _gap_to_chan_map[k1].second;
       }
       else
       {
         _chan_pairs_sf[k].first = _gap_to_chan_map[k1].first;
       }
 
       if (_gap_to_chan_map[k2].first == k)
       {
         _chan_pairs_sf[k].second = _gap_to_chan_map[k2].second;
       }
       else
       {
         _chan_pairs_sf[k].second = _gap_to_chan_map[k2].first;
       }
     }
     else if (_subch_type[k] == EChannelType::CORNER)
     {
       _gap_pairs_sf[k].first = _chan_to_gap_map[k][1];
       _gap_pairs_sf[k].second = _chan_to_gap_map[k][0];
 
       auto k1 = _gap_pairs_sf[k].first;
       auto k2 = _gap_pairs_sf[k].second;
 
       if (_gap_to_chan_map[k1].first == k)
       {
         _chan_pairs_sf[k].first = _gap_to_chan_map[k1].second;
       }
       else
       {
         _chan_pairs_sf[k].first = _gap_to_chan_map[k1].first;
       }
 
       if (_gap_to_chan_map[k2].first == k)
       {
         _chan_pairs_sf[k].second = _gap_to_chan_map[k2].second;
       }
       else
       {
         _chan_pairs_sf[k].second = _gap_to_chan_map[k2].first;
       }
     }
   }
 
   // set the _gij_map
   for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
   {
     for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
     {
       if (_gap_type[i_gap] == EChannelType::CENTER)
       {
         _gij_map[iz].push_back(_pitch - _pin_diameter);
       }
       else if (_gap_type[i_gap] == EChannelType::EDGE || _gap_type[i_gap] == EChannelType::CORNER)
       {
         _gij_map[iz].push_back(_duct_to_pin_gap);
       }
     }
   }
 
   for (unsigned int i = 0; i < _n_channels; i++)
   {
     if (_subch_type[i] == EChannelType::CENTER || _subch_type[i] == EChannelType::EDGE)
     {
       for (unsigned int k = 0; k < 3; k++)
       {
         for (unsigned int j = 0; j < _n_gaps; j++)
         {
           if (_chan_to_gap_map[i][k] == j && i == _gap_to_chan_map[j].first)
           {
             if (i > _gap_to_chan_map[j].second)
             {
               _sign_id_crossflow_map[i][k] = negative_flow;
             }
             else
             {
               _sign_id_crossflow_map[i][k] = positive_flow;
             }
           }
           else if (_chan_to_gap_map[i][k] == j && i == _gap_to_chan_map[j].second)
           {
             if (i > _gap_to_chan_map[j].first)
             {
               _sign_id_crossflow_map[i][k] = negative_flow;
             }
             else
             {
               _sign_id_crossflow_map[i][k] = positive_flow;
             }
           }
         } // j
       } // k
     }
     else if (_subch_type[i] == EChannelType::CORNER)
     {
       for (unsigned int k = 0; k < 2; k++)
       {
         for (unsigned int j = 0; j < _n_gaps; j++)
         {
           if (_chan_to_gap_map[i][k] == j && i == _gap_to_chan_map[j].first)
           {
             if (i > _gap_to_chan_map[j].second)
             {
               _sign_id_crossflow_map[i][k] = negative_flow;
             }
             else
             {
               _sign_id_crossflow_map[i][k] = positive_flow;
             }
           }
           else if (_chan_to_gap_map[i][k] == j && i == _gap_to_chan_map[j].second)
           {
             if (i > _gap_to_chan_map[j].first)
             {
               _sign_id_crossflow_map[i][k] = negative_flow;
             }
             else
             {
               _sign_id_crossflow_map[i][k] = positive_flow;
             }
           }
         } // j
       } // k
     } // subch_type =2
   } // i
 
   // set the subchannel positions
   for (unsigned int i = 0; i < _n_channels; i++)
   {
     if (_subch_type[i] == EChannelType::CENTER)
     {
       _subchannel_position[i][0] =
           (_pin_position[_chan_to_pin_map[i][0]](0) + _pin_position[_chan_to_pin_map[i][1]](0) +
            _pin_position[_chan_to_pin_map[i][2]](0)) /
           3.0;
       _subchannel_position[i][1] =
           (_pin_position[_chan_to_pin_map[i][0]](1) + _pin_position[_chan_to_pin_map[i][1]](1) +
            _pin_position[_chan_to_pin_map[i][2]](1)) /
           3.0;
     }
     else if (_subch_type[i] == EChannelType::EDGE)
     {
       for (unsigned int j = 0; j < _n_channels; j++)
       {
         if (_subch_type[j] == EChannelType::CENTER &&
             ((_chan_to_pin_map[i][0] == _chan_to_pin_map[j][0] &&
               _chan_to_pin_map[i][1] == _chan_to_pin_map[j][1]) ||
              (_chan_to_pin_map[i][0] == _chan_to_pin_map[j][1] &&
               _chan_to_pin_map[i][1] == _chan_to_pin_map[j][0])))
         {
           x0 = _pin_position[_chan_to_pin_map[j][2]](0);
           y0 = _pin_position[_chan_to_pin_map[j][2]](1);
         }
         else if (_subch_type[j] == EChannelType::CENTER &&
                  ((_chan_to_pin_map[i][0] == _chan_to_pin_map[j][0] &&
                    _chan_to_pin_map[i][1] == _chan_to_pin_map[j][2]) ||
                   (_chan_to_pin_map[i][0] == _chan_to_pin_map[j][2] &&
                    _chan_to_pin_map[i][1] == _chan_to_pin_map[j][0])))
         {
           x0 = _pin_position[_chan_to_pin_map[j][1]](0);
           y0 = _pin_position[_chan_to_pin_map[j][1]](1);
         }
         else if (_subch_type[j] == EChannelType::CENTER &&
                  ((_chan_to_pin_map[i][0] == _chan_to_pin_map[j][1] &&
                    _chan_to_pin_map[i][1] == _chan_to_pin_map[j][2]) ||
                   (_chan_to_pin_map[i][0] == _chan_to_pin_map[j][2] &&
                    _chan_to_pin_map[i][1] == _chan_to_pin_map[j][1])))
         {
           x0 = _pin_position[_chan_to_pin_map[j][0]](0);
           y0 = _pin_position[_chan_to_pin_map[j][0]](1);
         }
         x1 = 0.5 *
              (_pin_position[_chan_to_pin_map[i][0]](0) + _pin_position[_chan_to_pin_map[i][1]](0));
         y1 = 0.5 *
              (_pin_position[_chan_to_pin_map[i][0]](1) + _pin_position[_chan_to_pin_map[i][1]](1));
         a1 = _pin_diameter / 2.0 + _duct_to_pin_gap / 2.0;
         a2 = std::sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)) + a1;
         _subchannel_position[i][0] = (a2 * x1 - a1 * x0) / (a2 - a1);
         _subchannel_position[i][1] = (a2 * y1 - a1 * y0) / (a2 - a1);
       } // j
     }
     else if (_subch_type[i] == EChannelType::CORNER)
     {
       x0 = _pin_position[0](0);
       y0 = _pin_position[0](1);
       x1 = _pin_position[_chan_to_pin_map[i][0]](0);
       y1 = _pin_position[_chan_to_pin_map[i][0]](1);
       a1 = _pin_diameter / 2.0 + _duct_to_pin_gap / 2.0;
       a2 = std::sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)) + a1;
       _subchannel_position[i][0] = (a2 * x1 - a1 * x0) / (a2 - a1);
       _subchannel_position[i][1] = (a2 * y1 - a1 * y0) / (a2 - a1);
     }
   }
 
   // Reduce reserved memory in the channel-to-gap map.
   for (auto & gap : _chan_to_gap_map)
   {
     gap.shrink_to_fit();
   }
 }

Member Function Documentation

◆ buildPinMesh()

void SCMTriAssemblyMeshGenerator::buildPinMesh ( MeshBase & mesh_base )

protected

Build the 1D pin elements and append them to the subchannel mesh.

Definition at line 781 of file SCMTriAssemblyMeshGenerator.C.

Referenced by generate().

 {
   if (_npins == 0)
     return;
 
   mesh_base.reserve_elem(_n_cells * _npins);
   mesh_base.reserve_nodes((_n_cells + 1) * _npins);
 
   _pin_nodes.clear();
   _pin_nodes.resize(_npins);
 
   // Defining the extent of the subchannel mesh to append the pin mesh to the current subchannel
   // mesh.
   const unsigned int node_sub = mesh_base.n_nodes();
   const unsigned int elem_sub = mesh_base.n_elem();
 
   // Add the points in the shape of a rectilinear grid. The grid is regular on the xy-plane at the
   // triangular lattice pin positions. The grid along z is also regular. Store pointers in the
   // _pin_nodes array so we can keep track of which points are in which pins.
   unsigned int node_id = node_sub;
   for (unsigned int i = 0; i < _npins; i++)
   {
     _pin_nodes[i].reserve(_n_cells + 1);
     for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
       _pin_nodes[i].push_back(mesh_base.add_point(
           Point(_pin_position[i](0), _pin_position[i](1), _z_grid[iz]), node_id++));
   }
 
   // Add the elements which in this case are 2-node edges that link each pin's nodes vertically.
   unsigned int elem_id = elem_sub;
   for (unsigned int i = 0; i < _npins; i++)
     for (unsigned int iz = 0; iz < _n_cells; iz++)
     {
       Elem * elem = mesh_base.add_elem(std::make_unique<Edge2>());
       elem->subdomain_id() = _pin_block_id;
       elem->set_id(elem_id++);
       const int indx1 = (_n_cells + 1) * i + iz + node_sub;
       const int indx2 = (_n_cells + 1) * i + (iz + 1) + node_sub;
       elem->set_node(0, mesh_base.node_ptr(indx1));
       elem->set_node(1, mesh_base.node_ptr(indx2));
     }
 
   mesh_base.subdomain_name(_pin_block_id) = "fuel_pins";
 }

◆ generate()

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

overridevirtual

Implements MeshGenerator.

Definition at line 827 of file SCMTriAssemblyMeshGenerator.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 * (_n_channels + _npins));
   mesh_base->reserve_nodes((_n_cells + 1) * (_n_channels + _npins));
   _nodes.resize(_n_channels);
   // Add the points for the give x,y subchannel positions.  The grid is hexagonal.
   //  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.
   unsigned int node_id = 0;
   for (unsigned int i = 0; i < _n_channels; i++)
   {
     _nodes[i].reserve(_n_cells + 1);
     for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
     {
       _nodes[i].push_back(mesh_base->add_point(
           Point(_subchannel_position[i][0], _subchannel_position[i][1], _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 i = 0; i < _n_channels; i++)
   {
     for (unsigned int iz = 0; iz < _n_cells; iz++)
     {
       Elem * elem = mesh_base->add_elem(std::make_unique<Edge2>());
       elem->subdomain_id() = _subchannel_block_id;
       elem->set_id(elem_id++);
       const int indx1 = (_n_cells + 1) * i + iz;
       const int indx2 = (_n_cells + 1) * i + (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";
 
   // Naming the block
   mesh_base->subdomain_name(_subchannel_block_id) = "subchannel";
   buildPinMesh(*mesh_base);
 
   mesh_base->prepare_for_use();
 
   // move the meta data into TriSubChannelMesh
   auto & sch_mesh = static_cast<TriSubChannelMesh &>(*_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._n_rings = _n_rings;
   sch_mesh._n_channels = _n_channels;
   sch_mesh._flat_to_flat = _flat_to_flat;
   sch_mesh._dwire = _dwire;
   sch_mesh._hwire = _hwire;
   sch_mesh._duct_to_pin_gap = _duct_to_pin_gap;
   sch_mesh._nodes = _nodes;
   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._sign_id_crossflow_map = _sign_id_crossflow_map;
   sch_mesh._gij_map = _gij_map;
   sch_mesh._subchannel_position = _subchannel_position;
   sch_mesh._pin_position = _pin_position;
   sch_mesh._pins_in_rings = _pins_in_rings;
   sch_mesh._chan_to_pin_map = _chan_to_pin_map;
   sch_mesh._npins = _npins;
   sch_mesh._n_gaps = _n_gaps;
   sch_mesh._subch_type = _subch_type;
   sch_mesh._gap_type = _gap_type;
   sch_mesh._gap_pairs_sf = _gap_pairs_sf;
   sch_mesh._chan_pairs_sf = _chan_pairs_sf;
   sch_mesh._pin_to_chan_map = _pin_to_chan_map;
   sch_mesh._pin_nodes = _pin_nodes;
   sch_mesh._pin_mesh_exist = (_npins > 0);
   sch_mesh.computeAssemblyHydraulicParameters();
 
   return mesh_base;
 }

◆ validParams()

InputParameters SCMTriAssemblyMeshGenerator::validParams ( )

static

Definition at line 36 of file SCMTriAssemblyMeshGenerator.C.

 {
   InputParameters params = MeshGenerator::validParams();
   params.addClassDescription(
       "Creates a mesh of 1D subchannels and 1D pins in a triangular lattice arrangement");
   params.addRequiredParam<unsigned int>("n_cells", "The number of cells in the axial direction");
   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>(
       "nrings",
       "Number of fuel-pin rings per assembly, counting the center pin as the first ring [-]");
   params.addRequiredParam<Real>("flat_to_flat",
                                 "Flat to flat distance for the hexagonal assembly [m]");
   params.addRequiredParam<Real>("dwire", "Wire diameter [m]");
   params.addRequiredParam<Real>("hwire", "Wire lead length [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<Real>("Kij", 0.5, "Lateral form loss coefficient [-]");
   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<unsigned int>("block_id", 0, "Subchannel block id");
   params.deprecateParam("block_id", "subchannel_block_id", "07/01/2027");
   params.addParam<unsigned int>("pin_block_id", 1, "Fuel Pin block id");
   return params;
 }

Member Data Documentation

◆ _chan_pairs_sf

std::vector<std::pair<unsigned int, unsigned int> > SCMTriAssemblyMeshGenerator::_chan_pairs_sf

protected

sweeping flow model channel pairs to specify directional edge flow

Definition at line 115 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _chan_to_gap_map

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

protected

stores the gaps that forms each subchannel

Definition at line 86 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _chan_to_pin_map

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

protected

stores the fuel pins belonging to each subchannel

Definition at line 101 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _duct_to_pin_gap

const Real SCMTriAssemblyMeshGenerator::_duct_to_pin_gap

protected

the gap thickness between the duct and peripheral fuel pins

Definition at line 75 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _dwire

const Real SCMTriAssemblyMeshGenerator::_dwire

protected

wire diameter

Definition at line 71 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate().

◆ _flat_to_flat

const Real SCMTriAssemblyMeshGenerator::_flat_to_flat

protected

the distance between flat surfaces of the duct facing each other

Definition at line 69 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate().

◆ _gap_pairs_sf

std::vector<std::pair<unsigned int, unsigned int> > SCMTriAssemblyMeshGenerator::_gap_pairs_sf

protected

sweeping flow model gap pairs per channel to specify directional edge flow

Definition at line 113 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _gap_to_chan_map

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

protected

stores the channel pairs for each gap

Definition at line 82 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _gap_to_pin_map

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

protected

stores the fuel pin pairs for each gap each gap

Definition at line 84 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _gap_type

std::vector<EChannelType> SCMTriAssemblyMeshGenerator::_gap_type

protected

gap type

Definition at line 111 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _gij_map

std::vector<std::vector<Real> > SCMTriAssemblyMeshGenerator::_gij_map

protected

gap size

Definition at line 93 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _heated_length

const Real SCMTriAssemblyMeshGenerator::_heated_length

protected

heated length of the fuel Pin

Definition at line 33 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _hwire

const Real SCMTriAssemblyMeshGenerator::_hwire

protected

wire lead length

Definition at line 73 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate().

◆ _index_blockage

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

protected

index of subchannels affected by blockage

Definition at line 51 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _k_blockage

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

protected

form loss coefficient of subchannels affected by blockage

Definition at line 55 of file SCMTriAssemblyMeshGenerator.h.

Referenced by SCMTriAssemblyMeshGenerator().

◆ _k_grid

std::vector<std::vector<Real> > SCMTriAssemblyMeshGenerator::_k_grid

protected

axial form loss coefficient per computational cell

Definition at line 43 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _kij

const Real& SCMTriAssemblyMeshGenerator::_kij

protected

Lateral form loss coefficient.

Definition at line 59 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate().

◆ _n_cells

const unsigned int SCMTriAssemblyMeshGenerator::_n_cells

protected

number of axial cells

Definition at line 63 of file SCMTriAssemblyMeshGenerator.h.

Referenced by buildPinMesh(), generate(), and SCMTriAssemblyMeshGenerator().

◆ _n_channels

unsigned int SCMTriAssemblyMeshGenerator::_n_channels

protected

number of subchannels

Definition at line 67 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _n_gaps

unsigned int SCMTriAssemblyMeshGenerator::_n_gaps

protected

number of gaps

Definition at line 107 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _n_rings

const unsigned int SCMTriAssemblyMeshGenerator::_n_rings

protected

number of rings of fuel pins

Definition at line 65 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _nodes

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

protected

nodes

Definition at line 78 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate().

◆ _npins

unsigned int SCMTriAssemblyMeshGenerator::_npins

protected

number of fuel pins

Definition at line 105 of file SCMTriAssemblyMeshGenerator.h.

Referenced by buildPinMesh(), generate(), and SCMTriAssemblyMeshGenerator().

◆ _pin_block_id

const unsigned int SCMTriAssemblyMeshGenerator::_pin_block_id

protected

pin block index

Definition at line 39 of file SCMTriAssemblyMeshGenerator.h.

Referenced by buildPinMesh().

◆ _pin_diameter

const Real SCMTriAssemblyMeshGenerator::_pin_diameter

protected

fuel Pin diameter

Definition at line 61 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _pin_nodes

std::vector<std::vector<Node *> > SCMTriAssemblyMeshGenerator::_pin_nodes

protected

pin nodes

Definition at line 80 of file SCMTriAssemblyMeshGenerator.h.

Referenced by buildPinMesh(), and generate().

◆ _pin_position

std::vector<Point> SCMTriAssemblyMeshGenerator::_pin_position

protected

x,y coordinates of the fuel pins

Definition at line 97 of file SCMTriAssemblyMeshGenerator.h.

Referenced by buildPinMesh(), generate(), and SCMTriAssemblyMeshGenerator().

◆ _pin_to_chan_map

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

protected

stores the map from pins to channels

Definition at line 103 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _pins_in_rings

std::vector<std::vector<Real> > SCMTriAssemblyMeshGenerator::_pins_in_rings

protected

fuel pins that are belonging to each ring

Definition at line 99 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _pitch

const Real SCMTriAssemblyMeshGenerator::_pitch

protected

Distance between the neighbor fuel pins, pitch.

Definition at line 57 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _reduction_blockage

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

protected

area reduction of subchannels affected by blockage

Definition at line 53 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _sign_id_crossflow_map

std::vector<std::vector<Real> > SCMTriAssemblyMeshGenerator::_sign_id_crossflow_map

protected

Defines the global cross-flow direction -1 or 1 for each subchannel and for all gaps that are belonging to the corresponding subchannel.

Given a subchannel and a gap, if the neighbor subchannel index belonging to the same gap is lower, set it to -1, otherwise set it to 1.

Definition at line 91 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _spacer_k

const std::vector<Real>& SCMTriAssemblyMeshGenerator::_spacer_k

protected

form loss coefficient of the spacers

Definition at line 47 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _spacer_z

const std::vector<Real>& SCMTriAssemblyMeshGenerator::_spacer_z

protected

axial location of the spacers

Definition at line 45 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _subch_type

std::vector<EChannelType> SCMTriAssemblyMeshGenerator::_subch_type

protected

subchannel type

Definition at line 109 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _subchannel_block_id

const unsigned int SCMTriAssemblyMeshGenerator::_subchannel_block_id

protected

subchannel block index

Definition at line 37 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate().

◆ _subchannel_position

std::vector<std::vector<Real> > SCMTriAssemblyMeshGenerator::_subchannel_position

protected

x,y coordinates of the subchannel centroids

Definition at line 95 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _unheated_length_entry

const Real SCMTriAssemblyMeshGenerator::_unheated_length_entry

protected

unheated length of the fuel Pin at the entry of the assembly

Definition at line 31 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _unheated_length_exit

const Real SCMTriAssemblyMeshGenerator::_unheated_length_exit

protected

unheated length of the fuel Pin at the exit of the assembly

Definition at line 35 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _z_blockage

const std::vector<Real> SCMTriAssemblyMeshGenerator::_z_blockage

protected

axial location of blockage (inlet, outlet) [m]

Definition at line 49 of file SCMTriAssemblyMeshGenerator.h.

Referenced by generate(), and SCMTriAssemblyMeshGenerator().

◆ _z_grid

std::vector<Real> SCMTriAssemblyMeshGenerator::_z_grid

protected

axial location of nodes

Definition at line 41 of file SCMTriAssemblyMeshGenerator.h.

Referenced by buildPinMesh(), generate(), and SCMTriAssemblyMeshGenerator().

The documentation for this class was generated from the following files:

subchannel/include/meshgenerators/SCMTriAssemblyMeshGenerator.h
subchannel/src/meshgenerators/SCMTriAssemblyMeshGenerator.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SCMTriAssemblyMeshGenerator()

Member Function Documentation

◆ buildPinMesh()

◆ generate()

◆ validParams()

Member Data Documentation

◆ _chan_pairs_sf

◆ _chan_to_gap_map

◆ _chan_to_pin_map

◆ _duct_to_pin_gap

◆ _dwire

◆ _flat_to_flat

◆ _gap_pairs_sf

◆ _gap_to_chan_map

◆ _gap_to_pin_map

◆ _gap_type

◆ _gij_map

◆ _heated_length

◆ _hwire

◆ _index_blockage

◆ _k_blockage

◆ _k_grid

◆ _kij

◆ _n_cells

◆ _n_channels

◆ _n_gaps

◆ _n_rings

◆ _nodes

◆ _npins

◆ _pin_block_id

◆ _pin_diameter

◆ _pin_nodes

◆ _pin_position

◆ _pin_to_chan_map

◆ _pins_in_rings

◆ _pitch

◆ _reduction_blockage

◆ _sign_id_crossflow_map

◆ _spacer_k

◆ _spacer_z

◆ _subch_type

◆ _subchannel_block_id

◆ _subchannel_position

◆ _unheated_length_entry

◆ _unheated_length_exit

◆ _z_blockage

◆ _z_grid