Mesh generator for defining a reactor assembly using a Cartesian or hexagonal lattice with the option to be 2-D or 3-D. More...

#include <AssemblyMeshGenerator.h>

Inheritance diagram for AssemblyMeshGenerator:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	AssemblyMeshGenerator (const InputParameters &parameters)

std::unique_ptr< MeshBase >	generate () override

void	generateData () 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 void	addDepletionIDParams (InputParameters &parameters)

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 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	freeReactorMeshParams ()
	Releases the mesh obtained in _reactor_params_mesh. 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...

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 std::vector< MeshGeneratorName >	_inputs
	The names of the pins that compose the Assembly. More...

const subdomain_id_type	_assembly_type
	The id number for the type of the assembly. More...

const std::vector< std::vector< unsigned int > >	_pattern
	The 2D pin-by-pin layout of the assembly mapping indices into _inputs. More...

const std::vector< Real >	_duct_sizes
	The inner apothem of any ducts around the assembly. More...

const unsigned int	_background_intervals
	The number of divisions in the mesh outside of the pins and inside of the ducts. More...

const std::vector< unsigned int >	_duct_intervals
	The number of divisions in the meshes of the ducts. More...

std::vector< subdomain_id_type >	_background_region_id
	Vector used to set the "region_id" extra-element integer of the assembly background elements. More...

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

bool	_has_background_block_name
	Whether block names for assembly background elements have been provided by user. More...

bool	_has_duct_block_names
	Whether block names for assembly duct elements have been provided by user. More...

std::vector< std::string >	_background_block_name
	Optional vector used to set the block names of the assembly background elements. More...

std::vector< std::vector< std::string > >	_duct_block_names
	Optional 2-D vector (axial outer indexing, radial inner indexing) used to set the block names of the assembly duct elements. More...

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

std::string	_geom_type
	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...

std::vector< Real >	_axial_boundaries
	The heights of the axial regions that are stored on the ReactorMeshParams object. More...

std::vector< subdomain_id_type >	_peripheral_region_ids
	The region ids of peripheral regions in the 2D mesh. This includes the assembly background region and ducts. More...

std::map< subdomain_id_type, std::vector< std::vector< subdomain_id_type > > >	_pin_region_id_map
	A mapping from pin-type IDs to region IDs used when assigning region IDs during the pin stitching stage. More...

std::map< subdomain_id_type, std::vector< std::vector< std::string > > >	_pin_block_name_map
	A mapping from pin-type IDs to block names used when assigning block names during the pin stitching stage. More...

boundary_id_type	_assembly_boundary_id
	The ID of the assembly outer boundary, equal to the assembly type ID + 2000. More...

BoundaryName	_assembly_boundary_name
	The name of the assembly outer boundary, equal to the concatenation of "outer_assembly_" and the assembly-type ID. 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

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const Parallel::Communicator &	_communicator

Detailed Description

Mesh generator for defining a reactor assembly using a Cartesian or hexagonal lattice with the option to be 2-D or 3-D.

Definition at line 18 of file AssemblyMeshGenerator.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 249 of file ReactorGeometryMeshBuilderBase.h.

   {
     Pin,
     Assembly,
     Drum,
     Core
   };

Constructor & Destructor Documentation

◆ AssemblyMeshGenerator()

AssemblyMeshGenerator::AssemblyMeshGenerator ( const InputParameters & parameters )

