Mesh generator for defining a reactor pin with background and duct regions, with the option to be 2-D or 3-D. More...

#include <PinMeshGenerator.h>

Inheritance diagram for PinMeshGenerator:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	PinMeshGenerator (const InputParameters &parameters)

std::unique_ptr< MeshBase >	generate () override

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

void	generateData () override

std::unique_ptr< CSG::CSGBase >	generateInternalCSG ()

std::unique_ptr< MeshBase >	generateInternal ()

const std::set< MeshGeneratorName > &	getRequestedMeshGenerators () const

const std::set< MeshGeneratorName > &	getRequestedMeshGeneratorsForSub () const

void	addParentMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

void	addChildMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

const std::set< const MeshGenerator *, Comparator > &	getParentMeshGenerators () const

const std::set< const MeshGenerator *, Comparator > &	getChildMeshGenerators () const

const std::set< const MeshGenerator *, Comparator > &	getSubMeshGenerators () const

bool	isParentMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const

bool	isChildMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const

bool	isNullMeshName (const MeshGeneratorName &name) const

bool	hasSaveMesh () const

bool	hasOutput () const

const std::string &	getSavedMeshName () const

bool	hasGenerateData () const

bool	hasGenerateCSG () const

bool	isDataOnly () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	haveParameter (const std::string &name) const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

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

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

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

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

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

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

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

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

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

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

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

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

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

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static void	addDepletionIDParams (InputParameters &parameters)

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 Types
enum	DepletionIDGenerationLevel { DepletionIDGenerationLevel::Pin, DepletionIDGenerationLevel::Assembly, DepletionIDGenerationLevel::Drum, DepletionIDGenerationLevel::Core }
	specify the depletion id is generated at which reactor generation level More...

Protected Member Functions
void	generateFlexibleAssemblyBoundaries ()

void	generateMetadata ()

unsigned int	getElemIntegerFromMesh (MeshBase &input_mesh, std::string extra_int_name, bool should_exist=false)
	Initializes extra element integer from id name for a given mesh and throws an error if it should exist but cannot be found within the mesh. More...

void	initializeReactorMeshParams (const std::string reactor_param_name)
	Initializes and checks validity of ReactorMeshParams mesh generator object. More...

void	printReactorMetadata (const std::string geometry_type, const std::string mg_name, const bool first_function_call=true)
	Print metadata associated with ReactorGeometryMeshBuilder object. More...

void	printCoreMetadata (const std::string mg_name, const bool first_function_call)
	Print core-level metadata associated with ReactorGeometryMeshBuilder object. More...

void	printAssemblyMetadata (const std::string mg_name, const bool first_function_call)
	Print assembly-level metadata associated with ReactorGeometryMeshBuilder object. More...

void	printPinMetadata (const std::string mg_name)
	Print pin-level metadata associated with ReactorGeometryMeshBuilder object. More...

void	printGlobalReactorMetadata ()
	Print global ReactorMeshParams metadata associated with ReactorGeometryMeshBuilder object. More...

template<typename T >
void	printMetadataToConsole (const std::string metadata_name, const std::string mg_name)
	Print metadata with provided name that can be found with given mesh generator name. More...

template<typename T >
void	print2dMetadataToConsole (const std::string metadata_name, const std::string mg_name)
	Print metadata with data type std::vector<std::vector<T>> and provided name that can be found with given mesh generator name. More...

void	freeReactorParamsMesh ()
	Releases the mesh obtained in _reactor_params_mesh. More...

void	freeReactorParamsCSG ()
	Releases the CSG base object obtained in _reactor_params_csg. More...

template<typename T >
bool	hasReactorParam (const std::string param_name)
	Checks whether parameter is defined in ReactorMeshParams metadata. More...

template<typename T >
const T &	getReactorParam (const std::string &param_name)
	Returns reference of parameter in ReactorMeshParams object. More...

void	updateElementBlockNameId (MeshBase &input_mesh, Elem *elem, std::map< std::string, SubdomainID > &name_id_map, std::string elem_block_name, SubdomainID &next_free_id)
	Updates the block names and ids of the element in an input mesh according to a map of block name to block ids. More...

MeshGeneratorName	callExtrusionMeshSubgenerators (const MeshGeneratorName input_mesh_name)
	Calls mesh subgenerators related to extrusion, renaming of top / bottom boundaries, and defining plane IDs. More...

void	addDepletionId (MeshBase &input_mesh, const MooseEnum &option, const DepletionIDGenerationLevel generation_level, const bool extrude)
	add depletion IDs More...

std::vector< std::reference_wrapper< const CSG::CSGSurface > >	getOuterRadialSurfacesForUnitCell (unsigned int radial_index, Real halfpitch, CSG::CSGBase &csg_obj)
	Get CSGSurfaces corresponding to hexagonal or square region with given halfpitch and centered around (0, 0, 0) More...

std::vector< std::reference_wrapper< const CSG::CSGSurface > >	getAxialPlaneSurfaces (CSG::CSGBase &csg_obj)
	Get CSGSurfaces corresponding to axial planes of the extruded RGMB mesh. More...

const CSG::CSGLattice &	createRGMBLattice (const Real pitch, const std::vector< std::vector< std::reference_wrapper< const CSG::CSGUniverse >>> pattern, CSG::CSGBase &csg_obj)
	Create CSG lattice for assembly and core lattices. More...

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 subdomain_id_type	_pin_type
	The id number for this pin type. More...

const Real	_pitch
	The face-to-face size of this pin. More...

const unsigned int	_num_sectors
	The number of azimuthal divisions. More...

std::vector< Real >	_ring_radii
	The outer radii of concentric rings in the pin. More...

const std::vector< Real >	_duct_halfpitch
	The inner apothem of any surrounding ducts in the pin. More...

std::vector< unsigned int >	_intervals
	The number of mesh intervals in a radial division starting from the center. More...

std::vector< std::vector< subdomain_id_type > >	_region_ids
	2-D vector (axial outer indexing, radial inner indexing) used to set "region_id" extra-element integer of the pin mesh elements More...

bool	_has_block_names
	Whether block names have been provided by user. More...

std::vector< std::vector< std::string > >	_block_names
	2-D vector (axial outer indexing, radial inner indexing) used to set block names of pin mesh elements More...

std::string	_mesh_geometry
	The type of geometry that is being described (Square or Hex, declared in the ReactorMeshParams object) More...

unsigned int	_mesh_dimensions
	The number of dimensions the mesh is ultimately going to have (2 or 3, declared in the ReactorMeshParams object) More...

const bool	_extrude
	Whether this mesh should be extruded to 3-D, making it the final structure in the reactor mesh. More...

bool	_quad_center
	Whether the centermost elements in the pin should be quad elements as opposed to tri elements. More...

bool	_homogenized
	Whether the resulting pin mesh should be homogenized. More...

bool	_is_assembly
	Whether the resulting pin mesh should also be used as an assembly mesh. More...

std::unique_ptr< MeshBase > *	_build_mesh
	The final mesh that is generated by the subgenerators; This mesh is generated by the subgenerators with only element and boundary ids changed. More...

MeshGeneratorName	_reactor_params
	The ReactorMeshParams object that is storing the reactor global information for this reactor geometry mesh. More...

MooseMesh *const	_mesh

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const Parallel::Communicator &	_communicator

Detailed Description

Mesh generator for defining a reactor pin with background and duct regions, with the option to be 2-D or 3-D.

Definition at line 18 of file PinMeshGenerator.h.

Member Enumeration Documentation

◆ DepletionIDGenerationLevel

enum ReactorGeometryMeshBuilderBase::DepletionIDGenerationLevel

strongprotectedinherited

specify the depletion id is generated at which reactor generation level

Enumerator
Pin
Assembly
Drum
Core

Definition at line 263 of file ReactorGeometryMeshBuilderBase.h.

   {
     Pin,
     Assembly,
     Drum,
     Core
   };

Constructor & Destructor Documentation

◆ PinMeshGenerator()

PinMeshGenerator::PinMeshGenerator ( const InputParameters & parameters )

