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             : #pragma once
      11             : 
      12             : #include "MeshGenerator.h"
      13             : #include "libmesh/elem.h"
      14             : 
      15             : namespace RGMB
      16             : {
      17             : 
      18             : // General global quantities for mesh building
      19             : static const std::string mesh_dimensions = "mesh_dimensions";
      20             : static const std::string mesh_geometry = "mesh_geometry";
      21             : static const std::string top_boundary_id = "top_boundary_id";
      22             : static const std::string bottom_boundary_id = "bottom_boundary_id";
      23             : static const std::string radial_boundary_id = "radial_boundary_id";
      24             : static const std::string axial_mesh_intervals = "axial_mesh_intervals";
      25             : static const std::string axial_mesh_sizes = "axial_mesh_sizes";
      26             : static const std::string reactor_params_name = "reactor_params_name";
      27             : static const std::string is_single_pin = "is_single_pin";
      28             : static const std::string is_homogenized = "is_homogenized";
      29             : static const std::string extruded = "extruded";
      30             : static const std::string pin_region_ids = "pin_region_ids";
      31             : static const std::string pin_block_names = "pin_block_names";
      32             : static const std::string pin_region_id_map = "pin_region_id_map";
      33             : static const std::string pin_block_name_map = "pin_block_name_map";
      34             : static const std::string flexible_assembly_stitching = "flexible_assembly_stitching";
      35             : static const std::string num_sectors_flexible_stitching = "num_sectors_flexible_stitching";
      36             : static const std::string is_control_drum = "is_control_drum";
      37             : static const std::string drum_region_ids = "drum_region_ids";
      38             : static const std::string drum_block_names = "drum_block_names";
      39             : 
      40             : // Geometrical quantities
      41             : static const std::string pitch = "pitch";
      42             : static const std::string assembly_pitch = "assembly_pitch";
      43             : static const std::string ring_radii = "ring_radii";
      44             : static const std::string duct_halfpitches = "duct_halfpitches";
      45             : static const std::string peripheral_ring_radius = "peripheral_ring_radius";
      46             : static const std::string pin_lattice = "pin_lattice";
      47             : static const std::string assembly_lattice = "assembly_lattice";
      48             : static const std::string drum_pad_angles = "drum_pad_angles";
      49             : static const std::string drum_radii = "drum_radii";
      50             : 
      51             : // Quantities related to region ids, type ids, and block names
      52             : static const std::string pin_type = "pin_type";
      53             : static const std::string pin_names = "pin_names";
      54             : static const std::string assembly_type = "assembly_type";
      55             : static const std::string assembly_names = "assembly_names";
      56             : static const std::string ring_region_ids = "ring_region_ids";
      57             : static const std::string background_region_id = "background_region_id";
      58             : static const std::string background_block_name = "background_block_name";
      59             : static const std::string duct_region_ids = "duct_region_ids";
      60             : static const std::string duct_block_names = "duct_block_names";
      61             : static const std::string peripheral_ring_region_id = "peripheral_ring_region_id";
      62             : static const std::string region_id_as_block_name = "region_id_as_block_name";
      63             : 
      64             : // Name of a boolean metadata that indicates whether or not we skipped mesh generation in favor of
      65             : // only generating the mesh metadata
      66             : static const std::string bypass_meshgen = "bypass_meshgen";
      67             : 
      68             : // Default values for setting block IDs and region IDs of RGMB regions
      69             : const subdomain_id_type PIN_BLOCK_ID_TRI_FLEXIBLE = 9998;
      70             : const subdomain_id_type PIN_BLOCK_ID_TRI = 9999;
      71             : const subdomain_id_type PIN_BLOCK_ID_START = 10000;
      72             : 
      73             : const subdomain_id_type CONTROL_DRUM_BLOCK_ID_INNER_TRI = 19995;
      74             : const subdomain_id_type CONTROL_DRUM_BLOCK_ID_INNER = 19996;
      75             : const subdomain_id_type CONTROL_DRUM_BLOCK_ID_PAD = 19997;
      76             : const subdomain_id_type CONTROL_DRUM_BLOCK_ID_OUTER = 19998;
      77             : 
      78             : const subdomain_id_type ASSEMBLY_BLOCK_ID_TRI_FLEXIBLE = 19999;
      79             : const subdomain_id_type ASSEMBLY_BLOCK_ID_START = 20000;
      80             : 
      81             : const subdomain_id_type DUMMY_ASSEMBLY_BLOCK_ID = (UINT16_MAX / 2) - 1;
      82             : const subdomain_id_type PERIPHERAL_RING_BLOCK_ID = 25000;
      83             : 
      84             : const subdomain_id_type MAX_PIN_TYPE_ID = (UINT16_MAX / 2) - 1;
      85             : 
      86             : // Default values for setting block names of RGMB regions
      87             : const SubdomainName PIN_BLOCK_NAME_PREFIX = "RGMB_PIN";
      88             : const SubdomainName ASSEMBLY_BLOCK_NAME_PREFIX = "RGMB_ASSEMBLY";
      89             : const SubdomainName DRUM_BLOCK_NAME_PREFIX = "RGMB_DRUM";
      90             : const SubdomainName CORE_BLOCK_NAME_PREFIX = "RGMB_CORE";
      91             : const SubdomainName TRI_BLOCK_NAME_SUFFIX = "_TRI";
      92             : const SubdomainName PERIPHERAL_RING_BLOCK_NAME = "PERIPHERY_GENERATED";
      93             : 
      94             : // Default values for setting boundary ids of RGMB regions
      95             : static constexpr boundary_id_type PIN_BOUNDARY_ID_START = 20000;
      96             : static constexpr boundary_id_type ASSEMBLY_BOUNDARY_ID_START = 2000;
      97             : 
      98             : // Default values for setting boundary names of RGMB regions
      99             : const BoundaryName PIN_BOUNDARY_NAME_PREFIX = "outer_pin_";
     100             : const BoundaryName ASSEMBLY_BOUNDARY_NAME_PREFIX = "outer_assembly_";
     101             : const BoundaryName CORE_BOUNDARY_NAME = "outer_core";
     102             : }
     103             : 
     104             : /**
     105             :  * A base class that contains common members for Reactor Geometry Mesh Builder mesh generators.
     106             :  */
     107             : class ReactorGeometryMeshBuilderBase : public MeshGenerator
     108             : {
     109             : public:
     110             :   static InputParameters validParams();
     111             : 
     112             :   static void addDepletionIDParams(InputParameters & parameters);
     113             : 
     114             :   ReactorGeometryMeshBuilderBase(const InputParameters & parameters);
     115             : 
     116        1764 :   void generateData() override{};
     117             : 
     118             : protected:
     119             :   /**
     120             :    * Initializes extra element integer from id name for a given mesh and throws an error
     121             :    * if it should exist but cannot be found within the mesh
     122             :    * @param input_mesh input mesh
     123             :    * @param extra_int_name extra element id name
     124             :    * @param should_exist whether extra element integer should already exist in mesh
     125             :    * @return extra element integer
     126             :    */
     127             :   unsigned int getElemIntegerFromMesh(MeshBase & input_mesh,
     128             :                                       std::string extra_int_name,
     129             :                                       bool should_exist = false);
     130             : 
     131             :   /**
     132             :    * Initializes and checks validity of ReactorMeshParams mesh generator object
     133             :    * @param reactor_param_name name of ReactorMeshParams mesh generator
     134             :    */
     135             :   void initializeReactorMeshParams(const std::string reactor_param_name);
     136             : 
     137             :   /**
     138             :    * Print metadata associated with ReactorGeometryMeshBuilder object
     139             :    * @param geometry_type       type of geometry (pin / assembly / core) under consideration
     140             :    * @param mg_name             name of mesh generator associated with this object
     141             :    * @param first_function_call whether this is the original function call, which will trigger
     142             :    * additional output messages
     143             :    */
     144             :   void printReactorMetadata(const std::string geometry_type,
     145             :                             const std::string mg_name,
     146             :                             const bool first_function_call = true);
     147             : 
     148             :   /**
     149             :    * Print core-level metadata associated with ReactorGeometryMeshBuilder object
     150             :    * @param mg_name name of mesh generator associated with core
     151             :    * @param first_function_call whether this is the original function call, which will trigger
     152             :    * additional output messages
     153             :    */
     154             :   void printCoreMetadata(const std::string mg_name, const bool first_function_call);
     155             : 
     156             :   /**
     157             :    * Print assembly-level metadata associated with ReactorGeometryMeshBuilder object
     158             :    * @param mg_name name of mesh generator associated with assembly
     159             :    * @param whether this is the original function call, which will trigger additional output
     160             :    * messages
     161             :    */
     162             :   void printAssemblyMetadata(const std::string mg_name, const bool first_function_call);
     163             : 
     164             :   /**
     165             :    * Print pin-level metadata associated with ReactorGeometryMeshBuilder object
     166             :    * @param mg_name name of mesh generator associated with assembly
     167             :    */
     168             :   void printPinMetadata(const std::string mg_name);
     169             : 
     170             :   /**
     171             :    * Print global ReactorMeshParams metadata associated with ReactorGeometryMeshBuilder object
     172             :    */
     173             :   void printGlobalReactorMetadata();
     174             : 
     175             :   /**
     176             :    * Print metadata with provided name that can be found with given mesh generator name
     177             :    * @tparam T datatype of metadata value to output
     178             :    * @param metadata_name Name of metadata to output
     179             :    * @param mg_name Name of mesh generator that stores metadata
     180             :    */
     181             :   template <typename T>
     182             :   void printMetadataToConsole(const std::string metadata_name, const std::string mg_name);
     183             : 
     184             :   /**
     185             :    * Print metadata with data type std::vector<std::vector<T>> and provided name that can be found
     186             :    * with given mesh generator name
     187             :    * @tparam T datatype of elements in 2-D vector to output
     188             :    * @param metadata_name Name of metadata to output
     189             :    * @param mg_name Name of mesh generator that stores metadata
     190             :    */
     191             :   template <typename T>
     192             :   void print2dMetadataToConsole(const std::string metadata_name, const std::string mg_name);
     193             : 
     194             :   /**
     195             :    * Releases the mesh obtained in _reactor_params_mesh.
     196             :    *
     197             :    * This _must_ be called in any object that derives from this one, because
     198             :    * the MeshGenerator system requires that all meshes that are requested from
     199             :    * the system are moved out of the MeshGenerator system and into the MeshGenerator
     200             :    * that requests them. In our case, we move it into this MeshGenerator and then
     201             :    * release (delete) it.
     202             :    */
     203             :   void freeReactorMeshParams();
     204             : 
     205             :   /**
     206             :    * Checks whether parameter is defined in ReactorMeshParams metadata
     207             :    * @tparam T datatype of metadata value associated with metadata name
     208             :    * @param param_name name of ReactorMeshParams parameter
     209             :    * @return whether parameter is defined in ReactorMeshParams metadata
     210             :    */
     211             :   template <typename T>
     212             :   bool hasReactorParam(const std::string param_name);
     213             : 
     214             :   /**
     215             :    * Returns reference of parameter in ReactorMeshParams object
     216             :    * @tparam T datatype of metadata value associated with metadata name
     217             :    * @param param_name name of ReactorMeshParams parameter
     218             :    * @return reference to parameter defined in ReactorMeshParams metadata
     219             :    */
     220             :   template <typename T>
     221             :   const T & getReactorParam(const std::string & param_name);
     222             : 
     223             :   /**
     224             :    * Updates the block names and ids of the element in an input mesh according
     225             :    * to a map of block name to block ids. Updates the map if the block name is not in the map
     226             :    * @param input_name input mesh
     227             :    * @param elem iterator to mesh element
     228             :    * @param name_id_map map of name-id pairs used in mesh
     229             :    * @param elem_block_name block name to set for element
     230             :    * @param next_free_id next free block id to use if block name does not exist in map
     231             :    */
     232             :   void updateElementBlockNameId(MeshBase & input_mesh,
     233             :                                 Elem * elem,
     234             :                                 std::map<std::string, SubdomainID> & name_id_map,
     235             :                                 std::string elem_block_name,
     236             :                                 SubdomainID & next_free_id);
     237             : 
     238             :   /**
     239             :    * Calls mesh subgenerators related to extrusion, renaming of top / bottom boundaries, and
     240             :    * defining plane IDs
     241             :    * @param input_mesh_name name of input 2D mesh generator to extrude
     242             :    * @return name of final output 3D mesh generator
     243             :    */
     244             :   MeshGeneratorName callExtrusionMeshSubgenerators(const MeshGeneratorName input_mesh_name);
     245             : 
     246             :   ///The ReactorMeshParams object that is storing the reactor global information for this reactor geometry mesh
     247             :   MeshGeneratorName _reactor_params;
     248             :   /// specify the depletion id is generated at which reactor generation level
     249             :   enum class DepletionIDGenerationLevel
     250             :   {
     251             :     Pin,
     252             :     Assembly,
     253             :     Drum,
     254             :     Core
     255             :   };
     256             : 
     257             :   /**
     258             :    * add depletion IDs
     259             :    * @param input_mesh input mesh
     260             :    * @param option option for specifying level of details
     261             :    * @param generation_level depletion id is generated at which reactor generator level
     262             :    * @param extrude whether input mesh is extruded, if false, assume that input mesh is defined in
     263             :    * 2D and do not use 'plane_id` in depletion id generation
     264             :    */
     265             :   void addDepletionId(MeshBase & input_mesh,
     266             :                       const MooseEnum & option,
     267             :                       const DepletionIDGenerationLevel generation_level,
     268             :                       const bool extrude);
     269             : 
     270             : private:
     271             :   /// The dummy param mesh that we need to clear once we've generated (in freeReactorMeshParams)
     272             :   std::unique_ptr<MeshBase> * _reactor_params_mesh;
     273             : };
     274             : 
     275             : template <typename T>
     276             : bool
     277             : ReactorGeometryMeshBuilderBase::hasReactorParam(const std::string param_name)
     278             : {
     279         804 :   return hasMeshProperty<T>(param_name, _reactor_params);
     280             : }
     281             : 
     282             : template <typename T>
     283             : const T &
     284             : ReactorGeometryMeshBuilderBase::getReactorParam(const std::string & param_name)
     285             : {
     286      549458 :   return getMeshProperty<T>(param_name, _reactor_params);
     287             : }