Reactor System Requirements Specification

This template follows INL template TEM-135, "IT System Requirements Specification".

note

This document serves as an addendum to Framework System Requirements Specification and captures information for SRS specific to the Reactor module.

Framework System Requirements Specification

Introduction

System Purpose

The MOOSE Reactor module provides an interface and libraries for creating meshes for nuclear reactor systems.

It is intended to be used using other MOOSE ecosystem codes (including MOOSE-wrapped applications) to perform the physics solve as it does not contain any physics. Thus, the Reactor module uses the same object-oriented design as MOOSE in order to make simulation design and new development straightforward for engineers and researchers.

System Scope

The scope of the Reactor module is to provide a set of utilities for building reactor meshes for finite element or finite volume simulations. The modules relies on the MOOSE framework for utilities that are common with other applications.

It covers several reactor types, mostly those with geometry that are axially extruded or close to being so. This includes: liquid metal fast reactors, prismatic high temperature reactors, some variations of micro reactors and pressurized water reactors. Every design variation of each advanced reactor type cannot be covered by the module. It covers the meshing and rotation of control drum in certain reactors.

The system contains, generally, a base set of mesh generators and meshing utilities. Reactor module developers work with framework and other module and application developers to ensure that the Reactor module provides adequate capability to support ongoing and prospective research opportunities involving advanced reactors.

System Overview

System Context

The Reactor module is command-line driven. Like MOOSE, this is typical for a high-performance software that is designed to run across several nodes of a cluster system. As such, all usage of the software is through any standard terminal program generally available on all supported operating systems. Similarly, for the purpose of interacting through the software, there is only a single user, "the user", which interacts with the software through the command-line. The Reactor module does not maintain any back-end database or interact with any system daemons. It is an executable, which may be launched from the command line and writes out various result files as it runs.

Figure 1: Usage of the Reactor module and other MOOSE-based applications.

System Functions

Since the Reactor module is a command-line driven application, all functionality provided in the software is operated through the use of standard UNIX command line flags and the extendable MOOSE input file. The Reactor module is completely extendable so individual design pages should be consulted for specific behaviors of each user-defined object.

User Characteristics

Like MOOSE, there are three kinds of users working on the Reactor module:

Reactor module Developers: These are the core developers of the Reactor module. They are responsible for following and enforcing the software development standards of the module, as well as designing, implementing, and maintaining the software.
Developers: A scientist or engineer that uses the Reactor module alongside MOOSE to build their own application. This user will typically have a background in modeling or simulation techniques (and perhaps numerical analysis) but may only have a limited skillset when it comes to code development using the C++ language. This is the primary focus group of the module. In many cases, these developers will be encouraged to contribute module-appropriate code back to the Reactor module, or to MOOSE itself.
Analysts: These are users that will run the code and perform analysis on the simulations they perform. These users may interact with developers of the system requesting new features and reporting bugs found and will typically make heavy use of the input file format.

Assumptions and Dependencies

The Reactor module is developed using MOOSE and can itself be based on various MOOSE modules, as such the SRS for the Reactor module is dependent upon the files listed at the beginning of this document. Any further assumptions or dependencies are outlined in the remainder of this section.

The Reactor module is designed with the fewest possible constraints on hardware and software. For more context on this point, the Reactor module SRS defers to the framework Assumptions and Dependencies. Any physics-based or geometry-based assumptions in code simulations and code objects are highlighted in their respective documentation pages.

References

ISO/IEC/IEEE 24765:2010(E). Systems and software engineering—Vocabulary. first edition, December 15 2010.

@manual{ISO-systems-software,
    author = "24765:2010(E), ISO/IEC/IEEE",
    title = "Systems and software engineering---Vocabulary",
    edition = "First",
    year = "2010",
    month = "December 15"
}

ASME NQA-1. ASME NQA-1-2008 with the NQA-1a-2009 addenda: Quality Assurance Requirements for Nuclear Facility Applications. first edition, August 31 2009.

@manual{ASME-NQA-1-2008,
    author = "NQA-1, ASME",
    title = "ASME NQA-1-2008 with the NQA-1a-2009 addenda: Quality Assurance Requirements for Nuclear Facility Applications",
    orginization = "American Socieity of Mechanical Engineers",
    year = "2009",
    month = "August 31",
    edition = "First"
}

Definitions and Acronyms

This section defines, or provides the definition of, all terms and acronyms required to properly understand this specification.

Definitions

Verification: (1) The process of: evaluating a system or component to determine whether the products of a given development phase satisfy the conditions imposed at the start of that phase. (2) Formal proof of program correctness (e.g., requirements, design, implementation reviews, system tests) (24765:2010(E), 2010).