Definition at line 103 of file PinMeshGenerator.C.

   : ReactorGeometryMeshBuilderBase(parameters),
     _pin_type(getParam<subdomain_id_type>("pin_type")),
     _pitch(getParam<Real>("pitch")),
     _num_sectors(isParamValid("num_sectors") ? getParam<unsigned int>("num_sectors") : 0),
     _ring_radii(isParamValid("ring_radii") ? getParam<std::vector<Real>>("ring_radii")
                                            : std::vector<Real>()),
     _duct_halfpitch(isParamValid("duct_halfpitch") ? getParam<std::vector<Real>>("duct_halfpitch")
                                                    : std::vector<Real>()),
     _intervals(getParam<std::vector<unsigned int>>("mesh_intervals")),
     _region_ids(isParamValid("region_ids")
                     ? getParam<std::vector<std::vector<subdomain_id_type>>>("region_ids")
                     : std::vector<std::vector<subdomain_id_type>>()),
     _extrude(getParam<bool>("extrude")),
     _quad_center(getParam<bool>("quad_center_elements")),
     _homogenized(getParam<bool>("homogenized")),
     _is_assembly(getParam<bool>("use_as_assembly"))
 {
   // Initialize ReactorMeshParams object
   initializeReactorMeshParams(getParam<MeshGeneratorName>("reactor_params"));
 
   _mesh_dimensions = getReactorParam<unsigned int>(RGMB::mesh_dimensions);
   _mesh_geometry = getReactorParam<std::string>(RGMB::mesh_geometry);
 
   if (_is_assembly)
   {
     auto assembly_pitch = getReactorParam<Real>(RGMB::assembly_pitch);
     if (assembly_pitch != _pitch)
       mooseError("Pitch defined in PinMeshGenerator must match assembly_pitch defined in "
                  "ReactorMeshParams if use_as_assembly is set to true");
   }
 
   if (_extrude && _mesh_dimensions != 3)
     paramError("extrude",
                "In order to extrude this mesh, ReactorMeshParams/dim needs to be set to 3\n");
   if (_extrude && (!hasReactorParam<boundary_id_type>(RGMB::top_boundary_id) ||
                    !hasReactorParam<boundary_id_type>(RGMB::bottom_boundary_id)))
     mooseError("Both top_boundary_id and bottom_boundary_id must be provided in ReactorMeshParams "
                "if using extruded geometry");
 
   if (_homogenized)
   {
     if (_mesh_geometry == "Square")
       mooseError("Homogenization in PinMeshGenerator is only supported for hexagonal geometries");
     const std::vector<std::string> disallowed_parameters = {
         "num_sectors", "ring_radii", "duct_halfpitch", "mesh_intervals"};
     for (const auto & parameter : disallowed_parameters)
       if (parameters.isParamSetByUser(parameter))
         paramError(parameter,
                    "Parameter " + parameter + " should not be defined for a homogenized pin mesh");
   }
   else
   {
     if (_num_sectors == 0)
       mooseError(
           "Number of sectors must be assigned with parameter num_sectors for non-homogenized pins");
     if (_intervals.size() != (_ring_radii.size() + _duct_halfpitch.size() + 1))
       mooseError(
           "The number of mesh intervals must be equal to the number of annular regions + the "
           "number of duct regions + 1"
           " for the region between the rings and ducts\n");
   }
 
   if (isParamValid("region_ids"))
   {
     unsigned int n_axial_levels =
         (_mesh_dimensions == 3)
             ? getReactorParam<std::vector<unsigned int>>(RGMB::axial_mesh_intervals).size()
             : 1;
     if (_region_ids.size() != n_axial_levels)
       mooseError("The size of region IDs must be equal to the number of axial levels as defined in "
                  "the ReactorMeshParams object");
     if (_region_ids[0].size() != (_ring_radii.size() + _duct_halfpitch.size() + 1))
       mooseError("The number of region IDs given needs to be one more than the number of "
                  "ring_radii + the number of duct_radii\n");
   }
   else
   {
     mooseError("Region IDs must be assigned with parameter region_ids");
   }
   if (isParamValid("block_names"))
   {
     if (getReactorParam<bool>(RGMB::region_id_as_block_name))
       paramError("block_names",
                  "If ReactorMeshParams/region_id_as_block_name is set, block_names should not be "
                  "specified in PinMeshGenerator");
     _has_block_names = true;
     _block_names = getParam<std::vector<std::vector<std::string>>>("block_names");
     if (_region_ids.size() != _block_names.size())
       mooseError("The size of block_names must match the size of region_ids");
     for (const auto i : index_range(_region_ids))
       if (_region_ids[i].size() != _block_names[i].size())
         mooseError("The size of block_names must match the size of region_ids");
   }
   else
     _has_block_names = false;
 
   const auto use_flexible_stitching = getReactorParam<bool>(RGMB::flexible_assembly_stitching);
   std::string build_mesh_name;
 
   // No subgenerators will be called if option to bypass mesh generators is enabled
   if (!getReactorParam<bool>(RGMB::bypass_meshgen))
   {
     if (_homogenized)
     {
       // If flexible assembly stitching is invoked and this is a homogeneous assembly mesh, do not
       // call mesh subgenerators here. The homogeneous assembly mesh should be created entirely in
       // generateFlexibleAssemblyBoundaries()
       bool skip_assembly_generation = _is_assembly && use_flexible_stitching;
 
       auto params = _app.getFactory().getValidParams("SimpleHexagonGenerator");
 
       params.set<Real>("hexagon_size") = _pitch / 2.0;
       params.set<boundary_id_type>("external_boundary_id") =
           RGMB::PIN_BOUNDARY_ID_START + _pin_type;
       const auto boundary_name =
           (_is_assembly ? RGMB::ASSEMBLY_BOUNDARY_NAME_PREFIX : RGMB::PIN_BOUNDARY_NAME_PREFIX) +
           std::to_string(_pin_type);
       params.set<BoundaryName>("external_boundary_name") = boundary_name;
       params.set<std::vector<subdomain_id_type>>("block_id") = {
           _quad_center ? RGMB::PIN_BLOCK_ID_START : RGMB::PIN_BLOCK_ID_TRI};
       params.set<MooseEnum>("element_type") = _quad_center ? "QUAD" : "TRI";
       auto block_name = RGMB::PIN_BLOCK_NAME_PREFIX + std::to_string(_pin_type) + "_R0";
       if (!_quad_center)
         block_name += RGMB::TRI_BLOCK_NAME_SUFFIX;
       params.set<std::vector<SubdomainName>>("block_name") = {block_name};
 
       if (!skip_assembly_generation)
       {
         build_mesh_name = name() + "_2D";
         addMeshSubgenerator("SimpleHexagonGenerator", build_mesh_name, params);
       }
     }
     else
     {
       // Define all id variables used in the pin
       std::vector<unsigned int> ring_intervals;
       std::vector<subdomain_id_type> ring_blk_ids;
       std::vector<SubdomainName> ring_blk_names;
       unsigned int background_intervals = 1;
       std::vector<subdomain_id_type> background_blk_ids;
       std::vector<SubdomainName> background_blk_names;
       std::vector<unsigned int> duct_intervals;
       std::vector<subdomain_id_type> duct_blk_ids;
       std::vector<SubdomainName> duct_blk_names;
 
       for (const auto i : index_range(_intervals))
       {
         const auto block_name =
             RGMB::PIN_BLOCK_NAME_PREFIX + std::to_string(_pin_type) + "_R" + std::to_string(i);
         const auto block_id = RGMB::PIN_BLOCK_ID_START + i;
 
         if (i < _ring_radii.size())
         {
           ring_intervals.push_back(_intervals[i]);
           ring_blk_ids.push_back(block_id);
           ring_blk_names.push_back(block_name);
         }
         else if (i > _ring_radii.size())
         {
           duct_intervals.push_back(_intervals[i]);
           duct_blk_ids.push_back(block_id);
           duct_blk_names.push_back(block_name);
         }
         else
         {
           background_intervals = _intervals[i];
           background_blk_ids.push_back(block_id);
           background_blk_names.push_back(block_name);
         }
       }
       if (ring_intervals.size() > 0)
       {
         if (ring_intervals.front() != 1)
         {
           // If quad center elements, copy element at beginning of block names and
           // block ids. Otherwise add RGMB::TRI_BLOCK_NAME_SUFFIX to block names and generate new
           // block id
           if (_quad_center)
           {
             ring_blk_ids.insert(ring_blk_ids.begin(), ring_blk_ids.front());
             ring_blk_names.insert(ring_blk_names.begin(), ring_blk_names.front());
           }
           else
           {
             const auto block_name = ring_blk_names.front() + RGMB::TRI_BLOCK_NAME_SUFFIX;
             const auto block_id = RGMB::PIN_BLOCK_ID_TRI;
             ring_blk_ids.insert(ring_blk_ids.begin(), block_id);
             ring_blk_names.insert(ring_blk_names.begin(), block_name);
           }
         }
         // Add RGMB::TRI_BLOCK_NAME_SUFFIX if only one radial region and tri center elements
         else if (!_quad_center)
         {
           ring_blk_ids[0] = RGMB::PIN_BLOCK_ID_TRI;
           ring_blk_names[0] += RGMB::TRI_BLOCK_NAME_SUFFIX;
         }
       }
       else
       {
         if (background_intervals > 1)
         {
           // If quad center elements, copy element at beginning of block names and
           // block ids. Otherwise add RGMB::TRI_BLOCK_NAME_SUFFIX to block names and generate new
           // block id
           if (_quad_center)
           {
             background_blk_ids.insert(background_blk_ids.begin(), background_blk_ids.front());
             background_blk_names.insert(background_blk_names.begin(), background_blk_names.front());
           }
           else
           {
             const auto block_name = background_blk_names.front() + RGMB::TRI_BLOCK_NAME_SUFFIX;
             const auto block_id = RGMB::PIN_BLOCK_ID_TRI;
             background_blk_ids.insert(background_blk_ids.begin(), block_id);
             background_blk_names.insert(background_blk_names.begin(), block_name);
           }
         }
         // Add RGMB::TRI_BLOCK_NAME_SUFFIX if only one background region and tri center elements
         // and no ring regions
         else if (!_quad_center)
         {
           background_blk_ids[0] = RGMB::PIN_BLOCK_ID_TRI;
           background_blk_names[0] += RGMB::TRI_BLOCK_NAME_SUFFIX;
         }
       }
 
       // If flexible assembly stitching is invoked and this is an assembly mesh with only a
       // background region, do not call mesh subgenerators here. This assembly mesh should be
       // created entirely in generateFlexibleAssemblyBoundaries()
       bool skip_assembly_generation =
           _is_assembly && use_flexible_stitching && _intervals.size() == 1;
 
       if (!skip_assembly_generation)
       {
         // Generate Cartesian/hex pin using PolygonConcentricCircleMeshGenerator
         {
           // Get and assign parameters for the main geometry feature of the Pin
           // which is created with a PolygonConcentricCircleMeshGenerator subgenerator
           auto params = _app.getFactory().getValidParams("PolygonConcentricCircleMeshGenerator");
           params.set<bool>("preserve_volumes") = true;
           params.set<bool>("quad_center_elements") = _quad_center;
           params.set<MooseEnum>("polygon_size_style") = "apothem";
           params.set<Real>("polygon_size") = _pitch / 2.0;
           params.set<boundary_id_type>("external_boundary_id") =
               RGMB::PIN_BOUNDARY_ID_START + _pin_type;
           const auto boundary_name = (_is_assembly ? RGMB::ASSEMBLY_BOUNDARY_NAME_PREFIX
                                                    : RGMB::PIN_BOUNDARY_NAME_PREFIX) +
                                      std::to_string(_pin_type);
           params.set<BoundaryName>("external_boundary_name") = boundary_name;
           bool flat_side_up = (_mesh_geometry == "Square");
           params.set<bool>("flat_side_up") = flat_side_up;
           params.set<bool>("create_outward_interface_boundaries") = false;
 
           const auto num_sides = (_mesh_geometry == "Square") ? 4 : 6;
           params.set<unsigned int>("num_sides") = num_sides;
           params.set<std::vector<unsigned int>>("num_sectors_per_side") =
               std::vector<unsigned int>(num_sides, _num_sectors);
 
           if (ring_intervals.size() > 0)
           {
             params.set<std::vector<Real>>("ring_radii") = _ring_radii;
             params.set<std::vector<subdomain_id_type>>("ring_block_ids") = ring_blk_ids;
             params.set<std::vector<SubdomainName>>("ring_block_names") = ring_blk_names;
             params.set<std::vector<unsigned int>>("ring_intervals") = ring_intervals;
           }
 
           params.set<std::vector<subdomain_id_type>>("background_block_ids") = background_blk_ids;
           params.set<std::vector<SubdomainName>>("background_block_names") = background_blk_names;
           params.set<unsigned int>("background_intervals") = background_intervals;
 
           if (duct_intervals.size() > 0)
           {
             params.set<MooseEnum>("duct_sizes_style") = "apothem";
             params.set<std::vector<Real>>("duct_sizes") = _duct_halfpitch;
             params.set<std::vector<subdomain_id_type>>("duct_block_ids") = duct_blk_ids;
             params.set<std::vector<SubdomainName>>("duct_block_names") = duct_blk_names;
             params.set<std::vector<unsigned int>>("duct_intervals") = duct_intervals;
           }
 
           addMeshSubgenerator("PolygonConcentricCircleMeshGenerator", name() + "_2D", params);
         }
 
         // Remove extra sidesets created by PolygonConcentricCircleMeshGenerator
         {
           auto params = _app.getFactory().getValidParams("BoundaryDeletionGenerator");
 
           params.set<MeshGeneratorName>("input") = name() + "_2D";
 
           auto num_sides = (_mesh_geometry == "Square") ? 4 : 6;
           std::vector<BoundaryName> boundaries_to_delete = {};
           for (const auto i : make_range(num_sides))
             boundaries_to_delete.insert(boundaries_to_delete.end(),
                                         {std::to_string(10001 + i), std::to_string(15001 + i)});
           params.set<std::vector<BoundaryName>>("boundary_names") = boundaries_to_delete;
 
           build_mesh_name = name() + "_delbds";
           addMeshSubgenerator("BoundaryDeletionGenerator", build_mesh_name, params);
         }
       }
     }
 
     // For pin acting as assembly, modify outermost mesh interval to enable flexible assembly
     // stitching
     if (_is_assembly && use_flexible_stitching)
     {
       generateFlexibleAssemblyBoundaries();
       build_mesh_name = name() + "_fpg_delbds";
     }
 
     // Pass mesh meta-data defined in subgenerator constructor to this MeshGenerator
     if (hasMeshProperty<Real>("pitch_meta", name() + "_2D"))
       copyMeshProperty<Real>("pitch_meta", name() + "_2D");
     if (hasMeshProperty<std::vector<unsigned int>>("num_sectors_per_side_meta", name() + "_2D"))
       copyMeshProperty<std::vector<unsigned int>>("num_sectors_per_side_meta", name() + "_2D");
     if (hasMeshProperty<Real>("max_radius_meta", name() + "_2D"))
       copyMeshProperty<Real>("max_radius_meta", name() + "_2D");
     if (hasMeshProperty<unsigned int>("background_intervals_meta", name() + "_2D"))
       copyMeshProperty<unsigned int>("background_intervals_meta", name() + "_2D");
     if (hasMeshProperty<dof_id_type>("node_id_background_meta", name() + "_2D"))
       copyMeshProperty<dof_id_type>("node_id_background_meta", name() + "_2D");
 
     if (_is_assembly)
       declareMeshProperty("pattern_pitch_meta", getReactorParam<Real>(RGMB::assembly_pitch));
     else if (hasMeshProperty<Real>("pattern_pitch_meta", name() + "_2D"))
       copyMeshProperty<Real>("pattern_pitch_meta", name() + "_2D");
     declareMeshProperty("is_control_drum_meta", false);
 
     if (_extrude)
       build_mesh_name = callExtrusionMeshSubgenerators(build_mesh_name);
 
     // Store final mesh subgenerator
     _build_mesh = &getMeshByName(build_mesh_name);
   }
 
   generateMetadata();
 }

