ReactorGeometryMeshBuilderBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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 "MeshGenerator.h"
#include "libmesh/elem.h"
 
namespace RGMB
{
 
// General global quantities for mesh building
static const std::string mesh_dimensions = "mesh_dimensions";
static const std::string mesh_geometry = "mesh_geometry";
static const std::string top_boundary_id = "top_boundary_id";
static const std::string bottom_boundary_id = "bottom_boundary_id";
static const std::string radial_boundary_id = "radial_boundary_id";
static const std::string axial_mesh_intervals = "axial_mesh_intervals";
static const std::string axial_mesh_sizes = "axial_mesh_sizes";
static const std::string reactor_params_name = "reactor_params_name";
static const std::string is_single_pin = "is_single_pin";
static const std::string is_homogenized = "is_homogenized";
static const std::string extruded = "extruded";
static const std::string pin_region_ids = "pin_region_ids";
static const std::string pin_block_names = "pin_block_names";
static const std::string pin_region_id_map = "pin_region_id_map";
static const std::string pin_block_name_map = "pin_block_name_map";
static const std::string flexible_assembly_stitching = "flexible_assembly_stitching";
static const std::string num_sectors_flexible_stitching = "num_sectors_flexible_stitching";
static const std::string is_control_drum = "is_control_drum";
static const std::string drum_region_ids = "drum_region_ids";
static const std::string drum_block_names = "drum_block_names";
 
// Geometrical quantities
static const std::string pitch = "pitch";
static const std::string assembly_pitch = "assembly_pitch";
static const std::string ring_radii = "ring_radii";
static const std::string duct_halfpitches = "duct_halfpitches";
static const std::string peripheral_ring_radius = "peripheral_ring_radius";
static const std::string pin_lattice = "pin_lattice";
static const std::string assembly_lattice = "assembly_lattice";
static const std::string drum_pad_angles = "drum_pad_angles";
static const std::string drum_radii = "drum_radii";
 
// Quantities related to region ids, type ids, and block names
static const std::string pin_type = "pin_type";
static const std::string pin_names = "pin_names";
static const std::string assembly_type = "assembly_type";
static const std::string assembly_names = "assembly_names";
static const std::string ring_region_ids = "ring_region_ids";
static const std::string background_region_id = "background_region_id";
static const std::string background_block_name = "background_block_name";
static const std::string duct_region_ids = "duct_region_ids";
static const std::string duct_block_names = "duct_block_names";
static const std::string peripheral_ring_region_id = "peripheral_ring_region_id";
static const std::string region_id_as_block_name = "region_id_as_block_name";
 
// Name of a boolean metadata that indicates whether or not we skipped mesh generation in favor of
// only generating the mesh metadata
static const std::string bypass_meshgen = "bypass_meshgen";
 
// Name of a boolean metadata that controls whether CSG components or engineering units are used in
// --csg-only mode
static const std::string expand_units = "expand_units";
 
// Default values for setting block IDs and region IDs of RGMB regions
const subdomain_id_type PIN_BLOCK_ID_TRI_FLEXIBLE = 9998;
const subdomain_id_type PIN_BLOCK_ID_TRI = 9999;
const subdomain_id_type PIN_BLOCK_ID_START = 10000;
 
const subdomain_id_type CONTROL_DRUM_BLOCK_ID_INNER_TRI = 19995;
const subdomain_id_type CONTROL_DRUM_BLOCK_ID_INNER = 19996;
const subdomain_id_type CONTROL_DRUM_BLOCK_ID_PAD = 19997;
const subdomain_id_type CONTROL_DRUM_BLOCK_ID_OUTER = 19998;
 
const subdomain_id_type ASSEMBLY_BLOCK_ID_TRI_FLEXIBLE = 19999;
const subdomain_id_type ASSEMBLY_BLOCK_ID_START = 20000;
 
const subdomain_id_type DUMMY_ASSEMBLY_BLOCK_ID = (UINT16_MAX / 2) - 1;
const subdomain_id_type PERIPHERAL_RING_BLOCK_ID = 25000;
 
const subdomain_id_type MAX_PIN_TYPE_ID = (UINT16_MAX / 2) - 1;
 
// Default values for setting block names of RGMB regions
const SubdomainName PIN_BLOCK_NAME_PREFIX = "RGMB_PIN";
const SubdomainName ASSEMBLY_BLOCK_NAME_PREFIX = "RGMB_ASSEMBLY";
const SubdomainName DRUM_BLOCK_NAME_PREFIX = "RGMB_DRUM";
const SubdomainName CORE_BLOCK_NAME_PREFIX = "RGMB_CORE";
const SubdomainName TRI_BLOCK_NAME_SUFFIX = "_TRI";
const SubdomainName PERIPHERAL_RING_BLOCK_NAME = "PERIPHERY_GENERATED";
 
// Default values for setting boundary ids of RGMB regions
static constexpr boundary_id_type PIN_BOUNDARY_ID_START = 20000;
static constexpr boundary_id_type ASSEMBLY_BOUNDARY_ID_START = 2000;
 
// Default values for setting boundary names of RGMB regions
const BoundaryName PIN_BOUNDARY_NAME_PREFIX = "outer_pin_";
const BoundaryName ASSEMBLY_BOUNDARY_NAME_PREFIX = "outer_assembly_";
const BoundaryName CORE_BOUNDARY_NAME = "outer_core";
 
// Default values for setting names of CSG surfaces
static const std::string CSG_AXIAL_PLANE_PREFIX = "rgmb_axial_plane_";
}
 
