Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "CartesianIDPatternedMeshGenerator.h"
      11             : #include "ReportingIDGeneratorUtils.h"
      12             : 
      13             : registerMooseObject("ReactorApp", CartesianIDPatternedMeshGenerator);
      14             : 
      15             : InputParameters
      16         140 : CartesianIDPatternedMeshGenerator::validParams()
      17             : {
      18         140 :   InputParameters params = PatternedMeshGenerator::validParams();
      19         280 :   params.addRequiredParam<std::string>("id_name", "Name of integer ID set");
      20         280 :   params.addParam<std::vector<MeshGeneratorName>>(
      21             :       "exclude_id", "Name of input meshes to be excluded in ID generation");
      22         280 :   MooseEnum option("cell pattern manual", "cell");
      23         280 :   params.addParam<MooseEnum>("assign_type", option, "Type of integer ID assignment");
      24         280 :   params.addParam<std::vector<std::vector<dof_id_type>>>(
      25             :       "id_pattern",
      26             :       "User-defined element IDs. A double-indexed array starting with the upper-left corner");
      27         140 :   params.addClassDescription("Generate Certesian lattice meshes with reporting ID assignment that "
      28             :                              "indentifies individual components of lattice.");
      29             : 
      30         140 :   return params;
      31         140 : }
      32             : 
      33          70 : CartesianIDPatternedMeshGenerator::CartesianIDPatternedMeshGenerator(
      34          70 :     const InputParameters & parameters)
      35             :   : PatternedMeshGenerator(parameters),
      36          70 :     _element_id_name(getParam<std::string>("id_name")),
      37          70 :     _assign_type(
      38          70 :         getParam<MooseEnum>("assign_type").getEnum<ReportingIDGeneratorUtils::AssignType>()),
      39         210 :     _use_exclude_id(isParamValid("exclude_id"))
      40             : {
      41          70 :   if (_use_exclude_id && _assign_type != ReportingIDGeneratorUtils::AssignType::cell)
      42           0 :     paramError("exclude_id", "works only when \"assign_type\" is equal 'cell'");
      43         210 :   if (!isParamValid("id_pattern") && _assign_type == ReportingIDGeneratorUtils::AssignType::manual)
      44           0 :     paramError("id_pattern", "required when \"assign_type\" is equal to 'manual'");
      45             : 
      46          70 :   if (_assign_type == ReportingIDGeneratorUtils::AssignType::manual)
      47          21 :     _id_pattern = getParam<std::vector<std::vector<dof_id_type>>>("id_pattern");
      48          70 :   _exclude_ids.resize(_input_names.size());
      49          70 :   if (_use_exclude_id)
      50             :   {
      51             :     std::vector<MeshGeneratorName> exclude_id_name =
      52          14 :         getParam<std::vector<MeshGeneratorName>>("exclude_id");
      53          28 :     for (unsigned int i = 0; i < _input_names.size(); ++i)
      54             :     {
      55             :       _exclude_ids[i] = false;
      56          35 :       for (auto input_name : exclude_id_name)
      57          21 :         if (_input_names[i] == input_name)
      58             :         {
      59             :           _exclude_ids[i] = true;
      60             :           break;
      61             :         }
      62             :     }
      63           7 :   }
      64             :   else
      65         182 :     for (unsigned int i = 0; i < _input_names.size(); ++i)
      66             :       _exclude_ids[i] = false;
      67          70 : }
      68             : 
      69             : std::unique_ptr<MeshBase>
      70          70 : CartesianIDPatternedMeshGenerator::generate()
      71             : {
      72          70 :   auto mesh = PatternedMeshGenerator::generate();
      73             : 
      74             :   unsigned int extra_id_index;
      75          70 :   if (!mesh->has_elem_integer(_element_id_name))
      76         140 :     extra_id_index = mesh->add_elem_integer(_element_id_name);
      77             :   else
      78             :   {
      79           0 :     extra_id_index = mesh->get_elem_integer_index(_element_id_name);
      80           0 :     paramWarning(
      81           0 :         "id_name", "An element integer with the name '", _element_id_name, "' already exists");
      82             :   }
      83             : 
      84             :   // patternedMeshGenerator for Carterisan lattice does not support duct structures
      85             :   const bool has_assembly_duct = false;
      86             :   const std::set<subdomain_id_type> duct_block_ids;
      87             :   // asssign reporting IDs to individual elements
      88          70 :   ReportingIDGeneratorUtils::assignReportingIDs(*mesh,
      89             :                                                 extra_id_index,
      90          70 :                                                 _assign_type,
      91          70 :                                                 _use_exclude_id,
      92          70 :                                                 _exclude_ids,
      93             :                                                 has_assembly_duct,
      94             :                                                 duct_block_ids,
      95          70 :                                                 _meshes,
      96             :                                                 _pattern,
      97          70 :                                                 _id_pattern);
      98             : 
      99          70 :   return mesh;
     100           0 : }