Member Function Documentation

◆ addDepletionId()

void ReactorGeometryMeshBuilderBase::addDepletionId	(	MeshBase &	input_mesh,
		const MooseEnum &	option,
		const DepletionIDGenerationLevel	generation_level,
		const bool	extrude
	)

protectedinherited

add depletion IDs

Parameters

input_mesh	input mesh
option	option for specifying level of details
generation_level	depletion id is generated at which reactor generator level
extrude	whether input mesh is extruded, if false, assume that input mesh is defined in 2D and do not use 'plane_id` in depletion id generation

Definition at line 130 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator::generate(), ControlDrumMeshGenerator::generate(), and CoreMeshGenerator::generate().

 {
   // prepare set of extra elem ids for depletion ID generation
   std::vector<ExtraElementIDName> id_names = {};
   if (extrude)
     id_names.push_back("plane_id");
   if (generation_level == DepletionIDGenerationLevel::Core)
   {
     if (option == "pin")
       id_names.insert(id_names.end(), {"assembly_id", "pin_id"});
     else if (option == "pin_type")
       id_names.insert(id_names.end(), {"assembly_id", "pin_type_id"});
     else if (option == "assembly")
       id_names.push_back("assembly_id");
     else if (option == "assembly_type")
       id_names.push_back("assembly_type_id");
   }
   else if (generation_level == DepletionIDGenerationLevel::Assembly)
   {
     if (option == "pin")
       id_names.push_back("pin_id");
     else if (option == "pin_type")
       id_names.push_back("pin_type_id");
     else
       paramError("depletion_id_type",
                  "'assembly_id' or 'assembly_type_id' is not allowed in depletion ID generation at "
                  "assembly level");
   }
   else if (generation_level == DepletionIDGenerationLevel::Drum)
   {
     if (option == "pin_type")
       id_names.push_back("pin_type_id");
     else
       paramError("depletion_id_type",
                  "Only 'pin_type' is allowed in depletion ID generation at "
                  "drum level");
   }
   else if (generation_level == DepletionIDGenerationLevel::Pin)
     mooseError("Depletion ID generation is not supported at pin level yet in RGMB");
   id_names.push_back("region_id");
   // no block restriction
   std::set<SubdomainID> block_ids = {};
   // create depletion IDs
   // depletion IDs will be assigned in the following order:
   // regions (materials) within pin -> pins in assembly -> assemblies in core -> axial planes
   std::unordered_map<dof_id_type, dof_id_type> depl_ids =
       MooseMeshUtils::getExtraIDUniqueCombinationMap(input_mesh, block_ids, id_names);
   // assign depletion ids to elements
   const auto depl_id_index = input_mesh.add_elem_integer("depletion_id");
   for (Elem * const elem : input_mesh.active_element_ptr_range())
     elem->set_extra_integer(depl_id_index, depl_ids.at(elem->id()));
 }

◆ addDepletionIDParams()

void ReactorGeometryMeshBuilderBase::addDepletionIDParams ( InputParameters & parameters )

staticinherited

Definition at line 35 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator::validParams(), ControlDrumMeshGenerator::validParams(), and CoreMeshGenerator::validParams().

 {
   params.addParam<bool>(
       "generate_depletion_id", false, "Determine wheter the depletion ID is assigned.");
   MooseEnum depletion_id_option("assembly assembly_type pin pin_type");
   params.addParam<MooseEnum>("depletion_id_type",
                              depletion_id_option,
                              "Determine level of details in depletion ID assignment.");
   params.addParamNamesToGroup("generate_depletion_id depletion_id_type", "Depletion ID assignment");
 }

◆ callExtrusionMeshSubgenerators()

MeshGeneratorName ReactorGeometryMeshBuilderBase::callExtrusionMeshSubgenerators ( const MeshGeneratorName input_mesh_name )

protectedinherited

Calls mesh subgenerators related to extrusion, renaming of top / bottom boundaries, and defining plane IDs.

Parameters

input_mesh_name name of input 2D mesh generator to extrude

Returns: name of final output 3D mesh generator

