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

#include <CoreMeshGenerator.h>

Inheritance diagram for CoreMeshGenerator:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	CoreMeshGenerator (const InputParameters &parameters)

std::unique_ptr< MeshBase >	generate () override

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

void	generateData () override

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

std::unique_ptr< MeshBase >	generateInternal ()

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

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

void	addParentMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

void	addChildMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

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

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

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

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

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

bool	isNullMeshName (const MeshGeneratorName &name) const

bool	hasSaveMesh () const

bool	hasOutput () const

const std::string &	getSavedMeshName () const

bool	hasGenerateData () const

bool	hasGenerateCSG () const

bool	isDataOnly () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static void	addDepletionIDParams (InputParameters &parameters)

static bool	hasGenerateData (const InputParameters &params)

static bool	hasGenerateCSG (const InputParameters &params)

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

static void	setHasGenerateData (InputParameters &params)

static void	setHasGenerateCSG (InputParameters &params)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	data_only_param

static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Types
enum class	DepletionIDGenerationLevel { Pin , Assembly , Drum , Core }
	specify the depletion id is generated at which reactor generation level More...

Protected Member Functions
void	generateMetadata ()

bool	constituentAssembliesNeedFlexibleStiching ()

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.

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

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

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

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

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

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

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.

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.

void	freeReactorParamsMesh ()
	Releases the mesh obtained in _reactor_params_mesh.

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	declareMeshForSub (const std::string &param_name)

void	declareMeshesForSub (const std::string &param_name)

void	declareMeshForSubByName (const MeshGeneratorName &mesh_generator_name)

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

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

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

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

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

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

void	declareNullMeshName (const MeshGeneratorName &name)

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Protected Attributes
const std::vector< MeshGeneratorName >	_inputs
	The names of the assemblies that compose the core.

const MeshGeneratorName	_empty_key
	The name of "filler" assembly given in the input to represent an empty space in the core pattern.

bool	_empty_pos = false
	Whether empty positions are to be used in the pattern.

const std::vector< std::vector< unsigned int > >	_pattern
	The 2D assembly layout of the core.

const bool	_extrude
	Whether this mesh should be extruded to 3-D, the core is always assumed to be the last.

std::string	_geom_type
	The geometry type for the reactor that is stored on the ReactorMeshParams object.

const bool	_mesh_periphery
	Whether the core periphery should be meshed.

const MooseEnum	_periphery_meshgenerator
	Which periphery meshgenerator to use.

const subdomain_id_type	_periphery_region_id
	"region_id" extra-element integer of the periphery mesh elements

const Real	_outer_circle_radius
	outer circle boundary radius

const unsigned int	_outer_circle_num_segments
	Number of segments in the outer circle boundary.

const std::string	_periphery_block_name
	The subdomain name for the generated mesh outer boundary.

const unsigned int	_periphery_num_layers
	Number of periphery layers.

const Real	_desired_area
	Desired (maximum) triangle area.

std::string	_desired_area_func
	Desired (local) triangle area as a function of (x,y)

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

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 assembly stitching stage.

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 assembly stitching stage.

std::map< subdomain_id_type, std::vector< std::vector< subdomain_id_type > > >	_duct_region_id_map
	A mapping from assembly-type IDs to region IDs in the assembly duct regions used when assigning region IDs during the assembly stitching stage.

std::map< subdomain_id_type, std::vector< std::vector< std::string > > >	_duct_block_name_map
	A mapping from assembly-type IDs to block names in the assembly duct regions used when assigning block names during the assembly stitching stage.

std::map< subdomain_id_type, std::vector< subdomain_id_type > >	_background_region_id_map
	A mapping from assembly-type IDs to region IDs in the assembly background regions used when assigning region IDs during the assembly stitching stage.

std::map< subdomain_id_type, std::vector< std::string > >	_background_block_name_map
	A mapping from assembly-type IDs to block names in the assembly background regions used when assigning block names during the assembly stitching stage.

std::map< subdomain_id_type, std::vector< std::vector< subdomain_id_type > > >	_drum_region_id_map
	A mapping from assembly-type IDs to region IDs in the drum regions used when assigning region IDs during the assembly stitching stage.

std::map< subdomain_id_type, std::vector< std::vector< std::string > > >	_drum_block_name_map
	A mapping from assembly-type IDs to block names in the drum regions used when assigning block names during the assembly stitching stage.

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.

std::vector< std::unique_ptr< CSG::CSGBase > * >	_input_csg_bases
	List of pointers to all CSG bases created by input mesh generators.

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

MooseMesh *const	_mesh

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const Parallel::Communicator &	_communicator

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

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

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

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

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

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

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

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

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

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

std::unique_ptr< CSG::CSGBase > *	_reactor_params_csg

std::set< MeshGeneratorName >	_requested_mesh_generators

std::set< MeshGeneratorName >	_requested_mesh_generators_for_sub

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

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

std::unique_ptr< MeshBase >	_null_mesh

std::unique_ptr< CSG::CSGBase >	_null_csg_base

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

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

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

std::set< std::string >	_null_mesh_names

const std::string &	_save_with_name

const bool	_data_only

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

Detailed Description

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

Definition at line 19 of file CoreMeshGenerator.h.

Member Enumeration Documentation

◆ DepletionIDGenerationLevel

enum class ReactorGeometryMeshBuilderBase::DepletionIDGenerationLevel

strongprotectedinherited

specify the depletion id is generated at which reactor generation level

Enumerator
Pin
Assembly
Drum
Core

Definition at line 263 of file ReactorGeometryMeshBuilderBase.h.

  {
    Pin,
    Assembly,
    Drum,
    Core
  };

Constructor & Destructor Documentation

◆ CoreMeshGenerator()

CoreMeshGenerator::CoreMeshGenerator ( const InputParameters & parameters )

