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

virtual void	generateData ()

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

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

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

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

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

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

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

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

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

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

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

void	declareMeshForSub (const std::string &param_name)

void	declareMeshesForSub (const std::string &param_name)

void	declareMeshForSubByName (const MeshGeneratorName &mesh_generator_name)

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

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

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

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

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

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

void	declareNullMeshName (const MeshGeneratorName &name)

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const Real	_heated_length
	heated length of the fuel Pin

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

const unsigned int	_subchannel_block_id
	subchannel block index

const unsigned int	_pin_block_id
	pin block index

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

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

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

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

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

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

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

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

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

const Real &	_kij
	Lateral form loss coefficient.

const Real	_pin_diameter
	fuel Pin diameter

const unsigned int	_n_cells
	number of axial cells

const unsigned int	_n_rings
	number of rings of fuel pins

unsigned int	_n_channels
	number of subchannels

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

const Real	_dwire
	wire diameter

const Real	_hwire
	wire lead length

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

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

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

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

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

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

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.

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

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

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

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

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

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

unsigned int	_npins
	number of fuel pins

unsigned int	_n_gaps
	number of gaps

std::vector< EChannelType >	_subch_type
	subchannel type

std::vector< EChannelType >	_gap_type
	gap type

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

std::vector< std::pair< unsigned int, unsigned int > >	_chan_pairs_sf
	sweeping flow model channel pairs to specify directional edge flow

MooseMesh *const	_mesh

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const Parallel::Communicator &	_communicator

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

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

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

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

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

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

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

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

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

Private Attributes
std::set< MeshGeneratorName >	_requested_mesh_generators

std::set< MeshGeneratorName >	_requested_mesh_generators_for_sub

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

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

std::unique_ptr< MeshBase >	_null_mesh

std::unique_ptr< CSG::CSGBase >	_null_csg_base

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

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

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

std::set< std::string >	_null_mesh_names

const std::string &	_save_with_name

const bool	_data_only

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

Detailed Description

Mesh generator that builds a 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

Build channel-gap connectivity from the channel-pin and gap-pin maps.

Center channels are bounded by three center gaps connecting their three pin pairs. Edge channels are bounded by one center gap between their two pins and two perimeter gaps along the duct. Corner channels are bounded by the two perimeter gaps that meet at the corner pin.

For a two-ring assembly every outer-ring pin is a corner pin. Consequently an edge channel can find a corner channel at both of its endpoint pins. The edge still owns only three local gap entries, matching _sign_id_crossflow_map and the reverse _gap_to_chan_map construction below, so the second corner lookup is skipped once those three entries are already present.

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);
      }
    }
  }
 
  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
 
      // Check whether the edge channel's first pin is also a corner pin. This second corner lookup
      // is only needed while the edge channel still needs another perimeter gap.
      if (_chan_to_gap_map[i].size() < 3)
      {
        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 792 of file SCMTriAssemblyMeshGenerator.C.

{
  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.set_subdomain_name(_pin_block_id, "fuel_pins", true);
}

Referenced by generate().

◆ generate()

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

overridevirtual

Implements MeshGenerator.

Definition at line 838 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->set_subdomain_name(_subchannel_block_id, "subchannel", true);
  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

Private Member Functions

Static Private Member Functions

Private 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