Acronyms

Acronym	Description
INL	Idaho National Laboratory
LGPL	GNU Lesser General Public License
MOOSE	Multiphysics Object Oriented Simulation Environment
NQA-1	Nuclear Quality Assurance Level 1
POSIX	Portable Operating System Interface
SRS	Software Requirement Specification

System Requirements

In general, the following is required for MOOSE-based development:

GCC/Clang C++17 compliant compiler (GCC @ 7.5.0, Clang @ 10.0.1 or greater)
- Note: Intel compilers are not supported.
Memory: 8 GBs of RAM for optimized compilation (16 GBs for debug compilation), 2 GB per core execution
Processor: 64-bit x86 or ARM64 (specifically, Apple Silicon)
Disk: 30GB
A POSIX compliant Unix-like operating system, including the two most recent versions of MacOS and most current versions of Linux.
Git version control system
Python @ 3.7 or greater

Functional Requirements

reactor: Functions
16.1.1
The system shall include a function that describes the rotation of multiple control drums
1. using control_drum_id.
2. without using control_drum_id.
16.1.2
The function that describes control drums shall throw an error
1. if start_angles and angular_speeds have different lengths.
2. if angle_ranges and angular_speeds have different lengths.
3. if input control drum parameters are not compatible with MeshMetaData.
4. if rotation_end_time is smaller than rotation_start_time.

