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

#include <SCMQuadInterWrapperMeshGenerator.h>

Inheritance diagram for SCMQuadInterWrapperMeshGenerator:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	SCMQuadInterWrapperMeshGenerator (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	_assembly_pitch
	Distance between the neighbor fuel assemblies, assembly pitch. More...

const Real	_assembly_side_x
	Sides of the assemblies in the x and y direction. More...

const Real	_assembly_side_y

const Real	_unheated_length_entry
	unheated length of the inter-wrapper section at the entry of the assembly More...

const Real	_heated_length
	heated length of the inter-wrapper section More...

const Real	_unheated_length_exit
	unheated length of the inter-wrapper section at the exit of the assembly More...

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

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

unsigned int	_nx
	Number of assemblies in the x direction. More...

unsigned int	_ny
	Number of assemblies in the y direction. More...

const Real	_side_bypass_length
	Extra bypass lengths in the sides of the assembly. More...

const unsigned int	_n_channels
	Total number of flow channels. More...

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

const unsigned int	_n_assemblies
	Number of assemblies. More...

const unsigned int	_block_id
	block index More...

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

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

unsigned int	_n_blocks
	number of axial blocks More...

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

std::vector< std::vector< Node * > >	_gapnodes
	Nodes of the gaps. More...

std::vector< std::pair< unsigned int, unsigned int > >	_gap_to_chan_map
	Defining the channel maps. More...

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

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

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

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

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

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

MooseMesh *const	_mesh

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const Parallel::Communicator &	_communicator

Friends
class	SCMQuadPinMeshGenerator

Detailed Description

Class for Subchannel mesh generation in the square lattice geometry.

Definition at line 19 of file SCMQuadInterWrapperMeshGenerator.h.

Constructor & Destructor Documentation

◆ SCMQuadInterWrapperMeshGenerator()

SCMQuadInterWrapperMeshGenerator::SCMQuadInterWrapperMeshGenerator ( const InputParameters & parameters )

Definition at line 44 of file SCMQuadInterWrapperMeshGenerator.C.

   : MeshGenerator(params),
     _assembly_pitch(getParam<Real>("assembly_pitch")),
     _assembly_side_x(getParam<Real>("assembly_side_x")),
     _assembly_side_y(getParam<Real>("assembly_side_y")),
     _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")),
     _n_cells(getParam<unsigned int>("n_cells")),
     _nx(getParam<unsigned int>("nx")),
     _ny(getParam<unsigned int>("ny")),
     _side_bypass_length(getParam<Real>("side_bypass")),
     _n_channels((_nx + 1) * (_ny + 1)),
     _n_gaps(_nx * (_ny + 1) + _ny * (_nx + 1)),
     _n_assemblies(_nx * _ny),
     _block_id(getParam<unsigned int>("block_id"))
 {
   // Converting number of assemblies into number of inter-wrapper flow channels
   _nx += 1;
   _ny += 1;
 
   if (_nx < 2 && _ny < 2)
     mooseError(name(), ": The number of assemblies cannot be less than one in any direction. ");
 
   // Defining the total length from 3 axial sections
   Real L = _unheated_length_entry + _heated_length + _unheated_length_exit;
 
   // Defining the dz based in the total length and the specified number of axial cells
   Real dz = L / _n_cells;
   for (unsigned int i = 0; i < _n_cells + 1; i++)
     _z_grid.push_back(dz * i);
 
   // Defining the array for axial resistances
   _k_grid.resize(_n_channels, std::vector<Real>(_n_cells + 1));
 
   // Defining the size of the maps
   _gap_to_chan_map.resize(_n_gaps);
   _gapnodes.resize(_n_gaps);
   _chan_to_gap_map.resize(_n_channels);
   _chan_to_pin_map.resize(_n_channels);
   _pin_to_chan_map.resize(_n_assemblies);
   _sign_id_crossflow_map.resize(_n_channels);
   _gij_map.resize(_n_gaps);
 
   // Defining the signs for positive and negative flows
   Real positive_flow = 1.0;
   Real negative_flow = -1.0;
 
   // Defining the subchannel types
   _subch_type.resize(_n_channels);
   for (unsigned int iy = 0; iy < _ny; iy++)
   {
     for (unsigned int ix = 0; ix < _nx; ix++)
     {
       unsigned int i_ch = _nx * iy + ix;
       bool is_corner = (ix == 0 && iy == 0) || (ix == _nx - 1 && iy == 0) ||
                        (ix == 0 && iy == _ny - 1) || (ix == _nx - 1 && iy == _ny - 1);
       bool is_edge = (ix == 0 || iy == 0 || ix == _nx - 1 || iy == _ny - 1);
 
       if (is_corner)
         _subch_type[i_ch] = EChannelType::CORNER;
       else if (is_edge)
         _subch_type[i_ch] = EChannelType::EDGE;
       else
         _subch_type[i_ch] = EChannelType::CENTER;
     }
   }
 
   // Index the east-west gaps.
   unsigned int i_gap = 0;
   for (unsigned int iy = 0; iy < _ny; iy++)
   {
     for (unsigned int ix = 0; ix < _nx - 1; ix++)
     {
       unsigned int i_ch = _nx * iy + ix;
       unsigned int j_ch = _nx * iy + (ix + 1);
       _gap_to_chan_map[i_gap] = {i_ch, j_ch};
       _chan_to_gap_map[i_ch].push_back(i_gap);
       _chan_to_gap_map[j_ch].push_back(i_gap);
       _sign_id_crossflow_map[i_ch].push_back(positive_flow);
       _sign_id_crossflow_map[j_ch].push_back(negative_flow);
 
       // make a gap size map
       if (iy == 0 || iy == _ny - 1)
         _gij_map[i_gap] = (_assembly_pitch - _assembly_side_x) / 2 + _side_bypass_length;
       else
         _gij_map[i_gap] = (_assembly_pitch - _assembly_side_x);
       ++i_gap;
     }
   }
 
   // Index the north-south gaps.
   for (unsigned int iy = 0; iy < _ny - 1; iy++)
   {
     for (unsigned int ix = 0; ix < _nx; ix++)
     {
       unsigned int i_ch = _nx * iy + ix;
       unsigned int j_ch = _nx * (iy + 1) + ix;
       _gap_to_chan_map[i_gap] = {i_ch, j_ch};
       _chan_to_gap_map[i_ch].push_back(i_gap);
       _chan_to_gap_map[j_ch].push_back(i_gap);
       _sign_id_crossflow_map[i_ch].push_back(positive_flow);
       _sign_id_crossflow_map[j_ch].push_back(negative_flow);
 
       // make a gap size map
       if (ix == 0 || ix == _nx - 1)
         _gij_map[i_gap] = (_assembly_pitch - _assembly_side_y) / 2 + _side_bypass_length;
       else
         _gij_map[i_gap] = (_assembly_pitch - _assembly_side_y);
       ++i_gap;
     }
   }
 
   // Make assembly to channel map
   for (unsigned int iy = 0; iy < _ny - 1; iy++)
   {
     for (unsigned int ix = 0; ix < _nx - 1; ix++)
     {
       unsigned int i_pin = (_nx - 1) * iy + ix;
       unsigned int i_chan_1 = _nx * iy + ix;
       unsigned int i_chan_2 = _nx * (iy + 1) + ix;
       unsigned int i_chan_3 = _nx * (iy + 1) + (ix + 1);
       unsigned int i_chan_4 = _nx * iy + (ix + 1);
       _pin_to_chan_map[i_pin].push_back(i_chan_1);
       _pin_to_chan_map[i_pin].push_back(i_chan_2);
       _pin_to_chan_map[i_pin].push_back(i_chan_3);
       _pin_to_chan_map[i_pin].push_back(i_chan_4);
     }
   }
 
   // Make channel to assembly map
   for (unsigned int iy = 0; iy < _ny; iy++) // row
   {
     for (unsigned int ix = 0; ix < _nx; ix++) // column
     {
       unsigned int i_ch = _nx * iy + ix;
       // Corners contact 1/4 of one pin
       if (iy == 0 && ix == 0)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
       }
       else if (iy == _ny - 1 && ix == 0)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
       }
       else if (iy == 0 && ix == _nx - 1)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
       }
       else if (iy == _ny - 1 && ix == _nx - 1)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
       }
       // Sides contact 1/4 of two pins
       else if (iy == 0)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
       }
       else if (iy == _ny - 1)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
       }
       else if (ix == 0)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
       }
       else if (ix == _nx - 1)
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
       }
       // interior contacts 1/4 of 4 pins
       else
       {
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * iy + ix - 1);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix);
         _chan_to_pin_map[i_ch].push_back((_nx - 1) * (iy - 1) + ix - 1);
       }
     }
   }
 
   // Reduce reserved memory in the channel-to-gap map.
   for (auto & gap : _chan_to_gap_map)
     gap.shrink_to_fit();
 
   // Reduce reserved memory in the channel-to-pin map.
   for (auto & pin : _chan_to_pin_map)
     pin.shrink_to_fit();
 
   // Reduce reserved memory in the pin-to-channel map.
   for (auto & pin : _pin_to_chan_map)
     pin.shrink_to_fit();
 
   _console << "Inter-wrapper quad mesh initialized" << std::endl;
 }