Definition at line 187 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator::AssemblyMeshGenerator(), ControlDrumMeshGenerator::ControlDrumMeshGenerator(), CoreMeshGenerator::CoreMeshGenerator(), and PinMeshGenerator().

 {
   std::vector<Real> axial_boundaries = getReactorParam<std::vector<Real>>(RGMB::axial_mesh_sizes);
   const auto top_boundary = getReactorParam<boundary_id_type>(RGMB::top_boundary_id);
   const auto bottom_boundary = getReactorParam<boundary_id_type>(RGMB::bottom_boundary_id);
 
   {
     auto params = _app.getFactory().getValidParams("AdvancedExtruderGenerator");
 
     params.set<MeshGeneratorName>("input") = input_mesh_name;
     params.set<Point>("direction") = Point(0, 0, 1);
     params.set<std::vector<unsigned int>>("num_layers") =
         getReactorParam<std::vector<unsigned int>>(RGMB::axial_mesh_intervals);
     params.set<std::vector<Real>>("heights") = axial_boundaries;
     params.set<BoundaryName>("bottom_boundary") = std::to_string(bottom_boundary);
     params.set<BoundaryName>("top_boundary") = std::to_string(top_boundary);
     addMeshSubgenerator("AdvancedExtruderGenerator", name() + "_extruded", params);
   }
 
   {
     auto params = _app.getFactory().getValidParams("RenameBoundaryGenerator");
 
     params.set<MeshGeneratorName>("input") = name() + "_extruded";
     params.set<std::vector<BoundaryName>>("old_boundary") = {
         std::to_string(top_boundary),
         std::to_string(bottom_boundary)}; // hard coded boundary IDs in patterned mesh generator
     params.set<std::vector<BoundaryName>>("new_boundary") = {"top", "bottom"};
     addMeshSubgenerator("RenameBoundaryGenerator", name() + "_change_plane_name", params);
   }
 
   const MeshGeneratorName output_mesh_name = name() + "_extrudedIDs";
   {
     auto params = _app.getFactory().getValidParams("PlaneIDMeshGenerator");
 
     params.set<MeshGeneratorName>("input") = name() + "_change_plane_name";
 
     std::vector<Real> plane_heights{0};
     for (Real z : axial_boundaries)
       plane_heights.push_back(z + plane_heights.back());
 
     params.set<std::vector<Real>>("plane_coordinates") = plane_heights;
 
     std::string plane_id_name = "plane_id";
     params.set<std::string>("id_name") = "plane_id";
 
     addMeshSubgenerator("PlaneIDMeshGenerator", output_mesh_name, params);
   }
 
   return output_mesh_name;
 }

◆ createRGMBLattice()

const CSG::CSGLattice & ReactorGeometryMeshBuilderBase::createRGMBLattice	(	const Real	pitch,
		const std::vector< std::vector< std::reference_wrapper< const CSG::CSGUniverse >>>	pattern,
		CSG::CSGBase &	csg_obj
	)

protectedinherited

Create CSG lattice for assembly and core lattices.

This method does not set the outer universe of the lattice

Parameters

pitch	lattice pitch
pattern	pattern of universes in the lattice
csg_obj	reference to CSGBase object

Definition at line 311 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator::generateCSG(), and CoreMeshGenerator::generateCSG().

 {
   // Create lattice based on whether it is hexagonal or Cartesian
   std::string lat_name = name() + "_lattice";
   std::unique_ptr<CSG::CSGLattice> lat_ptr;
   const auto mesh_geometry = getReactorParam<std::string>(RGMB::mesh_geometry);
   if (mesh_geometry == "Square")
     lat_ptr = std::make_unique<CSG::CSGCartesianLattice>(lat_name, pitch, pattern);
   else // _geom_type == "Hex"
     lat_ptr = std::make_unique<CSG::CSGHexagonalLattice>(lat_name, pitch, pattern);
 
   auto & assembly_lattice = csg_obj.addLattice(std::move(lat_ptr));
   return assembly_lattice;
 }

◆ freeReactorParamsCSG()

void ReactorGeometryMeshBuilderBase::freeReactorParamsCSG ( )

protectedinherited

Releases the CSG base object obtained in _reactor_params_csg.

This must be called in any object that derives from this one, because the MeshGenerator system requires that all meshes that are requested from the system are moved out of the MeshGenerator system and into the MeshGenerator that requests them. In our case, we move it into this MeshGenerator and then release (delete) it.

Definition at line 81 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator::generateCSG(), generateCSG(), and CoreMeshGenerator::generateCSG().

 {
   _reactor_params_csg->reset();
 }

◆ freeReactorParamsMesh()

void ReactorGeometryMeshBuilderBase::freeReactorParamsMesh ( )

protectedinherited

Releases the mesh obtained in _reactor_params_mesh.

This must be called in any object that derives from this one, because the MeshGenerator system requires that all meshes that are requested from the system are moved out of the MeshGenerator system and into the MeshGenerator that requests them. In our case, we move it into this MeshGenerator and then release (delete) it.

Definition at line 75 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator::generate(), generate(), ControlDrumMeshGenerator::generate(), and CoreMeshGenerator::generate().

 {
   _reactor_params_mesh->reset();
 }

◆ generate()

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

overridevirtual

Implements MeshGenerator.

Definition at line 587 of file PinMeshGenerator.C.

 {
   // Must be called to free the ReactorMeshParams mesh
   freeReactorParamsMesh();
 
   // If bypass_mesh is true, return a null mesh. In this mode, an output mesh is not
   // generated and only metadata is defined on the generator, so logic related to
   // generation of output mesh will not be called
   if (getReactorParam<bool>(RGMB::bypass_meshgen))
   {
     auto null_mesh = nullptr;
     return null_mesh;
   }
 
   // Update metadata at this point since values for these metadata only get set by PCCMG
   // at generate() stage
   if (hasMeshProperty<Real>("max_radius_meta", name() + "_2D"))
   {
     const auto max_radius_meta = getMeshProperty<Real>("max_radius_meta", name() + "_2D");
     setMeshProperty("max_radius_meta", max_radius_meta);
   }
   if (hasMeshProperty<unsigned int>("background_intervals_meta", name() + "_2D"))
   {
     const auto background_intervals_meta =
         getMeshProperty<unsigned int>("background_intervals_meta", name() + "_2D");
     setMeshProperty("background_intervals_meta", background_intervals_meta);
   }
   if (hasMeshProperty<dof_id_type>("node_id_background_meta", name() + "_2D"))
   {
     const auto node_id_background_meta =
         getMeshProperty<dof_id_type>("node_id_background_meta", name() + "_2D");
     setMeshProperty("node_id_background_meta", node_id_background_meta);
   }
 
   // This generate() method will be called once the subgenerators that we depend on
   // have been called. This is where we reassign subdomain ids/names according to what
   // the user has provided, and also where we set region_id, pin_type_id, and radial_id
   // extra element integers
 
   // Add region id, pin type id, and radial id to the mesh as element integers
   std::string region_id_name = "region_id";
   std::string pin_type_id_name = "pin_type_id";
   std::string assembly_type_id_name = "assembly_type_id";
   std::string plane_id_name = "plane_id";
   std::string radial_id_name = "radial_id";
   const std::string default_block_name =
       (_is_assembly ? RGMB::ASSEMBLY_BLOCK_NAME_PREFIX : RGMB::PIN_BLOCK_NAME_PREFIX) +
       std::to_string(_pin_type);
 
   auto region_id_int = getElemIntegerFromMesh(*(*_build_mesh), region_id_name);
   auto radial_id_int = getElemIntegerFromMesh(*(*_build_mesh), radial_id_name);
   auto pin_type_id_int = getElemIntegerFromMesh(*(*_build_mesh), pin_type_id_name);
   unsigned int plane_id_int = 0;
   unsigned int assembly_type_id_int = 0;
   if (_extrude)
     plane_id_int = getElemIntegerFromMesh(*(*_build_mesh), plane_id_name, true);
   if (_is_assembly)
     assembly_type_id_int = getElemIntegerFromMesh(*(*_build_mesh), assembly_type_id_name);
 
   // Get next free block ID in mesh in case subdomain ids need to be remapped
   auto next_block_id = MooseMeshUtils::getNextFreeSubdomainID(*(*(_build_mesh)));
   std::map<std::string, SubdomainID> rgmb_name_id_map;
 
   // Loop through all elements and set regions ids, pin type id, and radial idx.
   // These element integers are also used to infer the block name for the region,
   // and block IDs/names will be reassigned on the pin mesh if necessary
   for (auto & elem : (*_build_mesh)->active_element_ptr_range())
   {
     const auto base_block_id = elem->subdomain_id();
     const auto base_block_name = (*_build_mesh)->subdomain_name(base_block_id);
 
     // Check if block name has correct prefix
     std::string prefix = RGMB::PIN_BLOCK_NAME_PREFIX + std::to_string(_pin_type) + "_R";
     if (!(base_block_name.find(prefix, 0) == 0))
       continue;
     // Radial index is integer value of substring after prefix
     std::string radial_str = base_block_name.substr(prefix.length());
 
     // Filter out RGMB::TRI_BLOCK_NAME_SUFFIX if needed
     const std::string suffix = RGMB::TRI_BLOCK_NAME_SUFFIX;
     const std::size_t found = radial_str.find(suffix);
     if (found != std::string::npos)
       radial_str.replace(found, suffix.length(), "");
     const unsigned int radial_idx = std::stoi(radial_str);
 
     // Region id is inferred from z_id and radial_idx
     dof_id_type z_id = _extrude ? elem->get_extra_integer(plane_id_int) : 0;
     const subdomain_id_type elem_region_id = _region_ids[std::size_t(z_id)][radial_idx];
 
     // Set element integers
     elem->set_extra_integer(region_id_int, elem_region_id);
     elem->set_extra_integer(pin_type_id_int, _pin_type);
     elem->set_extra_integer(radial_id_int, radial_idx);
     if (_is_assembly)
       elem->set_extra_integer(assembly_type_id_int, _pin_type);
 
     // Set element block name and block id
     auto elem_block_name = default_block_name;
     if (_has_block_names)
       elem_block_name += "_" + _block_names[std::size_t(z_id)][radial_idx];
     else if (getReactorParam<bool>(RGMB::region_id_as_block_name))
       elem_block_name += "_REG" + std::to_string(elem_region_id);
     if (elem->type() == TRI3 || elem->type() == PRISM6)
       elem_block_name += RGMB::TRI_BLOCK_NAME_SUFFIX;
     updateElementBlockNameId(
         *(*_build_mesh), elem, rgmb_name_id_map, elem_block_name, next_block_id);
   }
 
   // Mark mesh as not prepared, as block IDs were re-assigned in this method
   (*_build_mesh)->unset_is_prepared();
 
   return std::move(*_build_mesh);
 }