Definition at line 89 of file AssemblyMeshGenerator.C.

   : ReactorGeometryMeshBuilderBase(parameters),
     _inputs(getParam<std::vector<MeshGeneratorName>>("inputs")),
     _assembly_type(getParam<subdomain_id_type>("assembly_type")),
     _pattern(getParam<std::vector<std::vector<unsigned int>>>("pattern")),
     _duct_sizes(isParamValid("duct_halfpitch") ? getParam<std::vector<Real>>("duct_halfpitch")
                                                : std::vector<Real>()),
     _background_intervals(
         isParamValid("background_intervals") ? getParam<unsigned int>("background_intervals") : 0),
     _duct_intervals(isParamValid("duct_intervals")
                         ? getParam<std::vector<unsigned int>>("duct_intervals")
                         : std::vector<unsigned int>()),
     _background_region_id(isParamValid("background_region_id")
                               ? getParam<std::vector<subdomain_id_type>>("background_region_id")
                               : std::vector<subdomain_id_type>()),
     _duct_region_ids(isParamValid("duct_region_ids")
                          ? getParam<std::vector<std::vector<subdomain_id_type>>>("duct_region_ids")
                          : std::vector<std::vector<subdomain_id_type>>()),
     _extrude(getParam<bool>("extrude"))
 {
   MeshGeneratorName reactor_params =
       MeshGeneratorName(getMeshProperty<std::string>(RGMB::reactor_params_name, _inputs[0]));
   // Check that MG name for reactor params is consistent across all assemblies
   for (unsigned int i = 1; i < _inputs.size(); i++)
     if (getMeshProperty<std::string>(RGMB::reactor_params_name, _inputs[i]) != reactor_params)
       mooseError("The name of all reactor_params objects should be identical across all input pins "
                  "in the assembly.\n");
 
   // Initialize ReactorMeshParams object stored in pin input
   initializeReactorMeshParams(reactor_params);
 
   _geom_type = getReactorParam<std::string>(RGMB::mesh_geometry);
   _mesh_dimensions = getReactorParam<unsigned int>(RGMB::mesh_dimensions);
 
   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");
 
   Real base_pitch = 0.0;
 
   // Check constitutent pins do not have shared pin_type ids
   std::map<subdomain_id_type, std::string> pin_map_type_to_name;
   for (const auto i : index_range(_inputs))
   {
     auto pin = _inputs[i];
     if (i == 0)
       base_pitch = getMeshProperty<Real>(RGMB::pitch, pin);
     else
     {
       auto pitch = getMeshProperty<Real>(RGMB::pitch, pin);
       if (!MooseUtils::absoluteFuzzyEqual(pitch, base_pitch))
         mooseError("All pins within an assembly must have the same pitch");
     }
     if (getMeshProperty<bool>(RGMB::extruded, pin))
       mooseError("Pins that have already been extruded cannot be used in AssemblyMeshGenerator "
                  "definition.\n");
     const auto pin_type = getMeshProperty<subdomain_id_type>(RGMB::pin_type, pin);
     if (pin_map_type_to_name.find(pin_type) != pin_map_type_to_name.end() &&
         pin_map_type_to_name[pin_type] != pin)
       mooseError("Constituent pins have shared pin_type ids but different names. Each uniquely "
                  "defined pin in PinMeshGenerator must have its own pin_type id.");
     pin_map_type_to_name[pin_type] = pin;
   }
   auto assembly_pitch = getReactorParam<Real>(RGMB::assembly_pitch);
 
   unsigned int n_axial_levels =
       (_mesh_dimensions == 3)
           ? getReactorParam<std::vector<unsigned int>>(RGMB::axial_mesh_intervals).size()
           : 1;
   if (_geom_type == "Square")
   {
     const auto ny = _pattern.size();
     const auto nx = _pattern[0].size();
     if (_background_region_id.size() == 0)
     {
       if ((!MooseUtils::absoluteFuzzyEqual(base_pitch * ny, assembly_pitch)) ||
           (!MooseUtils::absoluteFuzzyEqual(base_pitch * nx, assembly_pitch)))
         mooseError(
             "Assembly pitch must be equal to lattice dimension times pin pitch for Cartesian "
             "assemblies with no background region");
       if (_background_intervals > 0)
         mooseError("\"background_region_id\" must be defined if \"background_intervals\" is "
                    "greater than 0");
     }
     else
     {
       if ((base_pitch * ny > assembly_pitch) || (base_pitch * nx > assembly_pitch))
         mooseError(
             "Assembly pitch must be larger than lattice dimension times pin pitch for Cartesian "
             "assemblies with background region");
       if (_background_intervals == 0)
         mooseError("\"background_intervals\" must be greater than 0 if \"background_region_id\" is "
                    "defined");
       if (_background_region_id.size() != n_axial_levels)
         mooseError(
             "The size of background_region_id must be equal to the number of axial levels as "
             "defined in the ReactorMeshParams object");
     }
   }
   else
   {
     if ((_background_region_id.size() == 0) || _background_intervals == 0)
       mooseError("Hexagonal assemblies must have a background region defined");
     if (assembly_pitch / std::sin(M_PI / 3.0) < _pattern.size() * base_pitch)
       mooseError("Hexagonal diameter of assembly must be larger than the number of assembly rows "
                  "times the pin pitch");
     // Check size of background region id matches number of axial levels
     if (_background_region_id.size() != n_axial_levels)
       mooseError("The size of background_region_id must be equal to the number of axial levels as "
                  "defined in the ReactorMeshParams object");
   }
 
   if (_duct_sizes.size() != _duct_intervals.size())
     mooseError("If ducts are defined then \"duct_intervals\" and \"duct_region_ids\" must also be "
                "defined and of equal size.");
 
   if (_duct_sizes.size() != 0)
   {
     // Check size of duct region id matches number of axial levels
     if (_duct_region_ids.size() != n_axial_levels)
       mooseError("The size of duct_region_id must be equal to the number of axial levels as "
                  "defined in the ReactorMeshParams object");
     if (_duct_region_ids[0].size() != _duct_sizes.size())
       paramError("duct_halfpitch",
                  "If ducts are defined, then \"duct_intervals\" and \"duct_region_ids\" "
                  "must also be defined and of equal size.");
   }
 
   // Check whether block names are defined properly
   if (isParamValid("background_block_name"))
   {
     if (getReactorParam<bool>(RGMB::region_id_as_block_name))
       paramError("background_block_name",
                  "If ReactorMeshParams/region_id_as_block_name is set, background_block_name "
                  "should not be specified in AssemblyMeshGenerator");
     _has_background_block_name = true;
     _background_block_name = getParam<std::vector<std::string>>("background_block_name");
     if (_background_region_id.size() != _background_block_name.size())
       mooseError("The size of background_block_name must match the size of background_region_id");
   }
   else
     _has_background_block_name = false;
 
   if (isParamValid("duct_block_names"))
   {
     if (getReactorParam<bool>(RGMB::region_id_as_block_name))
       paramError("duct_block_names",
                  "If ReactorMeshParams/region_id_as_block_name is set, duct_block_names should not "
                  "be specified in AssemblyMeshGenerator");
     _has_duct_block_names = true;
     _duct_block_names = getParam<std::vector<std::vector<std::string>>>("duct_block_names");
     if (_duct_region_ids.size() != _duct_block_names.size())
       mooseError("The size of duct_block_names must match the size of duct_region_ids");
     for (const auto i : index_range(_duct_region_ids))
       if (_duct_region_ids[i].size() != _duct_block_names[i].size())
         mooseError("The size of duct_block_names must match the size of duct_region_ids");
   }
   else
     _has_duct_block_names = false;
 
   // No subgenerators will be called if option to bypass mesh generators is enabled
   if (!getReactorParam<bool>(RGMB::bypass_meshgen))
   {
     // Declare dependency of inputs to sub generator calls. If mesh generation
     declareMeshesForSub("inputs");
 
     _assembly_boundary_id = RGMB::ASSEMBLY_BOUNDARY_ID_START + _assembly_type;
     _assembly_boundary_name = RGMB::ASSEMBLY_BOUNDARY_NAME_PREFIX + std::to_string(_assembly_type);
 
     // Call PatternedHexMeshGenerator or PatternedCartesianMeshGenerator to stitch assembly
     {
       const auto patterned_mg_name =
           _geom_type == "Hex" ? "PatternedHexMeshGenerator" : "PatternedCartesianMeshGenerator";
       auto params = _app.getFactory().getValidParams(patterned_mg_name);
 
       if (_geom_type == "Hex")
       {
         params.set<Real>("hexagon_size") = getReactorParam<Real>(RGMB::assembly_pitch) / 2.0;
         params.set<MooseEnum>("hexagon_size_style") = "apothem";
       }
       else
       {
         if (_background_region_id.size() == 0)
           params.set<MooseEnum>("pattern_boundary") = "none";
         else
         {
           params.set<MooseEnum>("pattern_boundary") = "expanded";
           params.set<Real>("square_size") = getReactorParam<Real>(RGMB::assembly_pitch);
           params.set<bool>("uniform_mesh_on_sides") = true;
         }
       }
 
       params.set<std::vector<std::string>>("id_name") = {"pin_id"};
       params.set<std::vector<MooseEnum>>("assign_type") = {
           MooseEnum("cell", "cell")}; // give elems IDs relative to position in assembly
       params.set<std::vector<MeshGeneratorName>>("inputs") = _inputs;
       params.set<std::vector<std::vector<unsigned int>>>("pattern") = _pattern;
       params.set<bool>("create_outward_interface_boundaries") = false;
 
       if (_background_intervals > 0)
       {
         params.set<unsigned int>("background_intervals") = _background_intervals;
         // Initial block id used to define peripheral regions of assembly
 
         const auto background_block_name =
             RGMB::ASSEMBLY_BLOCK_NAME_PREFIX + std::to_string(_assembly_type) + "_R0";
         const auto background_block_id = RGMB::ASSEMBLY_BLOCK_ID_START;
         params.set<subdomain_id_type>("background_block_id") = background_block_id;
         params.set<SubdomainName>("background_block_name") = background_block_name;
       }
 
       if (_duct_sizes.size() > 0)
       {
         std::vector<subdomain_id_type> duct_block_ids;
         std::vector<SubdomainName> duct_block_names;
         for (const auto duct_it : index_range(_duct_region_ids[0]))
         {
           const auto duct_block_name = RGMB::ASSEMBLY_BLOCK_NAME_PREFIX +
                                        std::to_string(_assembly_type) + "_R" +
                                        std::to_string(duct_it + 1);
           const auto duct_block_id = RGMB::ASSEMBLY_BLOCK_ID_START + duct_it + 1;
           duct_block_ids.push_back(duct_block_id);
           duct_block_names.push_back(duct_block_name);
         }
 
         params.set<std::vector<Real>>("duct_sizes") = _duct_sizes;
         params.set<std::vector<subdomain_id_type>>("duct_block_ids") = duct_block_ids;
         params.set<std::vector<SubdomainName>>("duct_block_names") = duct_block_names;
         params.set<std::vector<unsigned int>>("duct_intervals") = _duct_intervals;
       }
 
       params.set<boundary_id_type>("external_boundary_id") = _assembly_boundary_id;
       params.set<BoundaryName>("external_boundary_name") = _assembly_boundary_name;
 
       addMeshSubgenerator(patterned_mg_name, name() + "_pattern", params);
 
       // Pass mesh meta-data defined in subgenerator constructor to this MeshGenerator
       copyMeshProperty<bool>("is_control_drum_meta", name() + "_pattern");
       copyMeshProperty<std::vector<Point>>("control_drum_positions", name() + "_pattern");
       copyMeshProperty<std::vector<Real>>("control_drum_angles", name() + "_pattern");
       copyMeshProperty<std::vector<std::vector<Real>>>("control_drums_azimuthal_meta",
                                                        name() + "_pattern");
       copyMeshProperty<std::string>("position_file_name", name() + "_pattern");
       copyMeshProperty<Real>("pattern_pitch_meta", name() + "_pattern");
     }
 
     std::string build_mesh_name = name() + "_delbds";
 
     // Remove outer pin sidesets created by PolygonConcentricCircleMeshGenerator
     {
       // Get outer boundaries of all constituent pins based on pin_type
       std::vector<BoundaryName> boundaries_to_delete = {};
       for (const auto & pattern_x : _pattern)
       {
         for (const auto & pattern_idx : pattern_x)
         {
           const auto pin_name = _inputs[pattern_idx];
           const auto pin_id = getMeshProperty<subdomain_id_type>(RGMB::pin_type, pin_name);
           const BoundaryName boundary_name =
               RGMB::PIN_BOUNDARY_NAME_PREFIX + std::to_string(pin_id);
           if (!std::count(boundaries_to_delete.begin(), boundaries_to_delete.end(), boundary_name))
             boundaries_to_delete.push_back(boundary_name);
         }
       }
       auto params = _app.getFactory().getValidParams("BoundaryDeletionGenerator");
 
       params.set<MeshGeneratorName>("input") = name() + "_pattern";
       params.set<std::vector<BoundaryName>>("boundary_names") = boundaries_to_delete;
 
       addMeshSubgenerator("BoundaryDeletionGenerator", build_mesh_name, params);
     }
 
     // Modify outermost mesh interval to enable flexible assembly stitching
     const auto use_flexible_stitching = getReactorParam<bool>(RGMB::flexible_assembly_stitching);
     if (use_flexible_stitching)
     {
       generateFlexibleAssemblyBoundaries();
       build_mesh_name = name() + "_fpg_delbds";
     }
 
     for (auto pinMG : _inputs)
     {
       std::map<subdomain_id_type, std::vector<std::vector<subdomain_id_type>>> region_id_map =
           getMeshProperty<std::map<subdomain_id_type, std::vector<std::vector<subdomain_id_type>>>>(
               RGMB::pin_region_ids, pinMG);
       _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));
       subdomain_id_type pin_type_id = getMeshProperty<subdomain_id_type>(RGMB::pin_type, pinMG);
       std::vector<std::vector<std::string>> pin_block_names =
           getMeshProperty<std::vector<std::vector<std::string>>>(RGMB::pin_block_names, pinMG);
       _pin_block_name_map.insert(
           std::pair<subdomain_id_type, std::vector<std::vector<std::string>>>(pin_type_id,
                                                                               pin_block_names));
     }
 
     if (_extrude && _mesh_dimensions == 3)
       build_mesh_name = callExtrusionMeshSubgenerators(build_mesh_name);
 
     // Store final mesh subgenerator
     _build_mesh = &getMeshByName(build_mesh_name);
   }
   // If mesh generation should be bypassed, call getMeshes to resolve MeshGeneratorSystem
   // dependencies
   else
     auto input_meshes = getMeshes("inputs");
 
   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 115 of file ReactorGeometryMeshBuilderBase.C.

