A base class that contains common members for Reactor Geometry Mesh Builder mesh generators. More...

#include <ReactorGeometryMeshBuilderBase.h>

Inheritance diagram for ReactorGeometryMeshBuilderBase:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	ReactorGeometryMeshBuilderBase (const InputParameters &parameters)

void	generateData () override

virtual std::unique_ptr< MeshBase >	generate ()=0

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

const std::string &	name () const

std::string	typeAndName () const

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

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

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

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

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

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

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

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

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

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

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

void	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	mooseWarningNonPrefixed (Args &&... args) const

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

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) 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	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node)

static void	setHasGenerateData (InputParameters &params)

Public Attributes
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 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
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
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

Private Attributes
std::unique_ptr< MeshBase > *	_reactor_params_mesh
	The dummy param mesh that we need to clear once we've generated (in freeReactorMeshParams) More...

Detailed Description

A base class that contains common members for Reactor Geometry Mesh Builder mesh generators.

Definition at line 107 of file ReactorGeometryMeshBuilderBase.h.

Member Enumeration Documentation

◆ DepletionIDGenerationLevel

enum ReactorGeometryMeshBuilderBase::DepletionIDGenerationLevel

strongprotected

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

◆ ReactorGeometryMeshBuilderBase()

ReactorGeometryMeshBuilderBase::ReactorGeometryMeshBuilderBase ( const InputParameters & parameters )

Definition at line 43 of file ReactorGeometryMeshBuilderBase.C.

   : MeshGenerator(parameters)
 {
 }

Member Function Documentation

◆ addDepletionId()

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

protected

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

static

Definition at line 32 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 )

protected

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::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 ( )

protected

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 AssemblyMeshGenerator::generate(), PinMeshGenerator::generate(), ControlDrumMeshGenerator::generate(), and CoreMeshGenerator::generate().

 {
   _reactor_params_mesh->reset();
 }

◆ generateData()

void ReactorGeometryMeshBuilderBase::generateData ( )

inlineoverridevirtual

Reimplemented from MeshGenerator.

Definition at line 116 of file ReactorGeometryMeshBuilderBase.h.

116 {};

◆ getElemIntegerFromMesh()

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

protected

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 AssemblyMeshGenerator::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 )

protected

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::AssemblyMeshGenerator(), 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 )

protected

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 )

protected

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::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
	)

protected

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
	)

protected

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
	)

protected

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 ( )

protected

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
	)

protected

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 )

protected

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`
	)

protected

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
	)

protected

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 AssemblyMeshGenerator::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 ReactorGeometryMeshBuilderBase::validParams ( )

static

Definition at line 15 of file ReactorGeometryMeshBuilderBase.C.

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

 {
   InputParameters params = MeshGenerator::validParams();
 
   params.addDeprecatedParam<bool>("show_rgmb_metadata",
                                   "Print out RGMB-related metadata to console output",
                                   "This parameter is deprecated. Please use MeshMetaDataReporter "
                                   "system to print out mesh metadata to JSON output file instead");
   params.addClassDescription("A base class that contains common members and methods for Reactor "
                              "Geometry Mesh Builder mesh generators.");
 
   // Declare that this generator has a generateData method
   MeshGenerator::setHasGenerateData(params);
   return params;
 }

Member Data Documentation

◆ _reactor_params

MeshGeneratorName ReactorGeometryMeshBuilderBase::_reactor_params

protected

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 getReactorParam(), hasReactorParam(), and initializeReactorMeshParams().

◆ _reactor_params_mesh

std::unique_ptr<MeshBase>* ReactorGeometryMeshBuilderBase::_reactor_params_mesh

private

The dummy param mesh that we need to clear once we've generated (in freeReactorMeshParams)

Definition at line 272 of file ReactorGeometryMeshBuilderBase.h.

Referenced by freeReactorMeshParams(), and initializeReactorMeshParams().

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

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

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ DepletionIDGenerationLevel

Constructor & Destructor Documentation

◆ ReactorGeometryMeshBuilderBase()

Member Function Documentation

◆ addDepletionId()

◆ addDepletionIDParams()

◆ callExtrusionMeshSubgenerators()

◆ freeReactorMeshParams()

◆ generateData()

◆ getElemIntegerFromMesh()

◆ getReactorParam()

◆ hasReactorParam()

◆ initializeReactorMeshParams()

◆ print2dMetadataToConsole()

◆ printAssemblyMetadata()

◆ printCoreMetadata()

◆ printGlobalReactorMetadata()

◆ printMetadataToConsole()

◆ printPinMetadata()

◆ printReactorMetadata()

◆ updateElementBlockNameId()

◆ validParams()

Member Data Documentation

◆ _reactor_params

◆ _reactor_params_mesh