Mesh class for triangular, edge and corner subchannels for hexagonal lattice fuel assemblies. More...

#include <SCMTriInterWrapperMeshGenerator.h>

Inheritance diagram for SCMTriInterWrapperMeshGenerator:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	SCMTriInterWrapperMeshGenerator (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...

const Real &	_kij
	Lateral form loss coefficient. 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 Real	_assembly_pitch
	Distance between the neighbor fuel pins, assembly_pitch. 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	_duct_to_pin_gap
	the gap thickness between the duct and peripheral fuel pins More...

const bool	_tight_side_bypass
	whether the side bypass shape follows the hexagonal shape of the assemblies TODO: add a picture in the documentation of both tight and non-tight layouts More...

std::vector< std::vector< Node * > >	_nodes
	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 interstice More...

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

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

std::vector< std::vector< Real > >	_subchannel_position
	x,y coordinates of the interstices 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 interstice More...

unsigned int	_n_assemblies
	number of assemblies More...

unsigned int	_n_gaps
	number of gaps More...

std::vector< EChannelType >	_subch_type
	interstice 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

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const Parallel::Communicator &	_communicator

Detailed Description

Mesh class for triangular, edge and corner subchannels for hexagonal lattice fuel assemblies.

Definition at line 18 of file SCMTriInterWrapperMeshGenerator.h.

Constructor & Destructor Documentation

◆ SCMTriInterWrapperMeshGenerator()

SCMTriInterWrapperMeshGenerator::SCMTriInterWrapperMeshGenerator ( const InputParameters & parameters )

Re-sizing the object lists with the right number of channels

initial assignment

Definition at line 46 of file SCMTriInterWrapperMeshGenerator.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")),
     _kij(getParam<Real>("Kij")),
     _assembly_pitch(getParam<Real>("assembly_pitch")),
     _n_cells(getParam<unsigned int>("n_cells")),
     _n_rings(getParam<unsigned int>("nrings")),
     _flat_to_flat(getParam<Real>("flat_to_flat")),
     _duct_to_pin_gap(getParam<Real>("side_bypass")),
     _tight_side_bypass(getParam<bool>("tight_side_bypass"))
 {
 
   InterWrapperMesh::generateZGrid(
       _unheated_length_entry, _heated_length, _unheated_length_exit, _n_cells, _z_grid);
 
   //  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;
   TriInterWrapperMesh::rodPositions(_pin_position, _n_rings, _assembly_pitch, Point(0, 0));
   _n_assemblies = _pin_position.size();
   // assign the assemblies to the corresponding rings
   // TODO: add corner to the hexagonal assemblies
   unsigned int k = 0; // initialize the fuel assembly 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;
   for (unsigned int j = 0; j < _n_rings - 1; j++)
     chancount += j * 6;
   _n_channels = chancount + _n_assemblies - 1 + (_n_rings - 1) * 6 + 6;
 
   // Defining the array for axial resistances
   _k_grid.resize(_n_channels, std::vector<Real>(_n_cells + 1));
 
   _chan_to_pin_map.resize(_n_channels);
   _subch_type.resize(_n_channels);
   _n_gaps = _n_channels + _n_assemblies - 1; 
   _gap_to_chan_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_gaps);
   _sign_id_crossflow_map.resize(_n_channels);
   _gap_to_pin_map.resize(_n_gaps);
   _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);
     }
   } // i
 
   // 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]);
           // corner subchannel-dummy added to hinder array size violations
           _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
 
   // 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 j = 0; j < _n_gaps; j++)
   {
     if (_gap_type[j] == EChannelType::CENTER)
     {
       _gij_map[j] = _assembly_pitch - _flat_to_flat;
     }
     else if (_gap_type[j] == EChannelType::EDGE || _gap_type[j] == EChannelType::CORNER)
     {
       _gij_map[j] = _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));
         if (_tight_side_bypass)
           a1 = _flat_to_flat * std::tan(libMesh::pi / 6.0) / 2.0 + _duct_to_pin_gap / 2.0;
         else
           a1 = _flat_to_flat / 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 = _flat_to_flat / 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);
     }
   } // i
   // Reduce reserved memory in the channel-to-gap map.
   for (auto & gap : _chan_to_gap_map)
   {
     gap.shrink_to_fit();
   }
 }