Referenced by 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 32 of file ReactorGeometryMeshBuilderBase.C.

Referenced by 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 172 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator(), ControlDrumMeshGenerator::ControlDrumMeshGenerator(), CoreMeshGenerator::CoreMeshGenerator(), and PinMeshGenerator::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;
 }

◆ freeReactorMeshParams()

void ReactorGeometryMeshBuilderBase::freeReactorMeshParams ( )

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 68 of file ReactorGeometryMeshBuilderBase.C.

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

 {
   _reactor_params_mesh->reset();
 }

◆ generate()

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

overridevirtual

Implements MeshGenerator.

Definition at line 504 of file AssemblyMeshGenerator.C.

 {
   // Must be called to free the ReactorMeshParams mesh
   freeReactorMeshParams();
 
   // 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>("pattern_pitch_meta", name() + "_pattern"))
   {
     const auto pattern_pitch_meta =
         getMeshProperty<Real>("pattern_pitch_meta", name() + "_pattern");
     setMeshProperty("pattern_pitch_meta", pattern_pitch_meta);
   }
 
   // This generate() method will be called once the subgenerators that we depend on are
   // called. This is where we reassign subdomain ids/name in case they were merged when
   // stitching pins into an assembly. This is also where we set region_id and
   // assembly_type_id element integers.
 
   // Define all extra element names and integers
   std::string plane_id_name = "plane_id";
   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 radial_id_name = "radial_id";
   const std::string default_block_name =
       RGMB::ASSEMBLY_BLOCK_NAME_PREFIX + std::to_string(_assembly_type);
 
   auto pin_type_id_int = getElemIntegerFromMesh(*(*_build_mesh), pin_type_id_name, true);
   auto region_id_int = getElemIntegerFromMesh(*(*_build_mesh), region_id_name, true);
   auto radial_id_int = getElemIntegerFromMesh(*(*_build_mesh), radial_id_name, true);
 
   auto assembly_type_id_int = getElemIntegerFromMesh(*(*_build_mesh), assembly_type_id_name);
 
   unsigned int plane_id_int = 0;
   if (_extrude)
     plane_id_int = getElemIntegerFromMesh(*(*_build_mesh), plane_id_name, true);
 
   // 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 mesh elements and set region ids and reassign block IDs/names
   // if they were merged during pin stitching
   for (auto & elem : (*_build_mesh)->active_element_ptr_range())
   {
     elem->set_extra_integer(assembly_type_id_int, _assembly_type);
     const dof_id_type pin_type_id = elem->get_extra_integer(pin_type_id_int);
     const dof_id_type z_id = _extrude ? elem->get_extra_integer(plane_id_int) : 0;
 
     // Element is part of a pin mesh
     if (_pin_region_id_map.find(pin_type_id) != _pin_region_id_map.end())
     {
       // Get region ID from pin_type, z_id, and radial_idx
       const dof_id_type radial_idx = elem->get_extra_integer(radial_id_int);
       const auto elem_rid = _pin_region_id_map[pin_type_id][z_id][radial_idx];
       elem->set_extra_integer(region_id_int, elem_rid);
 
       // Set element block name and block id
       bool has_block_names = !_pin_block_name_map[pin_type_id].empty();
       auto elem_block_name = default_block_name;
       if (has_block_names)
         elem_block_name += "_" + _pin_block_name_map[pin_type_id][z_id][radial_idx];
       else if (getReactorParam<bool>(RGMB::region_id_as_block_name))
         elem_block_name += "_REG" + std::to_string(elem_rid);
       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);
     }
     else
     {
       // Assembly peripheral element (background / duct), set subdomains according
       // to user preferences and set pin type id to RGMB::MAX_PIN_TYPE_ID - peripheral index
       // Region id is inferred from z_id and peripheral_idx
       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::ASSEMBLY_BLOCK_NAME_PREFIX + std::to_string(_assembly_type) + "_R";
       if (!(base_block_name.find(prefix, 0) == 0))
         continue;
       // Peripheral index is integer value of substring after prefix
       const unsigned int peripheral_idx = std::stoi(base_block_name.substr(prefix.length()));
 
       bool is_background_region = peripheral_idx == 0;
 
       subdomain_id_type pin_type = RGMB::MAX_PIN_TYPE_ID - peripheral_idx;
       elem->set_extra_integer(pin_type_id_int, pin_type);
 
       const auto elem_rid = (is_background_region ? _background_region_id[z_id]
                                                   : _duct_region_ids[z_id][peripheral_idx - 1]);
       elem->set_extra_integer(region_id_int, elem_rid);
 
       // Set element block name and block id
       auto elem_block_name = default_block_name;
       if (getReactorParam<bool>(RGMB::region_id_as_block_name))
         elem_block_name += "_REG" + std::to_string(elem_rid);
       else if (is_background_region && _has_background_block_name)
         elem_block_name += "_" + _background_block_name[z_id];
       else if (!is_background_region && _has_duct_block_names)
         elem_block_name += "_" + _duct_block_names[z_id][peripheral_idx - 1];
       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);
     }
   }
 
   if (getParam<bool>("generate_depletion_id"))
   {
     const MooseEnum option = getParam<MooseEnum>("depletion_id_type");
     addDepletionId(*(*_build_mesh), option, DepletionIDGenerationLevel::Assembly, _extrude);
   }
 
   // Mark mesh as not prepared, as block IDs were re-assigned in this method
   (*_build_mesh)->set_isnt_prepared();
 
   return std::move(*_build_mesh);
 }