◆ generateCSG()

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

overridevirtual

Reimplemented from MeshGenerator.

Definition at line 702 of file PinMeshGenerator.C.

 {
   // Must be called to free the ReactorMeshParams CSGBase object
   freeReactorParamsCSG();
 
   auto csg_obj = std::make_unique<CSG::CSGBase>();
 
   unsigned int radial_index = 0;
   std::vector<std::vector<std::reference_wrapper<const CSG::CSGSurface>>> surfaces_by_radial_region;
 
   // Add surfaces corresponding to pin rings
   for (const auto & radius : _ring_radii)
   {
     const auto surf_name = name() + "_radial_ring_" + std::to_string(radial_index);
     std::unique_ptr<CSG::CSGSurface> ring_surf_ptr =
         std::make_unique<CSG::CSGZCylinder>(surf_name, 0, 0, radius);
     const auto & ring_surf = csg_obj->addSurface(std::move(ring_surf_ptr));
     surfaces_by_radial_region.push_back({ring_surf});
     ++radial_index;
   }
 
   // Add surfaces corresponding to pin ducts
   for (const auto & duct_halfpitch : _duct_halfpitch)
   {
     const auto & duct_surfaces =
         getOuterRadialSurfacesForUnitCell(radial_index, duct_halfpitch, *csg_obj);
     surfaces_by_radial_region.push_back(duct_surfaces);
     ++radial_index;
   }
 
   // Add surfaces corresponding to outer pin boundary
   const auto & duct_surfaces =
       getOuterRadialSurfacesForUnitCell(radial_index, _pitch / 2., *csg_obj);
   surfaces_by_radial_region.push_back(duct_surfaces);
 
   // Define all radial regions
   std::vector<CSG::CSGRegion> radial_regions;
   CSG::CSGRegion inner_region, outer_region;
   for (const auto i : index_range(surfaces_by_radial_region))
   {
     const auto & radial_surfaces = surfaces_by_radial_region[i];
     CSG::CSGRegion radial_region;
     bool is_last_radial_region = i == surfaces_by_radial_region.size() - 1;
     if (inner_region.getRegionType() == CSG::CSGRegion::RegionType::EMPTY)
     {
       if (!is_last_radial_region)
       {
         // We are in the innermost radial region, the radial region is inner_region
         inner_region = CSGUtils::getInnerRegion(radial_surfaces, Point(0, 0, 0));
         radial_region = inner_region;
       }
     }
     else
     {
       // For all other regions, the radial region is the intersection of inner_region and
       // outer_region
       outer_region = ~inner_region;
       inner_region = CSGUtils::getInnerRegion(radial_surfaces, Point(0, 0, 0));
       radial_region = is_last_radial_region ? outer_region : (inner_region & outer_region);
     }
     radial_regions.push_back(radial_region);
   }
 
   // Define all axial surfaces and regions
   std::vector<CSG::CSGRegion> axial_regions;
   std::vector<std::reference_wrapper<const CSG::CSGSurface>> surfaces_by_axial_region;
   const auto extruded_pin = _mesh_dimensions == 3;
   if (extruded_pin)
   {
     surfaces_by_axial_region = getAxialPlaneSurfaces(*csg_obj);
     for (const auto i : make_range(surfaces_by_axial_region.size()))
       if (i != 0)
       {
         CSG::CSGRegion axial_region;
         const auto & lower_surf = surfaces_by_axial_region[i - 1].get();
         if (lower_surf != surfaces_by_axial_region.front())
           axial_region = +lower_surf;
         const auto & upper_surf = surfaces_by_axial_region[i].get();
         if (upper_surf != surfaces_by_axial_region.back())
         {
           if (axial_region.getRegionType() == CSG::CSGRegion::RegionType::EMPTY)
             axial_region = -upper_surf;
           else
             axial_region &= -upper_surf;
         }
         axial_regions.push_back(axial_region);
       }
   }
 
   // Define all cells within pin domain and add to separate universe
   const auto & pin_univ = csg_obj->createUniverse(name() + "_univ");
   for (const auto i : index_range(radial_regions))
   {
     for (const auto j : make_range(extruded_pin ? axial_regions.size() : 1))
     {
       auto cell_region = radial_regions[i];
       auto cell_name = name() + "_cell_radial_" + std::to_string(i);
       const auto region_id = _region_ids[j][i];
       const auto mat_name = "rgmb_region_" + std::to_string(region_id);
       if (extruded_pin)
       {
         // update name and region with axial info only if extruded
         const auto axial_region = axial_regions[j];
         if (axial_region.getRegionType() != CSG::CSGRegion::RegionType::EMPTY)
         {
           if (cell_region.getRegionType() != CSG::CSGRegion::RegionType::EMPTY)
             cell_region &= axial_region;
           else
             cell_region = axial_region;
         }
         cell_name += "_axial_" + std::to_string(j);
       }
       csg_obj->createCell(cell_name, mat_name, cell_region, &pin_univ);
     }
   }
 
   // Create new cell to bound universe based on pin outer boundaries and add this cell to the root
   // universe
   auto pin_region = CSGUtils::getInnerRegion(surfaces_by_radial_region.back(), Point(0, 0, 0));
   if (extruded_pin)
   {
     const auto & lowest_axial_surf = surfaces_by_axial_region.front().get();
     const auto & highest_axial_surf = surfaces_by_axial_region.back().get();
     auto axial_region = +lowest_axial_surf & -highest_axial_surf;
     pin_region &= axial_region;
   }
   csg_obj->createCell(name() + "_root_cell", pin_univ, pin_region);
 
   return csg_obj;
 }

◆ generateData()

void ReactorGeometryMeshBuilderBase::generateData ( )

inlineoverridevirtualinherited

Reimplemented from MeshGenerator.

Definition at line 119 of file ReactorGeometryMeshBuilderBase.h.

119 {};

◆ generateFlexibleAssemblyBoundaries()

void PinMeshGenerator::generateFlexibleAssemblyBoundaries ( )

protected

Definition at line 442 of file PinMeshGenerator.C.

Referenced by PinMeshGenerator().

 {
   SubdomainName outermost_block_name;
   bool has_single_mesh_interval;
 
   // Assemblies that invoke this method are either homogenized or have a single pin. First check if
   // the assembly only has a single region. Otherwise, determine the outermost region for deletion
   if (_homogenized || (_intervals.size() == 1))
   {
     outermost_block_name = RGMB::PIN_BLOCK_NAME_PREFIX + std::to_string(_pin_type) + "_R0";
     has_single_mesh_interval = true;
   }
   else
   {
     outermost_block_name = RGMB::PIN_BLOCK_NAME_PREFIX + std::to_string(_pin_type) + "_R" +
                            std::to_string(_intervals.size() - 1);
     has_single_mesh_interval = false;
 
     // Invoke BlockDeletionGenerator to delete outermost mesh interval of assembly
     auto params = _app.getFactory().getValidParams("BlockDeletionGenerator");
 
     params.set<std::vector<SubdomainName>>("block") = {outermost_block_name};
     params.set<MeshGeneratorName>("input") = _homogenized ? name() + "_2D" : name() + "_delbds";
 
     addMeshSubgenerator("BlockDeletionGenerator", name() + "_del_outer", params);
   }
 
   {
     // Invoke FlexiblePatternGenerator to triangulate deleted mesh interval
     auto params = _app.getFactory().getValidParams("FlexiblePatternGenerator");
 
     if (has_single_mesh_interval)
       params.set<std::vector<MeshGeneratorName>>("inputs") = {};
     else
     {
       params.set<std::vector<MeshGeneratorName>>("inputs") = {name() + "_del_outer"};
       params.set<std::vector<libMesh::Point>>("extra_positions") = {libMesh::Point(0, 0, 0)};
       params.set<std::vector<unsigned int>>("extra_positions_mg_indices") = {0};
     }
     params.set<bool>("use_auto_area_func") = true;
     params.set<bool>("verify_holes") = false;
     params.set<MooseEnum>("boundary_type") = (_mesh_geometry == "Hex") ? "HEXAGON" : "CARTESIAN";
     params.set<unsigned int>("boundary_sectors") =
         getReactorParam<unsigned int>(RGMB::num_sectors_flexible_stitching);
     params.set<Real>("boundary_size") = getReactorParam<Real>(RGMB::assembly_pitch);
     params.set<boundary_id_type>("external_boundary_id") = RGMB::PIN_BOUNDARY_ID_START + _pin_type;
     params.set<BoundaryName>("external_boundary_name") =
         RGMB::ASSEMBLY_BOUNDARY_NAME_PREFIX + std::to_string(_pin_type);
     params.set<SubdomainName>("background_subdomain_name") =
         outermost_block_name + RGMB::TRI_BLOCK_NAME_SUFFIX;
     params.set<unsigned short>("background_subdomain_id") = RGMB::PIN_BLOCK_ID_TRI_FLEXIBLE;
 
     addMeshSubgenerator("FlexiblePatternGenerator", name() + "_fpg", params);
   }
   {
     // Delete extra boundary created by FlexiblePatternGenerator
     auto params = _app.getFactory().getValidParams("BoundaryDeletionGenerator");
 
     params.set<MeshGeneratorName>("input") = name() + "_fpg";
     std::vector<BoundaryName> boundaries_to_delete = {};
     if (!has_single_mesh_interval)
       boundaries_to_delete.push_back(std::to_string(1));
     params.set<std::vector<BoundaryName>>("boundary_names") = boundaries_to_delete;
 
     addMeshSubgenerator("BoundaryDeletionGenerator", name() + "_fpg_delbds", params);
   }
 }

