diff --git a/modules/reactor/include/meshgenerators/CartesianIDPatternedMeshGenerator.h b/modules/reactor/include/meshgenerators/CartesianIDPatternedMeshGenerator.h index fc69e8ba7078..2b29cf7fafef 100644 --- a/modules/reactor/include/meshgenerators/CartesianIDPatternedMeshGenerator.h +++ b/modules/reactor/include/meshgenerators/CartesianIDPatternedMeshGenerator.h @@ -25,12 +25,6 @@ class CartesianIDPatternedMeshGenerator : public PatternedMeshGenerator std::unique_ptr generate() override; protected: - /// assign IDs for each component in lattice in sequential order - std::vector getCellwiseIntegerIDs() const; - /// assign IDs for each input component type - std::vector getPatternIntegerIDs() const; - /// Assign IDs based on user-defined mapping defined in id_pattern - std::vector getManualIntegerIDs() const; /// name of integer ID. const std::string _element_id_name; /// integer ID assignment type diff --git a/modules/reactor/include/meshgenerators/HexIDPatternedMeshGenerator.h b/modules/reactor/include/meshgenerators/HexIDPatternedMeshGenerator.h index 7e6927bb4520..13388ef7976b 100644 --- a/modules/reactor/include/meshgenerators/HexIDPatternedMeshGenerator.h +++ b/modules/reactor/include/meshgenerators/HexIDPatternedMeshGenerator.h @@ -26,17 +26,6 @@ class HexIDPatternedMeshGenerator : public PatternedHexMeshGenerator std::unique_ptr generate() override; protected: - /// assign IDs for each component in lattice in sequential order - std::vector getCellwiseIntegerIDs() const; - /// assign IDs for each input component type - std::vector getPatternIntegerIDs() const; - /// Assign IDs based on user-defined mapping defined in id_pattern - std::vector getManualIntegerIDs() const; - /// get list of block IDs in input mesh cells - std::set getCellBlockIDs() const; - /// get list of block IDs for duck regions - std::map getDuckBlockIDs(std::unique_ptr & mesh, - std::set & blks) const; /// name of integer ID const std::string _element_id_name; /// integer ID assignment type diff --git a/modules/reactor/include/utils/ReportingIDGeneratorUtils.h b/modules/reactor/include/utils/ReportingIDGeneratorUtils.h new file mode 100644 index 000000000000..10859835104a --- /dev/null +++ b/modules/reactor/include/utils/ReportingIDGeneratorUtils.h @@ -0,0 +1,99 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#pragma once + +#include "MooseTypes.h" +#include "libmesh/elem.h" +#include "libmesh/replicated_mesh.h" +#include "libmesh/dof_object.h" + +namespace ReportingIDGeneratorUtils +{ +/** + * assign IDs for each component in pattern in sequential order + * @param meshes input meshes of the cartesian or hexagonal patterned mesh generator + * @param pattern 2D vector of the mesh pattern + * @param use_exclude_id flag to indicate if exclude_id is defined + * @param exclude_ids flag to indicate if exclude_id is used for each input mesh + * @return list of reporting IDs for individual mesh elements + **/ +std::vector +getCellwiseIntegerIDs(const std::vector> & meshes, + const std::vector> & pattern, + const bool use_exclude_id, + const std::vector & exclude_ids); + +/** + * assign IDs for each input component type + * @param meshes input meshes of the cartesian or hexagonal patterned mesh generator + * @param pattern 2D vector of the mesh pattern + * @return list of reporting IDs for individual mesh elements + **/ +std::vector +getPatternIntegerIDs(const std::vector> & meshes, + const std::vector> & pattern); + +/** + * assign IDs based on user-defined mapping defined in id_pattern + * @param meshes input meshes of the cartesian or hexagonal patterned mesh generator + * @param pattern 2D vector of the mesh pattern + * @param id_pattern user-defined integer ID for each input pattern cell + * @return list of reporting IDs for individual mesh elements + **/ +std::vector +getManualIntegerIDs(const std::vector> & meshes, + const std::vector> & pattern, + const std::vector> & id_pattern); + +/** + * get list of block IDs in input mesh cells + * @param meshes input meshes of the cartesian or hexagonal patterned mesh generator + * @param pattern 2D vector of the mesh pattern + * @return list of block IDs in input meshes + **/ +std::set getCellBlockIDs(const std::vector> & meshes, + const std::vector> & pattern); + +/** + * get list of block IDs for the assembly duck regions + * @param mesh output mesh from the cartesian or hexagonal patterned mesh generator + * @param has_assembly_duct flag to indicate if assembly duct exists + * @param blks list of block defined in the input meshes of the cartesian or hexagonal patterned + *mesh generator + * @return list of block ids in the assembly duct region + **/ +std::map getDuckBlockIDs(const std::unique_ptr & mesh, + const bool has_assembly_duct, + const std::set & blks); + +/** + * assign the reporting IDs to the output mesh from the cartesian or hexagonal patterned mesh + *generator + * @param mesh output mesh from the cartesian or hexagonal patterned mesh generator + * @param extra_id_index index of extra integer id for assigning the reproting IDs + * @param assign_type type of integer ID assignment + * @param use_exclude_id flag to indicate if exclude_id is defined + * @param exclude_ids flag to indicate if exclude_id is used for each input mesh + * @param has_assembly_duct flag to indicate if assembly duct exists + * @param input_meshes input meshes of the cartesian or hexagonal patterned mesh generator + * @param pattern 2D vector of the mesh pattern + * @param id_pattern user-defined integer ID for each input pattern cell + * @return output mesh file having reporting IDs + **/ +void assignReportingIDs(std::unique_ptr & mesh, + const unsigned int extra_id_index, + const std::string assign_type, + const bool use_exclude_id, + const std::vector & exclude_ids, + const bool has_assembly_duct, + const std::vector> & input_meshes, + const std::vector> & pattern, + const std::vector> & id_pattern); +} diff --git a/modules/reactor/src/meshgenerators/CartesianIDPatternedMeshGenerator.C b/modules/reactor/src/meshgenerators/CartesianIDPatternedMeshGenerator.C index 9256e5f4cf1e..e7acd4af801c 100644 --- a/modules/reactor/src/meshgenerators/CartesianIDPatternedMeshGenerator.C +++ b/modules/reactor/src/meshgenerators/CartesianIDPatternedMeshGenerator.C @@ -8,7 +8,8 @@ //* https://www.gnu.org/licenses/lgpl-2.1.html #include "CartesianIDPatternedMeshGenerator.h" -#include "libmesh/elem.h" + +#include "ReportingIDGeneratorUtils.h" registerMooseObject("ReactorApp", CartesianIDPatternedMeshGenerator); @@ -16,18 +17,19 @@ InputParameters CartesianIDPatternedMeshGenerator::validParams() { InputParameters params = PatternedMeshGenerator::validParams(); - MooseEnum option("cell pattern manual", "cell"); - params.addRequiredParam("id_name", "Name of Integer ID set"); + params.addRequiredParam("id_name", "Name of integer ID set"); params.addParam>( "exclude_id", "Name of inputs to be excluded in ID generation."); - params.addParam("assign_type", option, "Type of integer id assignment"); + MooseEnum option("cell pattern manual", "cell"); + params.addParam("assign_type", option, "Type of integer ID assignment"); params.addParam>>( "id_pattern", "User-defined element IDs. A double-indexed array starting with the upper-left corner"); params.addClassDescription("This CartesianIDPatternedMeshGenerator source code is to generate " - "patterned Cartesian meshes with Reporting ID"); + "patterned Cartesian meshes with reporting ID"); return params; } + CartesianIDPatternedMeshGenerator::CartesianIDPatternedMeshGenerator( const InputParameters & parameters) : PatternedMeshGenerator(parameters), @@ -67,88 +69,28 @@ std::unique_ptr CartesianIDPatternedMeshGenerator::generate() { auto mesh = PatternedMeshGenerator::generate(); - // assumes that the entire mesh has elements of each individual mesh sequentially ordered. - std::vector integer_ids; - if (_assign_type == "cell") - integer_ids = getCellwiseIntegerIDs(); - else if (_assign_type == "pattern") - integer_ids = getPatternIntegerIDs(); - else if (_assign_type == "manual") - integer_ids = getManualIntegerIDs(); - unsigned int extra_id_index = 0; + unsigned int extra_id_index; if (!mesh->has_elem_integer(_element_id_name)) extra_id_index = mesh->add_elem_integer(_element_id_name); else - extra_id_index = mesh->get_elem_integer_index(_element_id_name); - unsigned int i = 0; - for (auto & elem : mesh->element_ptr_range()) - elem->set_extra_integer(extra_id_index, integer_ids[i++]); - return mesh; -} - -std::vector -CartesianIDPatternedMeshGenerator::getCellwiseIntegerIDs() const -{ - std::vector integer_ids; - dof_id_type id = 0; - for (MooseIndex(_pattern) i = 0; i < _pattern.size(); ++i) { - for (MooseIndex(_pattern[i]) j = 0; j < _pattern[i].size(); ++j) - { - const ReplicatedMesh & cell_mesh = *_meshes[_pattern[i][j]]; - unsigned int n_cell_elem = cell_mesh.n_elem(); - bool exclude_id = false; - if (_use_exclude_id) - if (_exclude_ids[_pattern[i][j]]) - exclude_id = true; - if (!exclude_id) - { - for (unsigned int k = 0; k < n_cell_elem; ++k) - integer_ids.push_back(id); - ++id; - } - else - { - for (unsigned int k = 0; k < n_cell_elem; ++k) - integer_ids.push_back(DofObject::invalid_id); - } - } + extra_id_index = mesh->get_elem_integer_index(_element_id_name); + mooseWarning("extra integer id name already exists", _element_id_name); } - return integer_ids; -} -std::vector -CartesianIDPatternedMeshGenerator::getPatternIntegerIDs() const -{ - std::vector integer_ids; - for (MooseIndex(_pattern) i = 0; i < _pattern.size(); ++i) - { - for (MooseIndex(_pattern[i]) j = 0; j < _pattern[i].size(); ++j) - { - const ReplicatedMesh & cell_mesh = *_meshes[_pattern[i][j]]; - unsigned int n_cell_elem = cell_mesh.n_elem(); - for (unsigned int k = 0; k < n_cell_elem; ++k) - integer_ids.push_back(_pattern[i][j]); - } - } - return integer_ids; -} + // patternedMeshGenerator for Carterisan lattice does not support duct structures + const bool has_assembly_duct = false; + // asssign reporting IDs to individual elements + ReportingIDGeneratorUtils::assignReportingIDs(mesh, + extra_id_index, + _assign_type, + _use_exclude_id, + _exclude_ids, + has_assembly_duct, + _meshes, + _pattern, + _id_pattern); -std::vector -CartesianIDPatternedMeshGenerator::getManualIntegerIDs() const -{ - std::vector integer_ids; - for (MooseIndex(_pattern) i = 0; i < _pattern.size(); ++i) - { - for (MooseIndex(_pattern[i]) j = 0; j < _pattern[i].size(); ++j) - { - dof_id_type id = _id_pattern[i][j]; - const ReplicatedMesh & cell_mesh = *_meshes[_pattern[i][j]]; - unsigned int n_cell_elem = cell_mesh.n_elem(); - for (unsigned int k = 0; k < n_cell_elem; ++k) - integer_ids.push_back(id); - } - } - return integer_ids; + return dynamic_pointer_cast(mesh); } diff --git a/modules/reactor/src/meshgenerators/HexIDPatternedMeshGenerator.C b/modules/reactor/src/meshgenerators/HexIDPatternedMeshGenerator.C index 2f8768a5f573..390703ab75de 100644 --- a/modules/reactor/src/meshgenerators/HexIDPatternedMeshGenerator.C +++ b/modules/reactor/src/meshgenerators/HexIDPatternedMeshGenerator.C @@ -1,22 +1,32 @@ -#include "PatternedHexMeshGenerator.h" +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + #include "HexIDPatternedMeshGenerator.h" +#include "ReportingIDGeneratorUtils.h" + registerMooseObject("ReactorApp", HexIDPatternedMeshGenerator); InputParameters HexIDPatternedMeshGenerator::validParams() { InputParameters params = PatternedHexMeshGenerator::validParams(); - params.addRequiredParam("id_name", "Reporting_id_name"); + params.addRequiredParam("id_name", "Name of extra integer ID set"); params.addParam>( "exclude_id", "Name of inputs to be excluded in ID generation."); MooseEnum option("cell pattern manual", "cell"); - params.addParam("assign_type", option, "Type of integer id assignment"); + params.addParam("assign_type", option, "Type of integer ID assignment"); params.addParam>>( "id_pattern", "User-defined element IDs. A double-indexed array starting with the upper-left corner"); params.addClassDescription("This HexIDPatternedMeshGenerator source code is to generate " - "patterned hexagonal meshes with Reporting ID"); + "patterned hexagonal meshes with reporting ID"); return params; } @@ -60,161 +70,35 @@ std::unique_ptr HexIDPatternedMeshGenerator::generate() { auto mesh = PatternedHexMeshGenerator::generate(); - std::vector integer_ids; - if (_assign_type == "cell") - integer_ids = getCellwiseIntegerIDs(); - else if (_assign_type == "pattern") - integer_ids = getPatternIntegerIDs(); - else if (_assign_type == "manual") - integer_ids = getManualIntegerIDs(); - - std::set blks = getCellBlockIDs(); - unsigned int duct_boundary_id = *std::max_element(integer_ids.begin(), integer_ids.end()) + 1; - std::map blks_duct = getDuckBlockIDs(mesh, blks); - - unsigned int extra_id_index = mesh->add_elem_integer(_element_id_name); - - unsigned int i = 0; - unsigned int id = integer_ids[i]; - unsigned old_id = id; - for (auto elem : mesh->element_ptr_range()) + unsigned int extra_id_index; + if (!mesh->has_elem_integer(_element_id_name)) + extra_id_index = mesh->add_elem_integer(_element_id_name); + else { - auto blk = elem->subdomain_id(); - auto it = blks.find(blk); - if (it == blks.end()) - { - if (_has_assembly_duct) - { - auto it2 = blks_duct.find(blk); - if (it2 == blks_duct.end()) - elem->set_extra_integer(extra_id_index, old_id); - else - elem->set_extra_integer(extra_id_index, duct_boundary_id + it2->second); - } - else - elem->set_extra_integer(extra_id_index, old_id); - } - else - { - elem->set_extra_integer(extra_id_index, id); - ++i; - old_id = id; - id = integer_ids[i]; - } + extra_id_index = mesh->get_elem_integer_index(_element_id_name); + mooseWarning("extra integer id name already exists", _element_id_name); } - return dynamic_pointer_cast(mesh); -} -std::vector -HexIDPatternedMeshGenerator::getCellwiseIntegerIDs() const -{ - std::vector integer_ids; - dof_id_type id = 0; - for (MooseIndex(_pattern) i = 0; i < _pattern.size(); ++i) + std::vector> meshes; + meshes.reserve(_input_names.size()); + for (MooseIndex(_input_names) i = 0; i < _input_names.size(); ++i) { - for (MooseIndex(_pattern[i]) j = 0; j < _pattern[i].size(); ++j) - { - // ReplicatedMesh & cell_mesh = *_meshes[_pattern[i][j]]; - const ReplicatedMesh * cell_mesh = - dynamic_cast((*_mesh_ptrs[_pattern[i][j]]).get()); - unsigned int n_cell_elem = cell_mesh->n_elem(); - bool exclude_id = false; - if (_use_exclude_id) - if (_exclude_ids[_pattern[i][j]]) - exclude_id = true; - if (!exclude_id) - { - for (unsigned int k = 0; k < n_cell_elem; ++k) - integer_ids.push_back(id); - ++id; - } - else - for (unsigned int k = 0; k < n_cell_elem; ++k) - integer_ids.push_back(DofObject::invalid_id); - } + std::unique_ptr cell_mesh = + dynamic_pointer_cast(*_mesh_ptrs[i]); + meshes.push_back(std::move(cell_mesh)); } - return integer_ids; -} -std::vector -HexIDPatternedMeshGenerator::getPatternIntegerIDs() const -{ - std::vector integer_ids; - for (MooseIndex(_pattern) i = 0; i < _pattern.size(); ++i) - { - for (MooseIndex(_pattern[i]) j = 0; j < _pattern[i].size(); ++j) - { - const ReplicatedMesh * cell_mesh = - dynamic_cast((*_mesh_ptrs[_pattern[i][j]]).get()); - unsigned int n_cell_elem = cell_mesh->n_elem(); - for (unsigned int k = 0; k < n_cell_elem; ++k) - integer_ids.push_back(_pattern[i][j]); - } - } - return integer_ids; -} -std::vector -HexIDPatternedMeshGenerator::getManualIntegerIDs() const -{ - std::vector integer_ids; - for (MooseIndex(_pattern) i = 0; i < _pattern.size(); ++i) - { - for (MooseIndex(_pattern[i]) j = 0; j < _pattern[i].size(); ++j) - { - unsigned int id = _id_pattern[i][j]; - const ReplicatedMesh * cell_mesh = - dynamic_cast((*_mesh_ptrs[_pattern[i][j]]).get()); - unsigned int n_cell_elem = cell_mesh->n_elem(); - for (unsigned int k = 0; k < n_cell_elem; ++k) - integer_ids.push_back(id); - } - } - return integer_ids; -} - -std::set -HexIDPatternedMeshGenerator::getCellBlockIDs() const -{ - std::set blks; - for (MooseIndex(_pattern) i = 0; i < _pattern.size(); ++i) - { - for (MooseIndex(_pattern[i]) j = 0; j < _pattern[i].size(); ++j) - { - const ReplicatedMesh * cell_mesh = - dynamic_cast((*_mesh_ptrs[_pattern[i][j]]).get()); - for (auto elem : cell_mesh->element_ptr_range()) - { - auto blk = elem->subdomain_id(); - auto it = blks.find(blk); - if (it == blks.end()) - blks.insert(blk); - } - } - } - return blks; -} + // asssign reporting IDs to individual elements + ReportingIDGeneratorUtils::assignReportingIDs(mesh, + extra_id_index, + _assign_type, + _use_exclude_id, + _exclude_ids, + _has_assembly_duct, + meshes, + _pattern, + _id_pattern); -std::map -HexIDPatternedMeshGenerator::getDuckBlockIDs(std::unique_ptr & mesh, - std::set & blks) const -{ - unsigned int i = 0; - std::map blks_duct; - if (_has_assembly_duct) - { - for (auto elem : mesh->element_ptr_range()) - { - auto blk = elem->subdomain_id(); - auto it1 = blks.find(blk); - if (it1 == blks.end()) - { - auto it2 = blks_duct.find(blk); - if (it2 == blks_duct.end()) - blks_duct[blk] = i++; - } - } - blks_duct.erase(blks_duct.begin()); - } - return blks_duct; + return dynamic_pointer_cast(mesh); } diff --git a/modules/reactor/src/utils/ReportingIDGeneratorUtils.C b/modules/reactor/src/utils/ReportingIDGeneratorUtils.C new file mode 100644 index 000000000000..467e55046fa7 --- /dev/null +++ b/modules/reactor/src/utils/ReportingIDGeneratorUtils.C @@ -0,0 +1,201 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#include "ReportingIDGeneratorUtils.h" + +std::vector +ReportingIDGeneratorUtils::getCellwiseIntegerIDs( + const std::vector> & meshes, + const std::vector> & pattern, + const bool use_exclude_id, + const std::vector & exclude_ids) +{ + std::vector integer_ids; + dof_id_type id = 0; + for (MooseIndex(pattern) i = 0; i < pattern.size(); ++i) + { + for (MooseIndex(pattern[i]) j = 0; j < pattern[i].size(); ++j) + { + ReplicatedMesh & cell_mesh = *meshes[pattern[i][j]]; + unsigned int n_cell_elem = cell_mesh.n_elem(); + bool exclude_id = false; + if (use_exclude_id) + if (exclude_ids[pattern[i][j]]) + exclude_id = true; + if (!exclude_id) + { + for (unsigned int k = 0; k < n_cell_elem; ++k) + integer_ids.push_back(id); + ++id; + } + else + for (unsigned int k = 0; k < n_cell_elem; ++k) + integer_ids.push_back(DofObject::invalid_id); + } + } + return integer_ids; +} + +std::vector +ReportingIDGeneratorUtils::getPatternIntegerIDs( + const std::vector> & meshes, + const std::vector> & pattern) +{ + std::vector integer_ids; + for (MooseIndex(pattern) i = 0; i < pattern.size(); ++i) + { + for (MooseIndex(pattern[i]) j = 0; j < pattern[i].size(); ++j) + { + ReplicatedMesh & cell_mesh = *meshes[pattern[i][j]]; + unsigned int n_cell_elem = cell_mesh.n_elem(); + for (unsigned int k = 0; k < n_cell_elem; ++k) + integer_ids.push_back(pattern[i][j]); + } + } + return integer_ids; +} + +std::vector +ReportingIDGeneratorUtils::getManualIntegerIDs( + const std::vector> & meshes, + const std::vector> & pattern, + const std::vector> & id_pattern) +{ + std::vector integer_ids; + for (MooseIndex(pattern) i = 0; i < pattern.size(); ++i) + { + for (MooseIndex(pattern[i]) j = 0; j < pattern[i].size(); ++j) + { + unsigned int id = id_pattern[i][j]; + ReplicatedMesh & cell_mesh = *meshes[pattern[i][j]]; + unsigned int n_cell_elem = cell_mesh.n_elem(); + for (unsigned int k = 0; k < n_cell_elem; ++k) + integer_ids.push_back(id); + } + } + return integer_ids; +} + +std::set +ReportingIDGeneratorUtils::getCellBlockIDs( + const std::vector> & meshes, + const std::vector> & pattern) +{ + std::set blks; + for (MooseIndex(pattern) i = 0; i < pattern.size(); ++i) + { + for (MooseIndex(pattern[i]) j = 0; j < pattern[i].size(); ++j) + { + ReplicatedMesh & cell_mesh = *meshes[pattern[i][j]]; + for (auto elem : cell_mesh.element_ptr_range()) + { + auto blk = elem->subdomain_id(); + auto it = blks.find(blk); + if (it == blks.end()) + blks.insert(blk); + } + } + } + return blks; +} + +std::map +ReportingIDGeneratorUtils::getDuckBlockIDs(const std::unique_ptr & mesh, + const bool has_assembly_duct, + const std::set & blks) +{ + std::map blks_duct; + if (has_assembly_duct) + { + unsigned int i = 0; + for (auto elem : mesh->element_ptr_range()) + { + auto blk = elem->subdomain_id(); + auto it1 = blks.find(blk); + if (it1 == blks.end()) + { + auto it2 = blks_duct.find(blk); + if (it2 == blks_duct.end()) + blks_duct[blk] = i++; + } + } + blks_duct.erase(blks_duct.begin()); + } + return blks_duct; +} + +void +ReportingIDGeneratorUtils::assignReportingIDs( + std::unique_ptr & mesh, + const unsigned int extra_id_index, + const std::string assign_type, + const bool use_exclude_id, + const std::vector & exclude_ids, + const bool has_assembly_duct, + const std::vector> & input_meshes, + const std::vector> & pattern, + const std::vector> & id_pattern) +{ + std::vector integer_ids; + // get reporting ID map + // assumes that the entire mesh has elements of each individual mesh sequentially ordered. + if (assign_type == "cell") + integer_ids = ReportingIDGeneratorUtils::getCellwiseIntegerIDs( + input_meshes, pattern, use_exclude_id, exclude_ids); + else if (assign_type == "pattern") + integer_ids = ReportingIDGeneratorUtils::getPatternIntegerIDs(input_meshes, pattern); + else if (assign_type == "manual") + integer_ids = ReportingIDGeneratorUtils::getManualIntegerIDs(input_meshes, pattern, id_pattern); + + if (has_assembly_duct) + { + // setup assembly duct information + std::set blks = ReportingIDGeneratorUtils::getCellBlockIDs(input_meshes, pattern); + unsigned int duct_boundary_id = *std::max_element(integer_ids.begin(), integer_ids.end()) + 1; + std::map blks_duct = + ReportingIDGeneratorUtils::getDuckBlockIDs(mesh, has_assembly_duct, blks); + + // assign reporting IDs to individual elements + unsigned int i = 0; + unsigned int id = integer_ids[i]; + unsigned old_id = id; + for (auto elem : mesh->element_ptr_range()) + { + auto blk = elem->subdomain_id(); + auto it = blks.find(blk); + // check whether the current element belongs to duct/surrouding regions or not + if (it == blks.end()) + { + // check whether the current element belongs to surroudning or duct regions + auto it2 = blks_duct.find(blk); + if (it2 == blks_duct.end()) + // if the current element belongs to the surronding region + elem->set_extra_integer(extra_id_index, old_id); + else + // if the current element belongs to the duct region + elem->set_extra_integer(extra_id_index, duct_boundary_id + it2->second); + } + else + { + // if the current element belongs to pin regions + elem->set_extra_integer(extra_id_index, id); + ++i; + old_id = id; + id = integer_ids[i]; + } + } + } + else + { + // assign reporting IDs to individual elements + unsigned int i = 0; + for (auto & elem : mesh->element_ptr_range()) + elem->set_extra_integer(extra_id_index, integer_ids[i++]); + } +} diff --git a/modules/reactor/test/tests/meshgenerators/reporting_id/cartesian_id/tests b/modules/reactor/test/tests/meshgenerators/reporting_id/cartesian_id/tests index b6903d12e363..0b56310cbe19 100644 --- a/modules/reactor/test/tests/meshgenerators/reporting_id/cartesian_id/tests +++ b/modules/reactor/test/tests/meshgenerators/reporting_id/cartesian_id/tests @@ -1,40 +1,46 @@ [Tests] - [assembly.cell] - type = 'Exodiff' - input = 'assembly_reporting_id.i' - exodiff = 'assembly_reporting_id_cell_out.e' - cli_args = "Outputs/file_base='assembly_reporting_id_cell_out'" - requirement = 'The system shall generate pin reporting IDs for cartesian assembly with assign_type=cell (default)' - recover = false + [assembly] + requirement = 'The system shall support the generation of reporting IDs for Cartesian assemblies' + [cell] + type = 'Exodiff' + input = 'assembly_reporting_id.i' + exodiff = 'assembly_reporting_id_cell_out.e' + cli_args = "Outputs/file_base='assembly_reporting_id_cell_out'" + detail = 'assign pin IDs in sequential order for each components in the lattice' + recover = false + [] + [pattern] + type = 'Exodiff' + input = 'assembly_reporting_id.i' + exodiff = 'assembly_reporting_id_pattern_out.e' + cli_args = "Mesh/assembly/assign_type='pattern' Outputs/file_base='assembly_reporting_id_pattern_out'" + detail = 'assign pin IDs based on the ID of the input pattern tiles' + recover = false + [] + [manual] + type = 'Exodiff' + input = 'assembly_reporting_id.i' + exodiff = 'assembly_reporting_id_manual_out.e' + cli_args = "Mesh/assembly/assign_type='manual' Mesh/assembly/id_pattern='0 0 1 1;0 0 1 1;2 2 3 3;2 2 3 3' Outputs/file_base='assembly_reporting_id_manual_out'" + detail = 'assign pin IDs based on user-defined mapping' + recover = false + [] [] - [assembly.pattern] - type = 'Exodiff' - input = 'assembly_reporting_id.i' - exodiff = 'assembly_reporting_id_pattern_out.e' - cli_args = "Mesh/assembly/assign_type='pattern' Outputs/file_base='assembly_reporting_id_pattern_out'" - requirement = 'The system shall generate pin reporting IDs for cartesian assembly with assign_type=pattern' - recover = false - [] - [assembly.manual] - type = 'Exodiff' - input = 'assembly_reporting_id.i' - exodiff = 'assembly_reporting_id_manual_out.e' - cli_args = "Mesh/assembly/assign_type='manual' Mesh/assembly/id_pattern='0 0 1 1;0 0 1 1;2 2 3 3;2 2 3 3' Outputs/file_base='assembly_reporting_id_manual_out'" - requirement = 'The system shall generate pin reporting IDs for cartesian assembly with assign_type=manual' - recover = false - [] - [core.regular_boundary] - type = 'Exodiff' - input = 'core_reporting_id.i' - exodiff = 'core_reporting_id_out.e' - requirement = 'The system shall generate pin and assembly reporting IDs for cartesian core' - recover = false - [] - [core.zigzag_boundary] - type = 'Exodiff' - input = 'core_zigzag_reporting_id.i' - exodiff = 'core_zigzag_reporting_id_out.e' - requirement = 'The system shall generate pin and assembly reporting IDs for cartesian core with zig-zag boundary' - recover = false + [core] + requirement = 'The system shall support the generation of reporting IDs for Cartesian cores' + [base] + type = 'Exodiff' + input = 'core_reporting_id.i' + exodiff = 'core_reporting_id_out.e' + detail = 'assign pin and assembly reporting IDS for each pin and assembly in the Cartesian core' + recover = false + [] + [zigzag_boundary] + type = 'Exodiff' + input = 'core_zigzag_reporting_id.i' + exodiff = 'core_zigzag_reporting_id_out.e' + detail = 'assign pin and assembly reporting IDS for the Cartesian core w/ zigzag boundary' + recover = false + [] [] [] diff --git a/modules/reactor/test/tests/meshgenerators/reporting_id/hexagonal_id/tests b/modules/reactor/test/tests/meshgenerators/reporting_id/hexagonal_id/tests index 2edabee88be5..a6d4ce296a79 100644 --- a/modules/reactor/test/tests/meshgenerators/reporting_id/hexagonal_id/tests +++ b/modules/reactor/test/tests/meshgenerators/reporting_id/hexagonal_id/tests @@ -1,40 +1,46 @@ [Tests] - [assembly.cell] - type = 'Exodiff' - input = 'assembly_reporting_id.i' - exodiff = 'assembly_reporting_id_cell_out.e' - cli_args = "Outputs/file_base='assembly_reporting_id_cell_out'" - requirement = 'The system shall generate pin reporting IDs for hexagonal assembly with assign_type=cell (default)' - recover = false - [] - [assembly.pattern] - type = 'Exodiff' - input = 'assembly_reporting_id.i' - exodiff = 'assembly_reporting_id_pattern_out.e' - cli_args = "Mesh/assembly/assign_type='pattern' Outputs/file_base='assembly_reporting_id_pattern_out'" - requirement = 'The system shall generate pin reporting IDs for hexagonal assembly with assign_type=pattern' - recover = false - [] - [assembly.manual] - type = 'Exodiff' - input = 'assembly_reporting_id.i' - exodiff = 'assembly_reporting_id_manual_out.e' - cli_args = "Mesh/assembly/assign_type='manual' Mesh/assembly/id_pattern='2 2 2;2 1 1 2;2 1 0 1 2;2 1 1 2;2 2 2' Outputs/file_base='assembly_reporting_id_manual_out'" - requirement = 'The system shall generate pin reporting IDs for hexagonal assembly with assign_type=manual' - recover = false + [assembly] + requirement = 'The system shall support the generation of reporting IDs for hexagonal assemblies' + [cell] + type = 'Exodiff' + input = 'assembly_reporting_id.i' + exodiff = 'assembly_reporting_id_cell_out.e' + cli_args = "Outputs/file_base='assembly_reporting_id_cell_out'" + detail = 'assign pin IDs in sequential order for each components in the lattice' + recover = false + [] + [pattern] + type = 'Exodiff' + input = 'assembly_reporting_id.i' + exodiff = 'assembly_reporting_id_pattern_out.e' + cli_args = "Mesh/assembly/assign_type='pattern' Outputs/file_base='assembly_reporting_id_pattern_out'" + detail = 'assign pin IDs based on the ID of the input pattern tiles' + recover = false + [] + [manual] + type = 'Exodiff' + input = 'assembly_reporting_id.i' + exodiff = 'assembly_reporting_id_manual_out.e' + cli_args = "Mesh/assembly/assign_type='manual' Mesh/assembly/id_pattern='2 2 2;2 1 1 2;2 1 0 1 2;2 1 1 2;2 2 2' Outputs/file_base='assembly_reporting_id_manual_out'" + detail = 'assign pin IDs based on user-defined mapping' + recover = false + [] [] [core] - type = 'Exodiff' - input = 'core_reporting_id.i' - exodiff = 'core_reporting_id_out.e' - requirement = 'The system shall generate pin and assembly reporting IDs for hexagonal core' - recover = false - [] - [core_exclude_id] - type = 'Exodiff' - input = 'core_reporting_id_exclude.i' - exodiff = 'core_reporting_id_exclude_out.e' - requirement = 'The system shall generate assembly reporting IDs for hexagonal core with exclude_id option' - recover = false + requirement = 'The system shall support the generation of reporting IDs for hexagonal cores' + [base] + type = 'Exodiff' + input = 'core_reporting_id.i' + exodiff = 'core_reporting_id_out.e' + detail = 'assign pin and assembly reporting IDS for each pin and assembly in the hexagonal core' + recover = false + [] + [core_exclude_id] + type = 'Exodiff' + input = 'core_reporting_id_exclude.i' + exodiff = 'core_reporting_id_exclude_out.e' + detail = 'assign assembly reporting IDs with exclusion of a certain input assembly' + recover = false + [] [] []