◆ generateData()

void ReactorGeometryMeshBuilderBase::generateData ( )

inlineoverridevirtualinherited

Reimplemented from MeshGenerator.

Definition at line 116 of file ReactorGeometryMeshBuilderBase.h.

116 {};

◆ generateFlexibleAssemblyBoundaries()

void AssemblyMeshGenerator::generateFlexibleAssemblyBoundaries ( )

protected

Definition at line 450 of file AssemblyMeshGenerator.C.

Referenced by AssemblyMeshGenerator().

 {
   // Assemblies that invoke this method have constituent pin lattice, delete outermost background or
   // duct region (if present)
   SubdomainName block_to_delete = "";
   if (_background_region_id.size() == 0)
     mooseError("Attempting to use flexible stitching on assembly " + name() +
                " that does not have a background region. This is not yet supported.");
   const auto radial_index = _duct_region_ids.size() == 0 ? 0 : _duct_region_ids[0].size();
   block_to_delete = RGMB::ASSEMBLY_BLOCK_NAME_PREFIX + std::to_string(_assembly_type) + "_R" +
                     std::to_string(radial_index);
 
   {
     // Invoke BlockDeletionGenerator to delete outermost mesh interval of assembly
     auto params = _app.getFactory().getValidParams("BlockDeletionGenerator");
 
     params.set<std::vector<SubdomainName>>("block") = {block_to_delete};
     params.set<MeshGeneratorName>("input") = name() + "_delbds";
 
     addMeshSubgenerator("BlockDeletionGenerator", name() + "_del_outer", params);
   }
   {
     // Invoke FlexiblePatternGenerator to triangulate deleted mesh region
     auto params = _app.getFactory().getValidParams("FlexiblePatternGenerator");
 
     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<MooseEnum>("boundary_type") = (_geom_type == "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") = _assembly_boundary_id;
     params.set<BoundaryName>("external_boundary_name") = _assembly_boundary_name;
     params.set<SubdomainName>("background_subdomain_name") =
         block_to_delete + RGMB::TRI_BLOCK_NAME_SUFFIX;
     params.set<bool>("verify_holes") = false;
     params.set<unsigned short>("background_subdomain_id") = RGMB::ASSEMBLY_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";
     params.set<std::vector<BoundaryName>>("boundary_names") = {std::to_string(1)};
 
     addMeshSubgenerator("BoundaryDeletionGenerator", name() + "_fpg_delbds", params);
   }
 }