class ReactorGeometryMeshBuilderBase : public MeshGenerator
{
public:
  static InputParameters validParams();
 
  static void addDepletionIDParams(InputParameters & parameters);
 
  ReactorGeometryMeshBuilderBase(const InputParameters & parameters);
 
  void generateData() override {};
 
protected:
  unsigned int getElemIntegerFromMesh(MeshBase & input_mesh,
                                      std::string extra_int_name,
                                      bool should_exist = false);
 
  void initializeReactorMeshParams(const std::string reactor_param_name);
 
  void printReactorMetadata(const std::string geometry_type,
                            const std::string mg_name,
                            const bool first_function_call = true);
 
  void printCoreMetadata(const std::string mg_name, const bool first_function_call);
 
  void printAssemblyMetadata(const std::string mg_name, const bool first_function_call);
 
  void printPinMetadata(const std::string mg_name);
 
  void printGlobalReactorMetadata();
 
  template <typename T>
  void printMetadataToConsole(const std::string metadata_name, const std::string mg_name);
 
  template <typename T>
  void print2dMetadataToConsole(const std::string metadata_name, const std::string mg_name);
 
  void freeReactorParamsMesh();
 
  void freeReactorParamsCSG();
 
  template <typename T>
  bool hasReactorParam(const std::string param_name);
 
  template <typename T>
  const T & getReactorParam(const std::string & param_name);
 
  void updateElementBlockNameId(MeshBase & input_mesh,
                                Elem * elem,
                                std::map<std::string, SubdomainID> & name_id_map,
                                std::string elem_block_name,
                                SubdomainID & next_free_id);
 
  MeshGeneratorName callExtrusionMeshSubgenerators(const MeshGeneratorName input_mesh_name);
 
  MeshGeneratorName _reactor_params;
  enum class DepletionIDGenerationLevel
  {
    Pin,
    Assembly,
    Drum,
    Core
  };
 
  void addDepletionId(MeshBase & input_mesh,
                      const MooseEnum & option,
                      const DepletionIDGenerationLevel generation_level,
                      const bool extrude);
 
  std::vector<std::reference_wrapper<const CSG::CSGSurface>>
  getAxialPlaneSurfaces(CSG::CSGBase & csg_obj, const bool skip_intermediate_plane_generation);
 
  const CSG::CSGLattice & createRGMBLattice(
      const Real pitch,
      const std::vector<std::vector<std::reference_wrapper<const CSG::CSGUniverse>>> pattern,
      CSG::CSGBase & csg_obj);
 
private:
  std::unique_ptr<MeshBase> * _reactor_params_mesh;
  std::unique_ptr<CSG::CSGBase> * _reactor_params_csg;
};
 
template <typename T>
bool
ReactorGeometryMeshBuilderBase::hasReactorParam(const std::string param_name)
{
  return hasMeshProperty<T>(param_name, _reactor_params);
}
 
template <typename T>
const T &
ReactorGeometryMeshBuilderBase::getReactorParam(const std::string & param_name)
{
  return getMeshProperty<T>(param_name, _reactor_params);
}