reactor: Meshgenerators
16.2.1The system shall generate a 3D square assembly mesh from 2 pin types
16.2.2The system shall generate a 3D square assembly mesh from 2 pin types and a background region
16.2.3The system shall allow for multiple region IDs to be mapped to a specific block name
16.2.4The system shall generate a 3D hexagonal assembly mesh with duct regions with assigned IDs
16.2.5The system shall generate a 2D hexagonal assembly mesh that transfers metadata correctly across RGMB mesh generators
16.2.6
The system should modify the azimuthal blocks
1. (without the external block) based on the given angle range.
2. (without the external block) in a mesh with center quad elements based on the given angle range.
3. (with the external block) based on the given angle range.
4. (based on block names) based on the given angle range.
16.2.7
The system shall throw an error
1. if old_blocks given as block ids and new_block_ids have different sizes.
2. if old_blocks given as block names and new_block_ids have different sizes.
3. if new_block_names and new_block_ids have different sizes.
4. if old_blocks contains blocks that do not exist in the input mesh.
5. if the list of blocks whose nodes should be moved contains a block with center quad elements.
6. if the circular region is overlapped with background region after radius correction.
7. if the mesh is too corase for the absorber.
16.2.8The system shall generate a square mesh that adapts one boundary of a mesh loaded from an exodus file.
16.2.9The system shall generate a non-adaptive square mesh when inputs and sides_to_adapt are not provided.
16.2.10The system shall throw an error if the vector of sides to adapts and the vector of input meshes to adapt to have different sizes for the adaptive cartesian mesh.
16.2.11The system shall be able to trim all of the four peripheral regions off a square assembly mesh.
16.2.12The system shall be able to trim a fraction of the four peripheral regions off a square assembly mesh.
16.2.13The system shall be able to trim a fraction of a square assembly mesh through its center.
16.2.14The system shall be able to trim a fraction of a square assembly mesh with its peripheral regions modified through its center.
16.2.15The system shall be able to perform both peripheral and center trimming simultaneously on a square assembly.
16.2.16The system shall be able to perform center trimming on a center-trimmable cartesian mesh with peripheral ring(s) added.
16.2.17The system shall be able to perform center trimming on a cartesian core mesh generated by double cartesian patterning.
16.2.18The system shall be able to perform center trimming on a cartesian core mesh generated by double cartesian patterning with the peripheral regions of assembly meshes modified.
16.2.19The system shall be able to perform center trimming on a core mesh generated by double cartesian patterning with pin centers consisting of triangular elements.
16.2.20The system shall be able to stitch together cartesian assembly meshes after peripheral trimming.
16.2.21The system shall throw an error if the input cartesian mesh does not contain the provided external boundary.
16.2.22The system shall throw an error if the input mesh has not been marked compatible with cartesian mesh trimming.
16.2.23The system shall throw an error if the input cartesian mesh cannot be center trimmed.
16.2.24The system shall throw an error if the input cartesian mesh is not to be trimmed at the center but the center trimming boundary is provided anyway.
16.2.25The system shall throw an error if the center trimming would yield a mesh that is over half of the input cartesian mesh, because more than half of the angular sectors are requested.
16.2.26The system shall throw an error if the center trimming index parameters are not given in a pair for cartesian mesh trimming.
16.2.27The system shall throw an error if the input cartesian mesh cannot be trimmed at the periphery.
16.2.28The system shall throw an error if the input cartesian mesh is not to be trimmed at the periphery but the peripheral trimming boundary is provided.
16.2.29The system shall throw an error if the block name assigned to the newly generated TRI elements already exists in the input cartesian mesh.
16.2.30The system shall throw a warning if new blocks are created in the cartesian mesh to avert degenerate elements.
16.2.31The system shall include the ability to assign coarse element IDs based on a coarse mesh for elements of a fine mesh.
16.2.32The system shall include the ability to assign extra element IDs based on the subdomain ID of a coarse mesh for elements of a fine mesh.
16.2.33The system shall include the ability to assign extra element IDs based on an extra element ID of a coarse mesh for elements of a fine mesh.
16.2.34The system shall be able to assign extra element IDs based on a coarse mesh for subdomain-restricted elements of a fine mesh.
16.2.35
The system shall return an error if
1. the coarse mesh extra element id used for assigning does not exist
2. the input mesh is not nested in the coarse mesh in CoarseMeshExtraElementIDGenerator
3. the fine mesh lies beyond the extent of the coarse mesh
4. any node of the fine mesh lies beyond the extent of the coarse mesh
5. requested subdomain restriction does not exist on the fine mesh
16.2.36The system shall generate a full 3D square core mesh with 3 pin types and 2 assembly types
16.2.37The system shall generate a full 3D square core mesh with an assembly that has a background and duct region and another with no duct/background region
16.2.38The system shall generate a 3D square core mesh with empty lattice positions
16.2.39The system shall generate a 3D hexagonal core mesh with empty lattice positions and explicit block name specification
16.2.40The system shall generate a full 3D square core mesh with 2 single assembly types
16.2.41The system shall generate a full 3D hexagonal core mesh with 2 single assembly types
16.2.42The system shall generate a full 3D hexagonal core mesh with 2 duct heterogeneous assembly types
16.2.43The system shall generate a 2D hexagonal core mesh that transfers metadata correctly across RGMB mesh generators
16.2.44The system shall generate a 2D hexagonal core mesh that transfers metadata correctly across RGMB mesh generators in mesh only with extra element ids that have been defined with default values for certain id names
16.2.45The system shall generate a 2D hex core mesh with a reactor periphery meshed using a triangular mesh.
16.2.46The system shall generate a 2D hex core mesh with a reactor periphery meshed using a quadrilateral element ring pattern.
16.2.47The system shall include the ability to copy an element ID to other element IDs.
16.2.48The system shall return an error if the requested source element ID does not exist on the mesh.
16.2.49The system shall generate a hexagon mesh that adapts one boundary of the mesh saved in the exodus file.
16.2.50The system shall generate a non-adaptive hexagon mesh when inputs and sides_to_adapt are not provided.
16.2.51The system shall throw an error if sides_to_adapt and inputs have different sizes for the adaptive hexagonal mesh.
16.2.52The system shall throw an error if the deprecated input parameter is provided along with the new parameter.
16.2.53The system shall be able to trim all of the six peripheral regions off an hexagonal assembly mesh.
16.2.54The system shall be able to trim a fraction of the six peripheral regions off an hexagonal assembly mesh.
16.2.55The system shall be able to trim a fraction of an hexagonal assembly mesh through its center.
16.2.56The system shall be able to trim a fraction of an hexagonal assembly mesh with its peripheral regions modified through its center.
16.2.57The system shall be able to perform both peripheral and center trimming simultaneously on an hexagonal assembly.
16.2.58The system shall be able to perform center trimming on a center-trimmable hexagonal mesh with peripheral ring(s) added.
16.2.59The system shall be able to perform center trimming on an hexagonal core mesh generated by double hexagonal patterning.
16.2.60The system shall be able to perform center trimming on an hexagonal core mesh generated by double hexagonal patterning with the peripheral regions of assembly meshes modified.
16.2.61The system shall be able to perform center trimming on a core mesh generated by double hexagonal patterning with pin centers consisting of triangular elements.
16.2.62The system shall be able to stitch together hexagonal assembly meshes after peripheral trimming.
16.2.63The system shall throw an error if the input hexagonal mesh does not contain the provided external boundary.
16.2.64The system shall throw an error if the input mesh has not been marked compatible with hexagonal mesh trimming.
16.2.65The system shall throw an error if the input hexagonal mesh cannot be center trimmed.
16.2.66The system shall throw an error if the input hexagonal mesh is not to be trimmed at the center but the center trimming boundary is provided anyway.
16.2.67The system shall throw an error if the center trimming would yield a mesh that is over half of the input hexagonal mesh, because more than half of the angular sectors are requested.
16.2.68The system shall throw an error if the center trimming index parameters are not given in a pair for hexagonal mesh trimming.
16.2.69The system shall throw an error if the input hexagonal mesh cannot be trimmed at the periphery.
16.2.70The system shall throw an error if the input hexagonal mesh is not to be trimmed at the periphery but the peripheral trimming boundary is provided.
16.2.71The system shall throw an error if the block name assigned to the newly generated TRI elements already exists in the input hexagonal mesh.
16.2.72The system shall throw a warning if new blocks are created in the hexagonal mesh to avert degenerate elements.
16.2.73The system shall stitch square meshes to form a large mesh with square boundary.
16.2.74The system shall stitch square meshes to form a large mesh with square boundary and without interface boundaries defined.
16.2.75The system shall stitch square meshes to form a large mesh with square boundary without deforming the input meshes.
16.2.76The system shall stitch cartesian meshes to form a large mesh without extra boundary.
16.2.77The system shall stitch square patterned meshes to form a large mesh.
16.2.78The system shall stitch square patterned meshes to form a large mesh with a control drum.
16.2.79The system shall throw a reasonable error when generating patterned cartesian mesh if one of the input meshes has a flat side facing up.
16.2.80The system shall throw an error if the input cartesian meshes contain different block ids that share the same block name.
16.2.81The system shall throw an error if the layer number of cartesian pattern is zero or unity.
16.2.82The system shall throw an error if the cartesian pattern does not represent a square pattern.
16.2.83The system shall throw an error if the pattern includes input cartesian mesh indices that exceed number of elements of input meshes.
16.2.84The system shall throw an error if background_block_id and duct_block_ids are not provided simultaneously if the cartesian mesh has ducts.
16.2.85The system shall throw an error if background_block_name and duct_block_names are not provided simultaneously if the cartesian mesh has ducts.
16.2.86The system shall throw an error if the specified duct size exceeds the external square boundary.
16.2.87The system shall throw an error if the specified square duct size is not strictly ascending.
16.2.88The system shall throw an error if length of duct_block_ids is not consistent with number of cartesian ducts.
16.2.89The system shall throw an error if number of duct names specified is not consistent with number of cartesian ducts.
16.2.90The system shall throw an error if background_block_name or background_block_id are provided for the cartesian pattern when pattern_boundary is none.
16.2.91The system shall throw an error if the enclosing square size is not provided when the pattern boundary style is expanded, which means there is an additional region around the pattern.
16.2.92The system shall throw an error if the enclosing square size is provided when pattern boundary style is none, which means there is no additional region around the pattern
16.2.93The system shall throw an error if not all the cartesian meshes provided in inputs are used in pattern.
16.2.94The system shall throw an error if no pitch meta data can be obtained from the input cartesian mesh.
16.2.95The system shall throw an error if no pattern pitch meta data can be obtained from the input cartesian mesh.
16.2.96The system shall throw an error if input cartesian meshes that should form a lattice have different pattern pitch meta data.
16.2.97The system shall throw an error if the circular regions or protected non-circular regions of the input cartesian mesh geometry are cut off.
16.2.98The system shall generate a square assembly mesh then modify the peripheral region to facilitate further stitching.
16.2.99The system shall generate square assembly meshes with peripheral regions modified in order to stitch them together to form a core mesh.
16.2.100The system shall throw an error if the peripheral modification is set to be performed twice.
16.2.101The system shall throw an error if the cartesian peripheral modifier is applied to a hexagonal mesh.
16.2.102The system shall stitch hexagon meshes to form a large mesh with hexagon boundary.
16.2.103The system shall stitch hexagon meshes to form a large mesh with hexagon boundary and without interface boundaries defined.
16.2.104The system shall stitch hexagon meshes to form a large mesh with hexagon boundary without deforming the input meshes.
16.2.105The system shall stitch hexagon meshes to form a large mesh without extra boundary.
16.2.106The system shall stitch simple hexagon meshes to form a large mesh without extra boundary.
16.2.107The system shall stitch hexagon meshes twice to form a larger mesh.
16.2.108The system shall stitch hexagon meshes twice to form a larger mesh with a control drum.
16.2.109The system shall throw a reasonable error when generating patterned hexagon mesh if one of the input meshes has a flat side facing up.
16.2.110The system shall throw an error if the input hexagonal meshes contain different block ids that share the same block name.
16.2.111The system shall throw an error if the layer number of pattern is not odd.
16.2.112The system shall throw an error if the layer number of hexagonal pattern is zero or unity.
16.2.113The system shall throw an error if the hexagonal pattern does not represent a hexagonal pattern.
16.2.114The system shall throw an error if the pattern includes input hexagonal mesh indices that exceed number of elements of inputs.
16.2.115The system shall throw an error if background_block_id and duct_block_ids are not provided simultaneously if the mesh has ducts.
16.2.116The system shall throw an error if background_block_name and duct_block_names are not provided simultaneously if the hexagonal mesh has ducts.
16.2.117The system shall throw an error if the specified duct size exceeds the external hexagonal boundary.
16.2.118The system shall throw an error if the specified hexagonal duct size is not strictly ascending.
16.2.119The system shall throw an error if length of duct_block_ids is not consistent with number of hexagonal ducts.
16.2.120The system shall throw an error if length of duct_block_names is not consistent with number of hexagonal ducts.
16.2.121The system shall throw an error if background_block_name or background_block_id are provided for the hexagonal pattern when pattern_boundary is none.
16.2.122The system shall throw an error if no hexagon size is provided when pattern_boundary is hexagon.
16.2.123The system shall throw an error if not all the hexagonal meshes provided in inputs are used in pattern.
16.2.124The system shall throw an error if no pitch meta data can be obtained from the input hexagonal mesh.
16.2.125The system shall throw an error if no pattern pitch meta data can be obtained from the input hexagonal mesh.
16.2.126The system shall throw an error if input hexagonal meshes have different pattern pitch meta data.
16.2.127The system shall throw an error if the input hexagonal mesh geometry that should not be deformed is cut off.
16.2.128The system shall throw an error if hexagon boundary needs to be generated for simple unit hexagon mesh.
16.2.129The system shall generate a hexagonal assembly mesh then modify the peripheral region to facilitate further stitching.
16.2.130The system shall generate a hexagonal assembly mesh with modified peripheral region and retain the specified reporting id.
16.2.131The system shall generate a hexagonal assembly mesh with modified peripheral region and assign new values to the specified reporting id.
16.2.132The system shall generate hexagonal assembly meshes with peripheral regions modified in order to stitch them together to form a core mesh.
16.2.133The system shall throw an error if the size of specificed reporting id values does not match size of specified reporting id names.
16.2.134The system shall throw an error if the specified reporting id to be modified does not exist on the input mesh.
16.2.135The system shall throw an error if the input mesh to the hexagonal mesh boundary modifier is generated by an incompatible mesh generator.
16.2.136The system shall throw an error if the hexagonal peripheral modifier is applied to a cartesian mesh.
16.2.137The system shall add a peripheral ring to to the input mesh without preserving volumes due to polygonization.
16.2.138The system shall add a peripheral ring to the input mesh with its centroid off the origin.
16.2.139The system shall add a peripheral ring to the input mesh after moving its centroid to the origin.
16.2.140The system shall be able to add a peripheral ring to the input mesh and preserve volumes even with polygonization.
16.2.141The system shall be able to add a peripheral ring with radial biasing to the input mesh and preserve volumes even with polygonization.
16.2.142The system shall be able to add a peripheral ring with boundary layers to the input mesh and preserve volumes even with polygonization.
16.2.143The system shall throw an error if the specified inner and outer boundary layers are overlapped.
16.2.144The system shall throw an error if a non-2D mesh is given as the input mesh.
16.2.145The system shall throw an error if the given boundary of the input mesh has two or more segments.
16.2.146The system shall throw an error if the given boundary of the input mesh is an open curve.
16.2.147The system shall throw an error if the consecutive nodes of the given boundary of the input mesh do not change monotonically.
16.2.148The system shall throw an error if the given peripheral ring radius is not enough to cover the input mesh.
16.2.149The system shall throw an error if the given external boundary is actually an internal boundary of the input mesh.
16.2.150The system shall generate a triangulation without any refinement.
16.2.151The system shall generate a triangulation with area refinement.
16.2.152The system shall generate a 2D square pin mesh with fuel, gap, clad, background regions
16.2.153The system shall generate a 3D square pin mesh with ring and background region and tri center elements
16.2.154The system shall generate a pin mesh with more than 1 radial region and tri center elements
16.2.155The system shall generate a pin mesh with more than 1 radial region and quad center elements
16.2.156The system shall generate a pin mesh with no radial region and more than 1 background intervals with tri center elements
16.2.157The system shall generate a 2D hexagonal pin mesh with 2 radial regions
16.2.158The system shall generate a 3D hexagonal pin mesh with radial, background, and duct regions
16.2.159The system shall generate a 2D hexagonal homogenized pin mesh with quad discretization
16.2.160The system shall generate a 2D hexagonal homogenized pin mesh with tri discretization
16.2.161The system shall generate a 3D hexagonal homogenized pin mesh with quad discretization
16.2.162The system shall generate a 2D hexagonal homogenized pin mesh that is treated as a single assembly
16.2.163The system shall generate a 2D hexagonal ducted pin mesh that is treated as a single assembly
16.2.164The system shall generate a 2D Cartesian ducted pin mesh that is treated as a single assembly
16.2.165The system shall generate a hexagon mesh without rings and ducts.
16.2.166The system shall generate a hexagon mesh without rings and ducts and without generating side specific boundaries.
16.2.167The system shall generate a polygon mesh without rings and ducts and with a multilayer QUAD background using a single set of block id and name.
16.2.168The system shall generate a hexagon mesh without rings and ducts with one of its flat side facing up.
16.2.169The system shall generate a hexagon mesh with only one radial layer of elements without rings and ducts.
16.2.170The system shall generate a hexagon mesh with only one radial layer of specially patterned quad elements without rings and ducts.
16.2.171The system shall generate a hexagon mesh with rings.
16.2.172The system shall generate a hexagon mesh with rings, with the innermost ring having multilayer QUAD elements and being assigned by a single set of block id and name.
16.2.173The system shall generate a hexagon mesh with ducts.
16.2.174The system shall generate a hexagon mesh with rings and ducts.
16.2.175The system shall generate a hexagon mesh with rings and ducts and without interface boundaries defined.
16.2.176The system shall generate a hexagon mesh with rings and ducts and with inward interface boundaries defined.
16.2.177The system shall generate a radially biased hexagon mesh with rings and ducts.
16.2.178The system shall generate a hexagon mesh with boundary layer.
16.2.179The system shall generate a hexagon mesh with rings and ducts including boundary layers.
16.2.180The system shall generate a hexagon mesh with rings, ducts and quad central elements.
16.2.181The system shall generate a hexagon mesh with rings, ducts and quad central elements with custom center quad factor.
16.2.182
The system shall generate a pin mesh with the reporting ID
1. for annular blocks.
2. for annular individual rings.
3. for sectors.
4. for ring and sectors on hexagonal pin.
16.2.183
The system shall throw an error if
1. num_sectors_per_side and quad_center_elements are not compatible.
2. the number of outward interface boundary names is different from the number of outward interfaces.
3. multiple background block ids have been specified at the same time as one or more ring(s) for the inner region
4. multiple background block names have been specified at the same time as one or more ring(s) for the inner region.
5. background_block_ids has a length other than zero or two when the mesh does not have rings and the total number of background intervals does not equal one.
6. background_block_names has a length other than zero or two when the mesh does not have rings and the total number of background intervals does not equal one.
7. multiple block ids share a single block name.
8. size of num_sectors_per_side is not num_sides.
9. num_sectors_per_side elements are not all even.
10. ring_radii and ring_intervals have different sizes.
11. ring_radii and ring_radial_biases have different sizes.
12. ring_block_ids size is not consistent with number of rings in the mesh.
13. ring_block_names size is not consistent with number of rings in the mesh.
14. ring_radii is not strictly ascending.
15. rings are bigger than the polygon.
16. duct_sizes and duct_intervals have different sizes.
17. duct_sizes and duct_radial_biases have different sizes.
18. duct_block_ids size is not consistent with the number of ducts in the mesh.
19. duct_block_names size is not consistent with the number of ducts in the mesh.
20. duct_sizes is not strictly ascending.
21. duct_sizes is non-positive or is low enough to be overlapped with rings.
22. duct_sizes is bigger than the polygon.
23. boundary layers in background region of a hexagonal cell are overlapped.
24. inner and outer ring boundary layer parameters have inconsistent size.
25. ring's inner boundary layer has zero interval but non-zero thickness.
26. ring's inner boundary layer has nonzero intervals but zero thickness.
27. ring's outer boundary layer has zero interval but non-zero thickness.
28. ring's outer boundary layer has nonzero intervals but zero thickness.
29. ring's boundary layers are thicker than the ring itself.
30. inner and outer duct boundary layer parameters have inconsistent size.
31. duct's inner boundary layer has zero interval but non-zero thickness.
32. duct's inner boundary layer has nonzero intervals but zero thickness.
33. duct's outer boundary layer has zero interval but non-zero thickness.
34. duct's outer boundary layer has nonzero intervals but zero thickness.
35. duct's boundary layers are thicker than the ring itself.
36. center_quad_factor is provided for triangular center elements.
37. outward interface boundaries related parameters are provided while outward interface boundaries are not set to be created.
38. inward interface boundaries related parameters are provided but inward interface boundaries are not set to be created.
39. interface boundary id shift parameter is provided but neither inward and outward boundaries are set to be created.
16.2.184
The system shall support the generation of reporting IDs for Cartesian assemblies assigned
1. in sequential order for each components in the lattice
2. based on the ID of the input pattern tiles
3. based on user-defined mapping
16.2.185
The system shall support the generation of assembly and pin reporting IDs for Cartesian cores
1. with regular square core boundary
2. with zagged core boundary formed by removal of certain assemblies on periphery
16.2.186
The system shall support the generation of reporting IDs
1. for Cartesian assemblies assigned in sequential order for each components in the lattice
2. for Cartesian assemblies assigned based on the ID of the input pattern tiles
3. for Cartesian assemblies assigned based on user-defined mapping
4. for Cartesian cores with regular square core boundary
16.2.187The system shall support the generation of depletion IDs for a 2D reactor core
16.2.188The system shall support the generation of plane depletion IDs for 2D reactor cores with skipped materials
16.2.189The system shall support the generation of sub-pin level depletion IDs
16.2.190
The system shall support the generation of reporting IDs for hexagonal assemblies assigned
1. in sequential order for each components in the lattice
2. based on the ID of the input pattern tiles
3. based on user-defined mapping
16.2.191The system shall support the generation of reporting IDs for hexagonal cores
16.2.192The system shall support the generation of reporting IDs for hexagonal cores with removal of certain assemblies on periphery
16.2.193
The system shall include the ability to create a simple hexagon mesh
1. with TRI elements
2. with QUAD elements
3. with hybrid elements
16.2.194
The system shall throw an error
1. if the radial element layer number is provided but a non-hybrid mesh is to be generated.
2. if excessive subdomain ids are provided.
3. if insufficient subdomain ids are provided.
4. if the custom subdomain ids and names provided have inconsistent sizes.
16.2.195The system shall include the ability to assign element IDs based on mesh subdomain IDs or names.
16.2.196
The system shall return an error if
1. the subdomain vector to use for assigning extra element IDs is empty
2. a subdomain is listed more than once when assigning extra element IDs
3. the subdomain ids and the extra element id names arent vectors of the same size
4. the subdomain ids and the extra element ids to set arent vectors of the same size
5. the default extra element IDs arent specified for each extra element id
16.2.197The system shall be able to generate a tri-pin hexagonal assembly mesh.
16.2.198The system shall be able to generate a tri-pin assembly mesh by specifying the apothem size.
16.2.199The system shall be able to generate a tri-pin assembly mesh with ring and sector Ids.
16.2.200The system shall generate a tri-pin assembly mesh with three identical pins.
16.2.201The system shall be able to generate a dummy core mesh containing a tri-pin assembly.
16.2.202The system shall throw an error if the number of rings radii specified does not match either one or the number of pins
16.2.203The system shall throw an error if the largest ring specified exceeds the assembly boundary.
16.2.204The system shall throw an error if the parameter specifying the radial intervals of ring regions does not have appropriate size.
16.2.205The system shall throw an error if the parameter specifying the block ids of ring regions does not have appropriate size.
16.2.206The system shall throw an error if the parameter specifying the radial intervals of ring regions is inconsistent with the parameter specifying the sizes of ring regions.
16.2.207The system shall throw an error if the parameter specifying the block ids of ring regions is inconsistent with the parameter specifying the sizes of ring regions (case 1).
16.2.208The system shall throw an error if the parameter specifying the block ids of ring regions is inconsistent with the parameter specifying the sizes of ring regions (case 2).
16.2.209The system shall throw an error if the parameter specifying the block names of ring regions is inconsistent with the parameter specifying the sizes of ring regions (case 1).
16.2.210The system shall throw an error if the parameter specifying the block names of ring regions is inconsistent with the parameter specifying the sizes of ring regions (case 2).
16.2.211The system shall throw an error if the parameter specifying the block names of ring regions is inconsistent with the parameter specifying the block ids of ring regions.
16.2.212The system shall throw an error if the size of the parameter specifying the block ids of background region is not one when all the three sections have rings.
16.2.213The system shall throw an error if the size of the parameter specifying the block names of background region is not one when all the three sections have rings.
16.2.214The system shall throw an error if the size of the parameter specifying the block ids of background region is not two when ring-free section exists.
16.2.215The system shall throw an error if the size of the parameter specifying the block names of background region is not two when ring-free section exists.
16.2.216The system shall throw an error if the size of the parameter specifying the block ids of background region is not one when all the sections are ring-free and background_intervals is 1.
16.2.217The system shall throw an error if the size of the parameter specifying the block names of background region is not one when all the sections are ring-free and background_intervals is 1.
16.2.218The system shall throw an error if extra element integer values of the pins are provided without specifying extra element integer names.
16.2.219The system shall throw an error if extra element integer values specified do not have the correct size.
16.2.220The system shall throw an error if the offset of the ring region center moves the center of the ring out of the hexagon assembly region.

Usability Requirements

No requirements of this type exist for this application, beyond those of its dependencies.

Performace Requirements

No requirements of this type exist for this application, beyond those of its dependencies.

System Interfaces

No requirements of this type exist for this application, beyond those of its dependencies.

System Operations

Human System Integration Requirements

The Reactor module is command line driven and conforms to all standard terminal behaviors. Specific human system interaction accommodations shall be a function of the end-user's terminal. MOOSE (and therefore the Reactor module) does support optional coloring within the terminal's ability to display color, which may be disabled.

Maintainablity

The latest working version (defined as the version that passes all tests in the current regression test suite) shall be publicly available at all times through the repository host provider.
Flaws identified in the system shall be reported and tracked in a ticket or issue based system. The technical lead will determine the severity and priority of all reported issues and assign resources at their discretion to resolve identified issues.
The software maintainers will entertain all proposed changes to the system in a timely manner (within two business days).
The core software in its entirety will be made available under the terms of a designated software license. These license terms are outlined in the LICENSE file alongside the Reactor module source code. As a MOOSE physics module, the license for the Reactor module is identical to that of the framework - that is, the LGPL version 2.1 license.

Reliability

The regression test suite will cover at least 95% of all lines of code within the Reactor module at all times. Known regressions will be recorded and tracked (see Maintainablity) to an independent and satisfactory resolution.

System Modes and States

MOOSE applications normally run in normal execution mode when an input file is supplied. However, there are a few other modes that can be triggered with various command line flags as indicated here:

Command Line Flag	Description of mode
`-i <input_file>`	Normal execution mode
`--split-mesh <splits>`	Read the mesh block splitting the mesh into two or more pieces for use in a subsequent run
`--use-split`	(implies -i flag) Execute the the simulation but use pre-split mesh files instead of the mesh from the input file
`--yaml`	Output all object descriptions and available parameters in YAML format
`--json`	Output all object descriptions and available parameters in JSON format
`--syntax`	Output all registered syntax
`--registry`	Output all known objects and actions
`--registry-hit`	Output all known objects and actions in HIT format
`--mesh-only` (implies -i flag)	Run only the mesh related tasks and output the final mesh that would be used for the simulation
`--start-in-debugger <debugger>`	Start the simulation attached to the supplied debugger

note

The list of system-modes may not be extensive as the system is designed to be extendable to end-user applications. The complete list of command line options for applications can be obtained by running the executable with zero arguments. See the command line usage.

Physical Characteristics

The Reactor module is software only with no associated physical media. See System Requirements for a description of the minimum required hardware necessary for running the Reactor module.

Environmental Conditions

Not Applicable

System Security

MOOSE-based applications such as the Reactor module have no requirements or special needs related to system security. The software is designed to run completely in user-space with no elevated privileges required nor recommended.

Information Management

The core framework and all modules in their entirety will be made publicly available on an appropriate repository hosting site. Day-to-day backups and security services will be provided by the hosting service. More information about MOOSE backups of the public repository on INL-hosted services can be found on the following page: GitHub Backups

Polices and Regulations

MOOSE-based applications must comply with all export control restrictions.

System Life Cycle Sustainment

MOOSE-based development follows various agile methods. The system is continuously built and deployed in a piecemeal fashion since objects within the system are more or less independent. Every new object requires a test, which in turn requires an associated requirement and design description. The Reactor module development team follows the NQA-1 standards.

Packaging, Handling, Shipping and Transportation

No special requirements are needed for packaging or shipping any media containing MOOSE and Reactor module source code. However, some MOOSE-based applications that use the Reactor module may be export-controlled, in which case all export control restrictions must be adhered to when packaging and shipping media.

Verification

The regression test suite will employ several verification tests using comparison against known analytical solutions, the method of manufactured solutions, and convergence rate analysis.

Introduction
System Overview
References
Definitions and Acronyms
System Requirements
Verification