◆ generateMetadata()

void AssemblyMeshGenerator::generateMetadata ( )

protected

Definition at line 404 of file AssemblyMeshGenerator.C.

Referenced by AssemblyMeshGenerator().

 {
   // Declare metadata for use in downstream mesh generators
   declareMeshProperty(RGMB::assembly_type, _assembly_type);
   declareMeshProperty(RGMB::pitch, getReactorParam<Real>(RGMB::assembly_pitch));
   declareMeshProperty(RGMB::background_region_id, _background_region_id);
   declareMeshProperty(RGMB::background_block_name, _background_block_name);
   declareMeshProperty(RGMB::duct_halfpitches, _duct_sizes);
   declareMeshProperty(RGMB::duct_region_ids, _duct_region_ids);
   declareMeshProperty(RGMB::duct_block_names, _duct_block_names);
   declareMeshProperty(RGMB::is_homogenized, false);
   declareMeshProperty(RGMB::is_single_pin, false);
   declareMeshProperty(RGMB::extruded, _extrude && _mesh_dimensions == 3);
   declareMeshProperty(RGMB::is_control_drum, false);
   // Following metadata is only relevant if an output mesh is generated by RGMB
   if (!getReactorParam<bool>(RGMB::bypass_meshgen))
   {
     declareMeshProperty(RGMB::pin_region_id_map, _pin_region_id_map);
     declareMeshProperty(RGMB::pin_block_name_map, _pin_block_name_map);
   }
 
   // Determine constituent pin names and define lattice as metadata
   std::vector<std::vector<int>> pin_name_lattice;
   std::vector<std::string> input_pin_names;
   for (const auto i : index_range(_pattern))
   {
     std::vector<int> pin_name_idx(_pattern[i].size());
     for (const auto j : index_range(_pattern[i]))
     {
       const auto input_pin_name = _inputs[_pattern[i][j]];
       const auto it = std::find(input_pin_names.begin(), input_pin_names.end(), input_pin_name);
       if (it == input_pin_names.end())
       {
         pin_name_idx[j] = input_pin_names.size();
         input_pin_names.push_back(input_pin_name);
       }
       else
         pin_name_idx[j] = it - input_pin_names.begin();
     }
     pin_name_lattice.push_back(pin_name_idx);
   }
   declareMeshProperty(RGMB::pin_names, input_pin_names);
   declareMeshProperty(RGMB::pin_lattice, pin_name_lattice);
 }