◆ generateMetadata()

void PinMeshGenerator::generateMetadata ( )

protected

Definition at line 511 of file PinMeshGenerator.C.

Referenced by PinMeshGenerator().

 {
   // Store pin region ids and block names for id swap after extrusion if needed
   // by future mesh generators
   std::map<subdomain_id_type, std::vector<std::vector<subdomain_id_type>>> region_id_map{
       {_pin_type, _region_ids}};
 
   // Declare mesh properties that need to be moved up to the assembly level
   if (_is_assembly)
   {
     declareMeshProperty(RGMB::assembly_type, _pin_type);
     declareMeshProperty(RGMB::background_block_name, std::vector<std::string>());
     declareMeshProperty(RGMB::duct_block_names, std::vector<std::vector<std::string>>());
     declareMeshProperty(RGMB::is_single_pin, _is_assembly);
     declareMeshProperty(RGMB::is_control_drum, false);
     // Following metadata is only relevant if an output mesh is generated by RGMB
     // because it pertains to region & block ids of elements in the output mesh
     if (!getReactorParam<bool>(RGMB::bypass_meshgen))
     {
       std::map<subdomain_id_type, std::vector<std::vector<subdomain_id_type>>> pin_region_id_map;
       pin_region_id_map.insert(
           std::pair<subdomain_id_type, std::vector<std::vector<subdomain_id_type>>>(
               region_id_map.begin()->first, region_id_map.begin()->second));
       declareMeshProperty(RGMB::pin_region_id_map, pin_region_id_map);
       std::map<subdomain_id_type, std::vector<std::vector<std::string>>> pin_block_name_map;
       pin_block_name_map.insert(std::pair<subdomain_id_type, std::vector<std::vector<std::string>>>(
           _pin_type, _block_names));
       declareMeshProperty(RGMB::pin_block_name_map, pin_block_name_map);
     }
   }
   // Declare mesh properties that are only relevant to pin meshes
   else
   {
     declareMeshProperty(RGMB::pin_type, _pin_type);
     declareMeshProperty(RGMB::pin_region_ids, region_id_map);
     declareMeshProperty(RGMB::pin_block_names, _block_names);
   }
 
   // Set metadata to describe pin attributes
   declareMeshProperty(RGMB::pitch, _pitch);
   declareMeshProperty(RGMB::is_homogenized, _homogenized);
   declareMeshProperty(RGMB::ring_radii, _ring_radii);
   declareMeshProperty(RGMB::duct_halfpitches, _duct_halfpitch);
   declareMeshProperty(RGMB::extruded, _extrude);
 
   unsigned int n_axial_levels =
       (_mesh_dimensions == 3)
           ? getReactorParam<std::vector<unsigned int>>(RGMB::axial_mesh_intervals).size()
           : 1;
   std::vector<std::vector<subdomain_id_type>> ring_region_ids(
       n_axial_levels, std::vector<subdomain_id_type>(_ring_radii.size()));
   std::vector<std::vector<subdomain_id_type>> duct_region_ids(
       n_axial_levels, std::vector<subdomain_id_type>(_duct_halfpitch.size()));
   std::vector<subdomain_id_type> background_region_ids(n_axial_levels);
 
   for (const auto axial_idx : make_range(n_axial_levels))
   {
     for (const auto ring_idx : index_range(_ring_radii))
       ring_region_ids[axial_idx][ring_idx] = _region_ids[axial_idx][ring_idx];
 
     background_region_ids[axial_idx] = _region_ids[axial_idx][_ring_radii.size()];
 
     for (unsigned int duct_idx = _ring_radii.size() + 1;
          duct_idx < _duct_halfpitch.size() + _ring_radii.size() + 1;
          ++duct_idx)
       duct_region_ids[axial_idx][duct_idx - _ring_radii.size() - 1] =
           _region_ids[axial_idx][duct_idx];
   }
 
   // Define mesh properties related to region ids
   declareMeshProperty(RGMB::ring_region_ids, ring_region_ids);
   declareMeshProperty(RGMB::background_region_id, background_region_ids);
   declareMeshProperty(RGMB::duct_region_ids, duct_region_ids);
 }

◆ getAxialPlaneSurfaces()

std::vector< std::reference_wrapper< const CSG::CSGSurface > > ReactorGeometryMeshBuilderBase::getAxialPlaneSurfaces ( CSG::CSGBase & csg_obj )

protectedinherited

Get CSGSurfaces corresponding to axial planes of the extruded RGMB mesh.

Parameters

csg_obj Reference to CSGBase object for adding defined surfaces to

Returns: vector of surfaces that correspond to axial planes of extruded RGMB mesh

Definition at line 279 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator::generateCSG(), generateCSG(), and CoreMeshGenerator::generateCSG().

 {
   std::vector<std::reference_wrapper<const CSG::CSGSurface>> surfaces_by_axial_region;
   const auto axial_boundaries = getReactorParam<std::vector<Real>>(RGMB::axial_mesh_sizes);
   Real axial_level = 0.;
 
   // Check if axial planes have been defined in CSGBase based on a surface name we expect
   // to find
   auto axial_surf_name = RGMB::CSG_AXIAL_PLANE_PREFIX + "0";
   const auto has_axial_surfaces = csg_obj.hasSurface(axial_surf_name);
 
   for (const auto i : make_range(axial_boundaries.size() + 1))
   {
     axial_surf_name = RGMB::CSG_AXIAL_PLANE_PREFIX + std::to_string(i);
     if (has_axial_surfaces)
       // Surface should exist in CSGBase, retrieve from object
       surfaces_by_axial_region.push_back(csg_obj.getSurfaceByName(axial_surf_name));
     else
     {
       // Surface has not been defined, create it and add to CSGBase
       axial_level += (i != 0) ? axial_boundaries[i - 1] : 0.;
       std::unique_ptr<CSG::CSGSurface> plane_surf_ptr =
           std::make_unique<CSG::CSGPlane>(axial_surf_name, 0, 0, 1, axial_level);
       const auto & plane_surf = csg_obj.addSurface(std::move(plane_surf_ptr));
       surfaces_by_axial_region.push_back(plane_surf);
     }
   }
 
   return surfaces_by_axial_region;
 }

◆ getElemIntegerFromMesh()

unsigned int ReactorGeometryMeshBuilderBase::getElemIntegerFromMesh	(	MeshBase &	input_mesh,
		std::string	extra_int_name,
		bool	should_exist = `false`
	)

protectedinherited

Initializes extra element integer from id name for a given mesh and throws an error if it should exist but cannot be found within the mesh.

Parameters

input_mesh	input mesh
extra_int_name	extra element id name
should_exist	whether extra element integer should already exist in mesh

Returns: extra element integer

Definition at line 87 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator::generate(), generate(), ControlDrumMeshGenerator::generate(), and CoreMeshGenerator::generate().

 {
   if (input_mesh.has_elem_integer(extra_int_name))
     return input_mesh.get_elem_integer_index(extra_int_name);
   else
   {
     if (should_exist)
       mooseError("Expected extruded mesh to have " + extra_int_name + " extra integers");
     else
       return input_mesh.add_elem_integer(extra_int_name);
   }
 }

◆ getOuterRadialSurfacesForUnitCell()

std::vector< std::reference_wrapper< const CSG::CSGSurface > > ReactorGeometryMeshBuilderBase::getOuterRadialSurfacesForUnitCell	(	unsigned int	radial_index,
		Real	halfpitch,
		CSG::CSGBase &	csg_obj
	)

protectedinherited

Get CSGSurfaces corresponding to hexagonal or square region with given halfpitch and centered around (0, 0, 0)

Parameters

radial_index	Radial index of hex / square region, for surface naming
halfpitch	Halfpitch of square or hexagon
csg_obj	Reference to CSGBase object for adding defined surfaces to

Returns: vector of surfaces that correspond to hexagonal or square region

