Merge pull request #26052 from shikhar413/bypass_meshgen

Option to bypass mesh generation using RGMB mesh generators

framework/src/base/MeshGeneratorSystem.C

@@ -614,7 +614,7 @@ MeshGeneratorSystem::getSavedMesh(const std::string & name)
   if (!mesh_unique_ptr)
     mooseError("While getting the saved mesh generator '",
                name,
-               "', said mesh has already been retreived");
+               "', said mesh has already been retrieved");
 
   return std::move(mesh_unique_ptr);
 }

modules/combined/test/src/base/CombinedTestApp.C

@@ -49,6 +49,8 @@ InputParameters
 CombinedTestApp::validParams()
 {
   InputParameters params = CombinedApp::validParams();
+  // Below parameter is set to enable data driven mesh generation in test suite
+  params.set<bool>(MeshGeneratorSystem::allow_data_driven_param) = true;
   return params;
 }
 

modules/reactor/doc/content/source/meshgenerators/AssemblyMeshGenerator.md

@@ -67,6 +67,8 @@ For each of the pins listed in `pin_names`, the pin-level metadata is also displ
 
 In addition, the value of the `reactor_params_name` metadata can be used to retrieve global metadata defined by [ReactorMeshParams](ReactorMeshParams.md). Please refer to [ReactorMeshParams](ReactorMeshParams.md) to see a list of metadata defined by this mesh generator.
 
+For applications where an output mesh does not need to be created and meshing routines can consist entirely of defining reactor-based metadata, the parameter `[Mesh]`/[!param](/Mesh/MeshGeneratorMesh/data_driven_generator) can be set to the mesh generator that would generate an output mesh from RGMB metadata.
+
 ## Example Syntax
 
 !listing modules/reactor/test/tests/meshgenerators/assembly_mesh_generator/assembly_square.i block=Mesh

modules/reactor/doc/content/source/meshgenerators/CoreMeshGenerator.md

@@ -52,6 +52,8 @@ For meshes where a core periphery is defined, the following metadata is also def
 
 In addition, the value of the metadata `reactor_params_name` can be used to retrieve global metadata defined by [ReactorMeshParams](ReactorMeshParams.md). Please refer to [ReactorMeshParams](ReactorMeshParams.md) to see a list of metadata defined by this mesh generator.
 
+For applications where an output mesh does not need to be created and meshing routines can consist entirely of defining reactor-based metadata, the parameter `[Mesh]`/[!param](/Mesh/MeshGeneratorMesh/data_driven_generator) can be set to the mesh generator that would generate an output mesh from RGMB metadata.
+
 ## Example Syntax
 
 !listing modules/reactor/test/tests/meshgenerators/core_mesh_generator/core_square.i block=Mesh

modules/reactor/doc/content/source/meshgenerators/PinMeshGenerator.md

@@ -52,6 +52,8 @@ At the pin level, the following metadata is defined on the pin mesh:
 
 In addition, the value of the metadata `reactor_params_name` can be used to retrieve global metadata defined by [ReactorMeshParams](ReactorMeshParams.md). Please refer to [ReactorMeshParams](ReactorMeshParams.md) to see a list of metadata defined by this mesh generator.
 
+For applications where an output mesh does not need to be created and meshing routines can consist entirely of defining reactor-based metadata, the parameter `[Mesh]`/[!param](/Mesh/MeshGeneratorMesh/data_driven_generator) can be set to the mesh generator that would generate an output mesh from RGMB metadata.
+
 ## Example Syntax
 
 !listing modules/reactor/test/tests/meshgenerators/pin_mesh_generator/pin_square.i block=Mesh

modules/reactor/include/meshgenerators/ReactorGeometryMeshBuilderBase.h

@@ -53,6 +53,9 @@ 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";
 