◆ 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 74 of file ReactorGeometryMeshBuilderBase.C.

Referenced by generate(), PinMeshGenerator::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);
   }
 }

◆ 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 284 of file ReactorGeometryMeshBuilderBase.h.

Referenced by AssemblyMeshGenerator(), ReactorGeometryMeshBuilderBase::callExtrusionMeshSubgenerators(), ControlDrumMeshGenerator::ControlDrumMeshGenerator(), PinMeshGenerator::generateMetadata(), and PinMeshGenerator::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 277 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 49 of file ReactorGeometryMeshBuilderBase.C.

Referenced by AssemblyMeshGenerator(), ControlDrumMeshGenerator::ControlDrumMeshGenerator(), CoreMeshGenerator::CoreMeshGenerator(), and PinMeshGenerator::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));
 }

◆ 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 90 of file ReactorGeometryMeshBuilderBase.C.

Referenced by generate(), PinMeshGenerator::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;
   }
 }

◆ validParams()

InputParameters AssemblyMeshGenerator::validParams ( )

static

Definition at line 21 of file AssemblyMeshGenerator.C.

 {
   auto params = ReactorGeometryMeshBuilderBase::validParams();
 
   params.addRequiredParam<std::vector<MeshGeneratorName>>(
       "inputs", "The PinMeshGenerators that form the components of the assembly.");
 
   params.addRequiredParam<subdomain_id_type>("assembly_type",
                                              "The integer ID for this assembly type definition");
 
   params.addRequiredParam<std::vector<std::vector<unsigned int>>>(
       "pattern",
       "A double-indexed array starting with the upper-left corner where the index"
       "represents the layout of input pins in the assembly lattice.");
 
   params.addRangeCheckedParam<std::vector<Real>>(
       "duct_halfpitch",
       "duct_halfpitch>0.0",
       "Distance(s) from center to duct(s) inner boundaries.");
 
   params.addRangeCheckedParam<unsigned int>("background_intervals",
                                             "background_intervals>0",
                                             "Radial intervals in the assembly peripheral region.");
 
   params.addRangeCheckedParam<std::vector<unsigned int>>(
       "duct_intervals", "duct_intervals>0", "Number of meshing intervals in each enclosing duct.");
 
   params.addParam<std::vector<subdomain_id_type>>(
       "background_region_id",
       "The region id for the background area between the pins and the ducts to set region_id "
       "extra-element integer");
 
   params.addParam<std::vector<std::vector<subdomain_id_type>>>(
       "duct_region_ids",
       "The region id for the ducts from innermost to outermost, to set region_id "
       "extra-element integer.");
 
   params.addParam<std::vector<std::string>>("background_block_name",
                                             "The block names for the assembly background regions");
 
   params.addParam<std::vector<std::vector<std::string>>>(
       "duct_block_names",
       "The block names for the assembly duct regions from innermost to outermost");
 
   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.addParamNamesToGroup("background_region_id duct_region_ids assembly_type", "ID assigment");
   params.addParamNamesToGroup("background_intervals background_region_id",
                               "Background specifications");
   params.addParamNamesToGroup("duct_intervals duct_region_ids duct_halfpitch",
                               "Duct specifications");
 
   params.addClassDescription("This AssemblyMeshGenerator object is designed to generate "
                              "assembly-like structures, with IDs, from a reactor geometry. "
                              "The assembly-like structures must consist of a full pattern of equal "
                              "sized pins from PinMeshGenerator. "
                              "A hexagonal assembly will be placed inside of a bounding hexagon "
                              "consisting of a background region and, optionally,"
                              " duct regions.");
   // depletion id generation params are added
   addDepletionIDParams(params);
 
   return params;
 }