Member Function Documentation

◆ generate()

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

overridevirtual

Implements MeshGenerator.

Definition at line 246 of file SCMQuadInterWrapperMeshGenerator.C.

 {
   auto mesh_base = buildMeshBaseObject();
   BoundaryInfo & boundary_info = mesh_base->get_boundary_info();
   mesh_base->set_spatial_dimension(3);
   mesh_base->reserve_elem(_n_cells * _ny * _nx);
   mesh_base->reserve_nodes((_n_cells + 1) * _ny * _nx);
   _nodes.resize(_nx * _ny);
   // Add the points in the shape of a rectilinear grid.  The grid is regular
   // on the xy-plane with a spacing of `pitch` between points.  The grid along
   // z is irregular to account for Pin spacers.  Store pointers in the _nodes
   // array so we can keep track of which points are in which channels.
   Real offset_x = (_nx - 1) * _assembly_pitch / 2.0;
   Real offset_y = (_ny - 1) * _assembly_pitch / 2.0;
   unsigned int node_id = 0;
   for (unsigned int iy = 0; iy < _ny; iy++)
   {
     for (unsigned int ix = 0; ix < _nx; ix++)
     {
       int i_ch = _nx * iy + ix;
       _nodes[i_ch].reserve(_n_cells);
       for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
       {
         _nodes[i_ch].push_back(mesh_base->add_point(
             Point(_assembly_pitch * ix - offset_x, _assembly_pitch * iy - offset_y, _z_grid[iz]),
             node_id++));
       }
     }
   }
 
   // Add the elements which in this case are 2-node edges that link each
   // subchannel's nodes vertically.
   unsigned int elem_id = 0;
   for (unsigned int iy = 0; iy < _ny; iy++)
   {
     for (unsigned int ix = 0; ix < _nx; ix++)
     {
       for (unsigned int iz = 0; iz < _n_cells; iz++)
       {
         Elem * elem = new Edge2;
         elem->subdomain_id() = _block_id;
         elem->set_id(elem_id++);
         elem = mesh_base->add_elem(elem);
         const int indx1 = ((_n_cells + 1) * _nx) * iy + (_n_cells + 1) * ix + iz;
         const int indx2 = ((_n_cells + 1) * _nx) * iy + (_n_cells + 1) * ix + (iz + 1);
         elem->set_node(0, mesh_base->node_ptr(indx1));
         elem->set_node(1, mesh_base->node_ptr(indx2));
 
         if (iz == 0)
           boundary_info.add_side(elem, 0, 0);
         if (iz == _n_cells - 1)
           boundary_info.add_side(elem, 1, 1);
       }
     }
   }
 
   boundary_info.sideset_name(0) = "inlet";
   boundary_info.sideset_name(1) = "outlet";
   boundary_info.nodeset_name(0) = "inlet";
   boundary_info.nodeset_name(1) = "outlet";
   mesh_base->subdomain_name(_block_id) = name();
   mesh_base->prepare_for_use();
 
   // move the meta data into QuadInterWrapperMesh
   auto & sch_mesh = static_cast<QuadInterWrapperMesh &>(*_mesh);
   sch_mesh._unheated_length_entry = _unheated_length_entry;
 
   sch_mesh._assembly_pitch = _assembly_pitch;
   sch_mesh._assembly_side_x = _assembly_side_x;
   sch_mesh._assembly_side_y = _assembly_side_y;
   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._n_cells = _n_cells;
   sch_mesh._nx = _nx;
   sch_mesh._ny = _ny;
   sch_mesh._side_bypass_length = _side_bypass_length;
   sch_mesh._n_channels = _n_channels;
   sch_mesh._n_gaps = _n_gaps;
   sch_mesh._n_assemblies = _n_assemblies;
   sch_mesh._nodes = _nodes;
   sch_mesh._gapnodes = _gapnodes;
   sch_mesh._gap_to_chan_map = _gap_to_chan_map;
   sch_mesh._chan_to_gap_map = _chan_to_gap_map;
   sch_mesh._chan_to_pin_map = _chan_to_pin_map;
   sch_mesh._pin_to_chan_map = _pin_to_chan_map;
   sch_mesh._sign_id_crossflow_map = _sign_id_crossflow_map;
   sch_mesh._gij_map = _gij_map;
   sch_mesh._subch_type = _subch_type;
 
   _console << "Inter-wrapper quad mesh generated" << std::endl;
 
   return mesh_base;
 }