Member Function Documentation

◆ generate()

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

overridevirtual

Implements MeshGenerator.

Definition at line 631 of file SCMTriInterWrapperMeshGenerator.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);
   mesh_base->reserve_nodes((_n_cells + 1) * _n_channels);
   _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 = new Edge2;
       elem->set_id(elem_id++);
       elem = mesh_base->add_elem(elem);
       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";
 
   mesh_base->prepare_for_use();
 
   // move the meta data into TriInterWrapperMesh
   auto & sch_mesh = static_cast<TriInterWrapperMesh &>(*_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._kij = _kij;
   sch_mesh._assembly_pitch = _assembly_pitch;
   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._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._n_assemblies = _n_assemblies;
   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._tight_side_bypass = _tight_side_bypass;
 
   // Overloading assembly sides with flat_to_flat distance
   sch_mesh._assembly_side_x = _flat_to_flat;
   sch_mesh._assembly_side_y = _flat_to_flat;
 
   return mesh_base;
 }

◆ validParams()

InputParameters SCMTriInterWrapperMeshGenerator::validParams ( )

static

Definition at line 23 of file SCMTriInterWrapperMeshGenerator.C.

 {
   InputParameters params = MeshGenerator::validParams();
   params.addClassDescription(
       "Creates a mesh for the inter-wrapper around triangular subassemblies");
   params.addRequiredParam<unsigned int>("n_cells", "The number of cells in the axial direction");
   params.addRequiredParam<Real>("assembly_pitch", "Pitch [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 [-]");
   params.addRequiredParam<Real>("flat_to_flat",
                                 "Flat to flat distance for the hexagonal assembly [m]");
   params.addParam<Real>("Kij", 0.5, "Lateral form loss coefficient [-]");
   params.addRequiredParam<Real>("side_bypass",
                                 "Extra size of the bypass for the side assemblies [m]");
   params.addParam<bool>(
       "tight_side_bypass",
       false,
       "Whether the side bypass shape follows the hexagonal shape of the assemblies");
   return params;
 }

Member Data Documentation

◆ _assembly_pitch

const Real SCMTriInterWrapperMeshGenerator::_assembly_pitch

protected

Distance between the neighbor fuel pins, assembly_pitch.

Definition at line 39 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _chan_pairs_sf

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

protected

sweeping flow model channel pairs to specify directional edge flow

Definition at line 88 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _chan_to_gap_map

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

protected

stores the gaps that forms each interstice

Definition at line 61 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _chan_to_pin_map

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

protected

stores the fuel pins belonging to each interstice

Definition at line 76 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _duct_to_pin_gap

const Real SCMTriInterWrapperMeshGenerator::_duct_to_pin_gap

protected

the gap thickness between the duct and peripheral fuel pins

Definition at line 49 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _flat_to_flat

const Real SCMTriInterWrapperMeshGenerator::_flat_to_flat

protected

the distance between flat surfaces of the duct facing each other

Definition at line 47 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _gap_pairs_sf

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

protected

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

Definition at line 86 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _gap_to_chan_map

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

protected

stores the channel pairs for each gap

Definition at line 57 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _gap_to_pin_map

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

protected

stores the fuel pin pairs for each gap each gap

Definition at line 59 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _gap_type

std::vector<EChannelType> SCMTriInterWrapperMeshGenerator::_gap_type

protected

gap type

Definition at line 84 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _gij_map

std::vector<Real> SCMTriInterWrapperMeshGenerator::_gij_map

protected

gap size

Definition at line 68 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _heated_length

const Real SCMTriInterWrapperMeshGenerator::_heated_length

protected

heated length of the fuel Pin

Definition at line 29 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _k_grid