Definition at line 108 of file CoreMeshGenerator.C.

  : ReactorGeometryMeshBuilderBase(parameters),
    _inputs(getParam<std::vector<MeshGeneratorName>>("inputs")),
    _empty_key(getParam<std::string>("dummy_assembly_name")),
    _pattern(getParam<std::vector<std::vector<unsigned int>>>("pattern")),
    _extrude(getParam<bool>("extrude")),
    _mesh_periphery(getParam<bool>("mesh_periphery")),
    _periphery_meshgenerator(getParam<MooseEnum>("periphery_generator")),
    _periphery_region_id(getParam<subdomain_id_type>("periphery_region_id")),
    _outer_circle_radius(getParam<Real>("outer_circle_radius")),
    _outer_circle_num_segments(getParam<unsigned int>("outer_circle_num_segments")),
    _periphery_block_name(getParam<std::string>("periphery_block_name")),
    _periphery_num_layers(getParam<unsigned int>("periphery_num_layers")),
    _desired_area(getParam<Real>("desired_area")),
    _desired_area_func(getParam<std::string>("desired_area_func"))
{
  // This sets it so that any mesh that is input with the name _empty_key is considered a "null"
  // mesh, that is, whenever we try to get it with the standard getMesh() API we get a nullptr
  // mesh instead. In the specific case of the CoreMeshGenerator, we use said "null" mesh to
  // represent an empty position
  declareNullMeshName(_empty_key);
 
  // periphery meshing input checking
  if (_mesh_periphery)
  {
    // missing required input
    if (!parameters.isParamSetByUser("outer_circle_radius"))
    {
      paramError("outer_circle_radius",
                 "Outer circle radius must be specified when using periphery meshing.");
    }
    if (!parameters.isParamSetByUser("periphery_region_id"))
    {
      paramError("periphery_region_id",
                 "Periphery region id must be specified when using periphery meshing.");
    }
    // using PTMG-specific options with PRMG
    if (_periphery_meshgenerator == "quad_ring")
    {
      if (parameters.isParamSetByUser("outer_circle_num_segments"))
      {
        paramError("outer_circle_num_segments",
                   "outer_circle_num_segments cannot be used with PRMG periphery mesher.");
      }
      if (parameters.isParamSetByUser("extra_circle_radii"))
      {
        paramError("extra_circle_radii",
                   "extra_circle_radii cannot be used with PRMG periphery mesher.");
      }
      if (parameters.isParamSetByUser("extra_circle_num_segments"))
      {
        paramError("extra_circle_num_segments",
                   "extra_circle_num_segments cannot be used with PRMG periphery mesher.");
      }
    }
    // using PRMG-specific options with PTMG
    else if (_periphery_meshgenerator == "triangle")
    {
      if (parameters.isParamSetByUser("periphery_num_layers"))
      {
        paramError("periphery_num_layers",
                   "periphery_num_layers cannot be used with PTMG periphery mesher.");
      }
    }
    else
      paramError("periphery_generator",
                 "Provided periphery meshgenerator has not been implemented.");
  }
 
  MeshGeneratorName first_nondummy_assembly = "";
  MeshGeneratorName reactor_params = "";
  bool assembly_homogenization = false;
  bool pin_as_assembly = false;
  std::map<subdomain_id_type, std::string> global_pin_map_type_to_name;
  std::map<subdomain_id_type, std::string> assembly_map_type_to_name;
  // Check that MG name for reactor params and assembly homogenization schemes are
  // consistent across all assemblies, and there is no overlap in pin_type / assembly_type ids
  for (const auto i : index_range(_inputs))
  {
    // Skip if assembly name is equal to dummy assembly name
    if (_inputs[i] == _empty_key)
      continue;
 
    // Save properties of first non-dummy assembly to compare to other assemblies
    if (first_nondummy_assembly == "")
    {
      first_nondummy_assembly = MeshGeneratorName(_inputs[i]);
      reactor_params =
          MeshGeneratorName(getMeshProperty<std::string>(RGMB::reactor_params_name, _inputs[i]));
      assembly_homogenization = getMeshProperty<bool>(RGMB::is_homogenized, _inputs[i]);
      pin_as_assembly = getMeshProperty<bool>(RGMB::is_single_pin, _inputs[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 pins in "
                 "the input assemblies.\n");
    if ((getMeshProperty<bool>(RGMB::is_homogenized, _inputs[i]) != assembly_homogenization) &&
        !getMeshProperty<bool>(RGMB::flexible_assembly_stitching, reactor_params))
      mooseError("In order to stitch heterogeneous assemblies with homogeneous assemblies in "
                 "CoreMeshGenerator, ReactorMeshParams/flexible_assembly_stitching should be set "
                 "to true\n");
 
    // Check assembly_types across constituent assemblies are uniquely defined
    const auto assembly_type = getMeshProperty<subdomain_id_type>(RGMB::assembly_type, _inputs[i]);
    if (assembly_map_type_to_name.find(assembly_type) != assembly_map_type_to_name.end() &&
        assembly_map_type_to_name[assembly_type] != _inputs[i])
      mooseError(
          "Constituent assemblies have shared assembly_type ids but different names. Each uniquely "
          "defined assembly in AssemblyMeshGenerator must have its own assembly_type id.");
    assembly_map_type_to_name[assembly_type] = _inputs[i];
 
    // If assembly is composed of pins, check pin_types across all constituent assemblies are
    // uniquely defined
    if (hasMeshProperty<std::vector<std::string>>(RGMB::pin_names, _inputs[i]))
    {
      const auto pin_names = getMeshProperty<std::vector<std::string>>(RGMB::pin_names, _inputs[i]);
      for (const auto & input_pin_name : pin_names)
      {
        const auto pin_type = getMeshProperty<subdomain_id_type>(RGMB::pin_type, input_pin_name);
        if (global_pin_map_type_to_name.find(pin_type) != global_pin_map_type_to_name.end() &&
            global_pin_map_type_to_name[pin_type] != input_pin_name)
          mooseError(
              "Constituent pins within assemblies have shared pin_type ids but different names. "
              "Each uniquely defined pin in AssemblyMeshGenerator must have its own pin_type id.");
        global_pin_map_type_to_name[pin_type] = input_pin_name;
      }
    }
  }
 
  // Check that there is at least one non-dummy assemby defined in lattice
  if (first_nondummy_assembly == "")
    paramError("inputs", "At least one non-dummy assembly must be defined in input assembly names");
 
  // 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");
  if (!hasReactorParam<boundary_id_type>(RGMB::radial_boundary_id))
    mooseError("radial_boundary_id must be provided in ReactorMeshParams for CoreMeshGenerators");
 
  if (parameters.isParamSetByUser("periphery_block_name") &&
      getReactorParam<bool>(RGMB::region_id_as_block_name))
    paramError("periphery_block_name",
               "If ReactorMeshParams/region_id_as_block_name is set, periphery_block_name should "
               "not be specified in CoreMeshGenerator");
 
  std::size_t empty_pattern_loc = 0;
  bool make_empty = false;
  for (auto assembly : _inputs)
  {
    if (assembly != _empty_key)
    {
      ++empty_pattern_loc;
      if (getMeshProperty<bool>(RGMB::extruded, assembly))
        mooseError("Assemblies that have already been extruded cannot be used in CoreMeshGenerator "
                   "definition.\n");
    }
    else
    {
      // Found dummy assembly in input assembly names
      make_empty = true;
      for (const auto i : index_range(_pattern))
      {
        for (const auto j : index_range(_pattern[i]))
        {
          // Found dummy assembly in input lattice definition
          if (_pattern[i][j] == empty_pattern_loc)
            _empty_pos = true;
        }
      }
    }
  }
 
  // No subgenerators will be called if option to bypass mesh generators is enabled
  if (!getReactorParam<bool>(RGMB::bypass_meshgen))
  {
    // Check whether flexible stitching should be used for constituent assemblies and throw a
    // warning if flexible stitching option is not enabled
    if (!getReactorParam<bool>(RGMB::flexible_assembly_stitching) &&
        constituentAssembliesNeedFlexibleStiching())
      mooseWarning("Constituent assemblies do not share the same number of nodes at the outer "
                   "boundary. In order to ensure that output mesh does not having hanging nodes, a "
                   "flexible stitching approach should be used by setting "
                   "ReactorMeshParams/flexible_assembly_stitching = true.");
 
    // Declare that all of the meshes in the "inputs" parameter are to be used by
    // a sub mesh generator.
    declareMeshesForSub("inputs");
 
    // Stitch assemblies into a hexagonal / Cartesian core lattice
    {
      // create a dummy assembly that is a renamed version of one of the inputs
      if (make_empty)
      {
        {
          if (assembly_homogenization)
          {
            auto params = _app.getFactory().getValidParams("SimpleHexagonGenerator");
 
            params.set<Real>("hexagon_size") = getReactorParam<Real>(RGMB::assembly_pitch) / 2.0;
            params.set<std::vector<subdomain_id_type>>("block_id") = {
                RGMB::DUMMY_ASSEMBLY_BLOCK_ID};
 
            addMeshSubgenerator("SimpleHexagonGenerator", std::string(_empty_key), params);
          }
          else
          {
            const auto adaptive_mg_name =
                _geom_type == "Hex" ? "HexagonConcentricCircleAdaptiveBoundaryMeshGenerator"
                                    : "CartesianConcentricCircleAdaptiveBoundaryMeshGenerator";
            auto params = _app.getFactory().getValidParams(adaptive_mg_name);
 
            const auto assembly_pitch = getReactorParam<Real>(RGMB::assembly_pitch);
            if (_geom_type == "Hex")
            {
              params.set<Real>("hexagon_size") = assembly_pitch / 2.0;
              params.set<std::vector<unsigned int>>("num_sectors_per_side") =
                  std::vector<unsigned int>(6, 2);
            }
            else
            {
              params.set<Real>("square_size") = assembly_pitch;
              params.set<std::vector<unsigned int>>("num_sectors_per_side") =
                  std::vector<unsigned int>(4, 2);
            }
            params.set<std::vector<unsigned int>>("sides_to_adapt") = std::vector<unsigned int>{0};
            params.set<std::vector<MeshGeneratorName>>("meshes_to_adapt_to") =
                std::vector<MeshGeneratorName>{first_nondummy_assembly};
            params.set<std::vector<subdomain_id_type>>("background_block_ids") =
                std::vector<subdomain_id_type>{RGMB::DUMMY_ASSEMBLY_BLOCK_ID};
 
            addMeshSubgenerator(adaptive_mg_name, std::string(_empty_key), params);
          }
        }
      }
      {
        const auto patterned_mg_name =
            _geom_type == "Hex" ? "PatternedHexMeshGenerator" : "PatternedCartesianMeshGenerator";
        auto params = _app.getFactory().getValidParams(patterned_mg_name);
 
        params.set<std::vector<std::string>>("id_name") = {"assembly_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<MooseEnum>("pattern_boundary") = "none";
        params.set<bool>("generate_core_metadata") = !pin_as_assembly;
        params.set<bool>("create_outward_interface_boundaries") = false;
        params.set<bool>("assign_control_drum_id") = getParam<bool>("assign_control_drum_id");
        if (make_empty)
        {
          params.set<std::vector<MeshGeneratorName>>("exclude_id") =
              std::vector<MeshGeneratorName>{_empty_key};
        }
 
        const auto radial_boundary = getReactorParam<boundary_id_type>(RGMB::radial_boundary_id);
        params.set<boundary_id_type>("external_boundary_id") = radial_boundary;
        params.set<BoundaryName>("external_boundary_name") = RGMB::CORE_BOUNDARY_NAME;
        params.set<double>("rotate_angle") = 0.0;
        params.set<bool>("allow_unused_inputs") = true;
 
        addMeshSubgenerator(patterned_mg_name, name() + "_pattern", params);
      }
    }
    if (_empty_pos)
    {
      auto params = _app.getFactory().getValidParams("BlockDeletionGenerator");
 
      params.set<std::vector<SubdomainName>>("block") = {
          std::to_string(RGMB::DUMMY_ASSEMBLY_BLOCK_ID)};
      params.set<MeshGeneratorName>("input") = name() + "_pattern";
      params.set<BoundaryName>("new_boundary") = RGMB::CORE_BOUNDARY_NAME;
 
      addMeshSubgenerator("BlockDeletionGenerator", name() + "_deleted", params);
    }
 
    std::string build_mesh_name;
 
    // Remove outer assembly sidesets created during assembly generation
    {
      // Get outer boundaries of all constituent assemblies based on assembly_type,
      // skipping all dummy assemblies
      std::vector<BoundaryName> boundaries_to_delete = {};
      for (const auto & pattern_x : _pattern)
      {
        for (const auto & pattern_idx : pattern_x)
        {
          const auto assembly_name = _inputs[pattern_idx];
          if (assembly_name == _empty_key)
            continue;
          const auto assembly_id =
              getMeshProperty<subdomain_id_type>(RGMB::assembly_type, assembly_name);
          const BoundaryName boundary_name =
              RGMB::ASSEMBLY_BOUNDARY_NAME_PREFIX + std::to_string(assembly_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") =
          _empty_pos ? name() + "_deleted" : name() + "_pattern";
      params.set<std::vector<BoundaryName>>("boundary_names") = boundaries_to_delete;
 
      build_mesh_name = name() + "_delbds";
      addMeshSubgenerator("BoundaryDeletionGenerator", build_mesh_name, params);
    }
 
    for (auto assembly : _inputs)
    {
      if (assembly != _empty_key)
      {
        subdomain_id_type assembly_type =
            getMeshProperty<subdomain_id_type>(RGMB::assembly_type, assembly);
        if (!getMeshProperty<bool>(RGMB::is_control_drum, assembly))
        {
          // For assembly structures, store region ID and block names of assembly regions and
          // constituent pins
          const auto & pin_region_id_map = getMeshProperty<
              std::map<subdomain_id_type, std::vector<std::vector<subdomain_id_type>>>>(
              RGMB::pin_region_id_map, assembly);
          for (auto pin = pin_region_id_map.begin(); pin != pin_region_id_map.end(); ++pin)
            _pin_region_id_map.insert(
                std::pair<subdomain_id_type, std::vector<std::vector<subdomain_id_type>>>(
                    pin->first, pin->second));
 
          const auto & pin_block_name_map =
              getMeshProperty<std::map<subdomain_id_type, std::vector<std::vector<std::string>>>>(
                  RGMB::pin_block_name_map, assembly);
          for (auto pin = pin_block_name_map.begin(); pin != pin_block_name_map.end(); ++pin)
            _pin_block_name_map.insert(
                std::pair<subdomain_id_type, std::vector<std::vector<std::string>>>(pin->first,
                                                                                    pin->second));
 
          // Define background and duct region ID map from constituent assemblies
          if (_background_region_id_map.find(assembly_type) == _background_region_id_map.end())
          {
            // Store region ids and block names associated with duct and background regions for each
            // assembly, in case block names need to be recovered from region ids after
            // multiple assemblies have been stitched together into a core
            std::vector<subdomain_id_type> background_region_ids =
                getMeshProperty<std::vector<subdomain_id_type>>(RGMB::background_region_id,
                                                                assembly);
            std::vector<std::vector<subdomain_id_type>> duct_region_ids =
                getMeshProperty<std::vector<std::vector<subdomain_id_type>>>(RGMB::duct_region_ids,
                                                                             assembly);
            _background_region_id_map.insert(
                std::pair<subdomain_id_type, std::vector<subdomain_id_type>>(
                    assembly_type, background_region_ids));
            _duct_region_id_map.insert(
                std::pair<subdomain_id_type, std::vector<std::vector<subdomain_id_type>>>(
                    assembly_type, duct_region_ids));
 
            std::vector<std::string> background_block_names =
                getMeshProperty<std::vector<std::string>>(RGMB::background_block_name, assembly);
            std::vector<std::vector<std::string>> duct_block_names =
                getMeshProperty<std::vector<std::vector<std::string>>>(RGMB::duct_block_names,
                                                                       assembly);
            _background_block_name_map.insert(
                std::pair<subdomain_id_type, std::vector<std::string>>(assembly_type,
                                                                       background_block_names));
            _duct_block_name_map.insert(
                std::pair<subdomain_id_type, std::vector<std::vector<std::string>>>(
                    assembly_type, duct_block_names));
          }
        }
        else
        {
          // For control drum structures, store region ID and block name information of drum regions
          const auto & drum_region_ids =
              getMeshProperty<std::vector<std::vector<subdomain_id_type>>>(RGMB::drum_region_ids,
                                                                           assembly);
          _drum_region_id_map.insert(
              std::pair<subdomain_id_type, std::vector<std::vector<subdomain_id_type>>>(
                  assembly_type, drum_region_ids));
          std::vector<std::vector<std::string>> drum_block_names =
              getMeshProperty<std::vector<std::vector<std::string>>>(RGMB::drum_block_names,
                                                                     assembly);
          _drum_block_name_map.insert(
              std::pair<subdomain_id_type, std::vector<std::vector<std::string>>>(
                  assembly_type, drum_block_names));
        }
      }
    }
 
    // periphery meshing
    if (_mesh_periphery)
    {
      std::string periphery_mg_name = (_periphery_meshgenerator == "triangle")
                                          ? "PeripheralTriangleMeshGenerator"
                                          : "PeripheralRingMeshGenerator";
 
      // set up common options
      auto params = _app.getFactory().getValidParams(periphery_mg_name);
      params.set<MeshGeneratorName>("input") = name() + "_delbds";
      params.set<Real>("peripheral_ring_radius") = _outer_circle_radius;
      params.set<BoundaryName>("external_boundary_name") = "outside_periphery";
      params.set<SubdomainName>("peripheral_ring_block_name") = RGMB::PERIPHERAL_RING_BLOCK_NAME;
 
      // unique MG options
      if (_periphery_meshgenerator == "triangle")
      {
        params.set<unsigned int>("peripheral_ring_num_segments") = _outer_circle_num_segments;
        params.set<Real>("desired_area") = _desired_area;
        params.set<std::string>("desired_area_func") = _desired_area_func;
      }
      else if (_periphery_meshgenerator == "quad_ring")
      {
        params.set<subdomain_id_type>("peripheral_ring_block_id") = RGMB::PERIPHERAL_RING_BLOCK_ID;
        params.set<BoundaryName>("input_mesh_external_boundary") = RGMB::CORE_BOUNDARY_NAME;
        params.set<unsigned int>("peripheral_layer_num") = _periphery_num_layers;
      }
 
      // finish periphery input
      build_mesh_name = name() + "_periphery";
      addMeshSubgenerator(periphery_mg_name, build_mesh_name, params);
    }
 
    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");
 
  // If we are in CSG only mode, store the CSGBase objects associated with input MG's
  if (_app.getMeshGeneratorSystem().getCSGOnly())
    _input_csg_bases = getCSGBases("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 130 of file ReactorGeometryMeshBuilderBase.C.

{
  // 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()));
}

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

◆ addDepletionIDParams()

void ReactorGeometryMeshBuilderBase::addDepletionIDParams ( InputParameters & parameters )

staticinherited

Definition at line 35 of file ReactorGeometryMeshBuilderBase.C.

{
  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");
}

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

◆ callExtrusionMeshSubgenerators()

MeshGeneratorName ReactorGeometryMeshBuilderBase::callExtrusionMeshSubgenerators ( const MeshGeneratorName input_mesh_name )

protectedinherited

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

Parameters

input_mesh_name name of input 2D mesh generator to extrude

Returns: name of final output 3D mesh generator

Definition at line 187 of file ReactorGeometryMeshBuilderBase.C.

{
  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;
}

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

◆ constituentAssembliesNeedFlexibleStiching()

bool CoreMeshGenerator::constituentAssembliesNeedFlexibleStiching ( )

protected

Definition at line 615 of file CoreMeshGenerator.C.

{
  MeshGeneratorName first_nondummy_assembly = "";
  bool assembly_homogenization = false;
  unsigned int n_constituent_pins = 0;
  unsigned int n_pin_sectors = 0;
 
  // Loop through all non-dummy input assemblies. Flexible assembly stitching is needed if one of
  // the following criteria are met:
  // 1. The number of constituent pins within the assembly does not match with another assembly
  // 2. The value of is_single_pin and is_homogenized metadata do not agree with another assembly
  // 3. The number of sectors of the constituent pins of an assembly do not match with the
  // constituent pins of another assembly
  for (const auto i : index_range(_inputs))
  {
    // Skip if assembly name is equal to dummy assembly name
    if (_inputs[i] == _empty_key)
      continue;
 
    // Compute total number of constituent pins in assembly, as well as the number of sectors per
    // side for each pin Note: number of sectors per side is defined uniformly across constituent
    // pins of an assembly, so only first one needs to be checked
    unsigned int total_pins = 0;
    unsigned int pin_sectors_per_side = 0;
    if (!getMeshProperty<bool>(RGMB::is_single_pin, _inputs[i]))
    {
      const auto first_pin_name =
          getMeshProperty<std::vector<std::string>>(RGMB::pin_names, _inputs[i])[0];
      pin_sectors_per_side = getMeshProperty<std::vector<unsigned int>>("num_sectors_per_side_meta",
                                                                        first_pin_name + "_2D")[0];
      const auto pin_lattice =
          getMeshProperty<std::vector<std::vector<int>>>(RGMB::pin_lattice, _inputs[i]);
      for (const auto i : index_range(pin_lattice))
        total_pins += pin_lattice[i].size();
    }
    else
    {
      if (getMeshProperty<bool>(RGMB::is_homogenized, _inputs[i]))
      {
        // Homogenized assembly
        total_pins = 0;
        pin_sectors_per_side = 0;
      }
      else
      {
        // Assembly with single constituent pin
        total_pins = 1;
        pin_sectors_per_side = getMeshProperty<std::vector<unsigned int>>(
            "num_sectors_per_side_meta", _inputs[i] + "_2D")[0];
      }
    }
 
    if (first_nondummy_assembly == "")
    {
      first_nondummy_assembly = MeshGeneratorName(_inputs[i]);
      assembly_homogenization = getMeshProperty<bool>(RGMB::is_homogenized, _inputs[i]);
      n_constituent_pins = total_pins;
      n_pin_sectors = pin_sectors_per_side;
    }
    else
    {
      if (getMeshProperty<bool>(RGMB::is_homogenized, _inputs[i]) != assembly_homogenization)
      {
        mooseWarning("Detected mix of homogenized and heterogeneous assemblies between " +
                     first_nondummy_assembly + " and " + _inputs[i]);
        return true;
      }
      if (total_pins != n_constituent_pins)
      {
        mooseWarning(
            "Detected assemblies with different number of total constituent pins between " +
            first_nondummy_assembly + " and " + _inputs[i]);
        return true;
      }
      if (pin_sectors_per_side != n_pin_sectors)
      {
        mooseWarning("Constituent pins in " + first_nondummy_assembly + " and " + _inputs[i] +
                     " differ in terms of number of sectors per side");
        return true;
      }
    }
  }
  return false;
}

Referenced by CoreMeshGenerator().

◆ createRGMBLattice()

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

protectedinherited

Create CSG lattice for assembly and core lattices.

This method does not set the outer universe of the lattice

Parameters

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

Definition at line 311 of file ReactorGeometryMeshBuilderBase.C.

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

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

◆ freeReactorParamsCSG()

void ReactorGeometryMeshBuilderBase::freeReactorParamsCSG ( )

protectedinherited

Releases the CSG base object obtained in _reactor_params_csg.

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

Definition at line 81 of file ReactorGeometryMeshBuilderBase.C.

{
  _reactor_params_csg->reset();
}

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

◆ freeReactorParamsMesh()

void ReactorGeometryMeshBuilderBase::freeReactorParamsMesh ( )

protectedinherited

Releases the mesh obtained in _reactor_params_mesh.

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

Definition at line 75 of file ReactorGeometryMeshBuilderBase.C.

{
  _reactor_params_mesh->reset();
}

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

◆ generate()

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

overridevirtual

Implements MeshGenerator.

Definition at line 701 of file CoreMeshGenerator.C.

{
  // Must be called to free the ReactorMeshParams mesh
  freeReactorParamsMesh();
 
  // If bypass_mesh is true, return a null mesh. In this mode, an output mesh is not
  // generated and only metadata is defined on the generator, so logic related to
  // generation of output mesh will not be called
  if (getReactorParam<bool>(RGMB::bypass_meshgen))
  {
    auto null_mesh = nullptr;
    return null_mesh;
  }
  // This generate() method will be called once the subgenerators that we depend on are
  // called. This is where we reassign subdomain ids/names in case they were merged
  // when stitching assemblies into the core. This is also where we set region_id extra
  // element integers, which has not been set yet for extruded geometries
 
  // Define all extra element names and integers
  std::string pin_type_id_name = "pin_type_id";
  std::string assembly_type_id_name = "assembly_type_id";
  std::string plane_id_name = "plane_id";
  std::string region_id_name = "region_id";
  std::string radial_id_name = "radial_id";
  const std::string default_block_name = RGMB::CORE_BLOCK_NAME_PREFIX;
 
  auto pin_type_id_int = getElemIntegerFromMesh(*(*_build_mesh), pin_type_id_name, true);
  auto assembly_type_id_int = getElemIntegerFromMesh(*(*_build_mesh), assembly_type_id_name, true);
  auto radial_id_int = getElemIntegerFromMesh(*(*_build_mesh), radial_id_name, true);
  auto region_id_int = getElemIntegerFromMesh(*(*_build_mesh), region_id_name, true);
  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 assembly stitching
  for (auto & elem : (*_build_mesh)->active_element_ptr_range())
  {
    dof_id_type z_id = _extrude ? elem->get_extra_integer(plane_id_int) : 0;
    dof_id_type pin_type_id = elem->get_extra_integer(pin_type_id_int);
 
    if (_pin_region_id_map.find(pin_type_id) != _pin_region_id_map.end())
    {
      // Pin type element, 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 if ((*_build_mesh)->subdomain_name(elem->subdomain_id()) ==
             RGMB::PERIPHERAL_RING_BLOCK_NAME)
    // periphery type element
    {
      // set region ID of core periphery element
      elem->set_extra_integer(region_id_int, _periphery_region_id);
      // set block name and block name of core periphery element
      auto elem_block_name = _periphery_block_name;
      if (getReactorParam<bool>(RGMB::region_id_as_block_name))
        elem_block_name += "_REG" + std::to_string(_periphery_region_id);
      if (elem->type() == TRI3 || elem->type() == PRISM6)
        elem_block_name += RGMB::TRI_BLOCK_NAME_SUFFIX;
      updateElementBlockNameId(
          *(*_build_mesh), elem, rgmb_name_id_map, elem_block_name, next_block_id);
    }
    else
    {
      dof_id_type assembly_type_id = elem->get_extra_integer(assembly_type_id_int);
      // Infer peripheral index of assembly background, assembly duct, or control drum regions from
      // pin_type_id
      unsigned int peripheral_idx = RGMB::MAX_PIN_TYPE_ID - pin_type_id;
 
      // check if element is part of drum region
      if (_drum_region_id_map.find(assembly_type_id) != _drum_region_id_map.end())
      {
        // Element is in a control drum region. Infer region id from assembly_type_id, z_id, and
        // peripheral_index
        const auto elem_rid = _drum_region_id_map[assembly_type_id][z_id][peripheral_idx];
        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
        {
          bool has_drum_block_name = !_drum_block_name_map[assembly_type_id].empty();
          if (has_drum_block_name)
            elem_block_name += "_" + _drum_block_name_map[assembly_type_id][z_id][peripheral_idx];
        }
        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
      {
        // Element is in an assembly duct or background region since it doesn't
        // have an assembly type id in the drum region map. Infer region id from
        // assembly_type_id, z_id, and peripheral_index
        bool is_background_region = peripheral_idx == 0;
        const auto elem_rid =
            (is_background_region
                 ? _background_region_id_map[assembly_type_id][z_id]
                 : _duct_region_id_map[assembly_type_id][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)
          {
            bool has_background_block_name = !_background_block_name_map[assembly_type_id].empty();
            if (has_background_block_name)
              elem_block_name += "_" + _background_block_name_map[assembly_type_id][z_id];
          }
          else
          {
            bool has_duct_block_names = !_duct_block_name_map[assembly_type_id].empty();
            if (has_duct_block_names)
              elem_block_name +=
                  "_" + _duct_block_name_map[assembly_type_id][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);
      }
    }
  }
 
  // Sideset 10000 does not get stitched properly when BlockDeletionGenerator
  // is used for deleting dummy assemblies. This block copies missing sides
  // into sideset 10000 from sideset RGMB::CORE_BOUNDARY_NAME
  BoundaryInfo & boundary_info = (*_build_mesh)->get_boundary_info();
  boundary_id_type source_id =
      MooseMeshUtils::getBoundaryIDs(**_build_mesh, {RGMB::CORE_BOUNDARY_NAME}, true)[0];
  boundary_id_type target_id = 10000;
  const auto sideset_map = boundary_info.get_sideset_map();
 
  for (const auto & [elem, id_pair] : sideset_map)
  {
    const auto side_id = id_pair.first;
    const auto sideset_id = id_pair.second;
 
    // Filter all sides that belong to RGMB::CORE_BOUNDARY_NAME sideset
    if (sideset_id == source_id)
    {
      auto mm_it = sideset_map.equal_range(elem);
      bool found = false;
      // Check if side is defined in sideset 10000
      for (auto it = mm_it.first; it != mm_it.second; it++)
      {
        if (it->second.first == side_id && it->second.second == target_id)
          found = true;
      }
      // Add side if not found in sideset 10000
      if (!found)
        boundary_info.add_side(elem, side_id, target_id);
    }
  }
 
  if (getParam<bool>("generate_depletion_id"))
  {
    const MooseEnum option = getParam<MooseEnum>("depletion_id_type");
    addDepletionId(*(*_build_mesh), option, DepletionIDGenerationLevel::Core, _extrude);
  }
 
  // Mark mesh as not prepared, as block ID's were re-assigned in this method
  (*_build_mesh)->unset_is_prepared();
 
  return std::move(*_build_mesh);
}

◆ generateCSG()

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

overridevirtual

Reimplemented from MeshGenerator.

Definition at line 894 of file CoreMeshGenerator.C.

{
  // Must be called to free the ReactorMeshParams CSGBase object
  freeReactorParamsCSG();
 
  auto csg_obj = std::make_unique<CSG::CSGBase>();
 
  const auto dummy_univ_name = _empty_key + "_univ";
  if (_empty_pos || !_mesh_periphery)
  {
    // Create universe with a single void cell with an empty region. This universe is used for
    // defining dummy assemblies in the core lattice and the lattce outer universe for lattices
    // that do not have a mesh periphery
    const auto dummy_cell_name = _empty_key + "_cell";
    const auto & dummy_univ = csg_obj->createUniverse(dummy_univ_name);
    CSG::CSGRegion empty_region;
    csg_obj->createCell(dummy_cell_name, empty_region, &dummy_univ);
  }
 
  // Combine all bases from AssemblyMG inputs into this base. We expect each AssemblyMG
  // input to contain a root universe with a single cell that constrains the assembly based
  // on the FEM boundary. Root universes from inputs are renamed to a new universe name.
  // These universes and their cells will be discarded, so that only the infinite assembly
  // universes are retained.
  std::unordered_map<unsigned int, std::string> univ_id_names;
  std::vector<std::string> univs_to_discard;
  for (const auto i : index_range(_inputs))
  {
    if (_inputs[i] == _empty_key)
      univ_id_names[i] = dummy_univ_name;
    else
    {
      const auto input_univ_name_discard = _inputs[i] + "_root_univ";
      const auto input_univ_name = _inputs[i] + "_univ";
      csg_obj->joinOtherBase(std::move(*_input_csg_bases[i]), true, input_univ_name_discard);
      univs_to_discard.push_back(input_univ_name_discard);
      univ_id_names[i] = input_univ_name;
    }
  }
 
  // Discard root universes of the input assemblies and their cells
  for (const auto & univ_name : univs_to_discard)
  {
    const auto & universe_to_delete = csg_obj->getUniverseByName(univ_name);
    const auto cells_to_delete = universe_to_delete.getAllCells();
    csg_obj->deleteUniverse(universe_to_delete);
    for (const auto & cell : cells_to_delete)
      csg_obj->deleteCell(cell.get());
  }
 
  // Build the universe pattern for the assembly lattice from the input pattern
  std::vector<std::vector<std::reference_wrapper<const CSG::CSGUniverse>>> universe_pattern;
  for (const auto & row : _pattern)
  {
    std::vector<std::reference_wrapper<const CSG::CSGUniverse>> universe_row;
    for (const auto & univ_id : row)
    {
      const auto & lattice_univ = csg_obj->getUniverseByName(univ_id_names[univ_id]);
      universe_row.push_back(lattice_univ);
    }
    universe_pattern.push_back(universe_row);
  }
 
  const auto assembly_pitch = getReactorParam<Real>(RGMB::assembly_pitch);
  auto & core_lattice = createRGMBLattice(assembly_pitch, universe_pattern, *csg_obj);
 
  // Define universe that fills region outside of lattice. For an explicity
  // defined outer ring, this is a material outer corresponding to the region ID
  // of the ring region. Otherwise, the outer is defined as a universe containing a void cell
  if (_mesh_periphery)
  {
    std::string region_name = "rgmb_region_" + std::to_string(_periphery_region_id);
    csg_obj->setLatticeOuter(core_lattice, region_name);
  }
  else
  {
    const auto & outer_univ = csg_obj->getUniverseByName(dummy_univ_name);
    csg_obj->setLatticeOuter(core_lattice, outer_univ);
  }
 
  // Define lattice cell, with the lattice surrounded by a bounding circle whose radius is
  // determined by the mesh periphery radius. If no mesh periphery is defined, the radius will be (N
  // + 1) times the assembly pitch of the lattice for hex lattices, where N is the number of rings
  // for a hexagonal lattice. For Cartesian lattices, the radius will be (N / 2 * sqrt(2)) times the
  // assembly pitch, where N is the number of assembly widths that span a square lattice. This
  // ensures that the ring radius completely surrounds the underlying lattice.
  std::string lat_cell_name = name() + "_lattice_cell";
  const auto ring_radius = _mesh_periphery ? _outer_circle_radius
                           : (_geom_type == "Hex")
                               ? (universe_pattern.size() + 2) / 2. * assembly_pitch
                               : universe_pattern.size() / 2. * sqrt(2.) * assembly_pitch;
  const auto ring_surf_name = name() + "_radial_ring";
  std::unique_ptr<CSG::CSGSurface> ring_surf_ptr =
      std::make_unique<CSG::CSGZCylinder>(ring_surf_name, 0, 0, ring_radius);
  const auto & ring_surf = csg_obj->addSurface(std::move(ring_surf_ptr));
  auto lat_cell_region = -ring_surf;
 
  if (_mesh_dimensions == 3)
  {
    const auto surfaces_by_axial_region = getAxialPlaneSurfaces(*csg_obj);
    const auto & lowest_axial_surf = surfaces_by_axial_region.front().get();
    const auto & highest_axial_surf = surfaces_by_axial_region.back().get();
    lat_cell_region = lat_cell_region & +lowest_axial_surf & -highest_axial_surf;
  }
  csg_obj->createCell(lat_cell_name, core_lattice, lat_cell_region);
 
  return csg_obj;
}

◆ generateData()

void ReactorGeometryMeshBuilderBase::generateData ( )

inlineoverridevirtualinherited

Reimplemented from MeshGenerator.

Definition at line 119 of file ReactorGeometryMeshBuilderBase.h.

119{};

◆ generateMetadata()

void CoreMeshGenerator::generateMetadata ( )

protected

Definition at line 553 of file CoreMeshGenerator.C.

{
  // Define metadata related to downstream function calls
  if (_mesh_periphery)
  {
    declareMeshProperty(RGMB::peripheral_ring_radius, _outer_circle_radius);
    declareMeshProperty(RGMB::peripheral_ring_region_id, _periphery_region_id);
  }
 
  // Determine constituent pin type ids and define lattice
  std::vector<std::vector<int>> assembly_name_lattice;
  std::vector<std::string> input_assembly_names;
  std::vector<std::string> input_pin_names;
 
  // Iterate through input assembly names and define constituent assemblies and pins
  for (const auto i : index_range(_inputs))
  {
    const auto input_assembly_name = _inputs[i];
    if (input_assembly_name != _empty_key)
    {
      input_assembly_names.push_back(input_assembly_name);
      if (!getMeshProperty<bool>(RGMB::is_control_drum, input_assembly_name) &&
          !getMeshProperty<bool>(RGMB::is_single_pin, input_assembly_name))
      {
        const auto pin_names =
            getMeshProperty<std::vector<std::string>>(RGMB::pin_names, input_assembly_name);
        for (const auto & pin_name : pin_names)
          if (std::find(input_pin_names.begin(), input_pin_names.end(), pin_name) ==
              input_pin_names.end())
            input_pin_names.push_back(pin_name);
      }
    }
  }
 
  // Iterate through pattern and remap dummy assemblies with index -1
  for (const auto i : index_range(_pattern))
  {
    std::vector<int> assembly_name_idx(_pattern[i].size());
    for (const auto j : index_range(_pattern[i]))
    {
      const auto input_assembly_name = _inputs[_pattern[i][j]];
      // Use an assembly type of -1 to represent a dummy assembly
      if (input_assembly_name == _empty_key)
        assembly_name_idx[j] = -1;
      // Set index of assembly name based on `input_assembly_names` variable
      else
      {
        const auto it = std::find(
            input_assembly_names.begin(), input_assembly_names.end(), input_assembly_name);
        assembly_name_idx[j] = it - input_assembly_names.begin();
      }
    }
    assembly_name_lattice.push_back(assembly_name_idx);
  }
 
  declareMeshProperty(RGMB::pin_names, input_pin_names);
  declareMeshProperty(RGMB::assembly_names, input_assembly_names);
  declareMeshProperty(RGMB::assembly_lattice, assembly_name_lattice);
  declareMeshProperty(RGMB::extruded, _extrude && _mesh_dimensions == 3);
}

Referenced by CoreMeshGenerator().

◆ getAxialPlaneSurfaces()

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

protectedinherited

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

Parameters

csg_obj Reference to CSGBase object for adding defined surfaces to

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

Definition at line 279 of file ReactorGeometryMeshBuilderBase.C.

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

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

◆ getElemIntegerFromMesh()

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

protectedinherited

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

Parameters

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

Returns: extra element integer

Definition at line 87 of file ReactorGeometryMeshBuilderBase.C.

{
  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);
  }
}

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

◆ getOuterRadialSurfacesForUnitCell()

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

protectedinherited

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

Parameters

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

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

Definition at line 240 of file ReactorGeometryMeshBuilderBase.C.

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

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

◆ getReactorParam()

template<typename T >

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

protectedinherited

Returns reference of parameter in ReactorMeshParams object.

Template Parameters

T	datatype of metadata value associated with metadata name

Parameters

param_name name of ReactorMeshParams parameter

Returns: reference to parameter defined in ReactorMeshParams metadata

Definition at line 330 of file ReactorGeometryMeshBuilderBase.h.

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

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

◆ hasReactorParam()

template<typename T >

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

protectedinherited

Checks whether parameter is defined in ReactorMeshParams metadata.

Template Parameters

T	datatype of metadata value associated with metadata name

Parameters

param_name name of ReactorMeshParams parameter

Returns: whether parameter is defined in ReactorMeshParams metadata

Definition at line 323 of file ReactorGeometryMeshBuilderBase.h.

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

◆ initializeReactorMeshParams()

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

protectedinherited

Initializes and checks validity of ReactorMeshParams mesh generator object.

Parameters

reactor_param_name name of ReactorMeshParams mesh generator

Definition at line 52 of file ReactorGeometryMeshBuilderBase.C.

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

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

◆ print2dMetadataToConsole()

template<typename T >

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

protectedinherited

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

Template Parameters

T	datatype of elements in 2-D vector to output

Parameters

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

◆ printAssemblyMetadata()

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

protectedinherited

Print assembly-level metadata associated with ReactorGeometryMeshBuilder object.

Parameters

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

◆ printCoreMetadata()

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

protectedinherited

Print core-level metadata associated with ReactorGeometryMeshBuilder object.

Parameters

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

◆ printGlobalReactorMetadata()

void ReactorGeometryMeshBuilderBase::printGlobalReactorMetadata ( )

protectedinherited

Print global ReactorMeshParams metadata associated with ReactorGeometryMeshBuilder object.

◆ printMetadataToConsole()

template<typename T >

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

protectedinherited

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

Template Parameters

T	datatype of metadata value to output

Parameters

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

◆ printPinMetadata()

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

protectedinherited

Print pin-level metadata associated with ReactorGeometryMeshBuilder object.

Parameters

mg_name name of mesh generator associated with assembly

◆ printReactorMetadata()

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

protectedinherited

Print metadata associated with ReactorGeometryMeshBuilder object.

Parameters

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

◆ updateElementBlockNameId()

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

protectedinherited

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

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

Parameters

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

Definition at line 103 of file ReactorGeometryMeshBuilderBase.C.

{
  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.set_subdomain_name(elem_block_id, elem_block_name);
    name_id_map[elem_block_name] = elem_block_id;
  }
  else
  {
    // Block name exists in mesh, reuse block id
    elem_block_id = name_id_map[elem_block_name];
    elem->subdomain_id() = elem_block_id;
  }
 
  input_mesh.unset_has_cached_elem_data();
}

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

◆ validParams()

InputParameters CoreMeshGenerator::validParams ( )

static

Definition at line 21 of file CoreMeshGenerator.C.

{
  auto params = ReactorGeometryMeshBuilderBase::validParams();
 
  params.addRequiredParam<std::vector<MeshGeneratorName>>(
      "inputs",
      "The AssemblyMeshGenerator and ControlDrumMeshGenerator objects that form the components of "
      "the assembly.");
 
  params.addParam<std::string>(
      "dummy_assembly_name",
      "dummy",
      "The place holder name in \"inputs\" that indicates an empty position.");
 
  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 assemblies in the core lattice.");
  params.addParam<bool>(
      "mesh_periphery", false, "Determines if the core periphery should be meshed.");
  MooseEnum periphery_mesher("triangle quad_ring", "triangle");
  params.addParam<MooseEnum>("periphery_generator",
                             periphery_mesher,
                             "The meshgenerator to use when meshing the core boundary.");
 
  // Periphery meshing interface
  params.addRangeCheckedParam<Real>(
      "outer_circle_radius", 0, "outer_circle_radius>=0", "Radius of outer circle boundary.");
  params.addRangeCheckedParam<unsigned int>(
      "outer_circle_num_segments",
      0,
      "outer_circle_num_segments>=0",
      "Number of radial segments to subdivide outer circle boundary.");
  params.addRangeCheckedParam<unsigned int>(
      "periphery_num_layers",
      1,
      "periphery_num_layers>0",
      "Number of layers to subdivide the periphery boundary.");
  params.addParam<std::string>(
      "periphery_block_name", RGMB::CORE_BLOCK_NAME_PREFIX, "Block name for periphery zone.");
  params.addParam<subdomain_id_type>(
      "periphery_region_id",
      -1,
      "ID for periphery zone for assignment of region_id extra element id.");
  params.addRangeCheckedParam<Real>(
      "desired_area",
      0,
      "desired_area>=0",
      "Desired (maximum) triangle area, or 0 to skip uniform refinement");
  params.addParam<std::string>(
      "desired_area_func",
      std::string(),
      "Desired (local) triangle area as a function of x,y; omit to skip non-uniform refinement");
  params.addParam<bool>("assign_control_drum_id",
                        true,
                        "Whether control drum id is assigned to the mesh as an extra integer.");
  params.addParamNamesToGroup("periphery_block_name periphery_region_id outer_circle_radius "
                              "mesh_periphery periphery_generator",
                              "Periphery Meshing");
  params.addParamNamesToGroup("outer_circle_num_segments desired_area desired_area_func",
                              "Periphery Meshing: PTMG specific");
  params.addParamNamesToGroup("periphery_num_layers", "Periphery Meshing: PRMG specific");
  // end meshing interface
 
  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.addClassDescription(
      "This CoreMeshGenerator object is designed to generate a core-like "
      "structure, with IDs, from a reactor geometry. "
      "The core-like structure consists of a pattern of assembly-like "
      "structures generated with AssemblyMeshGenerator and/or ControlDrumMeshGenerator "
      "and is permitted to have \"empty\" locations. The size and spacing "
      "of the assembly-like structures is defined, and "
      "enforced by declaration in the ReactorMeshParams.");
  // depletion id generation params are added
  addDepletionIDParams(params);
 
  // Declare that this generator has a generateCSG method
  MeshGenerator::setHasGenerateCSG(params);
 
  return params;
}

Member Data Documentation

◆ _background_block_name_map

std::map<subdomain_id_type, std::vector<std::string> > CoreMeshGenerator::_background_block_name_map

protected

A mapping from assembly-type IDs to block names in the assembly background regions used when assigning block names during the assembly stitching stage.

Definition at line 94 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator(), and generate().

◆ _background_region_id_map

std::map<subdomain_id_type, std::vector<subdomain_id_type> > CoreMeshGenerator::_background_region_id_map

protected

A mapping from assembly-type IDs to region IDs in the assembly background regions used when assigning region IDs during the assembly stitching stage.

Definition at line 91 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator(), and generate().

◆ _build_mesh

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

Referenced by CoreMeshGenerator(), and generate().

◆ _desired_area

const Real CoreMeshGenerator::_desired_area

protected

Desired (maximum) triangle area.

Definition at line 71 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator().

◆ _desired_area_func

std::string CoreMeshGenerator::_desired_area_func

protected

Desired (local) triangle area as a function of (x,y)

Definition at line 73 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator().

◆ _drum_block_name_map

std::map<subdomain_id_type, std::vector<std::vector<std::string> > > CoreMeshGenerator::_drum_block_name_map

protected

A mapping from assembly-type IDs to block names in the drum regions used when assigning block names during the assembly stitching stage.

Definition at line 100 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator(), and generate().

◆ _drum_region_id_map

std::map<subdomain_id_type, std::vector<std::vector<subdomain_id_type> > > CoreMeshGenerator::_drum_region_id_map

protected

A mapping from assembly-type IDs to region IDs in the drum regions used when assigning region IDs during the assembly stitching stage.

Definition at line 97 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator(), and generate().

◆ _duct_block_name_map

std::map<subdomain_id_type, std::vector<std::vector<std::string> > > CoreMeshGenerator::_duct_block_name_map

protected

A mapping from assembly-type IDs to block names in the assembly duct regions used when assigning block names during the assembly stitching stage.

Definition at line 88 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator(), and generate().

◆ _duct_region_id_map

std::map<subdomain_id_type, std::vector<std::vector<subdomain_id_type> > > CoreMeshGenerator::_duct_region_id_map

protected

A mapping from assembly-type IDs to region IDs in the assembly duct regions used when assigning region IDs during the assembly stitching stage.

Definition at line 85 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator(), and generate().

◆ _empty_key

const MeshGeneratorName CoreMeshGenerator::_empty_key

protected

The name of "filler" assembly given in the input to represent an empty space in the core pattern.

Definition at line 42 of file CoreMeshGenerator.h.

Referenced by constituentAssembliesNeedFlexibleStiching(), CoreMeshGenerator(), generateCSG(), and generateMetadata().

◆ _empty_pos

bool CoreMeshGenerator::_empty_pos = false

protected

Whether empty positions are to be used in the pattern.

Definition at line 45 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator(), and generateCSG().

◆ _extrude

const bool CoreMeshGenerator::_extrude

protected

Whether this mesh should be extruded to 3-D, the core is always assumed to be the last.

Definition at line 51 of file CoreMeshGenerator.h.

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

◆ _geom_type

std::string CoreMeshGenerator::_geom_type

protected

The geometry type for the reactor that is stored on the ReactorMeshParams object.

Definition at line 54 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator(), and generateCSG().

◆ _input_csg_bases

std::vector<std::unique_ptr<CSG::CSGBase> *> CoreMeshGenerator::_input_csg_bases

protected

List of pointers to all CSG bases created by input mesh generators.

Definition at line 107 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator(), and generateCSG().

◆ _inputs

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

protected

The names of the assemblies that compose the core.

Definition at line 39 of file CoreMeshGenerator.h.

Referenced by constituentAssembliesNeedFlexibleStiching(), CoreMeshGenerator(), generateCSG(), and generateMetadata().

◆ _mesh_dimensions

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

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

◆ _mesh_periphery

const bool CoreMeshGenerator::_mesh_periphery

protected

Whether the core periphery should be meshed.

Definition at line 57 of file CoreMeshGenerator.h.

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

◆ _outer_circle_num_segments

const unsigned int CoreMeshGenerator::_outer_circle_num_segments

protected

Number of segments in the outer circle boundary.

Definition at line 65 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator().

◆ _outer_circle_radius

const Real CoreMeshGenerator::_outer_circle_radius

protected

outer circle boundary radius

Definition at line 63 of file CoreMeshGenerator.h.

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

◆ _pattern

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

protected

The 2D assembly layout of the core.

Definition at line 48 of file CoreMeshGenerator.h.

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

◆ _periphery_block_name

const std::string CoreMeshGenerator::_periphery_block_name

protected

The subdomain name for the generated mesh outer boundary.

Definition at line 67 of file CoreMeshGenerator.h.

Referenced by generate().

◆ _periphery_meshgenerator

const MooseEnum CoreMeshGenerator::_periphery_meshgenerator

protected

Which periphery meshgenerator to use.

Definition at line 59 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator().

◆ _periphery_num_layers

const unsigned int CoreMeshGenerator::_periphery_num_layers

protected

Number of periphery layers.

Definition at line 69 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator().

◆ _periphery_region_id

const subdomain_id_type CoreMeshGenerator::_periphery_region_id

protected

"region_id" extra-element integer of the periphery mesh elements

Definition at line 61 of file CoreMeshGenerator.h.

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

◆ _pin_block_name_map

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

protected

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

Definition at line 82 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator(), and generate().

◆ _pin_region_id_map

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

protected

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

Definition at line 79 of file CoreMeshGenerator.h.

Referenced by CoreMeshGenerator(), and generate().

◆ _reactor_params

MeshGeneratorName ReactorGeometryMeshBuilderBase::_reactor_params

protectedinherited

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

Definition at line 261 of file ReactorGeometryMeshBuilderBase.h.

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

◆ _reactor_params_csg

std::unique_ptr<CSG::CSGBase>* ReactorGeometryMeshBuilderBase::_reactor_params_csg

privateinherited

Definition at line 318 of file ReactorGeometryMeshBuilderBase.h.

Referenced by ReactorGeometryMeshBuilderBase::freeReactorParamsCSG(), and ReactorGeometryMeshBuilderBase::initializeReactorMeshParams().

◆ _reactor_params_mesh

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

privateinherited

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

Definition at line 317 of file ReactorGeometryMeshBuilderBase.h.

Referenced by ReactorGeometryMeshBuilderBase::freeReactorParamsMesh(), and ReactorGeometryMeshBuilderBase::initializeReactorMeshParams().

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

reactor/include/meshgenerators/CoreMeshGenerator.h
reactor/src/meshgenerators/CoreMeshGenerator.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 Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ DepletionIDGenerationLevel

Constructor & Destructor Documentation

◆ CoreMeshGenerator()

Member Function Documentation

◆ addDepletionId()

◆ addDepletionIDParams()

◆ callExtrusionMeshSubgenerators()

◆ constituentAssembliesNeedFlexibleStiching()

◆ createRGMBLattice()

◆ freeReactorParamsCSG()

◆ freeReactorParamsMesh()

◆ generate()

◆ generateCSG()

◆ generateData()

◆ generateMetadata()

◆ getAxialPlaneSurfaces()

◆ getElemIntegerFromMesh()

◆ getOuterRadialSurfacesForUnitCell()

◆ getReactorParam()

◆ hasReactorParam()

◆ initializeReactorMeshParams()

◆ print2dMetadataToConsole()

◆ printAssemblyMetadata()

◆ printCoreMetadata()

◆ printGlobalReactorMetadata()

◆ printMetadataToConsole()

◆ printPinMetadata()

◆ printReactorMetadata()

◆ updateElementBlockNameId()

◆ validParams()

Member Data Documentation

◆ _background_block_name_map

◆ _background_region_id_map

◆ _build_mesh

◆ _desired_area

◆ _desired_area_func

◆ _drum_block_name_map

◆ _drum_region_id_map

◆ _duct_block_name_map

◆ _duct_region_id_map

◆ _empty_key

◆ _empty_pos

◆ _extrude

◆ _geom_type

◆ _input_csg_bases

◆ _inputs

◆ _mesh_dimensions

◆ _mesh_periphery

◆ _outer_circle_num_segments

◆ _outer_circle_radius

◆ _pattern

◆ _periphery_block_name

◆ _periphery_meshgenerator

◆ _periphery_num_layers

◆ _periphery_region_id

◆ _pin_block_name_map

◆ _pin_region_id_map

◆ _reactor_params

◆ _reactor_params_csg

◆ _reactor_params_mesh