Member Data Documentation

◆ _assembly_boundary_id

boundary_id_type AssemblyMeshGenerator::_assembly_boundary_id

protected

The ID of the assembly outer boundary, equal to the assembly type ID + 2000.

Definition at line 93 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator(), and generateFlexibleAssemblyBoundaries().

◆ _assembly_boundary_name

BoundaryName AssemblyMeshGenerator::_assembly_boundary_name

protected

The name of the assembly outer boundary, equal to the concatenation of "outer_assembly_" and the assembly-type ID.

Definition at line 96 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator(), and generateFlexibleAssemblyBoundaries().

◆ _assembly_type

const subdomain_id_type AssemblyMeshGenerator::_assembly_type

protected

The id number for the type of the assembly.

Definition at line 39 of file AssemblyMeshGenerator.h.

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

◆ _axial_boundaries

std::vector<Real> AssemblyMeshGenerator::_axial_boundaries

protected

The heights of the axial regions that are stored on the ReactorMeshParams object.

Definition at line 81 of file AssemblyMeshGenerator.h.

◆ _background_block_name

std::vector<std::string> AssemblyMeshGenerator::_background_block_name

protected

Optional vector used to set the block names of the assembly background elements.

Definition at line 66 of file AssemblyMeshGenerator.h.

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

◆ _background_intervals

const unsigned int AssemblyMeshGenerator::_background_intervals

protected

The number of divisions in the mesh outside of the pins and inside of the ducts.

Definition at line 48 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator().

◆ _background_region_id

std::vector<subdomain_id_type> AssemblyMeshGenerator::_background_region_id

protected

Vector used to set the "region_id" extra-element integer of the assembly background elements.

Definition at line 54 of file AssemblyMeshGenerator.h.

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

◆ _build_mesh

std::unique_ptr<MeshBase>* AssemblyMeshGenerator::_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 100 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator(), and generate().

◆ _duct_block_names