◆ validParams()

InputParameters SCMQuadInterWrapperMeshGenerator::validParams ( )

static

Definition at line 22 of file SCMQuadInterWrapperMeshGenerator.C.

 {
   InputParameters params = MeshGenerator::validParams();
   params.addClassDescription("Creates a mesh for the inter-wrapper around square subassemblies");
   params.addRequiredParam<Real>("assembly_pitch", "Assembly Pitch [m]");
   params.addRequiredParam<Real>("assembly_side_x",
                                 "Outer side lengths of assembly in x [m] - including duct");
   params.addRequiredParam<Real>("assembly_side_y",
                                 "Outer side lengths of assembly in y [m] - including duct");
   params.addParam<Real>("unheated_length_entry", 0.0, "Unheated length at entry [m]");
   params.addRequiredParam<Real>("heated_length", "Heated length [m]");
   params.addParam<Real>("unheated_length_exit", 0.0, "Unheated length at exit [m]");
   params.addParam<Real>("Kij", 0.5, "Lateral form loss coefficient [-]");
   params.addRequiredParam<unsigned int>("n_cells", "The number of cells in the axial direction");
   params.addRequiredParam<unsigned int>("nx", "Number of assemblies in the x direction [-]");
   params.addRequiredParam<unsigned int>("ny", "Number of assemblies in the y direction [-]");
   params.addRequiredParam<Real>("side_bypass",
                                 "Extra size of the bypass for the side assemblies [m]");
   params.addParam<unsigned int>("block_id", 0, "Domain Index");
   return params;
 }