std::vector<std::vector<Real> > SCMTriInterWrapperMeshGenerator::_k_grid

protected

axial form loss coefficient per computational cell

Definition at line 37 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _kij

const Real& SCMTriInterWrapperMeshGenerator::_kij

protected

Lateral form loss coefficient.

Definition at line 33 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate().

◆ _n_assemblies

unsigned int SCMTriInterWrapperMeshGenerator::_n_assemblies

protected

number of assemblies

Definition at line 78 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _n_cells

const unsigned int SCMTriInterWrapperMeshGenerator::_n_cells

protected

number of axial cells

Definition at line 41 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _n_channels

unsigned int SCMTriInterWrapperMeshGenerator::_n_channels

protected

number of subchannels

Definition at line 45 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _n_gaps

unsigned int SCMTriInterWrapperMeshGenerator::_n_gaps

protected

number of gaps

Definition at line 80 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _n_rings

const unsigned int SCMTriInterWrapperMeshGenerator::_n_rings

protected

number of rings of fuel pins

Definition at line 43 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _nodes

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

protected

nodes

Definition at line 55 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate().

◆ _pin_position

std::vector<Point> SCMTriInterWrapperMeshGenerator::_pin_position

protected

x,y coordinates of the fuel pins

Definition at line 72 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _pins_in_rings

std::vector<std::vector<Real> > SCMTriInterWrapperMeshGenerator::_pins_in_rings

protected

fuel pins that are belonging to each ring

Definition at line 74 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _sign_id_crossflow_map

std::vector<std::vector<Real> > SCMTriInterWrapperMeshGenerator::_sign_id_crossflow_map

protected

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

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

Definition at line 66 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _subch_type

std::vector<EChannelType> SCMTriInterWrapperMeshGenerator::_subch_type

protected

interstice type

Definition at line 82 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _subchannel_position

std::vector<std::vector<Real> > SCMTriInterWrapperMeshGenerator::_subchannel_position

protected

x,y coordinates of the interstices

Definition at line 70 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _tight_side_bypass

const bool SCMTriInterWrapperMeshGenerator::_tight_side_bypass

protected

whether the side bypass shape follows the hexagonal shape of the assemblies TODO: add a picture in the documentation of both tight and non-tight layouts

Definition at line 52 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _unheated_length_entry

const Real SCMTriInterWrapperMeshGenerator::_unheated_length_entry

protected

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

Definition at line 27 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _unheated_length_exit

const Real SCMTriInterWrapperMeshGenerator::_unheated_length_exit

protected

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

Definition at line 31 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

◆ _z_grid

std::vector<Real> SCMTriInterWrapperMeshGenerator::_z_grid

protected

axial location of nodes

Definition at line 35 of file SCMTriInterWrapperMeshGenerator.h.

Referenced by generate(), and SCMTriInterWrapperMeshGenerator().

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

subchannel/include/meshgenerators/SCMTriInterWrapperMeshGenerator.h
subchannel/src/meshgenerators/SCMTriInterWrapperMeshGenerator.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

◆ SCMTriInterWrapperMeshGenerator()

Member Function Documentation

◆ generate()

◆ validParams()

Member Data Documentation

◆ _assembly_pitch

◆ _chan_pairs_sf

◆ _chan_to_gap_map

◆ _chan_to_pin_map

◆ _duct_to_pin_gap

◆ _flat_to_flat

◆ _gap_pairs_sf

◆ _gap_to_chan_map

◆ _gap_to_pin_map

◆ _gap_type

◆ _gij_map

◆ _heated_length

◆ _k_grid

◆ _kij

◆ _n_assemblies

◆ _n_cells

◆ _n_channels

◆ _n_gaps

◆ _n_rings

◆ _nodes

◆ _pin_position

◆ _pins_in_rings

◆ _sign_id_crossflow_map

◆ _subch_type

◆ _subchannel_position

◆ _tight_side_bypass

◆ _unheated_length_entry

◆ _unheated_length_exit

◆ _z_grid