std::vector<std::vector<std::string> > AssemblyMeshGenerator::_duct_block_names

protected

Optional 2-D vector (axial outer indexing, radial inner indexing) used to set the block names of the assembly duct elements.

Definition at line 69 of file AssemblyMeshGenerator.h.

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

◆ _duct_intervals

const std::vector<unsigned int> AssemblyMeshGenerator::_duct_intervals

protected

The number of divisions in the meshes of the ducts.

Definition at line 51 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator().

◆ _duct_region_ids

std::vector<std::vector<subdomain_id_type> > AssemblyMeshGenerator::_duct_region_ids

protected

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

Definition at line 57 of file AssemblyMeshGenerator.h.

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

◆ _duct_sizes

const std::vector<Real> AssemblyMeshGenerator::_duct_sizes

protected

The inner apothem of any ducts around the assembly.

Definition at line 45 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator(), and generateMetadata().

◆ _extrude

const bool AssemblyMeshGenerator::_extrude

protected

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

Definition at line 72 of file AssemblyMeshGenerator.h.

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

◆ _geom_type

std::string AssemblyMeshGenerator::_geom_type

protected

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

Definition at line 75 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator(), and generateFlexibleAssemblyBoundaries().

◆ _has_background_block_name

bool AssemblyMeshGenerator::_has_background_block_name

protected

Whether block names for assembly background elements have been provided by user.

Definition at line 60 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator(), and generate().

◆ _has_duct_block_names

bool AssemblyMeshGenerator::_has_duct_block_names

protected

Whether block names for assembly duct elements have been provided by user.

Definition at line 63 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator(), and generate().

◆ _inputs

const std::vector<MeshGeneratorName> AssemblyMeshGenerator::_inputs

protected

The names of the pins that compose the Assembly.

Definition at line 36 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator(), and generateMetadata().

◆ _mesh_dimensions

unsigned int AssemblyMeshGenerator::_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 78 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator(), and generateMetadata().

◆ _pattern

const std::vector<std::vector<unsigned int> > AssemblyMeshGenerator::_pattern

protected

The 2D pin-by-pin layout of the assembly mapping indices into _inputs.

Definition at line 42 of file AssemblyMeshGenerator.h.

Referenced by AssemblyMeshGenerator(), and generateMetadata().

◆ _peripheral_region_ids

std::vector<subdomain_id_type> AssemblyMeshGenerator::_peripheral_region_ids

protected

The region ids of peripheral regions in the 2D mesh. This includes the assembly background region and ducts.

Definition at line 84 of file AssemblyMeshGenerator.h.

◆ _pin_block_name_map

std::map<subdomain_id_type, std::vector<std::vector<std::string> > > AssemblyMeshGenerator::_pin_block_name_map

protected

A mapping from pin-type IDs to block names used when assigning block names during the pin stitching stage.

Definition at line 90 of file AssemblyMeshGenerator.h.

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

◆ _pin_region_id_map

std::map<subdomain_id_type, std::vector<std::vector<subdomain_id_type> > > AssemblyMeshGenerator::_pin_region_id_map

protected

A mapping from pin-type IDs to region IDs used when assigning region IDs during the pin stitching stage.

Definition at line 87 of file AssemblyMeshGenerator.h.

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

◆ _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 247 of file ReactorGeometryMeshBuilderBase.h.

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

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

reactor/include/meshgenerators/AssemblyMeshGenerator.h
reactor/src/meshgenerators/AssemblyMeshGenerator.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

◆ AssemblyMeshGenerator()

Member Function Documentation

◆ addDepletionId()

◆ addDepletionIDParams()

◆ callExtrusionMeshSubgenerators()

◆ freeReactorMeshParams()

◆ generate()

◆ generateData()

◆ generateFlexibleAssemblyBoundaries()

◆ generateMetadata()

◆ getElemIntegerFromMesh()

◆ getReactorParam()

◆ hasReactorParam()

◆ initializeReactorMeshParams()

◆ print2dMetadataToConsole()

◆ printAssemblyMetadata()

◆ printCoreMetadata()

◆ printGlobalReactorMetadata()

◆ printMetadataToConsole()

◆ printPinMetadata()

◆ printReactorMetadata()

◆ updateElementBlockNameId()

◆ validParams()

Member Data Documentation

◆ _assembly_boundary_id

◆ _assembly_boundary_name

◆ _assembly_type

◆ _axial_boundaries

◆ _background_block_name

◆ _background_intervals

◆ _background_region_id

◆ _build_mesh

◆ _duct_block_names

◆ _duct_intervals

◆ _duct_region_ids

◆ _duct_sizes

◆ _extrude

◆ _geom_type

◆ _has_background_block_name

◆ _has_duct_block_names

◆ _inputs

◆ _mesh_dimensions

◆ _pattern

◆ _peripheral_region_ids

◆ _pin_block_name_map

◆ _pin_region_id_map

◆ _reactor_params