+// 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";
 }
 
 /**
@@ -67,6 +70,8 @@ class ReactorGeometryMeshBuilderBase : public MeshGenerator
 
   ReactorGeometryMeshBuilderBase(const InputParameters & parameters);
 
+  void generateData() override{};
+
 protected:
   /**
    * Initializes extra element integer from id name for a given mesh and throws an error

modules/reactor/include/meshgenerators/ReactorMeshParams.h

@@ -24,6 +24,8 @@ class ReactorMeshParams : public MeshGenerator
 
   std::unique_ptr<MeshBase> generate() override;
 
+  void generateData() override{};
+
 protected:
   /// The number of dimension in the mesh
   const MooseEnum _dim;

modules/reactor/src/meshgenerators/ReactorGeometryMeshBuilderBase.C

@@ -21,6 +21,8 @@ ReactorGeometryMeshBuilderBase::validParams()
   params.addClassDescription("A base class that contains common members and methods for Reactor "
                              "Geometry Mesh Builder mesh generators.");
 
+  // Declare that this generator has a generateData method
+  MeshGenerator::setHasGenerateData(params);
   return params;
 }
 

modules/reactor/src/meshgenerators/ReactorMeshParams.C

@@ -45,6 +45,9 @@ ReactorMeshParams::validParams()
       "Number of elements in the Z direction for each axial region");
   params.addClassDescription("This ReactorMeshParams object acts as storage for persistent "
                              "information about the reactor geometry.");
+
+  // Declare that this generator has a generateData method
+  MeshGenerator::setHasGenerateData(params);
   return params;
 }
 
@@ -77,7 +80,18 @@ ReactorMeshParams::ReactorMeshParams(const InputParameters & parameters)
   this->declareMeshProperty(RGMB::mesh_dimensions, int(_dim));
   this->declareMeshProperty(RGMB::mesh_geometry, std::string(_geom));
   this->declareMeshProperty(RGMB::assembly_pitch, _assembly_pitch);
-  this->declareMeshProperty("name_id_map", _name_id_map);
+
+  // Option to bypass mesh generation is controlled by presence of Mesh/data_driven_generator
+  // and whether the current generator is in data only mode
+  const auto & moose_mesh = _app.actionWarehouse().getMesh();
+  const auto data_driven_generator =
+      moose_mesh->parameters().get<std::string>("data_driven_generator");
+  bool bypass_meshgen = (data_driven_generator != "") && isDataOnly();
+  this->declareMeshProperty(RGMB::bypass_meshgen, bypass_meshgen);
+
+  // Declare name id map only if RGMB is outputting a mesh
+  if (!bypass_meshgen)
+    this->declareMeshProperty("name_id_map", _name_id_map);
 
   if (isParamValid("top_boundary_id"))
   {
@@ -106,6 +120,13 @@ ReactorMeshParams::ReactorMeshParams(const InputParameters & parameters)
 std::unique_ptr<MeshBase>
 ReactorMeshParams::generate()
 {
+  // If mesh generation is requested and bypass_mesh is true, return a null mesh. generate()
+  // mesh should not be called with this option specified
+  if (getMeshProperty<bool>(RGMB::bypass_meshgen))
+  {
+    auto null_mesh = nullptr;
+    return null_mesh;
+  }
   auto mesh = buildMeshBaseObject();
   return dynamic_pointer_cast<MeshBase>(mesh);
 }

modules/reactor/test/include/meshgenerators/TestReactorGeometryMeshBuilderMeshGenerator.h

@@ -0,0 +1,33 @@
+//* 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 "MeshGenerator.h"
+
+class TestReactorGeometryMeshBuilderMeshGenerator : public MeshGenerator
+{
+public:
+  static InputParameters validParams();
+
+  TestReactorGeometryMeshBuilderMeshGenerator(const InputParameters & parameters);
+
+  std::unique_ptr<MeshBase> generate() override;
+
+private:
+  /// the input mesh name
+  const std::string _input;
+
+  /// The final mesh that is generated by the subgenerators;
+  /// This mesh is pointed to by the input. We store it so we can later reset it in `generate`.
+  std::unique_ptr<MeshBase> * _input_mesh;
+
+  /// The final mesh that is generated by the subgenerators;
+  std::unique_ptr<MeshBase> * _build_mesh;
+};

modules/reactor/test/src/meshgenerators/TestReactorGeometryMeshBuilderMeshGenerator.C

@@ -0,0 +1,56 @@
+//* 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 "TestReactorGeometryMeshBuilderMeshGenerator.h"
+#include "ReactorGeometryMeshBuilderBase.h"
+
+registerMooseObject("ReactorTestApp", TestReactorGeometryMeshBuilderMeshGenerator);
+
+InputParameters
+TestReactorGeometryMeshBuilderMeshGenerator::validParams()
+{
+  InputParameters params = MeshGenerator::validParams();
+  params.addRequiredParam<MeshGeneratorName>("input", "Input core mesh");
+  return params;
+}
+
+TestReactorGeometryMeshBuilderMeshGenerator::TestReactorGeometryMeshBuilderMeshGenerator(const InputParameters & params)
+  : MeshGenerator(params),
+    _input(getParam<MeshGeneratorName>("input")),
+    _input_mesh(&getMesh("input"))
+{
+  // Assumes input has been generated by CoreMeshGenerator and contains valid metadata for generation
+  const auto reactor_params_name = getMeshProperty<std::string>(RGMB::reactor_params_name, _input);
+
+  // Get assembly pitch from metadata and define a circular mesh that preserves volume of assembly structure
+  const auto assembly_pitch = getMeshProperty<double>(RGMB::assembly_pitch, reactor_params_name);
+  const auto mesh_geometry = getMeshProperty<std::string>(RGMB::mesh_geometry, reactor_params_name);
+  double vol_multiplier = (mesh_geometry == "Square") ? 1.0 : std::sqrt(3) / 2;
+  double equivalent_volume = vol_multiplier * assembly_pitch * assembly_pitch;
+  double equivalent_radius = std::sqrt(equivalent_volume / M_PI);
+
+  {
+    auto mesh_params = _app.getFactory().getValidParams("AdvancedConcentricCircleGenerator");
+    mesh_params.set<std::vector<double>>("ring_radii") = {equivalent_radius};
+    mesh_params.set<std::vector<unsigned int>>("ring_intervals") = {1};
+    mesh_params.set<unsigned int>("num_sectors") = 8;
+    addMeshSubgenerator("AdvancedConcentricCircleGenerator", "eqv_core_circle", mesh_params);
+
+    _build_mesh = &getMeshByName("eqv_core_circle");
+  }
+}
+
+std::unique_ptr<MeshBase>
+TestReactorGeometryMeshBuilderMeshGenerator::generate()
+{
+  // Input mesh is essentially a data store to build the equivalent core, so we reset it as it is no
+  // longer needed. The mesh we care about is the one created by the subgenerator
+  _input_mesh->reset();
+  return std::move(*_build_mesh);
+}

modules/reactor/test/tests/meshgenerators/core_mesh_generator/core_hex_2d_datadriven.i

@@ -0,0 +1,76 @@
+[Mesh]
+  [rmp]
+    type = ReactorMeshParams
+    dim = 2
+    geom = "Hex"
+    assembly_pitch = 3.7884
+    radial_boundary_id = 200
+  []
+
+  [pin1]
+    type = PinMeshGenerator
+    reactor_params = rmp
+    pin_type = 1
+    pitch = 1.3425
+    region_ids = '1 2'
+    quad_center_elements = false
+    num_sectors = 2
+    ring_radii = 0.5404
+    mesh_intervals = '1 1'
+  []
+
+  [amg1]
+    type = AssemblyMeshGenerator
+    assembly_type = 1
+    inputs = 'pin1'
+    pattern = '0 0;
+              0 0 0;
+               0 0'
+    background_intervals = 1
+    background_region_id = 3
+    duct_halfpitch = 1.7703
+    duct_intervals = 1
+    duct_region_ids = 4
+  []
+
+  [cmg]
+    type = CoreMeshGenerator
+    inputs = 'amg1'
+    dummy_assembly_name = empty
+    pattern = '0 0;
+              0 0 0;
+               0 0'
+    extrude = false
+    mesh_periphery = true
+    periphery_generator = quad_ring
+    periphery_region_id = 5
+    outer_circle_radius = 7
+    periphery_num_layers = 1
+    desired_area = 5.0
+  []
+  [test_rgmb]
+    type = TestReactorGeometryMeshBuilderMeshGenerator
+    input = cmg
+  []
+  data_driven_generator = test_rgmb
+[]
+
+[Problem]
+  solve = false
+[]
+
+[Executioner]
+  type = Steady
+[]
+
+[Reporters/metadata]
+  type = MeshMetaDataReporter
+[]
+
+[Outputs]
+  [out]
+    type = JSON
+    execute_on = FINAL
+    execute_system_information_on = none
+  []
+[]