Definition at line 240 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator::generateCSG(), and generateCSG().

 {
   std::vector<std::reference_wrapper<const CSG::CSGSurface>> duct_surfaces;
   const auto mesh_geometry = getReactorParam<std::string>(RGMB::mesh_geometry);
   const auto n_azim_surfaces = mesh_geometry == "Square" ? 4 : 6;
 
   // Convert halfpitch to radius (distance from vertex to center)
   const Real angle_offset_degrees = mesh_geometry == "Square" ? 45. : 30.;
   const Real angle_offset_radians = angle_offset_degrees * (M_PI / 180.);
   const auto radius = halfpitch / std::cos(angle_offset_radians);
 
   Real angle_increment_radians = 360. / n_azim_surfaces * (M_PI / 180.);
 
   for (const auto i : make_range(n_azim_surfaces))
   {
     const auto surf_name =
         name() + "_radial_duct_" + std::to_string(radial_index) + "_surf_" + std::to_string(i);
 
     // Define 3 points on the surface
     const auto current_angle = i * angle_increment_radians + angle_offset_radians;
     const auto next_angle = (i + 1) * angle_increment_radians + angle_offset_radians;
     libMesh::Point p0(radius * std::cos(current_angle), radius * std::sin(current_angle), 0.);
     libMesh::Point p1(radius * std::cos(next_angle), radius * std::sin(next_angle), 0.);
     libMesh::Point p2 = (p0 + p1) / 2.;
     // Place third point above the two others to form a vertical plane
     p2(2) = angle_offset_degrees;
 
     std::unique_ptr<CSG::CSGSurface> duct_surf_ptr =
         std::make_unique<CSG::CSGPlane>(surf_name, p0, p1, p2);
     const auto & duct_surf = csg_obj.addSurface(std::move(duct_surf_ptr));
     duct_surfaces.push_back(duct_surf);
   }
 
   return duct_surfaces;
 }

◆ getReactorParam()

template<typename T >

const T & ReactorGeometryMeshBuilderBase::getReactorParam ( const std::string & param_name )

protectedinherited

Returns reference of parameter in ReactorMeshParams object.

Template Parameters

T	datatype of metadata value associated with metadata name

Parameters

param_name name of ReactorMeshParams parameter

Returns: reference to parameter defined in ReactorMeshParams metadata

Definition at line 330 of file ReactorGeometryMeshBuilderBase.h.

Referenced by AssemblyMeshGenerator::AssemblyMeshGenerator(), ReactorGeometryMeshBuilderBase::callExtrusionMeshSubgenerators(), ControlDrumMeshGenerator::ControlDrumMeshGenerator(), generateMetadata(), and PinMeshGenerator().

 {
   return getMeshProperty<T>(param_name, _reactor_params);
 }

◆ hasReactorParam()

template<typename T >

bool ReactorGeometryMeshBuilderBase::hasReactorParam ( const std::string param_name )

protectedinherited

Checks whether parameter is defined in ReactorMeshParams metadata.

Template Parameters

T	datatype of metadata value associated with metadata name

Parameters

param_name name of ReactorMeshParams parameter

Returns: whether parameter is defined in ReactorMeshParams metadata

Definition at line 323 of file ReactorGeometryMeshBuilderBase.h.

 {
   return hasMeshProperty<T>(param_name, _reactor_params);
 }

◆ initializeReactorMeshParams()

void ReactorGeometryMeshBuilderBase::initializeReactorMeshParams ( const std::string reactor_param_name )

protectedinherited

Initializes and checks validity of ReactorMeshParams mesh generator object.

Parameters

reactor_param_name name of ReactorMeshParams mesh generator

Definition at line 52 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator::AssemblyMeshGenerator(), ControlDrumMeshGenerator::ControlDrumMeshGenerator(), CoreMeshGenerator::CoreMeshGenerator(), and PinMeshGenerator().

 {
   _reactor_params = reactor_param_name;
 
   // Ensure that the user has supplied a valid ReactorMeshParams object
   _reactor_params_mesh = &getMeshByName(reactor_param_name);
   if (*_reactor_params_mesh)
     mooseError("The reactor_params mesh is not of the correct type");
 
   if (!hasMeshProperty<unsigned int>("mesh_dimensions", _reactor_params) ||
       !hasMeshProperty<std::string>("mesh_geometry", _reactor_params))
     mooseError("The reactor_params input must be a ReactorMeshParams type MeshGenerator\n Please "
                "check that a valid definition and name of ReactorMeshParams has been provided.");
 
   // Set reactor_params_name metadata for use by future mesh generators
   declareMeshProperty("reactor_params_name", std::string(_reactor_params));
 
   // Store CSGBase object if we are in CSG only mode
   if (_app.getMeshGeneratorSystem().getCSGOnly())
     _reactor_params_csg = &getCSGBaseByName(_reactor_params);
 }

◆ print2dMetadataToConsole()

template<typename T >

void ReactorGeometryMeshBuilderBase::print2dMetadataToConsole	(	const std::string	metadata_name,
		const std::string	mg_name
	)

protectedinherited

Print metadata with data type std::vector<std::vector<T>> and provided name that can be found with given mesh generator name.

Template Parameters

T	datatype of elements in 2-D vector to output

Parameters

metadata_name	Name of metadata to output
mg_name	Name of mesh generator that stores metadata

◆ printAssemblyMetadata()

void ReactorGeometryMeshBuilderBase::printAssemblyMetadata	(	const std::string	mg_name,
		const bool	first_function_call
	)

protectedinherited

Print assembly-level metadata associated with ReactorGeometryMeshBuilder object.

Parameters

mg_name	name of mesh generator associated with assembly
whether	this is the original function call, which will trigger additional output messages

◆ printCoreMetadata()

void ReactorGeometryMeshBuilderBase::printCoreMetadata	(	const std::string	mg_name,
		const bool	first_function_call
	)

protectedinherited

Print core-level metadata associated with ReactorGeometryMeshBuilder object.

Parameters

mg_name	name of mesh generator associated with core
first_function_call	whether this is the original function call, which will trigger additional output messages

◆ printGlobalReactorMetadata()

void ReactorGeometryMeshBuilderBase::printGlobalReactorMetadata ( )

protectedinherited

Print global ReactorMeshParams metadata associated with ReactorGeometryMeshBuilder object.

◆ printMetadataToConsole()

template<typename T >

void ReactorGeometryMeshBuilderBase::printMetadataToConsole	(	const std::string	metadata_name,
		const std::string	mg_name
	)

protectedinherited

Print metadata with provided name that can be found with given mesh generator name.

Template Parameters

T	datatype of metadata value to output

Parameters

metadata_name	Name of metadata to output
mg_name	Name of mesh generator that stores metadata

◆ printPinMetadata()

void ReactorGeometryMeshBuilderBase::printPinMetadata ( const std::string mg_name )

protectedinherited

Print pin-level metadata associated with ReactorGeometryMeshBuilder object.

Parameters

mg_name name of mesh generator associated with assembly

◆ printReactorMetadata()

void ReactorGeometryMeshBuilderBase::printReactorMetadata	(	const std::string	geometry_type,
		const std::string	mg_name,
		const bool	first_function_call = `true`
	)

protectedinherited

Print metadata associated with ReactorGeometryMeshBuilder object.

Parameters

geometry_type	type of geometry (pin / assembly / core) under consideration
mg_name	name of mesh generator associated with this object
first_function_call	whether this is the original function call, which will trigger additional output messages

◆ updateElementBlockNameId()

void ReactorGeometryMeshBuilderBase::updateElementBlockNameId	(	MeshBase &	input_mesh,
		Elem *	elem,
		std::map< std::string, SubdomainID > &	name_id_map,
		std::string	elem_block_name,
		SubdomainID &	next_free_id
	)

protectedinherited

Updates the block names and ids of the element in an input mesh according to a map of block name to block ids.

Updates the map if the block name is not in the map

Parameters

input_name	input mesh
elem	iterator to mesh element
name_id_map	map of name-id pairs used in mesh
elem_block_name	block name to set for element
next_free_id	next free block id to use if block name does not exist in map

Definition at line 103 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator::generate(), generate(), ControlDrumMeshGenerator::generate(), and CoreMeshGenerator::generate().

 {
   SubdomainID elem_block_id;
   if (name_id_map.find(elem_block_name) == name_id_map.end())
   {
     // Block name does not exist in mesh yet, assign new block id and name
     elem_block_id = next_free_id++;
     elem->subdomain_id() = elem_block_id;
     input_mesh.subdomain_name(elem_block_id) = elem_block_name;
     name_id_map[elem_block_name] = elem_block_id;
   }
   else
   {
     // Block name exists in mesh, reuse block id
     elem_block_id = name_id_map[elem_block_name];
     elem->subdomain_id() = elem_block_id;
   }
 
   input_mesh.unset_has_cached_elem_data();
 }

◆ validParams()

InputParameters PinMeshGenerator::validParams ( )

static

