Assigns depletion IDs to elements based on reporting and material IDs. More...

#include <DepletionIDGenerator.h>

Inheritance diagram for DepletionIDGenerator:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	DepletionIDGenerator (const InputParameters &parameters)

virtual std::unique_ptr< MeshBase >	generate () override

std::unique_ptr< MeshBase >	generateInternal ()

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

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

void	addParentMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

void	addChildMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

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

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

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

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

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

bool	isNullMeshName (const MeshGeneratorName &name) const

bool	hasSaveMesh () const

bool	hasOutput () const

const std::string &	getSavedMeshName () const

bool	hasGenerateData () const

bool	isDataOnly () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

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

void	callMooseError (std::string msg, const bool with_prefix) const

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

const InputParameters &	parameters () const

MooseObjectName	uniqueName () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static bool	hasGenerateData (const InputParameters &params)

static void	setHasGenerateData (InputParameters &params)

Public Attributes
const ConsoleStream	_console

Static Public Attributes
static const std::string	data_only_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
virtual void	generateData ()

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

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

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

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

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

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

void	declareMeshForSub (const std::string &param_name)

void	declareMeshesForSub (const std::string &param_name)

void	declareMeshForSubByName (const MeshGeneratorName &mesh_generator_name)

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

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

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

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

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

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

void	declareNullMeshName (const MeshGeneratorName &name)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Protected Attributes
std::unique_ptr< MeshBase > &	_input
	input mesh for adding element IDs More...

ExtraElementIDName	_material_id_name
	material id name More...

MooseMesh *const	_mesh

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const Parallel::Communicator &	_communicator

Detailed Description

Assigns depletion IDs to elements based on reporting and material IDs.

Definition at line 16 of file DepletionIDGenerator.h.

Constructor & Destructor Documentation

◆ DepletionIDGenerator()

DepletionIDGenerator::DepletionIDGenerator ( const InputParameters & parameters )

Definition at line 39 of file DepletionIDGenerator.C.

   : MeshGenerator(params),
     _input(getMesh("input")),
     _material_id_name(getParam<ExtraElementIDName>("material_id_name"))
 {
 }

Member Function Documentation

◆ generate()

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

overridevirtual

Implements MeshGenerator.

Definition at line 47 of file DepletionIDGenerator.C.

 {
   std::unique_ptr<MeshBase> mesh = std::move(_input);
   // parsing the extra ids
   std::vector<ExtraElementIDName> id_names;
   id_names = getParam<std::vector<ExtraElementIDName>>("id_name");
   if (!mesh->has_elem_integer(_material_id_name))
     paramError("material_id_name",
                "Material ID name '",
                _material_id_name,
                "'is not defined in input mesh!");
   id_names.push_back(_material_id_name);
   auto parsed_ids = MooseMeshUtils::getExtraIDUniqueCombinationMap(*mesh, {}, id_names);
   // re-numbering if exclude_id_name is used
   if (isParamValid("exclude_id_name") && isParamValid("exclude_id_value"))
   {
     const auto exclude_id_name = getParam<std::vector<ExtraElementIDName>>("exclude_id_name");
     const auto & exclude_id_value =
         getParam<std::vector<std::vector<dof_id_type>>>("exclude_id_value");
     std::vector<unsigned int> id_index;
     std::vector<std::set<dof_id_type>> id_value_set;
     id_index.resize(exclude_id_name.size());
     id_value_set.resize(exclude_id_name.size());
     for (unsigned int i = 0; i < exclude_id_name.size(); ++i)
     {
       id_index[i] = mesh->get_elem_integer_index(exclude_id_name[i]);
       std::copy(exclude_id_value[i].begin(),
                 exclude_id_value[i].end(),
                 std::inserter(id_value_set[i], id_value_set[i].end()));
     }
     // list of unique IDs not removed by "exclude_id_name" and "exclude_id_value" option
     std::set<dof_id_type> ids;
     for (const auto & elem : mesh->active_element_ptr_range())
     {
       // don't need to check if this unique parsed ID corresponding to this element is already in
       // the "ids"
       if (ids.count(parsed_ids[elem->id()]))
         continue;
       // check extra IDs of this element is defined in  "exclude_id_name" and "exclude_id_value"
       bool is_exclude_elem = false;
       for (unsigned int i = 0; i < id_index.size(); ++i)
       {
         const auto id = elem->get_extra_integer(id_index[i]);
         if (id_value_set[i].count(id))
         {
           is_exclude_elem = true;
           break;
         }
       }
       // if this element does not need to be excluded, having unique ID, add to "ids"
       if (!is_exclude_elem)
         ids.insert(parsed_ids[elem->id()]);
     }
     comm().set_union(ids);
 
     std::map<dof_id_type, dof_id_type> map_ids;
     for (auto id : parsed_ids)
     {
       dof_id_type new_id = std::distance(ids.begin(), ids.find(id.second)) + 1;
       map_ids[id.second] = new_id;
     }
 
     // reassign parsed (depletion) ids
     for (const auto & elem : mesh->active_element_ptr_range())
     {
       dof_id_type id = parsed_ids[elem->id()];
       dof_id_type new_id = 0;
       if (ids.count(id))
         new_id = map_ids[id];
       parsed_ids[elem->id()] = new_id;
     }
   }
   // assign depletion id to mesh
   const auto depletion_id =
       mesh->add_elem_integer(getParam<ExtraElementIDName>("generated_id_name"));
   for (Elem * const elem : mesh->active_element_ptr_range())
     elem->set_extra_integer(depletion_id, parsed_ids.at(elem->id()));
   return mesh;
 }

◆ validParams()

InputParameters DepletionIDGenerator::validParams ( )

static

Definition at line 17 of file DepletionIDGenerator.C.

 {
   InputParameters params = MeshGenerator::validParams();
   params.addRequiredParam<MeshGeneratorName>(
       "input", "Name of an existing mesh generator to which we assign element IDs");
   params.addParam<std::vector<ExtraElementIDName>>("id_name", "Extra integer id names");
   params.addParam<ExtraElementIDName>("material_id_name", "material_id", "Material id name");
   params.addParam<std::vector<dof_id_type>>(
       "exclude_material_id",
       "Define a list of material IDs to be excluded in the depletion ID generation");
   params.addParam<std::vector<ExtraElementIDName>>(
       "exclude_id_name", "Extra ID names that need to be excluded in the depletion ID generation");
   params.addParam<std::vector<std::vector<dof_id_type>>>(
       "exclude_id_value", "Extra ID values corresponding to names defined in `exclude_id_name`");
   params.addParam<ExtraElementIDName>(
       "generated_id_name", "depletion_id", "The generated extra element integer name");
   params.addClassDescription(
       "This DepletionIDGenerator source code is to assign an extra element integer for "
       "elements on a mesh based on material and other extra element IDs that is typically used for "
       "depletion.");
   return params;
 }

Member Data Documentation

◆ _input

std::unique_ptr<MeshBase>& DepletionIDGenerator::_input

protected

input mesh for adding element IDs

Definition at line 26 of file DepletionIDGenerator.h.

Referenced by generate().

◆ _material_id_name

ExtraElementIDName DepletionIDGenerator::_material_id_name

protected

material id name

Definition at line 28 of file DepletionIDGenerator.h.

Referenced by generate().

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

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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes