Level Set Requirements Traceability Matrix

This template follows INL template TEM-214, "IT System Requirements Traceability Matrix."

note

This document serves as an addendum to Framework Requirements Traceability Matrix and captures information for RTM specific to the Level Set application.

Framework Requirements Traceability Matrix

Introduction

Minimum System Requirements

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

GCC/Clang C++17 compliant compiler (GCC @ 7.5.0, Clang @ 5.0.2 or greater)
- Note: Intel compilers are not supported.
Memory: 16 GBs (debug builds)
Processor: 64-bit x86
Disk: 30GB

System Purpose

The MOOSE is a tool for solving complex coupled Multiphysics equations using the finite element method. MOOSE uses an object-oriented design to abstract data structure management, parallelism, threading and compiling while providing an easy to use interface targeted at engineers that may not have a lot of software development experience. MOOSE will require extreme scalability and flexibility when compared to other FEM frameworks. For instance, MOOSE needs the ability to run extremely complex material models, or even third-party applications within a parallel simulation without sacrificing parallelism. This capability is in contrast to what is often seen in commercial packages, where custom material models can limit the parallel scalability, forcing serial runs in the most severe cases. When comparing high-end capabilities, many MOOSE competitors target modest-sized clusters with just a few thousand processing cores. MOOSE, however, will be required to routinely executed on much larger clusters with scalability to clusters available in the top 500 systems (top500.org). MOOSE will also be targeted at smaller systems such as high-end laptop computers.

The design goal of MOOSE is to give developers ultimate control over their physical models and applications. Designing new models or solving completely new classes of problems will be accomplished by writing standard C++ source code within the framework's class hierarchy. Scientists and engineers will be free to implement completely new algorithms using pieces of the framework where possible, and extending the framework's capabilities where it makes sense to do so. Commercial applications do not have this capability, and instead opt for either a more rigid parameter system or a limited application-specific metalanguage.

System Scope

MOOSE's scope is to provide a set of interfaces for building FEM simulations. Abstractions to all underlying libraries are provided.

Solving coupled problems where competing physical phenomena impact one and other in a significant nonlinear fashion represents a serious challenge to several solution strategies. Small perturbations in strongly-coupled parameters often have very large adverse effects on convergence behavior. These adverse effects are compounded as additional physics are added to a model. To overcome these challenges, MOOSE employs three distinct yet compatible systems for solving these types of problems.

First, an advanced numerical technique called the JFNK method is employed to solve the most fully-coupled physics in an accurate, consistent way. An example of this would be the effect of temperature on the expansion or contraction of a material. While the JFNK numerical method is very effective at solving fully-coupled equations, it can also be computationally expensive. Plus, not all physical phenomena in a given model are truly coupled to one another. For instance, in a reactor, the speed of the coolant flow may not have any direct effect on the complex chemical reactions taking place inside the fuel rods. We call such models "loosely-coupled". A robust, scalable system must strike the proper balance between the various modeling strategies to avoid performing unnecessary computations or incorrectly predicting behavior in situations such as these.

MOOSE's Multiapp system will allow modelers to group physics into logical categories where MOOSE can solve some groups fully-coupled and others loosely-coupled. The Multiapp system goes even further by also supporting a "tightly-coupled" strategy, which falls somewhere between the "fully-coupled" and "loosely-coupled" approaches. Several sets of physics can then be linked together into logical hierarchies using any one of these coupling strategies, allowing for several potential solution strategies. For instance, a complex nuclear reactor model might consist of several tightly-coupled systems of fully-coupled equations.

Finally, MOOSE's Transfers system ties all of the physics groups contained within the Multiapp system together and allows for full control over the flow of information among the various groups. This capability bridges physical phenomena from several different complementary scales simultaneously. When these three MOOSE systems are combined, myriad coupling combinations are possible. In all cases, the MOOSE framework handles the parallel communication, input, output and execution of the underlying simulation. By handling these computer science tasks, the MOOSE framework keeps modelers focused on doing research.

MOOSE innovates by building advanced simulation capabilities on top of the very best available software technologies in a way that makes them widely accessible for innovative research. MOOSE is equally capable of solving small models on common laptops and the very biggest FEM models ever attempted—all without any major changes to configuration or source code. Since its inception, the MOOSE project has focused on both developer and computational efficiency. Improved developer efficiency is achieved by leveraging existing algorithms and technologies from several leading open-source packages. Additionally, MOOSE uses several complementary parallel technologies (both the distributed-memory message passing paradigm and shared-memory thread-based approaches are used) to lay an efficient computational foundation for development. Using existing open technologies in this manner helps the developers reduce the scope of the project and keeps the size of the MOOSE code base maintainable. This approach provides users with state-of-the-art finite element and solver technology as a basis for the advanced coupling and solution strategies mentioned previously.

MOOSE's developers work openly with other package developers to make sure that cutting-edge technologies are available through MOOSE, providing researchers with competitive research opportunities. MOOSE maintains a set of objects that hide parallel interfaces while exposing advanced spatial and temporal coupling algorithms in the framework. This accessible approach places developmental technology into the hands of scientists and engineers, which can speed the pace of scientific discovery.

Assumptions and Dependencies

The Level Set application is developed using MOOSE and is based on various modules, as such the RTM for Level Set is dependent upon the files listed at the beginning of this document.

Pre-test Instructions/Environment/Setup

Ideally all testing should be performed on a clean test machine following one of the supported configurations setup by the test system engineer. Testing may be performed on local workstations and cluster systems containing supported operating systems.

The repository should be clean prior to building and testing. When using "git" this can be done by doing a force clean in the main repository and each one of the submodules:


git clean -xfd
git submodule foreach 'git clean -xfd'

All tests must pass in accordance with the type of test being performed. This list can be found in the Software Test Plan.

System Requirements Traceability

Functional Requirements

level_set: Functions
17.1.1The level set module shall include the bubble function defined in Olsson and Kreiss (2005).
Specification(s): test
Design: LevelSetOlssonBubble
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): Exodiff
36
17.1.2The Olsson bubble function shall return correct derivatives for dual number points.
Specification(s): adjac
Design: LevelSetOlssonBubble
Issue(s): #20193
Collection(s): FUNCTIONAL
Type(s): PetscJacobianTester
31
17.1.3The level set module shall include the plane function defined in Olsson and Kreiss (2005).
Specification(s): test
Design: LevelSetOlssonPlane
Issue(s): #15167
Collection(s): FUNCTIONAL
Type(s): Exodiff
36
17.1.4The level set module shall include the vortex function defined in Olsson and Kreiss (2005) with an instantaneous reverse feature.
Specification(s): instantenous
Design: LevelSetOlssonVortex
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): Exodiff
36
17.1.5The level set module shall include the vortex function defined in Olsson and Kreiss (2005) with an cosine reverse feature.
Specification(s): cosine
Design: LevelSetOlssonVortex
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): Exodiff
36

level_set: Kernels
17.2.1The LevelSetAdvection Kernel shall converage at the correct rate as tested by the method of manufactured solutions.
Specification(s): mms
Design: LevelSetAdvection
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): CSVDiff
36
17.2.2The level set module shall include the reinitialization scheme presented by Olsson and Kreiss (2005).
Specification(s): test
Design: LevelSetAdvection
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): Exodiff
36

level_set: Reinitialization
17.3.1The level set module shall be capable of solving the level set equation with original reinitialization.
Specification(s): full_original_reinitialization
Design: Level Set Module
Issue(s): #14849
Collection(s): FUNCTIONAL
Type(s): Exodiff
32
17.3.2The level set module shall be capable of solving the level set equation with modified reinitialization.
Specification(s): full_modified_reinitialization
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): Exodiff
32

level_set: Transfers
17.4.1The level set module shall include the ability to transfer a non-linear variable between the master and a sub-application.
Specification(s): copy
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): Exodiff
36
17.4.2The level set module shall include the ability to transfer refinement patterns, with multiple levels of refinement, to a sub-application.
Specification(s): test
Design: Level Set Module LevelSetMeshRefinementTransfer
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): Exodiff
36
17.4.3The level set module shall include the ability to transfer refinement patterns, with a single level of refinement, to a sub-application.
Specification(s): test
Design: Level Set Module LevelSetMeshRefinementTransfer
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): Exodiff
36
17.4.4The system shall return an error if parameters for an unsupported direction are passed to a transfer
Specification(s): parameter_error
Design: Level Set Module LevelSetMeshRefinementTransfer
Issue(s): #19451
Collection(s): FAILURE_ANALYSISFUNCTIONAL
Type(s): RunException
36

level_set: Verification
17.5.1The level set module shall use the method of manufactured solutions to test convergence of the level set equation and ensure that the level 0 solution is consistent.
Specification(s): level_00
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): CSVDiff
36
17.5.2The level set module shall use the method of manufactured solutions to test convergence of the level set equation and ensure that the level 1 solution is consistent.
Specification(s): level_01
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): CSVDiff
36
17.5.3The level set module shall use the method of manufactured solutions to test convergence of the level set equation and ensure that the level 2 solution is consistent.
Specification(s): level_02
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): CSVDiff
36
17.5.4The level set module shall use the method of manufactured solutions to test convergence of the level set equation and ensure that the level 3 solution is consistent.
Specification(s): level_03
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): CSVDiff
36
17.5.5The level set module shall use the method of manufactured solutions to test convergence of the level set equation and ensure that the level 4 solution is consistent.
Specification(s): level_04
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): CSVDiff
36
17.5.6The level set module shall use the method of manufactured solutions to test convergence of the level set equation with SUPG and ensure that the level 0 solution is consistent.
Specification(s): level_00
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): CSVDiff
36
17.5.7The level set module shall use the method of manufactured solutions to test convergence of the level set equation with SUPG and ensure that the level 1 solution is consistent.
Specification(s): level_01
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): CSVDiff
36
17.5.8The level set module shall use the method of manufactured solutions to test convergence of the level set equation with SUPG and ensure that the level 2 solution is consistent.
Specification(s): level_02
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): CSVDiff
36
17.5.9The level set module shall use the method of manufactured solutions to test convergence of the level set equation with SUPG and ensure that the level 3 solution is consistent.
Specification(s): level_03
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): CSVDiff
36
17.5.10The level set module shall use the method of manufactured solutions to test convergence of the level set equation with SUPG and ensure that the level 4 solution is consistent.
Specification(s): level_04
Design: Level Set Module
Issue(s): #8465
Collection(s): FUNCTIONAL
Type(s): CSVDiff
36

Usability Requirements

Performance Requirements

System Interface Requirements

References

Elin Olsson and Gunilla Kreiss. A conservative level set method for two phase flow. Journal of computational physics, 210(1):225–246, 2005. URL: http://dx.doi.org/10.1016/j.jcp.2005.04.007.

@article{olsson2005conservative,
    author = "Olsson, Elin and Kreiss, Gunilla",
    title = "A conservative level set method for two phase flow",
    journal = "Journal of computational physics",
    volume = "210",
    number = "1",
    pages = "225--246",
    year = "2005",
    publisher = "Elsevier",
    url = "http://dx.doi.org/10.1016/j.jcp.2005.04.007"
}


[./test]
  type = Exodiff
  input = olsson_bubble.i
  exodiff = olsson_bubble_out.e
  issues = '#8465'
  requirement = "The level set module shall include the bubble function defined in [!cite](olsson2005conservative)."
[../]


[./adjac]
  type = PetscJacobianTester
  input = olsson_bubble_adjac.i
  ratio_tol = 1e-7
  issues = '#20193'
  requirement = "The Olsson bubble function shall return correct derivatives for dual number points."
[../]


[./instantenous]
  type = Exodiff
  input = olsson_vortex.i
  exodiff = olsson_vortex_out.e
  requirement = "The level set module shall include the vortex function defined in [!cite](olsson2005conservative) with an instantaneous reverse feature."
[../]


[./cosine]
  type = Exodiff
  input = olsson_vortex.i
  cli_args = "Functions/velocity_func/reverse_type=cosine Outputs/file_base=olsson_vortex_cosine_out"
  exodiff = olsson_vortex_cosine_out.e
  requirement = "The level set module shall include the vortex function defined in [!cite](olsson2005conservative) with an cosine reverse feature."
[../]


[./mms]
  type = CSVDiff
  input = advection_mms.i
  csvdiff = advection_mms_out.csv
  # This problem uses SuperLU.
  superlu = true
  requirement = "The LevelSetAdvection Kernel shall converage at the correct rate as tested by the method of manufactured solutions."
[../]


[./test]
  type = Exodiff
  input = olsson_1d.i
  exodiff = olsson_1d_out.e
  requirement = "The level set module shall include the reinitialization scheme presented by [!cite](olsson2005conservative)."
  valgrind = HEAVY
[../]


[./full_original_reinitialization]
  # Runs two steps of a full original reinitialization problem just to make sure it continues to work
  type = Exodiff
  input = master.i
  exodiff = master_original.e
  cli_args = 'Executioner/num_steps=2 Outputs/file_base=master_original'
  method = '!dbg' # complete reinitilization solve, debug is slow and not needed
  valgrind = HEAVY
  requirement = "The level set module shall be capable of solving the level set equation with original reinitialization."
  issues = '#14849'
[../]


[./full_modified_reinitialization]
  # Runs two steps of a full modified reinitialization problem just to make sure it continues to work
  type = Exodiff
  input = master.i
  exodiff = master_modified.e
  cli_args = 'Executioner/num_steps=2 MultiApps/reinit/input_files=reinit_modified.i Outputs/file_base=master_modified'
  method = '!dbg' # complete reinitilization solve, debug is slow and not needed
  valgrind = HEAVY
  requirement = "The level set module shall be capable of solving the level set equation with modified reinitialization."
  issues = '#8465'
[../]


[./copy]
  type = Exodiff
  input = master.i
  exodiff = master_out_sub0.e
  requirement = "The level set module shall include the ability to transfer a non-linear variable between the master and a sub-application."
[../]


[./test]
  type = Exodiff
  input = master.i
  exodiff = 'master_out.e master_out.e-s002 master_out.e-s003 master_out.e-s004 master_out_sub0.e master_out_sub0.e-s002 master_out_sub0.e-s003 master_out_sub0.e-s004'
  requirement = "The level set module shall include the ability to transfer refinement patterns, with multiple levels of refinement, to a sub-application."
[../]


[test]
  type = Exodiff
  input = master.i
  exodiff = 'master_out.e master_out_sub0_out.e'
  requirement = "The level set module shall include the ability to transfer refinement patterns, with a single level of refinement, to a sub-application."
  issues = '#8465'
[]


[parameter_error]
  type = RunException
  input = master.i
  expect_err = 'from_multiapp or between_multiapp transfers are not supported'
  cli_args = 'Transfers/marker_to_sub/from_multi_app=sub'
  requirement = "The system shall return an error if parameters for an unsupported direction are passed to a transfer"
  issues = '#19451'
[]


[./level_00]
  type = CSVDiff
  input = level_set_mms.i
  csvdiff = level_set_mms_00.csv
  cli_args = 'Mesh/uniform_refine=0 Outputs/file_base=level_set_mms_00'
  requirement = "The level set module shall use the method of manufactured solutions to test convergence of the level set equation and ensure that the level 0 solution is consistent."
[../]


[./level_01]
  type = CSVDiff
  input = level_set_mms.i
  csvdiff = level_set_mms_01.csv
  cli_args = 'Mesh/uniform_refine=1 Outputs/file_base=level_set_mms_01'
  requirement = "The level set module shall use the method of manufactured solutions to test convergence of the level set equation and ensure that the level 1 solution is consistent."
[../]


[./level_02]
  type = CSVDiff
  input = level_set_mms.i
  csvdiff = level_set_mms_02.csv
  cli_args = 'Mesh/uniform_refine=2 Outputs/file_base=level_set_mms_02'
  requirement = "The level set module shall use the method of manufactured solutions to test convergence of the level set equation and ensure that the level 2 solution is consistent."
[../]


[./level_03]
  type = CSVDiff
  input = level_set_mms.i
  csvdiff = level_set_mms_03.csv
  cli_args = 'Mesh/uniform_refine=3 Outputs/file_base=level_set_mms_03'
  requirement = "The level set module shall use the method of manufactured solutions to test convergence of the level set equation and ensure that the level 3 solution is consistent."
[../]


[./level_04]
  type = CSVDiff
  input = level_set_mms.i
  csvdiff = level_set_mms_04.csv
  cli_args = 'Mesh/uniform_refine=4 Outputs/file_base=level_set_mms_04'
  requirement = "The level set module shall use the method of manufactured solutions to test convergence of the level set equation and ensure that the level 4 solution is consistent."
  valgrind = HEAVY
[../]


[./level_00]
  type = CSVDiff
  input = 1d_level_set_supg_mms.i
  csvdiff = 1d_level_set_supg_mms_00.csv
  cli_args = 'Mesh/uniform_refine=0 Outputs/file_base=1d_level_set_supg_mms_00'
  requirement = "The level set module shall use the method of manufactured solutions to test convergence of the level set equation with SUPG and ensure that the level 0 solution is consistent."
[../]


[./level_01]
  type = CSVDiff
  input = 1d_level_set_supg_mms.i
  csvdiff = 1d_level_set_supg_mms_01.csv
  cli_args = 'Mesh/uniform_refine=1 Outputs/file_base=1d_level_set_supg_mms_01'
  requirement = "The level set module shall use the method of manufactured solutions to test convergence of the level set equation with SUPG and ensure that the level 1 solution is consistent."
[../]


[./level_02]
  type = CSVDiff
  input = 1d_level_set_supg_mms.i
  csvdiff = 1d_level_set_supg_mms_02.csv
  cli_args = 'Mesh/uniform_refine=2 Outputs/file_base=1d_level_set_supg_mms_02'
  requirement = "The level set module shall use the method of manufactured solutions to test convergence of the level set equation with SUPG and ensure that the level 2 solution is consistent."
[../]


[./level_03]
  type = CSVDiff
  input = 1d_level_set_supg_mms.i
  csvdiff = 1d_level_set_supg_mms_03.csv
  cli_args = 'Mesh/uniform_refine=3 Outputs/file_base=1d_level_set_supg_mms_03'
  requirement = "The level set module shall use the method of manufactured solutions to test convergence of the level set equation with SUPG and ensure that the level 3 solution is consistent."
[../]


[./level_04]
  type = CSVDiff
  input = 1d_level_set_supg_mms.i
  csvdiff = 1d_level_set_supg_mms_04.csv
  cli_args = 'Mesh/uniform_refine=4 Outputs/file_base=1d_level_set_supg_mms_04'
  requirement = "The level set module shall use the method of manufactured solutions to test convergence of the level set equation with SUPG and ensure that the level 4 solution is consistent."
[../]

Introduction
Minimum System Requirements
System Requirements Traceability
References

Install MOOSE

New Users

Examples and Tutorials

Application Usage

Physics and Syntax

Application Development

Framework Development

MOOSEDocs

Infrastructure

Questions

Information and Tools

INL Applications and Remote Access