Definition at line 26 of file PinMeshGenerator.C.

 {
   auto params = ReactorGeometryMeshBuilderBase::validParams();
 
   params.addRequiredParam<MeshGeneratorName>(
       "reactor_params",
       "The ReactorMeshParams MeshGenerator that is the basis for this component conformal mesh.");
 
   params.addRequiredParam<subdomain_id_type>("pin_type",
                                              "The integer ID for this pin type definition");
 
   params.addRequiredRangeCheckedParam<Real>(
       "pitch", "pitch>0.0", "The pitch for the outermost boundary polygon");
 
   params.addRangeCheckedParam<unsigned int>(
       "num_sectors", "num_sectors>0", "Number of azimuthal sectors in each quadrant");
 
   params.addRangeCheckedParam<std::vector<Real>>(
       "ring_radii",
       "ring_radii>0.0",
       "Radii of major concentric circles of the pin. If unspecified, no pin is present.");
 
   params.addRangeCheckedParam<std::vector<Real>>(
       "duct_halfpitch",
       "duct_halfpitch>0.0",
       "Apothem of the ducts. If unspecified, no duct is present.");
 
   params.addRangeCheckedParam<std::vector<unsigned int>>(
       "mesh_intervals",
       std::vector<unsigned int>{1},
       "mesh_intervals>0",
       "The number of meshing intervals for each region starting at the center. Parameter should be "
       "size:"
       "((length(ring_radii) + length(duct_halfpitch) + 1");
 
   params.addParam<std::vector<std::vector<std::string>>>(
       "block_names",
       "Block names for each radial and axial zone. "
       "Inner indexing is radial zones (pin/background/duct), outer indexing is axial");
 
   params.addParam<std::vector<std::vector<subdomain_id_type>>>(
       "region_ids",
       "IDs for each radial and axial zone for assignment of region_id extra element "
       "id. "
       "Inner indexing is radial zones (pin/background/duct), outer indexing is axial");
 
   params.addParam<bool>("extrude",
                         false,
                         "Determines if this is the final step in the geometry construction"
                         " and extrudes the 2D geometry to 3D. If this is true then this mesh "
                         "cannot be used in further mesh building in the Reactor workflow");
   params.addParam<bool>(
       "homogenized", false, "Determines whether homogenized pin mesh should be generated");
   params.addParam<bool>(
       "use_as_assembly", false, "Determines whether pin mesh should be used as an assembly mesh");
 
   params.addParam<bool>(
       "quad_center_elements", true, "Whether the center elements are quad or triangular.");
   params.addParamNamesToGroup("region_ids pin_type", "ID assigment");
   params.addParamNamesToGroup(
       "mesh_intervals ring_radii num_sectors pin_type homogenized use_as_assembly",
       "Pin specifications");
   params.addParamNamesToGroup("mesh_intervals duct_halfpitch num_sectors", "Duct specifications");
 
   params.addClassDescription("This PinMeshGenerator object is designed to generate pin-like "
                              "structures, with IDs, from a reactor geometry. "
                              "Whether it be a square or hexagonal pin, they are divided into three "
                              "substructures - the innermost "
                              "radial pin regions, the single bridging background region, and the "
                              "square or hexagonal ducts regions.");
 
   // Declare that this generator has a generateCSG method
   MeshGenerator::setHasGenerateCSG(params);
 
   return params;
 }

Member Data Documentation

◆ _block_names

std::vector<std::vector<std::string> > PinMeshGenerator::_block_names

protected

2-D vector (axial outer indexing, radial inner indexing) used to set block names of pin mesh elements

Definition at line 62 of file PinMeshGenerator.h.

Referenced by generate(), generateMetadata(), and PinMeshGenerator().

◆ _build_mesh

std::unique_ptr<MeshBase>* PinMeshGenerator::_build_mesh

protected

The final mesh that is generated by the subgenerators; This mesh is generated by the subgenerators with only element and boundary ids changed.

Definition at line 84 of file PinMeshGenerator.h.

Referenced by generate(), and PinMeshGenerator().

◆ _duct_halfpitch

const std::vector<Real> PinMeshGenerator::_duct_halfpitch

protected

The inner apothem of any surrounding ducts in the pin.

Definition at line 50 of file PinMeshGenerator.h.

Referenced by generateCSG(), generateMetadata(), and PinMeshGenerator().

◆ _extrude

const bool PinMeshGenerator::_extrude

protected

Whether this mesh should be extruded to 3-D, making it the final structure in the reactor mesh.

Definition at line 71 of file PinMeshGenerator.h.

Referenced by generate(), generateMetadata(), and PinMeshGenerator().

◆ _has_block_names

bool PinMeshGenerator::_has_block_names

protected

Whether block names have been provided by user.

Definition at line 59 of file PinMeshGenerator.h.

Referenced by generate(), and PinMeshGenerator().

◆ _homogenized

bool PinMeshGenerator::_homogenized

protected

Whether the resulting pin mesh should be homogenized.

Definition at line 77 of file PinMeshGenerator.h.

Referenced by generateFlexibleAssemblyBoundaries(), generateMetadata(), and PinMeshGenerator().

◆ _intervals

std::vector<unsigned int> PinMeshGenerator::_intervals

protected

The number of mesh intervals in a radial division starting from the center.

Definition at line 53 of file PinMeshGenerator.h.

Referenced by generateFlexibleAssemblyBoundaries(), and PinMeshGenerator().

◆ _is_assembly

bool PinMeshGenerator::_is_assembly

protected

Whether the resulting pin mesh should also be used as an assembly mesh.

Definition at line 80 of file PinMeshGenerator.h.

Referenced by generate(), generateMetadata(), and PinMeshGenerator().

◆ _mesh_dimensions

unsigned int PinMeshGenerator::_mesh_dimensions

protected

The number of dimensions the mesh is ultimately going to have (2 or 3, declared in the ReactorMeshParams object)

Definition at line 68 of file PinMeshGenerator.h.

Referenced by generateCSG(), generateMetadata(), and PinMeshGenerator().

◆ _mesh_geometry

std::string PinMeshGenerator::_mesh_geometry

protected

The type of geometry that is being described (Square or Hex, declared in the ReactorMeshParams object)

Definition at line 65 of file PinMeshGenerator.h.

Referenced by generateFlexibleAssemblyBoundaries(), and PinMeshGenerator().

◆ _num_sectors

const unsigned int PinMeshGenerator::_num_sectors

protected

The number of azimuthal divisions.

Definition at line 44 of file PinMeshGenerator.h.

Referenced by PinMeshGenerator().

◆ _pin_type

const subdomain_id_type PinMeshGenerator::_pin_type

protected

The id number for this pin type.

Definition at line 38 of file PinMeshGenerator.h.

Referenced by generate(), generateFlexibleAssemblyBoundaries(), generateMetadata(), and PinMeshGenerator().

◆ _pitch

const Real PinMeshGenerator::_pitch

protected

The face-to-face size of this pin.

Definition at line 41 of file PinMeshGenerator.h.

Referenced by generateCSG(), generateMetadata(), and PinMeshGenerator().

◆ _quad_center

bool PinMeshGenerator::_quad_center

protected

Whether the centermost elements in the pin should be quad elements as opposed to tri elements.

Definition at line 74 of file PinMeshGenerator.h.

Referenced by PinMeshGenerator().

◆ _reactor_params

MeshGeneratorName ReactorGeometryMeshBuilderBase::_reactor_params

protectedinherited

The ReactorMeshParams object that is storing the reactor global information for this reactor geometry mesh.

Definition at line 261 of file ReactorGeometryMeshBuilderBase.h.

Referenced by ReactorGeometryMeshBuilderBase::getReactorParam(), ReactorGeometryMeshBuilderBase::hasReactorParam(), and ReactorGeometryMeshBuilderBase::initializeReactorMeshParams().

◆ _region_ids

std::vector<std::vector<subdomain_id_type> > PinMeshGenerator::_region_ids

protected

2-D vector (axial outer indexing, radial inner indexing) used to set "region_id" extra-element integer of the pin mesh elements

Definition at line 56 of file PinMeshGenerator.h.

Referenced by generate(), generateCSG(), generateMetadata(), and PinMeshGenerator().

◆ _ring_radii

std::vector<Real> PinMeshGenerator::_ring_radii

protected

The outer radii of concentric rings in the pin.

Definition at line 47 of file PinMeshGenerator.h.

Referenced by generateCSG(), generateMetadata(), and PinMeshGenerator().

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

reactor/include/meshgenerators/PinMeshGenerator.h
reactor/src/meshgenerators/PinMeshGenerator.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ DepletionIDGenerationLevel

Constructor & Destructor Documentation

◆ PinMeshGenerator()

Member Function Documentation

◆ addDepletionId()

◆ addDepletionIDParams()

◆ callExtrusionMeshSubgenerators()

◆ createRGMBLattice()

◆ freeReactorParamsCSG()

◆ freeReactorParamsMesh()

◆ generate()

◆ generateCSG()

◆ generateData()

◆ generateFlexibleAssemblyBoundaries()

◆ generateMetadata()

◆ getAxialPlaneSurfaces()

◆ getElemIntegerFromMesh()

◆ getOuterRadialSurfacesForUnitCell()

◆ getReactorParam()

◆ hasReactorParam()

◆ initializeReactorMeshParams()

◆ print2dMetadataToConsole()

◆ printAssemblyMetadata()

◆ printCoreMetadata()

◆ printGlobalReactorMetadata()

◆ printMetadataToConsole()

◆ printPinMetadata()

◆ printReactorMetadata()

◆ updateElementBlockNameId()

◆ validParams()

Member Data Documentation

◆ _block_names

◆ _build_mesh

◆ _duct_halfpitch

◆ _extrude

◆ _has_block_names

◆ _homogenized

◆ _intervals

◆ _is_assembly

◆ _mesh_dimensions

◆ _mesh_geometry

◆ _num_sectors

◆ _pin_type

◆ _pitch

◆ _quad_center

◆ _reactor_params

◆ _region_ids

◆ _ring_radii