Framework System Requirements Specification

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

Introduction

System Purpose

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 Finite Element Method (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 Jacobian-Free Newton-Krylov (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.

System Overview

System Context

MOOSE is a command-line driven application. This is typical for high-performance software that is designed to run across several nodes of a cluster system. As such, all of the 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. MOOSE 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 MOOSE and MOOSE-based applications.

System Functions

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

User Characteristics

Framework Developers: These are the core developers of the framework. They will be responsible for following and enforcing the appropriate software development standards. They will be responsible for designing, implementing and maintaining the software.
Developers: A Scientist or Engineer that utilizes the framework to build their own application. This user will typically have a background in modeling and simulation techniques and/or numerical analysis but may only have a limited skill-set when it comes to object-oriented coding and the C++ language. This is our primary focus group. In many cases these developers will be encouraged to give their code back to the framework maintainers.
Analysts: These are users that will run the code and perform various 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

This section outlines any assumptions and/or dependencies of the software.

The software should be designed with the fewest possible constraints. Ideally the software should run on a wide variety of evolving hardware so it should follow well-adopted standards and guidelines. The software should run on any Portable Operating System Interface (POSIX) compliant system. The software will also make use FEM and numerical libraries that run on POSIX systems as well. The main interface for the software will be command line based with no assumptions requiring advanced terminal capabilities such as coloring and line control.

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"
}

D. F. Griffiths. The `No Boundary Condition' outflow boundary condition. International Journal of Numerical Methods in Fluids, 24(4):393–411, 1997. URL: http://tinyurl.com/y77au2k.

@article{griffiths1997noboundary,
    author = "Griffiths, D. F.",
    title = "{The `No Boundary Condition' outflow boundary condition}",
    journal = "International Journal of Numerical Methods in Fluids",
    year = "1997",
    volume = "24",
    number = "4",
    pages = "393--411",
    url = "http://tinyurl.com/y77au2k"
}

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
FEM	Finite Element Method
INL	Idaho National Laboratory
JFNK	Jacobian-Free Newton-Krylov
LGPL	GNU Lesser General Public License
MOOSE	Multiphysics Object Oriented Simulation Environment
NQA-1	Nuclear Quality Assurance Level 1
POSIX	Portable Operating System Interface

System Requirements

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

A POSIX compliant Unix-like operating system. This includes any modern Linux-based operating system (e.g., Ubuntu, Fedora, Rocky, etc.), or a Macintosh machine running either of the last two MacOS releases.

Hardware	Information
CPU Architecture	x86_64, ARM (Apple Silicon)
Memory	8 GB (16 GBs for debug compilation)
Disk Space	30GB

Libraries	Version / Information
GCC	8.5.0 - 12.2.1
LLVM/Clang	10.0.1 - 16.0.6
Intel (ICC/ICX)	Not supported at this time
Python	3.7 - 3.11
Python Packages	packaging pyaml jinja2

Functional Requirements

framework: Actioncomponents
2.1.1The system shall be able to add equations onto the mesh of (action)components using the Physics syntax.
2.1.2The system shall be able to combine two (action)components in a single simulation.
2.1.3
The system shall be able to use a mesh produced by a mesh generator for an (action)component
1. using the saved mesh options,
2. and using the mesh from the final mesh generator.

framework: Actions
2.2.1
The system shall allow the shortcut syntax specifying an AuxKernel
1. nested under an AuxVariable, and
2. it shall produce the same output as with the standard syntax.
2.2.2The system shall report an error if the supplied order of scalar auxiliary variable is of an unknown order.
2.2.3The system shall support calculations with an auxiliary scalar variable represented with a 21st order monomial function.
2.2.4The system shall be capable of reporting Action object dependencies.
2.2.5The system shall be capable of reporting Action object task information.
2.2.6The system shall support the detailed on-screen output of all of the Reporters that were declared and requested, including type, producer, context, and consumers.
2.2.7The system shall be able to retrieve other Action objects from within another Action object.
2.2.8The Action system shall allow Action objects to create other Action objects.
2.2.9The Action system shall allow the creation of Action objects with multiple tasks.

framework: Adaptivity
2.3.1The system shall be able to use block-restricted indicators for adaptivity.
2.3.2The system shall emit a warning if the block restriction of the marker is larger than that of its indicator.
2.3.3The Adaptivity system shall allow for multiple mesh adaptivity steps per timestep.
2.3.4
The system shall be able to p-refine discontinuous variables while disabling p-refinement of
1. Lagrange variables on a first order mesh,
2. Lagrange variables on a second order mesh,
3. Hermite variables on a first order mesh,
4. Hermite variables on a second order mesh,
5. Hierarchic variables on a first order mesh,
6. Hierarchic variables on a second order mesh,
7. Lagrange vector variables on a first order mesh,
8. Lagrange vector variables on a second order mesh,
9. Monomial vector variables on a first order mesh,
10. Monomial vector variables on a second order mesh,
11. Nedelec vector variables on a second order mesh,
2.3.5The Adaptivity system shall support mesh adaptivity during initial setup.
2.3.6The Adaptivity system shall support marking elements for refinement during initial setup using a different marker than used during execution.
2.3.7The Adaptivity system shall support execution at every n timestep.
2.3.8The Adaptivity system shall be capable of restricting the element refinement level.
2.3.9The Adaptivity system shall allow for Marker objects to be recomputed with each adaptivity cycle.
2.3.10The system shall support adaptivity with high-order scalar variables
2.3.11The system shall support initial uniform mesh refinement within a subdomain for a steady-state calculation.

framework: Auxkernels
2.4.1
The system shall be able to output the components of the flux vector for advection problems
1. in x direction
2. in normal direction
2.4.2The system shall throw an error when finite volume variables are used to compute a volumetric advection flux, as it is currently not supported.
2.4.3The system shall include the ability to set the value of an array variable using a function.
2.4.4The system shall be able to evaluate a parsed expression dependent on an array of variable values.
2.4.5The system shall issue an error when evaluating a parsed expression with array variable values if the number of components of the variable and coupled variables do not match.
2.4.6The system shall provide a way to convert a component of an array variable to a standard variable.
2.4.7The system shall provide a way to reduce values in an array variable to a single variable using max/min/sum/average operations.
2.4.8The system shall support auxiliary calculations for scalar variables at nodes.
2.4.9The AuxScalarKernel system shall automatically resolve dependencies between objects.
2.4.10The system shall support the copy the values of standard variables into the component fields of an array variable.
2.4.11
The system shall report a reasonable error when copying standard variables into the components of an array variable when
1. the variables have inconsistent sizes or
2. when the variables have inconsistent types.
2.4.12The ConstantScalarAux object shall set the value of an scalar auxiliary variable to a constant value.
2.4.13The system shall be able to identify what element contains a point through visualization of an auxiliary variable.
2.4.14The system shall be able to copy from a variable to another of the same finite element family and order.
2.4.15The system shall make current boundary id available in objects evaluated on boundaries.
2.4.16
The system shall be able to output the components of the flux vector for diffusion problems
1. with a non-AD diffusion material property
2. and with an AD diffusion material property
2.4.17The system shall be able to output the normal component of the flux vector for diffusion problems
2.4.18The system shall be able to compute the divergence of a vector of finite element variables.
2.4.19The system shall be able to compute the divergence of a vector of finite volume variables.
2.4.20The variable data created by a MaterialRealAux object shall support being limited to boundaries.
2.4.21The system shall support boundary restricted auxiliary elemental variables with high order shape functions.
2.4.22The system shall report an error if a boundary restricted elemental auxiliary kernel is evaluated on an element with multiple boundary sides
2.4.23The system shall allow a boundary restricted elemental auxiliary kernel to be evaluated on an element with multiple boundary sides by setting an input parameter.
2.4.24Kernel objects shall be capable of coupling to an auxiliary variable.
2.4.25AuxKernel object dependencies shall be resolved automatically.
2.4.26AuxKernel objects shall operate on higher-order monomial basis functions.
2.4.27AuxKernel objects shall operate on first-order L₂ basis functions.
2.4.28AuxKernel object dependencies shall be resolved between block and non-block restricted variables.
2.4.29The system shall include an AuxKernel object for returning the element length.
2.4.30The system shall be able to compute and visualize element quality metrics
2.4.31The system shall support the computation of a single value per element within the auxiliary system.
2.4.32The system shall include the ability to compute the L^p, L², and H¹ error norms for each element.
2.4.33The system shall allow objects that depend on each other but have differing execution flags to run without error.
2.4.34The system shall have the capability of visualizing element integers in an auxiliary variable.
2.4.35The system shall include the ability to access the normal of a coupled variable within an AuxKernel object.
2.4.36The system shall include the ability to increase the value of an AuxVariable from the previous time step using a forcing function.
2.4.37The system shall include the ability to set the value of a scalar variable using a function.
2.4.38The system shall be able to pass functor values as the time and space coordinates of a function, to compute an auxiliary field.
2.4.39The system shall be able to compute a vector auxvariable given by scaling a variable's gradient by a material property
2.4.40The system shall be able to output a functor to a nodal or elemental variable.
2.4.41The system shall include the ability to report values on a boundary from a boundary across a mesh gap.
2.4.42The system shall include the ability to report values on a boundary from a boundary across a mesh gap for a block restricted variable.
2.4.43
The system shall support viewing the elements that would be ghosted
1. to specific processors and
2. include local elements.
2.4.44The system shall utilize the minimum of ghosting necessary for the problem
2.4.45The system shall include the ability to extract a component of a linear Lagrange variable gradient as an auxiliary variable.
2.4.46The system shall include the ability to extract a component of a first order monomial variable gradient as an auxiliary variable.
2.4.47The system shall allow visualization of the MPI processes mapping to compute nodes
2.4.48The system shall include the ability to compute the linear combination of variables as an auxiliary variable.
2.4.49
The system shall allow populating lower-dimensional auxiliary variables using boundary restricted auxiliary kernels on
1. a mesh with a uniform level of refinement, and
2. a mesh with mixed levels of refinement along the boundary.
2.4.50
The system shall error if a boundary auxiliary kernel attempts to populate a lower-dimensional auxiliary variable when
1. the mesh lower-dimensional block restriction is not a superset of the boundary, or when
2. the variable lower-dimensional block restriction is not a superset of the boundary.
2.4.51The system shall compute the rate of change of a scalar material property
2.4.52The system shall include the ability to use extra element integers.
2.4.53The system shall include the ability to use extra element integers on element faces.
2.4.54The system shall include the ability to compute the shortest distance from a nodes across boundaries.
2.4.55The system shall have the ability to restrict AuxKernel objects with coupled variables to a boundary.
2.4.56The system shall include the ability to limit the execution of an AuxKernel object to initial setup.
2.4.57The system shall include the ability to couple auxiliary variables.
2.4.58The system shall be capable of resolving dependencies between AuxKernel objects regardless of input file order.
2.4.59Auxiliary kernel objects shall be capable of writing to multiple coupled variables.
2.4.60Writing to auxiliary variables shall be limited to use from AuxKernels, ElementUserObjects, or NodalUserObjects.
2.4.61Auxiliary kernel objects shall be capable of writing to to multiple coupled variables using the deprecated writeCoupledValue method.
2.4.62Writing to auxiliary variables shall be limited to use from AuxKernels, ElementUserObjects, or NodalUserObjects using variable values.
2.4.63The writing to auxiliary variables shall enforce nodal/elemental consistency between the kernel variable and the writable variables.
2.4.64The writableCoupledValue API can only act on AuxVariables.
2.4.65The writing to auxiliary variables shall error out if a constant value is passed in as variable name.
2.4.66Auxiliary kernel objects shall be capable of writing to finite volume coupled variables.
2.4.67The MOOSE auxiliary system shall be capable of updating multiple elemental auxiliary variables within a single AuxKernel object, including the kernel variable itsef using the setNodalValue method.
2.4.68The MOOSE auxiliary system shall be capable of updating multiple elemental auxiliary variables within a single AuxKernel object.
2.4.69The MOOSE auxiliary system shall check compatibility between primary and writable coupled variables.
2.4.70The MOOSE auxiliary system shall be capable of coupling to nonlinear variables at the end of a timestep.
2.4.71The system shall include the ability to normalize a variable based on a Postprocessor value.
2.4.72The system shall include the ability to normalize and shift a variable based on a Postprocessor value.
2.4.73AuxKernel objects shall support the use of material properties from the previous two timesteps.
2.4.74The system shall include an AuxKernel object capable of computing values from a functional expression.
2.4.75The parsed expression AuxKernel in The system shall expose quadrature/nodal point coordinates and time if requested by the user.
2.4.76The system shall be capable of computing parsed expressions setting a variable using material properties.
2.4.77The system shall be capable of computing parsed expressions setting a variable using material properties with automatic differentiation.
2.4.78The system shall be capable of computing values from a functor.
2.4.79
The system shall report an error if
1. functor symbols parameter does not have the same length as functor names parameter
2. functor symbols parameter contains 'x', 'y', 'z', or 't' when coordinates and time parameters are already in use
3. functor symbols cannot overlap with coupled variable names
4. functor names parameter contains 'x', 'y', 'z', or 't' when coordinates and time parameters are already in use
5. functor names cannot overlap with coupled variable names
6. an invalid function is provided.
2.4.80The system shall be able to compute a vector of values from a vector of functional expressions.
2.4.81Execution of a UserObject shall occur after the execution of the AuxKernel objects if the former depends on the latter.
2.4.82The system shall be able to detect wrong implicit dependencies of a function value postprocessor that depends on a function which depends on a second postprocessor.
2.4.83Explicit dependencies of function value postprocessors may be declared to resolve execution order independently of construction order.
2.4.84
The system shall be able to project
1. a constant to all variable families supported in 1d at various orders,
2. a linear variation to all variable families supported in 1d at various orders,
3. a quadratic variation to all variable families supported in 1d at various orders,
4. a constant to all variable families supported in 2d at various orders,
5. a linear variation to all variable families supported in 2d at various orders,
6. between variables supported in 2d at various orders on a displaced mesh,
7. a quadratic variation to all variable families supported in 2d at various orders,
8. a constant to all variable families supported in 2d at various orders on a triangle mesh,
9. a linear variation to all variable families supported in 2d at various orders on a triangle mesh,
10. a quadratic variation to all variable families supported in 2d at various orders on a triangle mesh,
11. a cubic variation to all variable families supported in 2d at various orders on a triangle mesh,
12. between variables on regular elements, in the presence of lower D elements,
13. between variables defined on multiple blocks, ignoring the source variable values on the subdomains that the auxkernel is not defined on.
2.4.85The system shall support the ability to compute the quotient of two variables.
2.4.86
The system shall be capable of initializing an auxiliary variable from an existing solution
1. from data generated by a simulation
2. and loaded using location,
3. using a direct degree-of-freedom copy for identical meshes,
4. with scaling the supplied data,
5. and that errors if data for the supplied variable is not found.
2.4.87The SolutionAux object shall be capable of populating an auxiliary variable from an ExodusII file.
2.4.88The SolutionAux object shall be capable of populating an auxiliary variable from an ExodusII file with a custom extension (e.g., *.e-s003).
2.4.89The SolutionAux object shall be capable of reading elemental data for the largest timestep.
2.4.90The SolutionAux object shall be capable of reading elemental data for a specific timestep.
2.4.91The SolutionAux object shall be capable of restricting reading to a single elemental variable.
2.4.92The SolutionAux object shall be capable of initializing an auxiliary variable from an existing ExodusII file using a direct degree-of-freedom copy for identical meshes.
2.4.93The SolutionAux object shall be capable of setting an auxiliary variable with temporal interpolation.
2.4.94
The system shall be capable of initializing an auxiliary variable from an existing solution that
1. is created in a simulation and
2. used to restart another.
2.4.95The SolutionAux object shall be capable of setting an auxiliary variable with temporal interpolation using a direct degree-of-freedom copy for identical meshes.
2.4.96The SolutionAux object shall be capable of accessing specific variables from a SolutionUserObject.
2.4.97The SolutionAux object shall produce an error if the 'from_variable' parameter is not set and the supplied UserObject has multiple variables.
2.4.98
The systems object shall be capable of setting values using an auxiliary variable
1. from a simulation using
2. an ASCII file and
3. a binary file.
2.4.99
The system shall be capable of setting values using an auxiliary variable
1. create4d from a simulation with adaptivity
2. from an ASCII file
3. with multiple threads.
2.4.100
The system shall read a scalar variable from an Exodus file and use its value
1. from data generated by simulation
2. and loaded by another.
2.4.101Kernel objects shall be able to couple to the time derivative of an auxiliary variable.
2.4.102AuxKernel objects shall be able to couple to the time derivative of a nonlinear variable.
2.4.103AuxKernel objects shall be able to couple to the time derivative of a nonlinear variable even if the problem is in fact linear and solved as such.
2.4.104Error an AuxKernel object attemps to couple to the time derivative of an auxiliary variable.
2.4.105The system shall be able to compute the time derivative of a non linear variable.
2.4.106The system shall be able to compute the time derivative of functors for which the capability to obtain time derivatives on the fly is implemented.
2.4.107The system shall be able to compute the time derivative of finite volume variables.
2.4.108
The system shall report an error if
1. a time derivative is requested from a functor material property for which the functor time derivative not implemented
2. a time derivative is requested but the variable is a nodal variable which is currently unsupported
3. a time derivative for a finite element variable is to be saved in a finite volume variable
4. a time derivative for a finite volume variable is to be saved in a finite element variable
2.4.109The system shall be able to compute the second time derivative of a nonlinear variable.
2.4.110
The system shall report an error if
1. a second time derivative is requested but the variable is a nodal variable which is currently unsupported, and
2. a second time derivative for a finite element variable is requested to be stored in a finite volume variable.
2.4.111The system shall include the ability to compute the integral of a variable over time.
2.4.112The system shall resolve the dependency of auxiliary kernels on user objects including the objects that the aux kernels indirectly depend on.
2.4.113The system shall include the ability to set the components of a vector auxiliary variable using a function defined within the input file.
2.4.114The system shall include the ability to compute the Euclidean norm of three coupled variables.
2.4.115The system shall be able to output vector auxiliary variables based on the values of vector material properties, regardless of whether the material properties are computed using automatic differentiation or not.
2.4.116The system shall be capable of populating an auxiliary variable from VectorPostprocessor data sized to the number of processors.
2.4.117The system shall include the ability to compute auxiliary quantities at the nodes of elements based on the values of a LAGRANGE_VEC variable.
2.4.118AuxKernel objects shall be capable of coupling to VectorPostprocessor objects.
2.4.119
The system shall include the ability to sample
1. elemental
2. and side volumes
2.4.120The system shall report a reasonable error when trying to sample element volumes into a non constant monomial variable

framework: Batch Material
2.5.1The batch material system shall provide the capability for gathering and serializing variable and material property values for batch property computation.

framework: Batch Property Derivative
2.6.1The batch property derivative shall be able to gather, serialize material property values and receives material property derivatives for batch property computation.

framework: Bcs
2.7.1The system shall support Neumann type boundary conditions for a 1D problem.
2.7.2The system shall support Neumann type boundary conditions for a 1D problem using an imported mesh.
2.7.3
The system shall support Neumann type boundary conditions using automatic differentiation for a 1D problem
1. using a generated mesh.
2. and shall be able to produce the exact Jacobian
3. using an imported mesh.
2.7.4The system shall support setting AD Dirichlet type boundary conditions, supplied as a function, directly to the solution vector prior to the solve.
2.7.5The system shall support setting AD Dirichlet type boundary conditions directly to the solution vector prior to the solve.
2.7.6The system shall support setting AD Dirichlet type boundary conditions, supplied as a function, directly to the solution vector prior to the solve and have perfect Jacobians.
2.7.7The system shall support setting AD Dirichlet type boundary conditions directly to the solution vector prior to the solve and have perfect Jacobians.
2.7.8We shall be able to produce the expected result using ADKernel, ADNodalBC, and ADIntegratedBC
2.7.9We shall be able to produce the exact Jacobian using ADKernel, ADNodalBC, and ADIntegratedBC with a first order variable
2.7.10We shall be able to produce the exact Jacobian using ADKernel, ADNodalBC, and ADIntegratedBC with a second order variable
2.7.11We shall be able to produce the expected result using ADVectorKernel, ADVectorNodalBC, and ADVectorIntegratedBC
2.7.12We shall be able to produce the exact Jacobian using ADVectorKernel, ADVectorNodalBC, and ADVectorIntegratedBC with a first order variable
2.7.13We shall be able to produce the exact Jacobian using ADVectorKernel, ADVectorNodalBC, and ADVectorIntegratedBC with a second order variable
2.7.14The system shall be able to couple a lower-dimensional variable into a boundary condition for a higher-dimensional variable.
2.7.15The system shall be able to compute the residual and Jacobian together when boundary conditions couple in variables defined on lower-dimensional blocks.
2.7.16
The system shall support Dirichlet type boundary conditions defined by a function
1. using automatic differentiation.
2. using automatic differentiation and shall be able to produce the exact Jacobian.
2.7.17
The system shall support Neumann type boundary conditions defined by a function
1. using automatic differentiation.
2. using automatic differentiation and shall be able to produce the exact Jacobian.
2.7.18The system shall support matching variable values on a boundary using automatic differentiation
2.7.19The system shall produce the exact Jacobian for BC matching variable values on a boundary using automatic differentiation
2.7.20
The system shall be able to impose a nodal boundary condition constraint that involves nonlocal degrees of freedom and
1. get the expected result in which the average value of the solution is zero, and
2. exhibit a perfect Jacobian.
2.7.21
The system shall support the application of Dirichlet type boundary conditions using the penalty method using the AD system
1. with a constant value on the boundary.
2. with a constant value on the boundary and shall be able to produce the exact Jacobian.
3. with a value on the boundary set by a function.
4. with a value on the boundary set by a function and shall be able to produce the exact Jacobian.
2.7.22
The system shall support Neumann type boundary conditions defined by a function
1. for vector variables with automatic differentiation and
2. be able to produce the exact Jacobian.
2.7.23The system shall provide array vacuum boundary condition.
2.7.24The system shall support setting Dirichlet type boundary conditions, supplied as a function, directly to the solution vector prior to the solve.
2.7.25The system shall support setting Dirichlet type boundary conditions directly to the solution vector prior to the solve.
2.7.26The system shall support the creation of BoundaryCondition objects that support conditional activation.
2.7.27The system shall support the creation of BoundaryCondition objects that couple to nonlinear variables.
2.7.28The system shall support coupled Neumann type boundary conditions.
2.7.29The system shall enable scaling of the Neumann type boundary conditions.
2.7.30
When coupling nonlinear variables into a Neumann type boundary condition, the system shall
1. generate accurate results
2. generate a perfect Jacobian
3. generate accurate results using automatic differentiation
4. generate a perfect Jacobian using automatic differentiation
2.7.31The system shall be able to determine if a non-scalable algorithm is being used for ghosting boundaries.
2.7.32The system shall make sure that boundaries are actually distributed.
2.7.33The system shall support periodic boundary conditions in a parallel generated 2D mesh.
2.7.34The system shall support periodic boundary conditions in a parallel generated 3D mesh.
2.7.35The system shall support periodic boundary conditions in a parallel generated 1D mesh.
2.7.36The system shall support Dirichlet type boundary conditions defined by a function.
2.7.37The system shall support applying a function of space-time as a Neumann boundary condition.
2.7.38The system shall support Dirichlet type boundary conditions defined by a functor.
2.7.39The system shall support Neumann boundary conditions defined by a functor.
2.7.40The system shall support applying a material property as a Neumann boundary condition.
2.7.41The system shall support applying a material property as a Neumann boundary condition using AD.
2.7.42The system shall support matching variable values on a boundary.
2.7.43The system shall support the ability to create convective flux boundary conditions.
2.7.44The system shall support a vacuum boundary condition for neutron diffusion on the boundary.
2.7.45The system shall support Neumann type boundary conditions where the specified value is defined as the value of a vector, $v$ , in the direction of the boundary outward facing normal, $\hat{n}$ (i.e., $v\cdot\hat{n}$ ).
2.7.46The system shall support the 'no boundary condition' type boundary condition (Griffiths, 1997).
2.7.47The system shall be capable of computing the nodal normals for triangle elements.
2.7.48The system shall be capable of computing the nodal normals for quadrilateral elements.
2.7.49The system shall be capable of computing the nodal normals for first order hexahedron elements.
2.7.50The system shall be capable of computing the nodal normals for second order hexahedron elements.
2.7.51The system shall be capable of computing the first order nodal normals for second order hexahedron elements.
2.7.52The system shall be capable of computing the nodal normals for quadrilateral elements on a square domain.
2.7.53The system shall support the application of Dirichlet type boundary conditions using the penalty method.
2.7.54The system shall support the application of Dirichlet type boundary conditions, defined by a function, using the penalty method.
2.7.55The system shall support periodic boundary conditions with transforms defined as functions.
2.7.56The system shall support periodic boundary conditions with transforms that are computed automatically in the 'x' and 'y' directions.
2.7.57The system shall support periodic boundary conditions with transforms that are computed automatically in the 'x' and 'y' directions using a non-generated mesh.
2.7.58The system shall produce an error within the PeriodicDistanceAux object when a point is provided that is outside the mesh domain.
2.7.59The system shall support periodic boundary conditions with transforms that are computed automatically in the 'x', 'y', and 'z' directions.
2.7.60The system shall support periodic boundary conditions on orthogonal boundaries with transforms defined as functions.
2.7.61The system shall support periodic boundary conditions on parallel boundaries with transforms defined as functions.
2.7.62The system shall support periodic boundary conditions with mesh adaptivity.
2.7.63The system shall support periodic boundary conditions with transforms prescribed as a translation.
2.7.64The system shall support periodic boundary conditions on vector variables with transforms prescribed as a translation.
2.7.65The system shall support periodic boundary conditions with displacements.
2.7.66The system shall support periodic boundary conditions on a trapezoid domain with transforms prescribed as functions.
2.7.67The system shall support calls to periodic distance and bounds methods on the mesh when periodic boundary conditions are not used.
2.7.68The system shall support periodic boundary conditions on a wedge domain with transforms prescribed as functions.
2.7.69The system shall support periodic boundary conditions for a single variable on a wedge domain with transforms prescribed as functions.
2.7.70The system shall support periodic boundary conditions for input meshes that have repeated element ids.
2.7.71When using periodic boundary detection, the system shall not attempt to add periodic boundary conditions to scalar variables.
2.7.72The system shall support the application of a Neumann boundary condition computed via Postprocessor object.
2.7.73The system shall be able to compute the residual and the Jacobian of each nodal BC and integrated BC together.
2.7.74The system shall properly compute second derivatives within BoundaryCondition objects.
2.7.75The system shall support creating sidesets from nodesets for hexahedron elements to use with Boundary Condition objects.
2.7.76The system shall support creating sidesets from nodesets for tetrahedron elements to use with Boundary Condition objects.
2.7.77The system shall include the ability to apply a Neumann boundary condition according to a sin function.
2.7.78The system shall include the ability to apply a Dirichlet boundary condition according to a sin function.
2.7.79The system shall be able to apply penalty Dirichlet boundary conditions to all three components of a vector variable in a three-dimensional diffusion simulation.
2.7.80BoundaryCondition objects shall support retrieval of VectorPostprocessor data.

framework: Bounds
2.8.1The system shall include the ability to compute a nodal field variable with a constant upper and lower bounds.
2.8.2The system shall include the ability to compute a field variable with a lower bound given by variable's old value.
2.8.3The system shall include the ability to compute a constant monomial field variable with constant upper and lower bounds.
2.8.4The system shall be able to impose constant upper and lower bounds on a finite volume variable.
2.8.5
The system shall
1. emit a warning if a variational inequalities (VI) solver is not found when the bounds system is used.
2. error if an unsupported variable type is provided to the constant bounds kernel
3. error if the type of the dummy auxiliary variable does not match the bounded variable.

framework: Constraints
2.9.1The system shall include ability to force the value of a variable to be the same on both sides of an interface using Lagrange multipliers.
2.9.2The system shall include the ability to constrain the values on a boundary to a value at a prescribed node.
2.9.3The system shall be able to enforce the equal value boundary constraint in parallel with adaptivity.
2.9.4
The system shall support embedded constraints between using a kinematic formulation between
1. 1D and 2D;
2. 1D and 3D;
3. 2D;
4. 2D and 3D; and
5. 3D subdomains.
2.9.5
The system shall support embedded constraints between using a penalty formulation between
1. 1D and 2D;
2. 1D and 3D;
3. 2D;
4. 2D and 3D; and
5. 3D subdomains.
2.9.6The system shall support the ability to constrain nodal values.
2.9.7The system shall support the ability to constrain nodal values using a displaced mesh.
2.9.8The system shall support the ability to linearly constrain nodal values.
2.9.9The system shall support the ability to constrain nodal values of different variables.
2.9.10The system shall be able to allow overwriting of solution variables in node-face constraint objects.
2.9.11The system shall include the ability to force the value of a variable to be the same on both sides of an interface.

framework: Controls
2.10.1The Control system shall include a means to control input parameters added by MOOSE action systems.
2.10.2The Control system shall allow a boolean parameter to be controlled with a function.
2.10.3The Control system shall be capable of activating or deactivating MOOSE objects using a conditional function.
2.10.4The MOOSE control system shall allow parameters from differing objects, with differing names to be associated and changed together.
2.10.5The MOOSE control system shall allow parameters from objects to be assigned aliases for the purpose of changing the value.
2.10.6The system shall allow controlling piecewise functions and material properties.
2.10.7The Control system shall support explicitly defined dependencies.
2.10.8The Control system shall error if an attempt to alter a non-controllable parameter is performed.
2.10.9The Control system shall error if multiple controllable parameters exists, but only a single parameter is expected to be controlled.
2.10.10The Control system shall error if an unknown parameter is supplied for control.
2.10.11The Control system shall error if a thread id greater than the number of threads available is supplied when retrieving a Control object.
2.10.12The Control system shall error if an attempt is made to disable the Executioner.
2.10.13The Control system shall error if an invalid control name is supplied to the Control dependency resolution procedure.
2.10.14The system shall be able to read a neural network from a torchscript file and use it to control a transient process.
2.10.15The system shall be able to read a neural network from a parameter file and use it to control a transient process.
2.10.16The system shall be able to run with a libtorch controller without having a neural net initialized in it.
2.10.17The system shall forbid specifying parameters when reading a neural network from a torchscript file.
2.10.18The Control system shall support the modification of a single parameter using the objects base class name, object name, and parameter name.
2.10.19The Control system shall support the modification of multiple parameters using the objects base class and the parameter name.
2.10.20The Control system shall include a means to output information regarding the controlled parameters.
2.10.21The Control system shall include a means to output information regarding the controlled parameters, including only showing information regarding a parameter if it has changed since the last output.
2.10.22The system shall include a command line flag for displaying controllable parameter information.
2.10.23The Control system shall include a means to output information regarding the objects with controllable parameters.
2.10.24
The Control system shall be able to control an input parameter to make a postprocessor match a target value,
1. using the principle of Proportional Integral Derivative control,
2. allowing the Proportional Integral Derivative control to have limits for its maximum and minimum output,
3. allowing the Proportional Integral Derivative control to have limits for its absolute maximum rate of change of control variable,
4. using a input postprocessor in lieu of an input parameter,
5. with integral windup control, resetting the integral term if the error crosses zero,
6. keeping the PID process within a single timestep,
7. and resetting the PID process correctly if the solver fails during a Picard/coupling iteration.
2.10.25The Control system shall allow a scalar parameter to be controlled with a function.
2.10.26The Control system shall allow multiple scalar parameters to be controlled with a function.
2.10.27The MOOSE control system shall be capable of restricting parameters to be controlled for specific execution flags.
2.10.28The Control system shall allow multiple parameters to be changed by the parameter name alone using input syntax format.
2.10.29The Control system shall allow multiple parameters to be changed given the object and parameter names using input syntax format.
2.10.30The Control system shall allow for a single parameter to be changes given the input syntax, object name, and parameter name.
2.10.31The Control system shall allow for multiple parameters to be changed given input syntax and a parameter name.
2.10.32The Control system shall allow multiple parameters to be changed by the parameter name alone using a tag.
2.10.33The Control system shall allow multiple parameters to be changed given a tag and parameter names, given a tag assigned across input blocks.
2.10.34The Control system shall allow for a single parameter to be changes given a tag and parameter name, given a tag assigned to a single object.
2.10.35The Control system shall allow for multiple parameters to be changed given a tag and a parameter name, given a tag assigned within a single input block on multiple objects.
2.10.36The Control system shall be capable of activating or deactivating AuxKernel objects with time.
2.10.37The Control system shall be capable of activating or deactivating AuxScalarKernel objects with time, given identical start end times.
2.10.38The Control system shall be capable of activating or deactivating AuxScalarKernel objects with time, given differing start end times.
2.10.39
The system shall be capable of activating and/or deactivating boundary contributions to the residual with time
1. for contributions from finite element nodes,
2. for contributions integrated over a finite element side,
3. for contributions from automatic differentiation, and
4. perform the activation/deactivation with a single control.
2.10.40The Control system shall be capable of activating or deactivating Constraint objects with time.
2.10.41The system shall support disabling an object using an input parameter.
2.10.42The system shall support enabling an object using an input parameter.
2.10.43The system shall be capable of activating or deactivating Damper objects with time via the Control system.
2.10.44The Control system shall be capable of activating or deactivating DGKernel objects with time.
2.10.45The Control system shall be capable of activating or deactivating DiracKernel objects with time.
2.10.46The TimePeriod object shall error when used with a steady state problem.
2.10.47The TimePeriod object shall error when the start and end time parameters are not the same length.
2.10.48The TimePeriod object shall error when start and end time parameters differ in length than the supplied object list.
2.10.49The TimePeriod object shall error when a list of objects to control is omitted.
2.10.50The TimePeriod object shall error when start time is greater than the end time.
2.10.51
The system shall be capable of activating or deactivating volume residual contributions with time:
1. for non-automatic differentiation and
2. automatic differentiation terms.
2.10.52The system shall be capable of activating or deactivating materials in the input file depending on time.
2.10.53The Control system shall be capable of activating or deactivating MultiApp objects with time.
2.10.54The Control system shall be capable of activating or deactivating NodalKernel objects with time.
2.10.55The Control system shall be capable of activating or deactivating ScalarKernel objects with time.
2.10.56The Control system shall be capable of activating or deactivating Transfer objects with time.
2.10.57The Control system shall be capable of activating or deactivating UserObject objects with time.
2.10.58The system shall be able to enable/disable an object based on whether the simulation time hits the times specified in a times object.
2.10.59The system shall be able to enable/disable an object based on whether the simulation time passes the times specified in a times object.
2.10.60
The system shall support controlling a parameter via a REST API with a parameter type of a
1. boolean
2. double precision number
3. integer
4. string
5. vector of double precision numbers
6. vector of integers
7. vector of strings
2.10.61The system shall support retreiving a postprocessor value via a REST API
2.10.62The system shall support connecting to a REST API via a port
2.10.63The system shall support changing controllable parameters via a REST API in a manner that is parallel consistent
2.10.64
The system shall report a reasonable error when interacting with the REST API when
1. setting a controllable parameter that does not exist
2. getting a postprocessor that does not exist
3. setting a controllable parameter whose type is not supported
4. setting a controllable parameter with an incompatible JSON type
5. setting a controllable parameter with a type that does not match
2.10.65
The system that supports controlling parameters via a REST API should report a reasonable error when
1. a parameter was not provided that specifies where the server should listen
2. both a port and a file were specified to listen on

framework: Coord Type
2.11.1The system shall support cylindrical coordinates with the radial direction in the 'x' direction.
2.11.2The system shall support cylindrical coordinates with the radial direction in the 'y' direction.
2.11.3The system shall support cylindrical coordinates with the radial direction in the 'x' direction with discontinous Galkerin and integrated boundary conditions.
2.11.4The system shall support cylindrical coordinates with the radial direction in the 'y' direction with discontinous Galkerin and integrated boundary conditions.
2.11.5The system shall support cylindrical coordinates with a general axis.

framework: Dampers
2.12.1The system shall include the ability to reduce the change in nonlinear residual based on a maximum value on elements.
2.12.2The system shall include the ability to reduce the change in nonlinear residual based on a minimum value on elements.
2.12.3The system shall include the ability to reduce the change in nonlinear residual based on a maximum value on nodes.
2.12.4The system shall include the ability to reduce the change in nonlinear residual based on a minimum value on nodes.
2.12.5The system shall include the ability to reduce the change in nonlinear residual based on a constant value.
2.12.6The Damper system shall use the minimum of NodalDamper and ElementDamper, when the later computes the minimum.
2.12.7The Damper system shall use the minimum of NodalDamper and ElementDamper, when the former computes the minimum.
2.12.8The Damper system shall be capable of reducing the change in non linear residual based on an allowable increment on elements using an absolute increment.
2.12.9The Damper system shall be capable of reducing the change in non linear residual based on an allowable increment on elements using an fractional increment.
2.12.10The system shall give an informative error if user code requests a variable from the warehouse with a bad key.
2.12.11The BoundingValueNodalDamper object shall report if the minimum value is greater than the maximum value.
2.12.12The BoundingValueElementDamper object shall report if the minimum value is greater than the maximum value.
2.12.13The Damper system shall error if the damping value is below a minimum.

framework: Dgkernels
2.13.1The system shall support solving 1D advection using the discontinous Galerkin method.
2.13.2The system shall support solving 2D diffusion using the discontinuous Galerkin method.
2.13.3The system shall support solving 2D diffusion using the discontinuous Galerkin method with p-refinement.
2.13.4The system shall support solving 2D diffusion using the discontinuous Galerkin method with constant monomial shape functions.
2.13.5DGKernels shall coexist with stateful material properties
2.13.6The system shall not perform memory allocation automatic scaling when computing values using discontinuous finite element methods.
2.13.7When objects that need one layer of coupling (like DGKernels) are added via action, we shall ensure that we have added a proper relationship manager and thus incur no mallocs during calls to MatSetValues. We will not apply algebraic ghosting nor reinitialize system vectors in serial, but we will reinitialize the matrix sparsity
2.13.8When objects that need one layer of coupling (like DGKernels) are added via action, we shall ensure that we have added a proper relationship manager and thus incur no mallocs during calls to MatSetValues. We will also apply algebraic ghosting in parallel which will require reinitializing the system; the sparsity pattern will also have to be reinitialized
2.13.9If a RelationshipManager with sufficient coverage has already been added through a MooseObjectAction, then the CouplingFunctorCheck action shall not add any relationship managers, avoiding reinitialization of system vectors and the system matrix
2.13.10This test shall have one more rm than its replicated counter part because of the geometric-only GhostPointNeighbors rm, also demonstrating no mallocs. Sparsity will be reinitialized but not vectors
2.13.11This test shall have one more rm than its replicated counter part because of the geometric-only GhostPointNeighbors rm, also demonstrating no mallocs. Sparsity and vectors will both be reinitialized
2.13.12This test shall have one more rm than its replicated counter part because of the geometric-only GhostPointNeighbors rm, also demonstrating no addition of rms by the CouplingFunctorCheckAction
2.13.13The system shall support solving 3D diffusion using the discontinuous Galerkin method.
2.13.14The system shall support solving 3D diffusion using the discontinuous Galerkin method with p-refinement.
2.13.15We shall be able to use constant monomials with AD
2.13.16MOOSE should support AD in DG Kernels
2.13.17Adaptivity shall work with dg kernels as long as stateful properties are not used.
2.13.18The system shall report an error if the triad of dg kernels, adaptivity, and stateful properties are used together.
2.13.19The system shall be able to solve the advection diffusion equation using the discontinuous Galerkin method.
2.13.20The system shall compute the correct Jacobian for the advection diffusion equation using the discontinuous Galerkin method.
2.13.21The DGKernel system shall support restriction to subdomains, in 1D.
2.13.22The DGKernel system shall support restriction to subdomains, in 2D.
2.13.23The DGKernel system shall operate with displaced meshes.
2.13.24The example side-discontinuous kernels shall have correct analytic Jacobians.
2.13.25The DGCoupledDiffusion object shall compute the correct Jacobian.
2.13.26The system shall be ablve to solve an advection-diffusion problem discretized with discontinuous Galerkin, using some hand-coded Jacobians and automatic differentiation Jacobians.
2.13.27The system shall be able to use variables when initializing stateful material properties on neighbor materials used for the discontinuous Galerkin method.

framework: Dirackernels
2.14.1The system shall support the coupling of scalar aux variables for the purpose of sharing data and reporting values.
2.14.2The system shall support block restricted dirac kernels.
2.14.3
The system shall behave accordingly if the added point is not found, when point_not_found_behavior is set to
1. ERROR or
2. WARNING.
2.14.4
The system shall support a constant point source implemented as a Dirac function:
1. in 1D,
2. in 2D,
3. in 3D,
4. with finite volume variables
5. with vector variables in 2D
6. with vector variables in 3D
2.14.5The system shall allow for source locations to be set by a user-defined object.
2.14.6The system shall have the ability to set the value of point source from a function.
2.14.7The system shall allow point sources originating from the evaluation of material properties.
2.14.8
DiracKernel objects shall report an error if a material property from a previous time step is requested:
1. one step back, and
2. two steps back.
2.14.9The DiracKernel system shall allow for duplicate source locations to be defined.
2.14.10The system shall support the computation of off diagonal Jacobian terms for residual terms defined with a Dirac delta function.
2.14.11
The system shall support source location caching using element ids:
1. on a static mesh with no adaptivity,
2. with uniform mesh refinement,
3. with adaptive mesh refinement, and
4. with displaced mesh.
2.14.12The DiracKernel system shall report an error if a location does not correspond with the supplied element id.
2.14.13
The system shall support point sources with locations and values given by a Reporter
1. in a steady state 2D problem, reading data from a reporter and reproducing the constantPointSource.
2. in a steady state 2D problem, reading data from a vectorPostProcessor and reproducing the constantPointSource.
3. in a steady state 2D problem, reading data from a reporter with duplicate points and reproducing the constantPointSource.
4. in steady state 3D problem, reproducing the constantPointSource.
5. in a transient problem with the vpp source value changing as the vpp changes.
6. shall report an error if the input arrays are not the same size.
7. shall report an error if the input arrays have duplicated values.

framework: Executioners
2.15.1The Executioner system shall support the ability to create custom objects with custom execution callbacks.
2.15.2The Executioner system shall support the creation of custom objects with arbitrary execution flags.
2.15.3The system shall be able to detect steady-states using the auxiliary system solution.
2.15.4The system shall be able to solve an eigenvalue problem using something other than the L2 norm of Bx for normalization and a native eigenvalue solver.
2.15.5The system shall be able to solve an eigenvalue problem using the L2 norm of Bx and the sign of its first nonzero entry for normalization with a SLEPc eigenvalue solver.
2.15.6The system shall be able to solve an eigenvalue problem using the sign of the first nonzero entry of Bx combined with something other than the L2 norm of Bx for normalization with a SLEPc eigenvalue solver.
2.15.7The system shall be able to solve an eigenvalue problem using something other than the L2 norm of Bx for normalization and a SLEPc eigenvalue solver.
2.15.8The system shall support solving an Eigen value problem using the inverse power method.
2.15.9The system shall support solving an Eigen value problem using Newton's method.
2.15.10The system shall support solving an Eigen value problem using Newton's method in parallel.
2.15.11The system shall support the use of material properties during an Eigen problem solve.
2.15.12The system shall be capable of solving a diffusion problem using an Eigen value solver.
2.15.13The system shall be capable of solving a nonlinear diffusion problem using an Eigen value solver.
2.15.14The system shall be capable of solving a coupled nonlinear diffusion problem using an Eigen value solver.
2.15.15The system shall be capable of using coupled variables in the EigenKernel object.
2.15.16The system shall support adaptive solves for steady-state execution.
2.15.17The system shall be able to detect steady state conditions during execution.
2.15.18The system shall be capable of solving a steady state diffusion problem.
2.15.19The system shall be capable of solving a transient diffusion problem.
2.15.20The system shall print automatic scaling factors if specified.
2.15.21The system shall not print automatic scaling factors if not specified.
2.15.22
The system shall provide a capability to solve a problem iteratively with a tagged residual vector for
1. linear and
2. nonlinear problems.
2.15.23
The system shall provide a capability to solve a problem iteratively with a tagged solution vector being coupled in
1. kernels and/or
2. materials.
2.15.24
The system shall provide informative warnings when
1. fixed_point_rel_tol is set by the user and disable_fixed_point_residual_norm_check is set to true.
2. fixed_point_abs_tol is set by the user and disable_fixed_point_residual_norm_check is set to true.
3. fixed_point_force_norms is set by the user and disable_fixed_point_residual_norm_check is set to true.
2.15.25The system shall correctly compute Jacobians when boundary conditions are disabled.
2.15.26The Executioner system shall support the PETSc non-linear divergence tolerance.
2.15.27The system shall consider a nonlinear solve diverged if the nonlinear residual exceeds the absolute divergence tolerance while iterating
2.15.28The system shall perform n non linear iterations before checking for non linear divergence
2.15.29The system shall force the prescribed number of non linear iterations even if convergence tolerance is already satisfied.
2.15.30The system shall perform many non linear iterations before checking for non linear divergence
2.15.31The system shall perform many non linear iterations before checking for non linear divergence using reference residual
2.15.32The system shall consider a nonlinear solve diverged if the nonlinear residual oscillates by a user-controlled number of times.
2.15.33The system shall compute the solution of rank-deficient linear equations if the right hand side is within the range of the linear operator.
2.15.34The system shall compute the solution of rank-deficient linear equations if the right hand side has components that are orthogonal to the range of the linear operator.
2.15.35Executioner objects shall be capable of coupling to Postprocessor values.
2.15.36The system shall allow executioners to do setups before initializing the problem.
2.15.37The system shall correctly evaluate Jacobians with coupled problems and the LINEAR solve type
2.15.38The system shall not change the system time during steady-state execution.
2.15.39The system shall be able to set the system time for steady-state execution.
2.15.40The system shall support controlling what objects are executing based on start and end times.
2.15.41The system shall support explicit definition of execution times.
2.15.42The system shall support output using a time interval.

framework: Executors
2.16.1The system shall be able to utilize a modular/nested system of execution
2.16.2The system shall report an error if the Executor system contains an infinite cycle
2.16.3The system shall only have one root node in the Executor tree
2.16.4The system shall be able to experimentally use the executor system instead of an executioner.

framework: Fixedbugs
2.17.1The Material objects provided on all subdomains shall satisfy requests for objects on all subdomains.

framework: Functions
2.18.1Generate the fine tabulated function data for the coarsened_piecewise_linear test
2.18.2The Function system shall include an object that creates a function based on x- and y-data pairs, reduces the number of data points based on a user supplied cut-off and returns a linearly interpolated value from the coarsened data.
2.18.3The Function system shall include a constant function.
2.18.4The Function system shall include the ability to set default values for input parameters expecting a function name.
2.18.5The Function system shall include the ability to read comma or space separated data and perform linear interpolation using the supplied data.
2.18.6The Function system shall include the ability to pick rows or columns from comma or space separated data based on row or column headers.
2.18.7
The system shall be able to initialize a variable with values computed using a user-specified function
1. using the function directly.
2. with a scaling factor applied to the function.
2.18.8The Function object shall include a callback executed during each timestep.
2.18.9The Material system shall support defining properties within the input file that are associated with functions.
2.18.10The Material system shall support defining vector properties within the input file that are associated with functions.
2.18.11The Material system shall error out if the number of functions supplied does not match the size of the vector function material properties.
2.18.12The system shall allow for piecewise functions to directly set the x and y data internally.
2.18.13
The system shall include the ability to create functions from image files that errors if
1. an unsupported file type is provided;
2. if an invalid component value is supplied;
3. if an invalid filename is provided; and
4. the system is not configured with the correct dependencies.
2.18.14The system shall include the ability to define a function based on a 2D image and initialize a nodal variable.
2.18.15The system shall include the ability to define a function based on a 2D image and initialize a elemental variable.
2.18.16The system shall include the ability to define a function based on a stack of images and initialize a nodal variable.
2.18.17The system shall include the ability to define a function based on a subset stack of images and initialize a nodal variable.
2.18.18The system shall allow the image data within the ImageFunction object to be set as one of two values based on a threshold value.
2.18.19The system shall be capable of initializing a variable from image data and perform initial adaptivity based on the data.
2.18.20The system shall be capable of initializing a variable from image data and perform initial adaptivity based on the data, in parallel.
2.18.21The system shall be capable of initializing a variable from image data and perform initial adaptivity based on the data, in parallel and produce Nemesis output files.
2.18.22The system shall be capable of limiting the supplied data to the ImageFunction object to a single component of the RGB image data.
2.18.23The system shall be capable of shifting and scaling the supplied image data to the ImageFunction object.
2.18.24The system shall be capable of operating on domains that are larger than the image size in the ImageFunction object.
2.18.25The system shall be capable of flipping image data along the vertical axis in the ImageFunction object.
2.18.26The system shall be capable of flipping image data along vertical axis and shifting the origin using the ImageFunction object.
2.18.27The system shall be capable of flipping image data along vertical and horizontal axis within the ImageFunction object.
2.18.28The system shall be capable of operating on domains that are smaller than the image size within the ImageFunction object.
2.18.29The system shall be capable of generating a 3D mesh based on a stack of 2D images using the ImageMesh object.
2.18.30The system shall be capable of generating a 2D mesh based on an image using the ImageMesh object.
2.18.31The system shall perform shift and scale options independently using the ImageFunction object.
2.18.32The LinearCombinationFunction shall report an error if the parameters listing the functions differs in size than the list of coefficients.
2.18.33The LinearCombinationFunction shall be capable of computing the sum of function values, each multiplied by a scale factor.
2.18.34The LinearCombinationFunction shall be capable of computing the sum of function gradients, each multiplied by a scale factor.
2.18.35The LinearCombinationFunction shall be capable of computing the sum of vector functions, each multiplied by a scale factor.
2.18.36The Function system shall support the creation of objects that execute a function defined within the input file.
2.18.37The ParsedFunction object shall be capable of defining function within the input file for use with the method of manufactured solutions.
2.18.38The Function system shall support the creation of objects that execute a vector function defined within the input file.
2.18.39The Function system shall support the creation of objects that execute a function defined within the input file that includes a scalar variable.
2.18.40The ParsedFunction object shall support the use of other functions specified by their names in its expression.
2.18.41The ParsedFunction object shall support the use of functions, scalar expressions and postprocessor expressions specified by their names in its expression at the same time.
2.18.42The Function system shall support the creation of objects that execute a curl of a vector function defined within the input file.
2.18.43The ParsedFunction object shall fail with a human readable error if a vals entry is supplied that is neither a valid postprocessor, scalar variable, function, or real number.
2.18.44The system should error if a field variable is passed into a parsed function object, as this capability is currently not supported.
2.18.45The Function system shall provide the ability to take a base function and periodically repeat that function according to a user-defined period in time or in the x, y, or z direction, or a combination of those
2.18.46The system shall include an object that creates a function based on x- and y-data pairs and returns an explicit value from the supplied data when queried (i.e., linear interpolation is not performed).
2.18.47The system shall include an object that creates a function based on x- and y-data pairs and returns an explicit value from the supplied data when queried (i.e., linear interpolation is not performed) in a simple simulation, with both negative and positive values.
2.18.48The system shall be able to compute a piecewise constant function based on x- and y-data loaded from a JSON file.
2.18.49
The system shall report an error if
1. parameters meant for loading data from file are passed for a function loading data differently,
2. or if parameters meant for loading data from JSON are passed for a function loading data differently.
2.18.50
The Function system shall include a function that can obtain data from a CSV file
1. with data sorted by element ids
2. with data sorted by node ids
3. with data at given locations and using nearest neighbor interpolation between those data points
4. using nearest neighbor interpolation with a random tesselation
5. with data at given locations and using nearest neighbor interpolation between those data points, with periodic boundaries
6. with data sorted by blocks and with constant values on each block,
7. with multiple CSV files read on every execution of the user object.
2.18.51
The system shall report an error if
1. if the CSV reader object and the function expect the CSV data to be ordered differently
2. if the desired column number in the CSV file is higher than the number of columns in the file
3. if the data saught exceeds the row number in the CSV file
4. if the number of blocks specified to a CSV reader reading block-data is 0
5. if the number of nearest-neighbor regions specified to a CSV reader reading nearest-neighbor-region-data is 0
2.18.52
The system shall issue a warning if
1. if the desired column number in the CSV file is known to be a column holding point coordinates
2. if the data file contains more points/rows than the reader needs
2.18.53The Function system shall include an object that creates a function based on x- and y-data pairs and does not extrapolate.
2.18.54The Function system shall include an object that creates a function based on x- and y-data pairs and does extrapolate.
2.18.55The system shall be capable of linear interpolating data generated by a VectorPostprocessor object.
2.18.56The system shall be capable of linear interpolating data generated by a VPP with respect to time.
2.18.57The PiecewiseMultilinear object will error if the supplied file fails to open.
2.18.58The PiecewiseMultiInterpolation object shall error if the supplied data is not monotonically increasing.
2.18.59The PiecewiseMultiInterpolation object shall error if the number of requested functions differ than the number available from the file.
2.18.60The PiecewiseMultiInterpolation errors if the axes supplied are not independent.
2.18.61The PiecewiseMultilinear shall error if the axis lines are not located in the supplied data.
2.18.62The PiecewiseMultilinear object shall perform interpolation on a 1D domain.
2.18.63The PiecewiseMultilinear object shall perform interpolation on a 1D domain that compares to an equivalent known function.
2.18.64The PiecewiseMultilinear object shall perform interpolation of time-dependent data.
2.18.65The PiecewiseMultilinear object shall perform interpolation on a 2D domain.
2.18.66The PiecewiseMultilinear object shall perform interpolation on a 2D domain that compares to an equivalent known function.
2.18.67The PiecewiseMultilinear object shall perform constant interpolation on a 2D domain.
2.18.68The PiecewiseMultilinear object shall perform interpolation on a 3D domain with time-dependent data.
2.18.69The Function object shall support the ability to couple Postprocessor values.
2.18.70The SolutionFunction object shall be capable of evaluating a solution read from XDA mesh and solution files.
2.18.71The SolutionFunction object shall be capable of evaluating a solution read from an Exodus file with temporal interpolation.
2.18.72The SolutionFunction object shall be capable of evaluating a solution read from an Exodus file.
2.18.73The SolutionFunction object shall be capable of evaluating a solution read from an Exodus file and rotated 45 degrees about the z-axis.
2.18.74The SolutionFunction object shall be capable of evaluating a solution read from an Exodus file and rotated 45 degrees about the y-axis.
2.18.75The SolutionFunction object shall be capable of evaluating a solution read from an Exodus file and rotated 90 degrees about the z-axis and 45 degress about the x-axis.
2.18.76The SolutionFunction object shall be capable of evaluating a solution read from an Exodus file and rotated 45 degrees about the z-axis for a 2D domain.
2.18.77The SolutionFunction object shall be capable of evaluating a solution read from an Exodus file and scaled by a factor in the x and y directions as well as translated in the x-direction.
2.18.78The SolutionFunction object shall be capable of evaluating a solution read from an Exodus file and scaled by a factor of two in the x and y directions.
2.18.79The SolutionFunction object shall error if a variable that does not exist is requested.
2.18.80
The system shall be capable of evaluating the gradient of a solution
1. created in a simulation
2. and read from another.

framework: Functormaterials
2.19.1
The system shall support the output of functor material data as field variables including
1. outputting a functor property, defined within a functor material;
2. outputting a functor property with automatic differentiation, defined within a functor material.
2.19.2The system shall be able to parse an expression of functors to compute a functor material property.
2.19.3
The system shall be able to
1. use the average of the values of a functor on an element's face to compute the element value, which can be smoother, and
2. use the average of the values of a functor at an element's neighbors to compute the element value, which can be smoother, and
3. use a heuristic based on a functor's value on an element and the maximum values on the element's neighbors to compute a new element value that removes a checkerboard pattern.
2.19.4The system shall be able to compute the time derivatives of functors, and make them available as functor material properties.
2.19.5The system should be able to add a generic functor material without a suffix for the properties.
2.19.6The system should be able to add a generic functor material with a suffix for the names of the properties.

framework: Functors
2.20.1The system shall be able to accurately evaluate a finite element variable through the functor system in a finite volume Dirichlet boundary condition.
2.20.2The system shall compute the correct Jacobian when evaluating a finite element variable through the functor system in a finite volume Dirichlet boundary condition.
2.20.3The system shall be able to use a variable, function, functor material property, and a post-processor in a functor parameter.
2.20.4The system shall be able to evaluate functors at nodes, element centers, and quadrature points, and match an expected analytic solution.
2.20.5
The system shall be able to solve a diffusion problem with a second order reaction term in which one operand is evaluated with the current solution state and the other operand is evaluated
1. with the current solution state, and
2. show a perfect Jacobian, or
3. with the previous nonlinear iteration solution state, and
4. show a perfect Jacobian.

framework: Fvbcs
2.21.1The system shall allow the use of functors to set Dirichlet boundary values for FV.
2.21.2The system shall allow the use of functors to set Dirichlet boundary values for FV evaluated on the other side of the sideset.
2.21.3The system shall provide a boundary condition to satisfy neumann boundary conditions with a functor
2.21.4The system shall run a simple 1D diffusion problem with a Neumann BC value.
2.21.5The system shall report an error if a finite volume flux boundary condition, in this case a finite volume Neumann boundary condition, is used inside the domain.
2.21.6The system shall report an error if a finite volume flux boundary condition is used on a mesh element face that is not connected to an element with the corresponding finite volume variable.
2.21.7The system shall run a simple 1D diffusion problem with a Dirichlet BC value set by a postprocessor.

framework: Fvics
2.22.1The system shall support setting initial conditions of finite volume field variables to a constant value.
2.22.2The system shall support setting initial conditions of subdomain restricted finite volume field variables to a constant value.
2.22.3The system shall support the initialization of a finite volume variable from an exodus file.
2.22.4The system shall support the definition of a function initial condition for a finite volume variable.

framework: Fviks
2.23.1
The system shall be able to solve a diffusion problem with finite volumes with the domain split in half and force the two variables living on each side of the domain to match on the interface., when the residual and Jacobian are computed:
1. separately
2. together
2.23.2The system shall be able to solve a diffusion problem with the domain split in half and two finite volume variables living on each side.
2.23.3The system shall be able to solve a diffusion problem with the domain split in half and two finite volume variables living on each side and interpolating the diffusivities using a harmonic mean.
2.23.4The system shall be able to solve a block-restricted diffusion problem where the variables live on different nonlinear systems.
2.23.5The system shall report an error if a user specified variable on the 1st side of an interface does not actually exist on the 1st side.
2.23.6The system shall report an error if a user specified variable on the 2nd side of an interface does not actually exist on the 2nd side.
2.23.7The system shall report an error if a user does not specify a variable on the 2nd side of an interface, leading the system to assume that the variable on the 1st side of the interface should be used on the 2nd side, and the variable on the 1st side does not exist on the 2nd side.
2.23.8
The system shall be able to solve a diffusion problem with finite volumes with the domain split in half and show first order convergence due to its treatment of coefficient discontinuities both
1. with an interfacing object
2. without an interfacing object
2.23.9The system shall be able to solve a diffusion problem with finite volumes with the domain split in half and show second order convergence due to the harmonic interpolation of the diffusion coeffcient
2.23.10The system shall be able to compute the residual and Jacobian together for a finite volume interface kernel.

framework: Fvkernels
2.24.1The system shall support block restriction of finite volume variables and kernels, and shall properly handle material evaluation in block-restricted settings, in a one-dimensional example.
2.24.2The system shall allow definition of a functor material property with the same name by different block-restricted materials on neighboring subdomains even when there are different sets of finite volume flux kernels on those same neighboring subdomains.
2.24.3The system shall support simultaneous block restriction of finite volume and finite element variables and have coupling of the finite volume variables into the finite element equations.
2.24.4The system shall compute a perfect Jacobian when coupling block-restricted finite volume variables into block-restricted finite element calculations.
2.24.5The system shall allow different materials to define the same material property name on different sides of an interface when the finite volume physics is the same on both sides of the interface.
2.24.6The system shall compute a perfect Jacobian when different materials define the same material property on different sides of a interface and the finite volume physics are the same on both sides of the interface.
2.24.7The system shall be able to force execution of flux kernels on all external boundaries.
2.24.8The system shall be able to force execution of flux kernels on one (or several) external boundary(ies).
2.24.9The system shall be able to force execution of flux kernels on all but one (or several) external boundary(ies).
2.24.10The system shall be able to avoid executing on one (or several) internal boundary(ies) or sidesets.
2.24.11The system shall report an error if conflictingly told to avoid and execute a flux kernel on the same boundary.
2.24.12The system shall be able to impose a constraint on the domain integral of a variable.
2.24.13The system shall be able to impose a constraint where the value of the constraint is provided by a postprocessor.
2.24.14The system shall be able to impose a constraint on a single point value of a variable.
2.24.15The system shall be able to impose bounds for the values of a variable.
2.24.16The system shall be able to couple both finite element and finite volume variables, as functors, into functor material property calculations.
2.24.17The system shall support coupling of a finite volume variable into a finite element calculation.
2.24.18The system shall compute a perfect Jacobian when coupling a finite volume variable into a finite element calculation.
2.24.19The system shall allow a finite volume object to consume a material property that depends on another material property that is computed in a material that couples in a finite element variable.
2.24.20The system shall suggest that the user add a finite volume variable if a finite volume object cannot retrieve one
2.24.21The system shall be able to perform finite volume simulations with adaptivity and give correct results
2.24.22The system shall be able to combat a singular solve, resulting from two term boundary expansion during gradient computation, by reverting to a one term boundary expansion.
2.24.23The system shall display second order convergence when there is some skewness due to mismatch between cell levels.
2.24.24The system shall be able to solve anisotropic diffusion problems using the finite volume method.
2.24.25The system shall be able to solve the Burgers equation in 1D using the FV method
2.24.26The system shall run a 2D linear advection problems using the finite volume method a regular mesh.
2.24.27
The system shall be able to produce correct mathematical results for a coupled-reaction problem
1. using both finite element and finite volume discretizations with
2. the correct Jacobian entries.
2.24.28The system shall be able to compute the second time derivative of a variable when using the finite volume method and automatic differentiation.
2.24.29The system shall be able to couple variables at faces when using the finite volume method.
2.24.30The system shall have an accurate Jacobian when coupling variables at faces and using the finite volume method.
2.24.31The system shall support caching of functor evaluations performed with boundary face arguments.
2.24.32The system shall run a simple 2D linear diffusion problem using the finite volume method with Dirichlet boundary conditions on a regular mesh.
2.24.33The system shall run a simple 2D linear diffusion problem in RZ coordinates using the finite volume method with Dirichlet boundary conditions on a regular mesh.
2.24.34The system shall be able to compute a full Jacobian matrix when performing finite volume computations
2.24.35
The system shall run a simple 2D linear diffusion problem using the finite volume method with Neumann and Dirichlet boundary conditions on a regular mesh, computing the Jacobian and residual:
1. separately
2. together
2.24.36The system shall run a simple 2D transient linear diffusion problem using the finite volume method with Dirichlet boundary conditions on a regular mesh.
2.24.37
The system shall be able to solve a finite-volume-only problem
1. on an unrefined mesh
2. and on a mesh that has been refined to have the same amount of elements and achieve identical results
2.24.38The system shall be able solve a three-dimensional diffusion problem using the finite volume method.
2.24.39The system shall be able solve a one-dimensional diffusion problem using the finite volume method.
2.24.40The system shall correctly account for differences between gradient and divergence operators in cylindrical coordinates.
2.24.41The system shall be able to perform Laplacian-based adaptivity with finite volume variables.
2.24.42The system shall be able to impose the constraint that the average value of a variable on a boundary be a prescribed value.
2.24.43The system shall be able to to solve an advection-diffusion equation with a dirichlet condition on the left boundary and a zero gradient condition on the right boundary and display second order convergence with the finite volume method.
2.24.44
The system shall, while using an advective outflow boundary condition, demonstrate second order convergence if a two term Taylor series is used to approximate boundary face values and reduced order convergence if a one term Taylor series is used. These converges rates shall be observed with
1. a weighted averaging advection interpolation, and
2. a min-mod advection interpolation scheme.
2.24.45The system shall be able to do one-term and two-term Taylor expansions for extrapolating finite volume solutions to boundary faces, and these extrapolations should be usable by flux kernels at inflow/outflow boundaries to produce first and second order accurate solutions respectively as measured by an L2 norm.
2.24.46The system shall display first order convergence with an upwind limiter.
2.24.47The system shall display second order convergence with a central-differencing limiter.
2.24.48The system shall display second order convergence with a Van-Leer limiter.
2.24.49The system shall display second order convergence with a min-mod limiter.
2.24.50The system shall display second order convergence with a second-order-upwind limiter.
2.24.51The system shall display second order convergence with a QUICK limiter.
2.24.52
The system shall provide a Kurganov-Tadmor scheme for evaluating convective intercell fluxes
1. with central difference interpolation of face values and resulting second order convergence
2. with upwind interpolation of face values and resulting first order convergence
3. with central difference interpolation with Van-Leer limiting of face values and resulting two and a half order convergence
2.24.53The system shall display second order convergence when applying weakly enforced matching Dirichlet and flux conditions.
2.24.54The system shall be able to solve the diffusion equation in 2D axisymmetric coordinates using the finite volume method, and display a second order convergence rate.
2.24.55The system shall be able to solve a pure advection problem in 1D cylindrical coordinates using the finite volume method, and display a second order convergence rate.
2.24.56The system shall be able to solve a advection-reaction problem in 2D axisymmetric coordinates using the finite volume method, and display a second order convergence rate.
2.24.57The system shall be able to solve a advection-diffusion-reaction problem in 2D axisymmetric coordinates using the finite volume method, and display a second order convergence rate.
2.24.58The system shall be able to implement advection through an element based kernel, that leverages the system's ability to reconstruct gradients, and demonstrate second order convergence on a cartesian coordinate system.
2.24.59The system shall be able to retrieve and usefinite volume variable gradients in materials using a coupling interface and reproduce element-based advection results based on direct use of the variable gradient in a Cartesian coordinate system.
2.24.60The system shall be able to implement advection through an element based kernel, that leverages the system's ability to reconstruct gradients, and demonstrate second order convergence in an axisymmetric coordinate system.
2.24.61The system shall be able to retrieve and usefinite volume variable gradients in materials using a coupling interface and reproduce element-based advection results based on direct use of the variable gradient in an axisymmetric coordinate system.
2.24.62
The system shall display first order convergence,
1. when using a simple arithmetic average to determine the face values of discontinuous diffusion coefficients on a regular tri mesh.
2. when using a simple arithmetic average to determine the face values of discontinuous diffusion coefficients on a quad mesh.
2.24.63
The system shall display
1. close to second order convergence, when using a simple harmonic average to determine the face values of discontinuous diffusion coefficients on a regular tri mesh.
2. second order convergence, when using a simple harmonic average to determine the face values of discontinuous diffusion coefficients on a quad mesh.
2.24.64The system shall be able to solve a coupled mass and momentum-type two equation system, which includes advection and diffusion.
2.24.65The system shall exhibit second order convergence for the unknown in a coupled mass and momentum-type two equation system.
2.24.66The system shall display second order convergence, when using face side neighbors to compute face midpoint values during gradient reconstruction.
2.24.67The system shall display first order convergence with regular face averaging in an advection diffusion problem.
2.24.68The system shall display second order convergence with skew-corrected face averaging for the diffusion term in an advection diffusion problem.
2.24.69The system shall display second order convergence with skew-corrected face averaging for the diffusion and advection terms in an advection diffusion problem.
2.24.70The system shall display first order convergence, when averaging face side neighbors to compute face midpoint values during gradient reconstruction.
2.24.71The system shall display second order convergence, when skewness-corrected averaging to compute face midpoint values during gradient reconstruction.
2.24.72The system shall display first order convergence when using a skew-corrected average-based face-interpolation together with extrapolated BCs.
2.24.73The system shall be able to solve a diffusion problem with the finite volume method and display second order convergence.
2.24.74The system shall be able to solve a advection-diffusion problem with the finite volume method and display second order convergence.
2.24.75The system shall be able to solve a advection-diffusion problem with the finite volume method, using a velocity supplied by a material, and display second order convergence.
2.24.76The system shall be able to solve a advection-diffusion problem with the finite volume method and display first order convergence with an upwind scheme for the advection operator.
2.24.77The system shall be able to solve diffusion on an orthogonal grid using a diffusion kernel which accounts only for orthogonal diffusion.
2.24.78The system shall be able to identify and show when a matrix is ill conditioned.
2.24.79The system shall be able to condition a system automatically through variable scaling factors.
2.24.80The system shall be able to condition a system manually through variable scaling factors.
2.24.81The system shall be able to sequentially apply manual and automatic scaling and in the case of poor manual scaling, restore the condition number automatically.
2.24.82The system shall be able to run a flux boundary condition and a flux kernel for different variables on the same boundary and calculate correct function and Jacobian values.
2.24.83
The system shall be able to perform limiting schemes on Euclidean vector functors. These limiting schemes include
1. first-order upwind
2. central differencing
3. vanLeer

framework: Geomsearch
2.25.1The system shall be capable of computing the distance between two disjoint boundaries on a 1D domain.
2.25.2The system shall be capable of computing the distance as well as transfer data between interior boundaries on a 2D domain.
2.25.3The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, disjoint surfaces of a moving interface in 2D.
2.25.4The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, disjoint surfaces of a moving interface in 2D using second order elements.
2.25.5The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, disjoint surfaces of a moving interface in 2D using a tangential tolerance of for the distance.
2.25.6The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, disjoint surfaces of a moving interface in 2D using a tangential tolerance of for the distance and second order elements.
2.25.7The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, overlapping surfaces of a moving interface in 2D.
2.25.8The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, overlapping surfaces of a moving interface in 2D with second order elements.
2.25.9The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, overlapping surfaces of a moving interface in 2D using a tangential tolerance for the distance.
2.25.10The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, overlapping surfaces of a moving interface in 2D using a tangential tolerance for the distance and second order elements.
2.25.11The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and convex disjoint surfaces of a moving interface in 2D.
2.25.12The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and convex disjoint surfaces of a moving interface in 2D and second order elements.
2.25.13The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and convex disjoint surfaces of a moving interface in 2D using a tangential tolerance of for the distance.
2.25.14The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and convex disjoint surfaces of a moving interface in 2D using a tangential tolerance of for the distance and second order elements.
2.25.15The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and convex disjoint surfaces of a moving interface in 2D using normal smoothing for the distance.
2.25.16The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and convex disjoint surfaces of a moving interface in 2D using normal smoothing for the distance and second order elements.
2.25.17The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and convex disjoint surfaces of a moving interface in 2D using nodal normal based smoothing for the distance.
2.25.18The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and convex disjoint surfaces of a moving interface in 2D using nodal normal based smoothing for the distance and second order elements.
2.25.19The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and concave disjoint surfaces of a moving interface in 2D.
2.25.20The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and concave disjoint surfaces of a moving interface in 2D using second order elements.
2.25.21The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and concave disjoint surfaces of a moving interface in 2D using a tangential tolerance of for the distance.
2.25.22The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and concave disjoint surfaces of a moving interface in 2D using a tangential tolerance of for the distance and second order elements.
2.25.23The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and concave disjoint surfaces of a moving interface in 2D using normal smoothing for the distance.
2.25.24The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and concave disjoint surfaces of a moving interface in 2D using normal smoothing for the distance and second order elements.
2.25.25The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and concave disjoint surfaces of a moving interface in 2D using nodal normal based smoothing.
2.25.26The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and concave disjoint surfaces of a moving interface in 2D using nodal normal based smoothing and second order elements.
2.25.27
The systems shall be capable of performing simulations with geometric penetration
1. computed within one simulation
2. that are restarted from a another.
2.25.28The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, overlapping surfaces in 2D.
2.25.29The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, disjoint surfaces in 2D with triangular elements.
2.25.30The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, disjoint surfaces of a moving interface in 3D.
2.25.31The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, disjoint surfaces of a moving interface in 3D using second order elements.
2.25.32The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, disjoint surfaces of a moving interface in 3D using a tangential tolerance of for the distance.
2.25.33The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, disjoint surfaces of a moving interface in 3D using a tangential tolerance of for the distance and second order elements.
2.25.34The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, overlapping surfaces of a moving interface in 3D.
2.25.35The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, overlapping surfaces of a moving interface in 3D with second order elements.
2.25.36The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, overlapping surfaces of a moving interface in 3D using a tangential tolerance for the distance.
2.25.37The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, overlapping surfaces of a moving interface in 3D using a tangential tolerance for the distance and second order elements.
2.25.38The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and convex disjoint surfaces of a moving interface in 3D.
2.25.39The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and convex disjoint surfaces of a moving interface in 3D and second order elements.
2.25.40The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and convex disjoint surfaces of a moving interface in 3D using a tangential tolerance of for the distance and second order elements.
2.25.41The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and concave disjoint surfaces of a moving interface in 3D.
2.25.42The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and concave disjoint surfaces of a moving interface in 3D using second order elements.
2.25.43The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between a flat and concave disjoint surfaces of a moving interface in 3D using a tangential tolerance of for the distance.
2.25.44
The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two disjoint surfaces:
1. with nodal normal based smoothing;
2. with nodal normal based smoothing and a specified tangential tolerance;
3. with a specified normal smoothing distance;
4. with a specified normal smoothing distance and a specified tangential tolerance;
5. with second-order elements and third-order quadrature; and
6. with second-order elements and third-order quadrature and a specified tangential tolerance.
2.25.45
The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two overlapping surfaces:
1. with nodal normal based smoothing;
2. with nodal normal based smoothing and a specified tangential tolerance;
3. with a specified normal smoothing distance;
4. with a specified normal smoothing distance and a specified tangential tolerance;
5. with second-order elements and third-order quadrature; and
6. with second-order elements and third-order quadrature and a specified tangential tolerance.
2.25.46The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, overlapping surfaces in 3D.
2.25.47The PenetrationAux object shall be capable of computing the distance, tangential distance, normal, closest point, side id, and element id between two parallel, disjoint surfaces in 2D with tetrahedron elements.
2.25.48The system shall be able to find contact points on a geometry where the contact point search leads to element Jacobian computations too far from the element for the Jacobian to be non-negative.
2.25.49The NearestNodeDistanceAux object shall be capable of computing the shortest distance between a boundary and subdomain.
2.25.50The NearestNodeDistanceAux shall be capable of computing the shortest distance between two boundaries.
2.25.51The NearestNodeDistanceAux shall be capable of computing the shortest distance between two boundaries with adaptivity.
2.25.52The system shall support a means for updating the geometric search patch dynamically that may be disabled.
2.25.53The system shall support a means for updating the geometric search patch dynamically that automatically determines when an update to the patch shall occur.
2.25.54The system shall support a means for updating the geometric search patch dynamically that updates the patch prior to each solve.
2.25.55The system shall support a means for updating the geometric search patch dynamically that updates the patch prior to each iteration.
2.25.56The system shall report an error in the penetration locator system if penetration is not detected.
2.25.57The system shall be able to perform patch updates on every non-linear iteration while performing uniform coarsening and refinement from grid sequencing.
2.25.58The PenetrationAux object shall compute the distance between two boundaries in 3D that overlap.
2.25.59The PenetrationAux object shall compute, in parallel, the distance between two boundaries in 3D that overlap.
2.25.60The nonlinear system shall be able to augment its sparsity based on constraints when we have a quadrature nearest-node locator.
2.25.61The NearestNodeDistanceAux object shall compute the shortest distance between nodes on two overlapping boundaries using a constant monomial auxiliary variable.
2.25.62Volumetric AD assembly data shall be properly sized when reinitializing faces
2.25.63The PenetrationAux object shall compute the distance between two overlapping boundaries using a constant monomial auxiliary variable.
2.25.64The PenetrationAux object shall compute the distance between two overlapping boundaries using a constant monomial auxiliary variable in 1D.

framework: Globalparams
2.26.1The system shall include an input file syntax that supports defining global options.
2.26.2The system shall report an error if a private / suppressed parameter is set in the input file.
2.26.3The system shall not apply global parameter options onto suppressed parameters.

framework: Hdgkernels
2.27.1The system shall be to solve a simple diffusion problem using a hybridized discontinuous Galerkin discretization.
2.27.2
The system shall show second order convergence in the L2 norm of the scalar field with a first order basis using a hybridized discontinuous Galerkin discretization on
1. simplex elements and
2. tensor-product elements.
2.27.3
The system shall show first order convergence in the L2 norm of the scalar field when using constants for the scalar basis and first order L2 Raviart-Thomas basis functions for the vector field in a hybridized mixed method on
1. simplex elements and
2. tensor-product elements.
2.27.4The system shall be able to apply a non-zero normal gradient boundary condition for the primal scalar field.
2.27.5The system shall error if hybridized discontinuous Galerkin kernels and boundary conditions operate on a different variable set.
2.27.6The system shall error if a user attempts to use a non-unity scaling factor for a variable in a hybridized Discontinuous Galerkin discretization.

framework: Ics
2.28.1The system shall allow to set constant initial conditions for an array variable.
2.28.2The system shall report an error if the wrong number of components are provided in a constant initial condition for array variables.
2.28.3The system shall allow to set initial conditions for an array variable based on functions.
2.28.4The system shall report an error if the wrong number of components are provided in a functionalized initial condition for array variables.
2.28.5The system shall support setting initial conditions on boundaries.
2.28.6Generates a rectangular IC
2.28.7BoundingBoxIC shall have a diffuse interface option.
2.28.8The system shall report an error when multiple initial conditions are applied to the same boundary.
2.28.9The system shall report an error when multiple initial conditions are applied to the same subdomain.
2.28.10The system shall report an error when a global initial conditions overlap on the same variable.
2.28.11The system shall report an error when a global and subdomain restricted initial conditions overlap on the same variable.
2.28.12The system shall support setting different values for each coefficient of higher-order scalar values.
2.28.13The system shall support setting initial conditions of field variables to a constant value.
2.28.14The system shall support setting initial conditions of subdomain restricted field variables to a constant value.
2.28.15The system shall provide current node or element pointers when possible when evaluating initial conditions at a point in the domain.
2.28.16The system shall allow setting field initial condition from an user object
2.28.17The system shall allow setting scalar initial condition from an user object
2.28.18The system shall allow nodal initial condition objects to couple to other nodal variables for computing values for the current variable.
2.28.19The system shall allow elemental initial condition objects to couple to other elemental variables for computing values for the current variable.
2.28.20The system shall write output files containing nodal solutions in ExodusII format suitable for restart.
2.28.21The system shall be able to populate nodal initial conditions from a previous solution file in ExodusII format.
2.28.22The system shall write output files containing elemental solutions in ExodusII format suitable for restart.
2.28.23The system shall be able to populate elemental initial conditions from a previous solution file in ExodusII format.
2.28.24The system shall write output files containing elemental array variable solutions in ExodusII format suitable for restart.
2.28.25The system shall be able to populate elemental array variable initial conditions from a previous solution file in ExodusII format.
2.28.26The system shall write output files containing nodal array variable solutions in ExodusII format suitable for restart.
2.28.27The system shall be able to populate nodal array variable initial conditions from a previous solution file in ExodusII format.
2.28.28The system shall support setting gradient values for shape functions that support them.
2.28.29The system shall support using a spline function to set both value and gradient values in an initial condition.
2.28.30The system shall support setting a scalar initial condition by evaluating a function.
2.28.31The system shall support setting initial conditions for the Hermite set of shape functions.
2.28.32
The system shall report an error if
1. the postprocessor does not have execute_on initial
2. the postprocessor for normalization is zero
2.28.33The system shall be able to apply a normalized sinusoidal initial condition.
2.28.34The system shall support initial conditions on second order Lagrange variables in 3D space.
2.28.35The system shall allow initial conditions to retrieve post-processor values.
2.28.36The system shall generate parallel agnostic random initial conditions
2.28.37The system shall generate threaded agnostic random initial conditions
2.28.38The system shall be able to initialize a variable from an ExodusII file.
2.28.39The system shall be able to initialize a scalar variable from an ExodusII file.
2.28.40
The system shall report an error if
1. a solution is to be loaded at a block that does not exist in the source file.
2.28.41The system shall allow to set constant vector-valued initial conditions.
2.28.42The system shall allow to set constant vector-valued initial conditions when adding vector variables.
2.28.43
The system shall allow vector-valued initial conditions be set using a vector function for the following element families:
1. vector Lagrange,
2. Nedelec,
3. and Raviart-Thomas.
2.28.44The system shall allow vector-valued initial conditions be set using a function by components.
2.28.45The system shall report an error if the 'function' and 'function_x' parameters are both set within the VectorFunctionIC object.
2.28.46The system shall report an error if the 'function' and 'function_y' parameters are both set within the VectorFunctionIC object.
2.28.47The system shall report an error if the 'function' and 'function_z' parameters are both set within the VectorFunctionIC object.
2.28.48The system should supply a special convenience "zero" variable that can be indexed like a normal coupled variable.

framework: Indicators
2.29.1The system shall include the ability to compute the square of the difference between a solution variable and an analytical function for the purpose of performing automatic mesh adaptivity.
2.29.2The system shall include the ability to compute the square of the difference between a FV solution variable and an analytical function for the purpose of performing automatic mesh adaptivity.
2.29.3The system shall include the ability to compute the square of the change in the gradient of a variable across element boundaries for the purpose of performing automatic mesh adaptivity.
2.29.4The system shall include the ability to compute the square of the change in the gradient of a finite volume variable across element boundaries for the purpose of performing automatic mesh adaptivity.
2.29.5
The system shall include the ability to compute the square of the change in the Laplacian of a variable across element boundaries for the purpose of performing automatic mesh adaptivity:
1. with a penalty based flux boundary condition;
2. with a weakly imposed flux boundary condition; and
3. for transient calculations.
2.29.6The system shall include the ability to compute the square of the change in a variable across element boundaries for the purpose of performing automatic mesh adaptivity:
2.29.7The system shall include the ability to compute the square of the change in a FV variable across element boundaries for the purpose of performing automatic mesh adaptivity:

framework: Interfacekernels
2.30.1Interface kernels shall provide integrated conditions between subdomains, and shall work with boundary restricted materials with stateful properties.
2.30.2
The interface diffusion penalty method should reproduce the analytic solution
1. using a hand-coded Jacobian
2. using a Jacobian computed via automatic differentiation
2.30.3The InterfaceKernel system shall use with interface material in 1D.
2.30.4The system shall support the evaluation of neighboring quantities on elements containing different shape functions.
2.30.5The system shall produce correct Jacobians for coupled flux on an interface.
2.30.6The system shall support produce correct Jacobians when evaluating neighboring quantities on elements containing different shape functions.
2.30.7The system shall produce correct Jacobians for single variable coupled flux on an interface.
2.30.8Save-in shall record the correct residuals and Jacobians representing the interface kernel. This applies the DirichletBC to side a (block 0) of the interface.
2.30.9Save-in shall record the correct residuals and Jacobians representing the interface kernel. This applies the DirichletBC to side b (block 1) of the interface.
2.30.10The interface reaction kernel should reproduce the analytic solution
2.30.11The interface reaction kernel should work with interface diffusion kernel
2.30.12The result of an interface reaction kernel computed using automatic differentiation shall match the analytic solution in a steady-state simulation
2.30.13The result of an interface reaction kernel computed using automatic differentiation shall be consistent with the results of the non-AD transient interface reaction test.
2.30.14The solution should be discontinued at the interface due to the reaction taking place
2.30.15The Jacobian from InterfaceReaction shall be perfect
2.30.16The system shall ensure that interfacial materials are sorted such that consumers execute after producers.
2.30.17The system shall not try to reinit a displaced interface, leading to failed point inversions, if a displaced interface kernel has not been added to the simulation.
2.30.18The InterfaceKernel system shall operate with coupled variables in 2D. This uses a penalty implementation that is optimally convergent.
2.30.19Allow the interface to impose the same time derivative on two neighboring variables. This uses a penalty implementation that is optimally convergent.
2.30.20The InterfaceKernel system shall use with interface material in 2D.
2.30.21The Jacobian evaluation for InterfaceKernel objects in 2D shall be analytically correct.
2.30.22The finite difference preconditioner shall work in parallel.
2.30.23The InterfaceKernel system shall support Vector Finite Elements in 2D.
2.30.24The system shall not perform memory allocation for automatic scaling when computing values.
2.30.25The InterfaceKernel system shall operate with coupled variables in 3D. This uses a penalty implementation that is optimally convergent.
2.30.26The InterfaceKernel system shall support Vector Finite Elements in 3D.
2.30.27The InterfaceKernel system shall use with interface material in 3D.
2.30.28The system shall be able to solve a simple interfacial source problem using automatic differentiation in which the source term depends on the gradient jump of a coupled variable.
2.30.29The system shall be able to couple variable gradients at interfaces and have an accurate Jacobian provided through automatic differentiation.
2.30.30The system shall be able to solve a simple interfacial source problem using automatic differentiation in which the slope on the left-hand side of the interface has a slope greater by two than the slope on the right-hand side.
2.30.31The system shall be able to couple variables at interfaces and have an accurate Jacobian provided through automatic differentiation.
2.30.32The system shall be able to solve a simple interfacial source problem using automatic differentiation and vector variables in which the slope on the left-hand side of the interface has a slope greater by two than the slope on the right-hand side.
2.30.33The system shall be able to couple vector variables at interfaces and have an accurate Jacobian provided through automatic differentiation.
2.30.34Adaptivity shall work with interface kernels as long as stateful properties are not used.
2.30.35The system shall report an error if the triad of interface kernels, adaptivity, and stateful properties are used together.
2.30.36The system shall be able to execute interfacial conditions on sidesets generated by gmsh.
2.30.37The system shall support Dirichlet and Neumann interface conditions.
2.30.38The system shall support penalty interface conditions.
2.30.39The system shall support matched-value interface with different variable coefficients with automatic differentiation.
2.30.40The system shall support matched-value interface with different variable coefficients.
2.30.41When computing residuals and jacobians on an interface, the system shall be able to use element information from the displaced mesh when requested
2.30.42When computing residuals and jacobians on an interface, the system shall be able to use element information from the reference mesh
2.30.43The system shall be able to compute the residual and the Jacobian of each interface kernel together.

framework: Interfaces
2.31.1The system shall be able to compute the old and older values of a variable in the neighbor cell.
2.31.2The system shall be able to couple a standard variable with its name directly through the coupling interface.
2.31.3The system shall be able to couple an array variable with its name directly through the coupling interface.
2.31.4The system shall be able to retrieve the time derivatives of variables through the coupling interface.
2.31.5The system shall be able to retrieve the time derivatives of nodal variables through the coupling interface.
2.31.6The system shall build a bijective map between variable numbers and their couple variable indices.
2.31.7The system shall provide an interface to check whether or not a mesh property exists
2.31.8The system shall report a reasonable error when retrieving a property of the mesh when the underlying types differ
2.31.9
The system shall report a reasonable error when requesting a Postprocessor from a parameter when
1. the parameter is not found,
2. the parameter does not represent a Postprocessor,
3. the parameter is a single Postprocessor value and a greater index than zero is requested,
4. and the parameter is a single Postprocessor value and a greater index than zero is requested.
2.31.10The system shall report a reasonable error when requesting a Postprocessor name from a parameter in which the postprocessor is a default value and not a name.
2.31.11
The system shall report a reasonable error when it is too early to request if a postprocesor exists
1. by parameter name and
2. by Postprocessor name.
2.31.12
The system shall report a reasonable error when requesting a Postprocessor value
1. by parameter and the Postprocessor does not exist and
2. by Postprocessor name and the Postprocessor does not exist.
2.31.13The system shall produce parallel-agnostic random number fields on a single processor.
2.31.14The system shall produce parallel-agnostic random number fields on two or more processors.
2.31.15The system shall produce parallel-agnostic random number fields on two or more threads.
2.31.16The system shall produce a parallel field without repeating patterns on distributed meshes.
2.31.17The system shall produce parallel-agnostic random number fields via the user defined (UserObject) system.
2.31.18The system shall produce parallel-agnostic random number fields via the user defined (UserObject) system on two or more processors.
2.31.19The system shall produce parallel-agnostic random number fields via the user defined (UserObject) system on two or more threads.
2.31.20The system shall produce a parallel field without repeating patterns via the user defined (UserObject) system.
2.31.21The system shall produce a parallel-agnostic random number via the material system.
2.31.22The system shall produce a parallel-agnostic random number via the material system on two or more processors.
2.31.23
The system shall report a reasonable error when requesting a Reporter value from a parameter when
1. the parameter is not found and
2. the parameter does not represent a Reporter
2.31.24The system shall report a reasonable error when requesting a Reporter value when a Reporter with the same name exists with a different type.
2.31.25
The system shall report a reasonable error when requesting a Reporter value
1. by parameter and the Reporter value does not exist and
2. by Reporter name and the Reporter value does not exist.
2.31.26
The system shall report a reasonable error when it is too early to request if a Reporter value exists
1. by parameter name and
2. by Reporter name.
2.31.27
The system shall report a reasonable error when requesting a UserObject when
1. getting the name from a parameter and the parameter is not found,
2. getting the name from a parameter and the parameter does not represent a name,
3. getting the name from a parameter and the user object is not found,
4. getting the UserObject by name and the user object is not found,
5. getting the name from a paremeter and the provided object is not of the correct type, and
6. getting the UserObject by name and the provided object is not of the correct type.
2.31.28
The system shall provide an interface that reports if a UserObject exists by
1. parameter,
2. name,
3. parameter and type, and
4. name and type.
2.31.29
The system shall report a reasonable error when requesting a VectorPostprocessor value from a parameter when
1. the parameter is not found and
2. the parameter does not represent a VectorPostprocessor.
2.31.30
The system shall report a reasonable error when it is too early to request if a VectorPostprocessor exists
1. by vector name and parameter name,
2. by vector name and VectorPostprocessor name,
3. by parameter name, and
4. and by VectorPostprocessor name.
2.31.31
The system shall report a reasonable error when requesting a VectorPostprocessor value
1. by parameter and the VectorPostprocessor does not exist,
2. by parameter and the VectorPostprocessor exists but the requested vector does not,
3. by VectorPostprocessor name and the VectorPostprocessor does not exist, and
4. by VectorPostprocessor name and the VectorPostprocessor exists but the requested vector does not.

framework: Kernels
2.32.1The system shall provide an ability to solve a 2D diffusion problem with Dirichlet boundary conditions.
2.32.2The system shall provide an ability to solve a 2D diffusion problem with Neumann boundary conditions.
2.32.3The system shall provide a diffusion kernel that obtains the diffusion coefficient from a material property
2.32.4The system shall provide an ability to solve a 2D diffusion problem including a volumetric source term.
2.32.5The system shall provide a tester that checks hand-coded Jacobian against finite difference Jacobian using -snes_type=test option.
2.32.6The system shall force the solver to take at least one iteration regardless of the initial residual norm when the snes_force_iteration option is specified.
2.32.7The system shall not compute an extra residual if the linear solver is used.
2.32.8
The system shall provide an ability to solve a 2D diffusion problem with Dirichlet boundary conditions using
1. automatic differentiation and
2. compute the correct Jacobian matrix.
2.32.9
The system shall provide an ability to solve a 2D diffusion problem Neumann boundary conditions using
1. automatic differentiation and
2. compute the correct Jacobian matrix.
2.32.10
The system shall provide an ability to solve a 2D diffusion problem including a volumetric source term using
1. automatic differentiation and
2. compute the correct Jacobian matrix.
2.32.11Coupled variable gradient Jacobian entries generated with AD shall be accurate
2.32.12
The system shall provide a source term proportional to the value of
1. an aux variable and shall be able to produce the exact Jacobian
2. an finite element primary variable and shall be able to produce the exact Jacobian
2.32.13Coupled variable value Jacobian entries generated with AD shall be accurate
2.32.14We shall be able to get aux variable values through adCoupledValue with the knowledge that the derivatives will always be zero
2.32.15Getting a constant aux variable through adCoupledValue shall not destroy our Jacobian
2.32.16We shall be able to get dot aux variable values through adCoupledValue with the knowledge that the time derivatives will always be zero
2.32.17The system shall automatically generate a full coupling matrix when doing global AD indexing such that there are no new matrix memory allocations.
2.32.18The system shall automatically generate a full coupling matrix when doing global AD indexing, resulting in a perfect Jacobian even when the user has not requested full coupling.
2.32.19The system shall allow the user to override the automated generation of a full coupling matrix when doing global AD indexing, which for this test results in a new nonzero allocation because there is off-diagonal coupling.
2.32.20Jacobians calculated by ADTimeDerivative and ADBodyForce shall be perfect.
2.32.21The Jacobian of ADBodyForce with a force function shall be perfect.
2.32.22The system shall provide a source term proportional to the value of a coupled variable with a material property prefactor.
2.32.23
The system shall provide a source term proportional to the value of
1. an aux variable with a material property prefactor and shall be able to produce the exact Jacobian.
2. an finite element primary variable with a material property prefactor and shall be able to produce the exact Jacobian.
2.32.24
The system shall solve a one-dimensional Diffusion problem with a material property diffusivity and match a known solution.
1. without and
2. with automatic differentiation including
3. the correct Jacobian matrix.
2.32.25
The system shall solve a two-dimenional Diffusion problem with a material property diffusivity and match a known solution.
1. without and
2. with automatic differentiation including
3. the correct Jacobian matrix.
2.32.26The system shall provide an ability to solve a steady-state diffusion-reaction problem, where the reaction term has a material property reaction rate.
2.32.27The system shall calculate the correct Jacobian of ADMatReaction using automatic differentiation.
2.32.28The system shall contain a consuming reaction term object whose Jacobian is calculated via forward automatic differentiation.
2.32.29The system shall produce a perfect Jacobian for a consuming reaction term object using forward automatic differentiation.
2.32.30The system shall contain a consuming reaction term object with a scalar coefficient whose Jacobian is calculated via forward automatic differentiation.
2.32.31The system shall produce a perfect Jacobian for a consuming reaction term object with a scalar coefficient using forward automatic differentiation.
2.32.32
The system will produce a harmonic function with a prescribed average value,
1. showing the correct results with separate computation of residual and Jacobian
2. verifying the separated Jacobian
3. showing the correct results with computation of residual and Jacobian together
4. verifying the Jacobian together
2.32.33
The system shall solve the constrained Neumann problem using the AD Lagrange multiplier approach with LU solver,
1. showing the correct results with separate computation of residual and Jacobian for Neumann
2. verifying the separated Jacobian for Neumann
3. showing the correct results with computation of residual and Jacobian together for Neumann
4. verifying the Jacobian together for Neumann
2.32.34The system shall solve the constrained Neumann problem using the AD Lagrange multiplier approach with LU solver, computing the residual and Jacobian simultaneously.
2.32.35The system shall support the ability to include the AD scalar wrapper but not actually using a scalar variable.
2.32.36The system shall report an error if a user assigns a scalar and requests evaluation of scalar residuals, but does not override the quadrature point residual evaluation routine in their derived class.
2.32.37Jacobian entries generated with AD for a simple diffusion problem shall be accurate
2.32.38
The system shall be able to solve a transient diffusion problem with
1. automatic differentiation and
2. compute the correct Jacobian matrix.
2.32.39
The system shall be able to solve a transient diffusion problem with vector variables
1. automatic differentiation and
2. compute the correct Jacobian matrix.
2.32.40Jacobian entries generated with AD shall match hand-coded Jacobian entries as measured through save-in values
2.32.41The system shall provide a generic kernel object that allows for easy switching between hand-coded and automatic computation of the Jacobian, and encourages maximum kernel code-reuse.
2.32.42The system shall support coupling of variables with automatic differentiation and vector values.
2.32.43The system shall support coupling to the gradient of variables with automatic differentiation and vector values.
2.32.44The system shall support coupling of default values for variables with automatic differentiation and vector values.
2.32.45
The system shall run a coupled diffusion-advection problem with higher-order variables on a non-regular mesh domain:
1. in a steady-state calculation, and
2. in a transient calculation.
2.32.46The system shall support direct tensor-vector products and vector dot products to maintain dimension agnostic formulations where possible.
2.32.47The system shall be able to reproduce the exact Jacobian for a 1d grid for a coupled array time derivative kernel.
2.32.48The system shall be able to reproduce the exact Jacobian for a 2d grid for a coupled array time derivative kernel.
2.32.49The system shall be able to reproduce the exact Jacobian for a 3d grid for a coupled array time derivative kernel.
2.32.50The system shall provide array diffusion kernels on an array variable.
2.32.51The system shall provide array reaction kernels on an array variable.
2.32.52The system shall provide array DG diffusion kernels on an elemental array variable.
2.32.53The system shall provide coupling of standard variables in array kernels.
2.32.54The system shall provide coupling of array variables in standard kernels.
2.32.55
The system shall provide residual save-in and Jacobian diagonal save-in for
1. array and
2. standard variables.
2.32.56The system shall provide array time derivative kernels on an array variable.
2.32.57The system shall provide array body-force kernels on an array variable.
2.32.58The system shall assemble the Jacobian properly with array variables.
2.32.59We shall be able to show that without automatic scaling, this system is singular
2.32.60We shall be able to show that with automatic scaling, this system is non-singular
2.32.61We shall be able to show that with automatic scaling we can run this problem successfully in parallel
2.32.62
The system shall support the ability to apply a kernel to a subset of the domain
1. through a subdomain restriction on the kernel, and
2. through a subdomain restriction on the variable.
2.32.63The system shall support applying a function of space-time as a forcing function to the mesh domain.
2.32.64The system shall support applying a material property of space-time as a forcing function to the mesh domain.
2.32.65The system shall support applying a material property of space-time as a forcing function to the mesh domain using AD.
2.32.66The system shall report an error when a parsed function expression contains quote characters.
2.32.67The system shall support scaling the computed time derivative by a scalar coefficient.
2.32.68
The system shall include the ability to compute the residual contribution from the conservative form of the advection operator
1. without upwinding in 3D,
2. with upwinding in 3D,
3. without upwinding in 1D,
4. with upwinding in 1D,
5. without upwinding in 2D,
6. with upwinding in 2D,
7. with upwinding and an outflow boundary condition, and
8. without any outflow boundary conditions.
2.32.69A coupled time derivative kernel shall be provided
2.32.70A coupled time derivative kernel with forward mode automatic differentiation shall be provided
2.32.71A coupled time derivative kernel compatible with vector variables with hand-coded jacobians shall be provided
2.32.72The Jacobian from VectorCoupledTimeDerivative shall be perfect
2.32.73The SMP Jacobian for a problem with a hanging-node shall be non-singular
2.32.74The colored finite difference Jacobian for a problem with a hanging-node shall be non-singular
2.32.75The standard finite difference Jacobian for a problem with a hanging-node shall be non-singular
2.32.76A matrix-free operator shall be able to solve the hanging-node problem, indicating it is non-singular
2.32.77The SMP Jacobian shall be perfect for the hanging-node problem
2.32.78The system shall compute a perfect Jacobian via automatic differentiation for a hanging-node problem and simultaneously handle automatic differentiation objects that do not actually have nonlinear variable dependence.
2.32.79The system shall run a simple 2D linear diffusion problem with Dirichlet boundary conditions on a regular mesh, where the laplace operator uses a function coefficient.
2.32.80The system shall support hybrid finite element method (HFEM) calculations with Dirichlet boundary conditions using standard variables.
2.32.81The system shall support hybrid finite element method (HFEM) calculations with Dirichlet boundary conditions using array variables.
2.32.82The system shall support hybrid finite element method (HFEM) calculations with preconditioner only using the block diagonal Jacobian.
2.32.83The system shall support hybrid finite element method (HFEM) calculations with coupling of components of array variables on internal sides.
2.32.84The system shall support hybrid finite element method (HFEM) calculations with coupling of components of array variables on boundary sides.
2.32.85The system shall support hybrid finite element method (HFEM) calculations with Neumann boundary conditions using standard variables.
2.32.86The system shall support hybrid finite element method (HFEM) calculations with Neumann boundary conditions using array variables.
2.32.87The system shall support hybrid finite element method (HFEM) calculations with Robin boundary conditions using standard variables.
2.32.88The system shall support hybrid finite element method (HFEM) calculations with Robin boundary conditions using array variables.
2.32.89The system shall support hybrid finite element method (HFEM) calculations with high order shape functions.
2.32.90The system shall support hybrid finite element method (HFEM) calculations with Robin boundary conditions through Lagrange multipliers.
2.32.91The system shall support hybrid finite element method (HFEM) calculations with displaced meshes.
2.32.92The system shall issue an error for unsupported mesh adaptation with hybrid finite element method (HFEM) calculations.
2.32.93The system shall support hybrid finite element method (HFEM) calculations with Dirichlet boundary conditions with boundary values specified by variables.
2.32.94
The system shall be able to compute lower dimensional element volumes using element Jacobian information computed earlier during finite element object reinitialization and when the highest dimension of the mesh is
1. two
2. three
2.32.95We shall automatically capture the dependence of things like JxW and grad_test on (second order) displacements
2.32.96We shall automatically capture the dependence of things like JxW and grad_test on (first order) displacements
2.32.97We shall automatically capture the dependence of things like JxW and grad_test on (second order) displacements for a cylindrical geometry
2.32.98We shall automatically capture the dependence of things like JxW and grad_test on (first order) displacements for a cylindrical geometry
2.32.99We shall automatically capture the dependence of things like JxW and grad_test on (second order) displacements for a spherical geometry
2.32.100We shall automatically capture the dependence of things like JxW and grad_test on (first order) displacements for a spherical geometry
2.32.101The system shall provide optimized kernels for residuals with the test function or its gradient factored out.
2.32.102The system shall provide optimized kernels for residuals with the test function or its gradient factored out in the automatic differentiation system.
2.32.103The system shall calculate perfect Jacobians for the automatic differentiation precompute problem.
2.32.104The system shall support the ability to use mass lumping for time derivative terms.
2.32.105The system shall verify that the Jacobian terms when using mass lumping for time derivative terms are computed correctly.
2.32.106The system shall support a kernel for coupling the sum of several products of material properties with variables and constant coefficients
2.32.107The system shall have the ability to declare the derivatives of material properties.
2.32.108The system shall have the ability to verify individual Jacobian contributions before they are scaled by other finite element factors in the system.
2.32.109The system shall support solving Ordinary Differential Equations in explicit form.
2.32.110The system shall support solving Ordinary Differential Equations in implicit form.
2.32.111The system shall support solving ODEs specified within the input file through parsed expression syntax.
2.32.112The system support coupling of postprocessor values in the parsed expression ODE kernel.
2.32.113The system shall support solving Coupled Ordinary Differential Equations.
2.32.114The system shall allow scalar variable initial condition to be loaded from a file mesh
2.32.115The system shall allow auxscalar variable initial condition to be loaded from a file mesh
2.32.116The system shall be able to compute the residual and the Jacobian of each Kernel together.
2.32.117The system shall solve the constrained Neumann problem using the Lagrange multiplier approach.
2.32.118The system shall solve the constrained Neumann problem using the Lagrange multiplier approach when displacements are active.
2.32.119The system shall support the ability to set Dirichlet boundary conditions using the Lagrange multiplier approach.
2.32.120The system shall solve a constrained Neumann problem and volume averaging using the Lagrange multiplier approach derived from a scalar augmentation class.
2.32.121The system shall support the ability to include the scalar wrapper but not actually use a scalar variable.
2.32.122The system shall report an error if a derived object uses scalars and computes scalar residuals but does not override the quadrature point residual calculation routine.
2.32.123The system shall support retrieving a vector of values in a kernel object for the purpose of computing a residual statement.
2.32.124The system shall run a simple 2D linear diffusion problem with Dirichlet boundary conditions on a regular mesh.
2.32.125The system shall be able to run a transient diffusion problem
2.32.126The system shall not do any mallocs in MatSetValues for simple kernels
2.32.127We shall not be able to solve a problem where the physics Jacobians are very large compared to the jacobian from a Dirichlet BC (unity)
2.32.128We shall be able to solve an initially poorly scaled problem by using MOOSE's automatic scaling feature
2.32.129We shall be able to solve an initially poorly scaled problem by using MOOSE's automatic scaling feature in parallel
2.32.130We shall not be able to solve a problem where the physics has large changes over time if we only scale once
2.32.131We shall be able to solve a problem where the physics has large changes over time if we scale on every time step
2.32.132We shall be able to solve a problem where the physics has large changes over time if we scale on every time step in parallel
2.32.133The system shall be able to do on the fly time derivative and gradient evaluations of variable functors.
2.32.134The system shall report an error if the volumetric residual calculation is not assigned an associated vector within the numerical solving routine.
2.32.135Time kernel requires a transient executioner
2.32.136The kernel can be only assigned to the existing vector tags in the system
2.32.137The kernel can be only assigned to the existing matrix tags in the system
2.32.138The system shall be able to reproduce the simple_transient_diffusion test with VectorTimeDerivative (hand-coded Jacobian).
2.32.139The Jacobian from VectorTimeDerivative shall be perfect
2.32.140The system shall compute second-order time derivatives for vector variables
2.32.141The system shall be able to solve a curl-curl problem using Nedelec elements of the first kind.
2.32.142The system shall be able to estimate the L2 and H(curl) errors for a curl-curl problem solved using Nedelec elements of the first kind.
2.32.143The system shall be able to couple a vector variable into a standard kernel.
2.32.144The system shall be able to assign a default value for a vector variable from the source file.
2.32.145The system shall warn when assigning a default value with number of components less than LIBMESH_DIM, and it shall be able to assign the default value from the input file.
2.32.146The system shall be able to assign a default value for a vector variable from the input file and still have the correct jacobian.
2.32.147The system shall be able to solve multi-dimensional problems with vector Lagrange variables.
2.32.148The system shall be able to solve one-dimensional problems with vector Lagrange variables.
2.32.149The system shall be able to solve one-dimensional problems with vector Lagrange variables and produce the correct Jacobian.
2.32.150The system shall be able to solve multi-d vector Lagrange problems with automatic differentiation and reproduce the hand-coded result.
2.32.151The system shall be able to solve multi-d vector Lagrange problems with automatic differentiation and have a perfect Jacobian.
2.32.152The system shall be able to couple a vector variable into a standard kernel and produce the correct Jacobian.
2.32.153The system shall be able to couple a standard variable into a vector kernel. Additionally, the system shall be able to calculate time derivatives of variable gradients.
2.32.154The system shall be able to compute the correct Jacobian when coupling a standard variable into a vector kernel and taking time derivatives of variable gradients.
2.32.155The system shall be able to assign Dirichlet boundary conditions for vector Lagrange variables; obtain coupled vector variable gradients; and correctly initialize both volume and face curl shape functions when the curl of a variable is requested.
2.32.156The system shall report an error if the 'function' and 'function_x' parameters are both set when defining a vector function Dirichlet boundary condition.
2.32.157The system shall report an error if the 'function' and 'function_x' parameters are both set within the ADVectorFunctionDirichletBC object.
2.32.158
The system shall be capable of modeling a div-grad problem in H(div) using the following Raviart-Thomas elements:
1. HEX27,
2. TET14,
3. TRI6,
4. TRI7,
5. QUAD8,
6. and QUAD9.
2.32.159
The system shall be capable of estimating the L2 and H(div) errors for a div-grad problem in H(div) solved using the following Raviart-Thomas elements:
1. HEX27,
2. TET14,
3. TRI6,
4. TRI7,
5. QUAD8,
6. and QUAD9.

framework: Linearfvkernels
2.33.1The system shall display first-order convergence for advection problems with upwind interpolation solved using a linear finite volume system on a one-dimensional domain.
2.33.2The system shall display second-order convergence for advection problems with linear interpolation solved using a linear finite volume system on a one-dimensional domain.
2.33.3The system shall display first-order convergence for advection problems with upwind interpolation solved using a linear finite volume system on a two-dimensional orthogonal mesh.
2.33.4The system shall display second-order convergence for advection problems with linear interpolation solved using a linear finite volume system on a two-dimensional orthogonal mesh.
2.33.5The system shall display first-order convergence for advection problems with upwind interpolation solved using a linear finite volume system on a two-dimensional nonorthogonal mesh.
2.33.6The system shall display first-order convergence for advection problems with linear interpolation solved using a linear finite volume system on a two-dimensional nonorthogonal mesh.
2.33.7The system shall display second-order convergence for advection problems with linear interpolation solved using a linear finite volume system on a two-dimensional orthogonal mesh in cylindrical coordinate system.
2.33.8The system shall display second-order convergence for anisotropic diffusion problems with a central differencing scheme solved using a linear finite volume system on a two-dimensional orthogonal mesh.
2.33.9The system shall display second-order convergence for anisotropic diffusion problems with a central differencing scheme solved using a linear finite volume system on a two-dimensional nonorthogonal mesh.
2.33.10The system shall display second-order convergence for diffusion problems with Dirichlet boundary conditions using a linear finite volume system on a block-restricted two-dimensional orthogonal mesh.
2.33.11The system shall display second-order convergence for advection-diffusion-reaction problems with an outflow boundary condition using a linear finite volume system on a block-restricted two-dimensional orthogonal mesh.
2.33.12The system should be able to exactly solve a problem with a constant source and diffusion and reaction kernels restricted to two different subdomains.
2.33.13The system shall display second-order convergence for advection-diffusion-reaction problems with Dirichlet boundary conditions using a linear finite volume system on a one-dimensional domain.
2.33.14The system shall display second-order convergence for advection-diffusion-reaction problems with an outflow boundary condition using a linear finite volume system on a one-dimensional domain.
2.33.15The system shall display second-order convergence for advection-diffusion-reaction problems with Dirichlet boundary conditions using a linear finite volume system on a two-dimensional orthogonal mesh.
2.33.16The system shall display second-order convergence for advection-diffusion-reaction problems with outflow boundary conditions using a linear finite volume system on a two-dimensional orthogonal mesh.
2.33.17The system shall display second-order convergence for diffusion problems with a central differencing scheme solved using a linear finite volume system on a one-dimensional domain.
2.33.18The system shall display second-order convergence for diffusion problems with a central differencing scheme solved using a linear finite volume system on a two-dimensional orthogonal mesh.
2.33.19The system shall display second-order convergence for diffusion problems with a central differencing scheme solved using a linear finite volume system on a two-dimensional nonorthogonal mesh.
2.33.20The system shall display second-order convergence for diffusion problems with a central differencing scheme solved using a linear finite volume system on an orthogonal mesh in cylindrical coordinate system.
2.33.21The system shall be able to solve reaction problems using a linear finite volume system on a one-dimensional domain.

framework: Make Install
2.34.1The system shall support the ability to report installable inputs on the command line.
2.34.2
The system shall support the ability to "install" inputs:
1. from a pre-determined user-readable location;
2. copied using a MOOSE-based binary;
3. verifying a successful copy operation;
4. able to report an error if overwriting may occur using a MOOSE-based binary;
5. able to link a binary to an installed location;
6. able to successfully launch the TestHarness using a MOOSE-based binary;
7. and cleaned up from a user-readable location.

framework: Markers
2.35.1The system shall include the ability to mark a mesh subdomain for uniform refinement.
2.35.2The adaptivity system shall create an auxiliary field variable that marks elements for refinement adjacent to a boundary.
2.35.3The adaptivity system shall create an auxiliary field variable that marks elements for refinement within a given distance of a boundary.
2.35.4The adaptivity system shall create an auxiliary field variable that marks elements for refinement adjacent to any of a given set of boundaries.
2.35.5The adaptivity system shall create an auxiliary field variable that marks elements for refinement within a rectangular region.
2.35.6The adaptivity system shall adapt the mesh within a rectangular region.
2.35.7The system shall include the ability to combine multiple mesh refinement markers into a single value.
2.35.8The system shall include the ability to mark elements within a subdomain to be unchanged for mesh adaptivity.
2.35.9The system shall include a means for setting mesh refinement flags based on percent of error for a sorted vector of error values computed for each finite element.
2.35.10The system shall include the ability to use the same error extremes during all calculations of error fraction values during mesh adaptivity.
2.35.11The system shall include a means for setting mesh refinement flags based on percent of error for a sorted vector of error values computed for each finite element using FV variables
2.35.12The system shall include a means for computing mesh refinement flags based on an absolute values of error.
2.35.13The system shall include a means for performing mesh adaptivity based on an absolute values of error.
2.35.14It shall not be possible to specify Markers to run on the displaced mesh.
2.35.15The system shall support the ability to mark elements for mesh adaptivity based on a bounding box with arbitrary orientation.
2.35.16The system shall support access to finite element quadrature point locations during the calculation of refinement marker flags.
2.35.17The adaptivity system shall create an auxiliary field variable that marks elements containing the points from the reporter for refinement.
2.35.18The marker shall create an error if the coordinate vectors are not all the same size
2.35.19The marker shall be used for adaptivity for a moving point, being able to coarsen elements the point moves out of but not coarsen elements if it contains point.
2.35.20
The system shall support the capability of creating a tool for marking finite elements for mesh refinement, for example:
1. adding elements within the intersection of two circles;
2. adding elements within the intersection of two circles and removing elements outside the circles; and
3. performing adaptivity when a non-uniform initial condition is defined.
2.35.21The system shall support marking the entire finite element mesh for refinement.
2.35.22The system shall include the ability to mark elements within a finite element mesh for adaptivity based on if the value of a variable is within a specific range.
2.35.23The system shall include the ability to mark elements within a finite element mesh for adaptivity based on if the value of a variable is above or below a threshold.

framework: Materials
2.36.1The system shall provide a function for materials to check whether a declared material property is active on current element.
2.36.2The system shall be able to convert functors from AD to regular.
2.36.3The system shall be able to convert functors from regular to AD.
2.36.4The Jacobian from a material property declared as AD and gotten as AD shall be accurate
2.36.5The Jacobian from a material property declared as regular and gotten as regular shall be inaccurate
2.36.6AD shall work with stateful material properties and the Jacobian shall be beautiful
2.36.7The time evolution of the stateful diffusivity property shall show that AD works with stateful material properties
2.36.8We shall be able to set default values for AD material properties
2.36.9We shall have a perfect Jacobian when using default values for an AD material property
2.36.10For a given dual number, the system shall be able to construct a map from global degree of freedom index to the corresponding derivative
2.36.11ADPiecewiseLinearInterpolationMaterial shall create a material with a linear interpolation of a variable
2.36.12PiecewiseLinearInterpolationMaterial shall create a material with a linear interpolation of a variable and perform approriate scaling
2.36.13ADPiecewiseLinearInterpolationMaterial shall create a material with a linear interpolation and extrapolation of a variable
2.36.14ADPiecewiseLinearInterpolationMaterial shall throw an error if x, y, and xy_data are all specified
2.36.15ADPiecewiseLinearInterpolationMaterial shall throw an error if x and xy_data are both specified
2.36.16ADPiecewiseLinearInterpolationMaterial shall throw an error if x and y vectors are different lengths
2.36.17ADPiecewiseLinearInterpolationMaterial shall throw an error if xy_data vector is not a multiple of two
2.36.18ADPiecewiseLinearInterpolationMaterial shall calculate perfect Jacobians
2.36.19The system shall provide material properties in boundary restricted objects acting on nodal variables.
2.36.20The system shall provide material properties in boundary restricted objects acting on elemental variables.
2.36.21The system shall provide location dependent boundary material property evaluations with finite volume variables.
2.36.22The system shall be able to use automatic differentiation instantiations of piecewise linear functions.
2.36.23The system to construct compile time derivative materials shall correctly evaluate all derivatives of a given expression.
2.36.24By default coupled variables shall map to the x,y,z, and t function parameters.
2.36.25The user shall be able to provide a custom mapping of coupled variables to function parameters.
2.36.26Duplicate positions in the coupled variable mapping to function parameters shall raise an error.
2.36.27A number of positions in mapping to function parameters that does not match the number of coupled variable shall raise an error.
2.36.28The ADCoupledValueFunctionMaterial shall return correct derivatives for coupled AD variables.
2.36.29The system shall issue an error when multiple materials properties with the same name are declared on the same block.
2.36.30
The system shall be capable of producing analytic derivatives of material properties:
1. defined by function expressions,
2. involving chain rules of material properties defined by function expressions, and
3. for the free energy Allen-Cahn Bulk material function.
2.36.31
The system shall support late binding of derivative material properties:
1. so that construction order does not influence the outcome of the tests, and
2. so that construction order does not influence the outcome of the tests when using automatic differentiation, and
3. so that they may be retrieved before being declared.
2.36.32The system shall support supplying a constant literal in place of a property name for material property derivative consumers.
2.36.33The system shall support optional coupling where materials that do not exist are returned as valid objects containing zero.
2.36.34The system shall issue an error when required derivative materials that are retrieved are never declared.
2.36.35
The system shall handle a bad evaluation by
1. passing a silent nan.
2. throwing a warning and passing a silent nan.
3. throwing an error.
4. throwing an exception.
2.36.36
The system shall handle a bad evaluation when using JIT by
1. passing a silent nan.
2. throwing a warning and passing a silent nan.
3. throwing an error.
4. throwing an exception.
2.36.37
The system shall be capable of coupling postprocessor values in
1. ParsedMaterial
2. DerivativeParsedMaterialParsedMaterial
3. ADParsedMaterial
4. ADDerivativeParsedMaterial
2.36.38
The system shall be capable of producing analytic derivatives of material properties using dual numbers:
1. returning an exact jacobian.
2. returning an exact jacobian in derivative materials.
3. defined by function expressions,
4. involving chain rules of material properties defined by function expressions, and
2.36.39The system shall create AD material properties even if the derivatives are zero
2.36.40
The system shall support late binding of derivative material properties:
1. so that they may be retrieved before being declared.
2.36.41The system shall support supplying a constant literal in place of a property name for material property derivative consumers that require dual numbers.
2.36.42The system shall support optional coupling where materials that do not exist are returned as valid objects containing zero, supporting dual numbers.
2.36.43The system shall issue an error when required dual number derivative materials that are retrieved are never declared.
2.36.44
The system shall handle a bad evaluation using dual numbers by
1. passing a silent nan.
2. throwing a warning and passing a silent nan.
3. throwing an error.
4. throwing an exception.
2.36.45
The system shall allow users to request derivatives with respect to function symbols other than MOOSE variables
1. such as derivatives w.r.t. material properties
2. and error out if derivatives w.r.t unknown symbols are requested
3. and error out if derivatives MOOSE variables are requested in additional_derivative_symbols (as they are requested by default)
4. and error out if any symbols are supplied more than once
2.36.46
The system shall require explicitly coupled properties to exist
1. for regular properties in ParsedMaterials
2. and error out for non-existing for explicitly requested derivatives in ParsedMaterials
3. for explicitly requested derivatives in ParsedMaterials
4. for explicitly requested derivatives but optimized out derivatives in ParsedMaterials
5. but provide for a user override to default non-existing properties to zero
6. in DerivativeParsedMaterials
2.36.47
The system shall make available the property states
1. old,
2. older.
2.36.48The system shall make available current point location, simulation time, and current time step size.
2.36.49
The system shall provide a method for summing multiple DerivativeParsedMaterialsand compare exact to a single DerivativeParsedMaterial
1. validating coupling
2. without validating coupling
3. validating coupling using automatic differentiation
4. without validating coupling using automatic differentiation
2.36.50
The system shall support the ability for materials to force immediate execution of other (discrete) materials:
1. for a simple monomial expression, and
2. for a simple polynomial expression.
2.36.51The system shall not calculate materials that are meant to be controlled by other materials (discrete) materials.
2.36.52The system shall issue a warning when a "discrete" material object is retrieved for use in a controlling material but it is set to auto-execute.
2.36.53
The system shall verify that a material being retrieved is defined everywhere that the retrieving material is defined:
1. on compatible blocks, and
2. on compatible boundaries.
2.36.54The system shall issue a warning when a "discrete" material's "reset" method is not defined.
2.36.55The system shall allow block-restricted discrete material without producing a false positive cyclic dependency error.
2.36.56The system shall be able to convert functors to regular (using automatic differentiation or not) material properties.
2.36.57The system shall be able to convert functors to regular (using automatic differentiation or not) boundary material properties.
2.36.58The system shall be able to convert vector functors to regular vector material properties.
2.36.59
The system shall report an error
1. if the user requests conversions to both AD and regular material properties, as this is not supported,
2. if the user inputs a different number of functors and material properties, as the conversion match one to one.
2.36.60The system shall be able to convert functors from AD to regular and vice versa.
2.36.61
The system shall report an error with a clear parameter error if
1. the names for the regular functors to be converted are going to overlap with the new automatic differentiation functors
2. the names for the regular functors to be converted are going to overlap with the other new regular functors
3. the names for the automatic differentiation functors to be converted are going to overlap with the new regular functors
4. the names for the automatic differentiation functors to be converted are going to overlap with the other new automatic differentiation functors
5. the number of automatic differentiation functors to convert does not match the number of names for the converted functors
6. the number of regular functors to convert does not match the number of names for the converted functors
2.36.62
The system shall be able to execute functor material properties in integrated boundary conditions
1. with some caching of the property evaluations
2. with no caching of the property evaluations
2.36.63The system shall be able to create functor material properties from the gradient of other functors.
2.36.64The system shall be able to create material properties that can be evaluated on-the-fly provided geometric arguments.
2.36.65The system shall report an error if multiple definitions are given for a functor material property on a given subdomain.
2.36.66
The system shall be able to solve a diffusion problem with different diffusivities on different subdomains and obtain the same results using
1. material properties bound to references
2. material properties evaluated with geometric position information
2.36.67The system shall be able to transfer vector material properties to an auxiliary variable, on a per-component basis.
2.36.68
The system shall be able to evaluate, cache, and then clear functor material property evaluations
1. at the beginning of timesteps
2. always, so always perform evaluations
3. on nonlinear iterations
4. on linear iterations
2.36.69The system shall report an error if an automatic differentiation (AD) object requests a non-AD functor when the functor is AD. This prevents potential dropping of derivative information.
2.36.70The system shall report an error if a functor material property is declared with the same name as another functor.
2.36.71The system shall report an error if a functor vector material property is declared with the same name as another functor.
2.36.72The system shall be able to cache functor evaluations associated with cell centers.
2.36.73The system shall be able to compute the vector norm in a functor material property of component scalars
2.36.74The system shall be able to supply a functor capable of computing the norm of a vector functor.
2.36.75
The system shall report an error if a user provides to the vector magnitude functor material both a vector functor parameter and
1. x-component functor parameter
2. y-component functor parameter
2.36.76
The system shall be able to produce a valid Real material object on the fly for use in calculations requiring material properties
1. computed at each quadrature point.
2. with a single value per element for efficiency that is made available to all quadrature points in a coupled calculation.
2.36.77
The system shall shall be able to compute a RankTwoTensor material object
1. with constant values.
2. with constant values using automatic differentiation.
3. with values determined by functions.
4. with values determined by functions using automatic differentiation.
2.36.78
The system shall shall be able to compute a SymmetricRankTwoTensor material object
1. with constant values.
2. with constant values using automatic differentiation.
2.36.79
The system shall report the retrieval of material properties by names:
1. on boundaries,
2. on blocks,
3. on the all mesh boundaries, and
4. on the all mesh blocks.
2.36.80The system shall support retrieving a single property (name) supplied by different materials on different mesh blocks.
2.36.81The system shall report an error if a material property is needed on the entire domain but is only supplied on a subset of the subdomains.
2.36.82The system shall report that a material property is available when it is defined on a subdomain.
2.36.83The system shall support retrieving a boundary restricted material property for performing a calculation on a boundary.
2.36.84The system shall report and error when a boundary restricted material is not defined on the same boundary as a boundary restricted object using that property in a calculation.
2.36.85The system shall be able to grab face and neighboring face variable values and material properties in a single material object that lives on an interface
2.36.86The system shall be able to grab face and neighboring face variable values and material properties in a single material object that lives on an interface when the mesh is split
2.36.87The system shall be able to calculate stateful material properties in an interface material object
2.36.88The system shall evaluate interface materials such that they can be used in boundary restricted elemental auxiliary kernels
2.36.89
The system shall support material property calculations that depend on other material properties:
1. with one level of dependencies,
2. with two levels of dependencies,
3. with three levels of dependencies, and
4. with differing values across mesh subdomains.
2.36.90The system shall support material property calculations for used with discontinuous Galerkin finite element method.
2.36.91The system shall support material property calculations that are restricted to boundaries on the mesh.
2.36.92The system shall report an error if material property calculations result in a cyclic dependency.
2.36.93The system shall support material property calculations that operate on auxiliary systems and during volume and surface residual calculations.
2.36.94The system shall report an error if material properties are not computed on all subdomains.
2.36.95
The system shall include that ability to handle C++ exceptions during material property calculation routines:
1. on a single process,
2. from processor 1 during a parallel calculation with 4 processes,
3. from processor 0 during a parallel calculation with 4 processes.
2.36.96The system shall support the calculation of material properties that vary at numerical integration quadrature points.
2.36.97The system shall only compute material properties when they are needed (consumed by other objects).
2.36.98
The system shall report an error if a requested material property does not exist for
1. regular material properties
2. AD material properties
2.36.99
The material data system shall report a reasonable error when requesting
1. a non-AD property and the property has already been requested with a different non-AD type
2. an AD property and the property has already been requested with a different AD type
3. a non-AD property and the property has already been requested as an AD property
4. an AD property and the property has already been requested as a non-AD property
2.36.100The system shall support having multiple materials supplying multiple unique material properties on the same subdomains of the mesh.
2.36.101The system shall not create a dependency when old versions of material properties are retrieved and used in calculations.
2.36.102
The system shall support optional material property coupling when the requesting object
1. is a material that comes before the providing material
2. is a material that comes after the providing material
3. is an AuxKernel
4. is a UserObject
2.36.103Optional material property objects that cannot be resolved shall evaluate to false
2.36.104
The optional material property system use from a material object shall return
1. an accessible material for existing AD properties
2. an accessible material for existing non-AD properties
3. an inaccessible material for non-existing AD properties
4. an inaccessible material for non-existing non-AD properties
2.36.105
The system shall support the output of material data as field variables including
1. outputting all properties within a material definition;
2. outputting all AD properties within a material definition;
3. outputting all properties from the output definition;
4. outputting certain properties within a material definition;
5. outputting certain properties within the output definition on a subdomain;
6. outputting certain properties within the material definition on a subdomain;
7. outputting certain properties within the material definition on a subdomain with a displaced configuration;
8. outputting certain properties within the material definition on a boundary;
9. outputting certain properties within the material definition to different files; and
10. outputting properties for steady-state simulations.
2.36.106
The system shall support the output as auxiliary field variables of
1. automatic differentiation vector material properties
2.36.107The system shall report an error if an existing variable shares the same name as an auxiliary variable used for material output
2.36.108The system shall report an error if the supplied output options for material data output are not consistent with the list of available outputs.
2.36.109The system shall issue warnings if material data added by materials cannot be outputted as field variables.
2.36.110The system shall show the field variable names for outputting material data added by materials.
2.36.111The system shall support parsed material property calculations using functors as input.
2.36.112The system shall provide a material object that can, for a single material property, map subdomain IDs to a continuous property value.
2.36.113The system shall provide a material object that can, for a single material property, map subdomain IDs to a possibly discontinuous property value.
2.36.114The system shall provide a material object that can, for a single functor material property, map subdomain IDs to different functors.
2.36.115
The system shall support the calculation of a material property with a
1. linear interpolation of a variable,
2. with a scaling factor, and
3. extrapolation.
2.36.116
The system shall support the calculation of a material property with a linear interpolation and error if
1. x, y, and xy_data are all specified;
2. x and xy_data are both specified;
3. the x and y vectors are different lengths; and
4. the xy_data vector length is not a multiple of two.
2.36.117The system shall support the storage of old material property states projected onto a first order monomial basis.
2.36.118The system shall support the storage of old material property states projected onto a constant monomial basis.
2.36.119The system shall support the storage of old material property states projected onto a first order lagrange basis.
2.36.120The system shall be able to produce stateful material properties that can be consumed by other objects in the system.
2.36.121The system shall support coupling in an auxiliary field variable for use in initializing stateful material properties.
2.36.122The system shall allow the retrieval of stateful material properties for calculations on internal sides within a mesh.
2.36.123
The system shall be able to generate up to three states of material properties for use in other calculations: current, old and older
1. where properties are stored in auxiliary spatial fields, and
2. when those properties are averaged and output to a comma-separated value file.
2.36.124
The system shall verify that the oldest material property (older) can be coupled to other objects for use in another calculation:
1. where properties are stored in auxiliary spatial fields, and
2. when those properties are averaged and output to a comma-separated value file.
2.36.125The system shall be able to promote normal material properties to stateful when old/older properties are requested.
2.36.126The system shall be able to declare a property as AD after the old state has been requested.
2.36.127The system shall make material property calculations available during the computation of the initial Residual vector.
2.36.128
The system shall store stateful properties that vary at every calculation point (quadrature point) similarly to a normal field variable even though they are not interpolatory:
1. on blocks, and
2. on boundaries.
2.36.129The system shall support the ability to copy stored stateful data from one element to another element.
2.36.130
The system shall handle storing stateful properties related to elements on the mesh as the mesh is adapting:
1. when properties are spatially constant, and
2. when properties vary spatially,
3. when properties are spatially constant and we are performing p-refinement, and
4. when properties vary spatially and we are performing p-refinement.
2.36.131The system shall not store any stateful material properties that are declared but never used.
2.36.132
The system shall be able to correctly handle stateful materials
1. when using a regular material property.
2. when using an AD material property.
3. when using a regular material property using templated methods.
4. when using an AD material property using templated methods.
2.36.133The system shall be capable of outputting material properties through auxiliary field variables.
2.36.134The system shall report and error when invalid indices are requested when attempting to output material properties through auxiliary field variables.
2.36.135The system shall only prepare or setup field variables on each element when they are used by a material object.
2.36.136The system shall support coupling in a nonlinear field variable for use in initializing stateful material properties.

framework: Mesh
2.37.1
The system shall support importing mesh information from Abaqus that includes
1. element identifiers,
2. element sets, and
3. element sets with extra space in file.
2.37.2The system shall perform identical adaptivity patterns on both the reference mesh and the displaced mesh when it exists.
2.37.3The system shall support toggling adaptivity on/off during a simulation.
2.37.4The system shall perform one or more adaptivity steps on the mesh before the simulation begins.
2.37.5The system shall support patch-based error estimation among a stencil of elements.
2.37.6The system shall support multiple adaptive steps per solve.
2.37.7The system shall perform adaptivity on systems containing multiple independent field variables.
2.37.8The system shall support running adaptivity on an interval basis (every several time steps).
2.37.9The system shall support weighted error estimation when considering multiple field variables for adaptivity.
2.37.10The system shall allow specifying valid sideset IDs that do not exist on the initial mesh.
2.37.11The system shall allow specifying valid sideset IDs and names that do not exist on the initial mesh.
2.37.12The system shall allow specifying valid sideset names that do not exist on the initial mesh, and assign IDs automatically.
2.37.13The system shall allow specifying valid subdomain IDs that do not exist on the initial mesh.
2.37.14The system shall allow specifying valid subdomain IDs and names that do not exist on the initial mesh.
2.37.15The system shall allow specifying valid subdomain names that do not exist on the initial mesh.
2.37.16The system shall get the correct mesh dimension for a list of subdomains.
2.37.17The system shall output all boundary and subdomain connections.
2.37.18The system shall support the use of a centroid-based parallel partitioning scheme.
2.37.19The system shall generate pre-split mesh files using a standard input file combined with command line arguments.
2.37.20The system shall use pre-split mesh files using a standard input file combined with command line arguments.
2.37.21The system shall generate pre-split binary mesh files using a standard input file combined with command line arguments.
2.37.22The system shall use pre-split binary mesh files using a standard input file combined with command line arguments.
2.37.23The system shall generate a quadrilateral mesh consisting of concentric circles.
2.37.24
The system shall support the ability to create custom objects for performing mesh partitioning, for example
1. a linear partitioner that
2. operates with a displaced configuration and
3. is capable of restarting.
2.37.25
The system shall compute and store internal finite volume related element data on request for
1. quadrilateral elements,
2. quadrilateral elements in a cylindrical coordinate system, and
3. triangular elements.
2.37.26
The system shall compute and store internal face data on request for
1. quadrilateral elements,
2. triangular elements, and
3. quadrilateral elements in multiple regions.
2.37.27The system shall read GMesh (.msh) format file meshes.
2.37.28The system shall read GMesh (.msh) format file meshes containing multiple boundaries.
2.37.29The system shall support refinement of QUAD4 mesh elements.
2.37.30The system shall support refinement of QUAD8 mesh elements.
2.37.31The system shall support refinement of QUAD9 mesh elements.
2.37.32The system shall support refinement of TRI3 mesh elements.
2.37.33The system shall support refinement of TRI6 mesh elements.
2.37.34The system shall support refinement of TRI7 mesh elements.
2.37.35The system shall support refinement of HEX8 mesh elements.
2.37.36The system shall support refinement of HEX20 mesh elements.
2.37.37The system shall support refinement of HEX27 mesh elements.
2.37.38The system shall support refinement of TET4 mesh elements.
2.37.39The system shall support refinement of TET10 mesh elements.
2.37.40The system shall support refinement of TET14 mesh elements.
2.37.41The system shall support refinement of PRISM6 mesh elements.
2.37.42The system shall support refinement of PRISM15 mesh elements.
2.37.43The system shall support refinement of PRISM18 mesh elements.
2.37.44The system shall support refinement of PYRAMID5 mesh elements.
2.37.45The system shall support refinement of PYRAMID13 mesh elements.
2.37.46The system shall support refinement of PYRAMID14 mesh elements.
2.37.47The system shall be able to process boundary and subdomain names that start with digits but which have non-digits later in the name.
2.37.48The system shall generate a structured mesh on a Cartesian domain.
2.37.49The system shall generate first-order, structured meshes with biasing in the x, y, and z directions.
2.37.50The system shall generate second-order, structured meshes with biasing in the x, y, and z directions.
2.37.51
The system shall include the ability to generate an annular mesh that errors when
1. the min radius is larger than the max radius;
2. the min angle is greater than or equal to the max angle;
3. the angle separation is larger than 360 degrees;
4. the number of elements in the angular direction is too small due to the number of elements; and
5. the number of elements in the angular direction is too small due to the maximum angle.
6. shall throw an error if the quadrilateral and triangular subdomain ids are the same.
7. shall throw an error if both radial positions and the number of radial elements are prescribed.
8. shall throw an error if both radial positions and the radius growth parameter are prescribed.
9. shall throw an error if any of the radial positions fall out of the bounds between rmin and rmax.
2.37.52
The system shall include the ability to create
1. an annulus using quad elements;
2. an annulus sector using quad elements;
3. a circular disk using quad elements; and
4. circular disk sector using quad elements.
2.37.53The system shall have an algorithm for meshing an annular region with triangular elements.
2.37.54The system shall have an algorithm for generating triangular and quadrilateral meshes for the Ringleb problem.
2.37.61The system shall allow writing out the mesh without running a simulation.
2.37.62The system shall print out information about the mesh when writing out the mesh and avoid emitting petsc warnings in mesh-only mode.
2.37.63The system shall warn when using –mesh-only and there is no clear filename to use
2.37.64The system shall support overriding output dimension when necessary to store coordinates in higher planes
2.37.65The system shall support writing parallel checkpoint files with –mesh-only
2.37.66The system shall allow writing out the mesh with extra element ids without running a simulation.
2.37.67The system shall allow writing out the mesh with extra element ids without running a simulation and user-provided id names.
2.37.68The system shall throw a warning if user-provided extra element id names do not exist on mesh.
2.37.69The system shall support simulations on meshes containing both 1D and 2D element types.
2.37.70The system shall support proper material evaluations on meshes containing both 1D and 2D element types.
2.37.71The system shall support simulations on meshes containing both 1D and 3D element types.
2.37.72The system shall generate meshes with different sets of element integers and properly stitch them.
2.37.73The system shall support interchangeable use of integer and string identifiers for mesh entities.
2.37.74The system shall support interchangeable use of integer and string identifiers for mesh entities read from the XDA format.
2.37.75The system shall support interchangeable use of integer and string identifiers within the BCs/Periodic block.
2.37.76The system shall support the ability to assign and use string names to mesh entities during the simulation startup.
2.37.77The system shall support writing solution data in the Nemesis parallel file format.
2.37.78The system shall support the re-partitioning of mesh files input using the Nemesis format.
2.37.79The system shall issue an error if no Mesh block is provided.
2.37.80The system shall issue a diagnostic when a referenced node set does not exist in the mesh
2.37.81The system shall generate a mesh using one or more meshes stitched into a pattern controlled by a 2D array.
2.37.82The system shall read in a previously generated "patterned mesh" and run a simulation using that mesh.
2.37.83The system shall produce a valid periodic node map with only one periodic constraint direction.
2.37.84The system shall produce a valid periodic node map with two periodic constraint directions.
2.37.85The system shall produce a valid periodic node map with three periodic constraint directions.
2.37.86The system shall ensure that the mesh is prepared at the time users execute their simulation.
2.37.87
The system shall make available additional meshes as requested by the user
1. and be able to save only one of the mesh generator meshes
2.37.88
The system shall report a useful error when saving additional meshes when
1. the requested names are not unique,
2. the requested name uses a reserved name,
3. trying to use the mesh-saving capability with the final mesh,
4. the requested saved mesh does not exist, and when
5. the requested saved mesh has already been retrieved.
2.37.89The system shall issue a diagnostic when a referenced side set does not exist in the mesh.
2.37.90The system shall have the ability to construct a side set from a set of nodes.
2.37.91The system shall support optionally allowing uniform refinements when using a pre-split mesh
2.37.92A mesh can be split into a specified number of files using command line options.
2.37.93
A mesh can be pre-split properly and used to generate equivalent results to running a simulation with the unsplit mesh when
1. set by command line, no split extension specified
2. set by command line, with a specified split extension
3. set by an input parameter
2.37.94
Console output should include an indicator that a pre-split mesh is being used when using –split-mesh in distributed = auto mode
1. without and
2. with the forced option.
2.37.95The mesh splitter will throw an error when an attempt is made to split a "DistributedMesh".
2.37.96The mesh splitter capability will honor geometric RelationshipManager objects.
2.37.97Meshes that are pre-split with active RelationshipManager objects work the same as if using an online DistributedMesh.
2.37.98Splitting meshes from file should work with custom partitioners.
2.37.99Splitting meshes from a generated mesh should work with custom partitioners.
2.37.100The system should be able to load a pre-split mesh and perform additional mesh generation on it.
2.37.101The system shall support the creating a single mesh from multiple meshes stitched together.
2.37.102The system shall report an error if at least one mesh file is not supplied when creating a mesh from multiple meshes stitched together.
2.37.103The system shall provide a parallel partition based on mesh subdomains
2.37.104The parallel partitioning capability by subdomain shall report a reasonable error when a given subdomain does not exist
2.37.105The system shall read TetGen file meshes.
2.37.106The system shall construct a mesh by "tiling" another mesh repeatedly.
2.37.107The system shall support avoiding repartitioning the mesh and deleting remote elements after uniform refinements
2.37.108The system shall support having a truly unique_id (never recycled) for all mesh elements and nodes when using replicated mesh.
2.37.109The system shall support having a truly unique_id (never recycled) for all mesh elements and nodes when using distributed mes.

framework: Meshdivisions
2.38.1
The system shall be able to divide the mesh using
1. subdomains defined on the mesh,
2. a selection of subdomains defined on the mesh,
3. extra element integers stored on elements in the mesh,
4. a regular Cartesian grid,
5. a regular Cartesian grid specified using its center and width,
6. Cartesian grids with a fixed width and a group of center positions,
7. a mesh division based on the values of a functor,
8. a nearest-point/neighbor partition,
9. a regular cylindrical R-theta-Z grid,
10. cylindrical R-theta-Z grids with a group of positions for the cylinder axis coordinates,
11. a regular spherical radial grid,
12. spherical radial grids, using a group of positions for the sphere centers,
13. and a nesting of mesh divisions.
2.38.2
The system shall report an error if
1. Cartesian divisions from a group of co-planar center positions are overlapping,
2. cylindrical divisions from a group of co-planar center positions are overlapping,
3. and spherical divisions from a group of co-planar center positions are overlapping.

framework: Meshgenerators
2.39.1The system shall support automatic addition of sidesets based on outward facing normals of the mesh.
2.39.2The system shall group automatically added sidesets when multiple surfaces share the same outward facing normal.
2.39.3The system shall add some specific scalar and vector mesh meta data to the input mesh.
2.39.4The system shall throw an error if real_scalar_metadata_names and real_scalar_metadata_values are different in size.
2.39.5The system shall throw an error if uint_scalar_metadata_names and uint_scalar_metadata_values are different in size.
2.39.6The system shall throw an error if int_scalar_metadata_names and int_scalar_metadata_values are different in size.
2.39.7The system shall throw an error if dof_id_type_scalar_metadata_names and dof_id_type_scalar_metadata_values are different in size.
2.39.8The system shall throw an error if subdomain_id_type_scalar_metadata_names and subdomain_id_type_scalar_metadata_values are different in size.
2.39.9The system shall throw an error if boolean_scalar_metadata_names and boolean_scalar_metadata_values are different in size.
2.39.10The system shall throw an error if point_scalar_metadata_names and point_scalar_metadata_values are different in size.
2.39.11The system shall throw an error if real_vector_metadata_names and real_vector_metadata_values are different in size.
2.39.12The system shall throw an error if uint_vector_metadata_names and uint_vector_metadata_values are different in size.
2.39.13The system shall throw an error if int_vector_metadata_names and int_vector_metadata_values are different in size.
2.39.14The system shall throw an error if dof_id_type_vector_metadata_names and dof_id_type_vector_metadata_values are different in size.
2.39.15The system shall throw an error if subdomain_id_type_vector_metadata_names and subdomain_id_type_vector_metadata_values are different in size.
2.39.16The system shall throw an error if point_vector_metadata_names and point_vector_metadata_values are different in size.
2.39.17The system shall throw an error if real_scalar_metadata_names contains non-unique elements.
2.39.18The system shall throw an error if uint_scalar_metadata_names contains non-unique elements.
2.39.19The system shall throw an error if int_scalar_metadata_names contains non-unique elements.
2.39.20The system shall throw an error if dof_id_type_scalar_metadata_names contains non-unique elements.
2.39.21The system shall throw an error if subdomain_id_type_scalar_metadata_names contains non-unique elements.
2.39.22The system shall throw an error if boolean_scalar_metadata_names contains non-unique elements.
2.39.23The system shall throw an error if point_scalar_metadata_names contains non-unique elements.
2.39.24The system shall throw an error if real_vector_metadata_names contains non-unique elements.
2.39.25The system shall throw an error if uint_vector_metadata_names contains non-unique elements.
2.39.26The system shall throw an error if int_vector_metadata_names contains non-unique elements.
2.39.27The system shall throw an error if dof_id_type_vector_metadata_names contains non-unique elements.
2.39.28The system shall throw an error if subdomain_id_type_vector_metadata_names contains non-unique elements.
2.39.29The system shall throw an error if point_vector_metadata_names contains non-unique elements.
2.39.30The system shall be able to extrude a mesh with variable height elevations, with variable numbers of layers, and swap subdomain IDs
2.39.31The system shall be able to extrude a mesh with variable height elevations, with variable numbers of layers, and swap subdomain IDs in the reverse direction
2.39.32The system shall be able to extrude a mesh with variable height elevations, with variable numbers of layers, and swap interface boundaries
2.39.33The system shall be able to extrude a mesh with variable height elevations, with variable numbers of layers, with biased axial element sizes, and swap subdomain IDs
2.39.34The system shall make sure the mesh is prepared after a mesh generator has indicated the mesh is not prepared and before running a solve.
2.39.35The system shall be able to fix the negative-volume elements by flipping them during extrusion.
2.39.36The system shall be able to fix the negative-volume second order elements by flipping them during extrusion.
2.39.37The system shall be able to use the result from AdvancedExtruderGenerator in subsequent mesh generators
2.39.38The system shall be able to retain and swap element extra integers during extrusion.
2.39.39The system shall report an error if missing a consistent positive or negative extrusion direction.
2.39.40The system shall be able to retain and swap boundary ids during extrusion.
2.39.41The system shall be able to helically extrude a 2D mesh into a twisted 3D mesh.
2.39.42
The system shall error
1. if the source subdomain for a subdomain swap in a layer does not exist in the mesh,
2. if the source boundary for a boundary swap in a layer does not exist in the mesh,
3. if the source subdomain for an upward boundary assignment in a layer does not exist in the mesh,
4. if the source subdomain for an downward boundary assignment in a layer does not exist in the mesh,
2.39.43The system shall have the capability of generating a mesh based upon an annular geometry.
2.39.44The system shall have the capability of generating a mesh based upon an annular geometry with a negative growth ratio.
2.39.46The system shall generate an annular mesh with prescribed radial positions of the intermediate rings of nodes
2.39.47The system shall have the capability of generating an annular mesh with equal-area elements
2.39.48The system shall report an error when generating an annular mesh with equal-area elements when a growth ratio is also provided
2.39.49The system shall report an error when generating an annual mesh with equal-area elements when radial positions are also provided
2.39.50The system shall have the capability of generating an annular mesh with a user-defined prefix on boundary names and/or an offset on the boundary ids
2.39.51The system shall support the ability to add additional mesh generators from a user accessible programmatic interface.
2.39.52
The system shall only support the ability to add additional mesh generators from a user accessible programmatic interface when
1. there exists a generator to append to
2. such mesh generators take an input
3. other mesh generators have been added to be appended to
2.39.53
The system shall be capable of deleting
1. all of the elements in a mesh based on subdomain ID,
2. all of the elements in a mesh based on subdomain names and
3. multiple blocks simultaneously in a mesh based on subdomain ID.
4. blocks and assigning the new boundary even if the input mesh is not prepared.
5. blocks and properly removing lower dimensional elements with a deleted element as their interior parent.
6. blocks and retaining lower dimensional elements with a deleted interior parent if requested,
7. blocks and erroring if a block does not exist.
2.39.54
The system shall support removing elements including
1. a 3D concave subdomain;
2. a 2D interior subdomain;
3. a 3D interior subdomain;
4. a 2D non-concave subdomain;
5. a 3D non-concave subdomain;
6. a 2D removal of a union of disjoint pieces;
7. a 2D removal of a subdomain containing a nodeset;
8. a 2D removal of a subdomain that eliminates sideset;
9. a 2D removal of a subdomain containing a sideset;
10. a 2D concave subdomain with a cut across elements.
2.39.55
The system shall have the capability of creating a new mesh given one or more subdomains within an existing mesh, with
1. a one block, single element, 2d mesh of a square,
2. 2D blocks to be extracted from a 2D mesh
3. multiple subdomains/blocks which can be incorporated into a new mesh in 3D
4. a lower dimension block (1D) to be extracted from a 2D mesh
2.39.56
The system shall return an error if the following unsupported features are present:
1. the mesh is distributed in parallel
2. the block to extract is uniformly refined
2.39.57The system shall have the capability to remove boundaries in an existing mesh.
2.39.58The system shall report an error if attempting to delete a non-existent boundary
2.39.59
The system shall be capable of generating new mesh node sets based upon a user-specified bounding box
1. where the new node set will be placed on nodes within the bounding box, or
2. where the new node set will be placed on nodes outside of the bounding box.
2.39.60
The system shall produce an error when attempting to add a new mesh node set based on a bounding box
1. where the bounding box fails to span any mesh nodes, and
2. where multiple boundary IDs are supplied for a single bounding box.
2.39.61
The system shall be capable of splitting existing mesh boundary sets where their underlying subdomain changes
1. on external boundaries, and
2. on internal boundaries, and
3. error when the boundary does not exist in the mesh.
2.39.62
The system shall be able to create separate blocks in a mesh
1. without a split interface in 3D;
2. with a split interface in 3D;
3. with a polycrystal based mesh in 3D;
4. without a split interface in 2D;
5. with a split interface in 2D; and
6. with a polycrystal based mesh in 2D.
2.39.63
The system shall be able to break the mesh between listed blocks:
1. without splitting the interface and with splitting the transition interface;
2. with a split interface and without splitting the transition interface;
3. with a split interface and splitting the transition interface;
4. with a split interface, without splitting the transition interface, and without a transition interface;
5. without a split interface, splitting the transition interface, or a transition interface;
2.39.64The system shall be able to break the mesh between listed block pairs.
2.39.65
The system shall be able to break the mesh between listed block pairs
1. by creating one new node.
2. by creating two new nodes.
3. by creating three new nodes.
2.39.66The system shall be able to create two sides interface when interfaces are created between listed block pairs.
2.39.67The system shall properly assign node processor ids for paritioned meshes
2.39.68The system shall report an error if the mesh does not contain the specified block pair
2.39.69The system shall report an error if the mesh does not contain the specified surrounding block
2.39.70
The system shall be capable of generating an non-uniform mesh on a Cartesian domain in
1. one,
2. two, and
3. three dimensions.
2.39.71The system shall throw an error if the subdomains with different ID have duplicate names.
2.39.72The system shall correct full circular boundaries radii to preserve areas.
2.39.73The system shall correct partial circular boundaries radii to preserve areas by moving all the nodes in the radial direction.
2.39.74The system shall correct partial circular boundaries radii to preserve areas by moving all the node in the radial direction, as well as displacing the boundary end nodes in the span direction.
2.39.75The system shall throw an error if the length of the provided customized transition layer rarios does not match the number of the boundaries to be corrected.
2.39.76The system shall throw an error if the length of the provided customized circular verification tolerance does not match the number of the boundaries to be corrected.
2.39.77The system shall throw an error if the provided boundaries are not in XY plane.
2.39.78The system shall throw an error if the provided boundary contains fewer than three nodes.
2.39.79The system shall throw an error if any nodes are moved twice for radius correction.
2.39.80The system shall throw an error if the provided boundary to correct is not circular.
2.39.81The system shall throw an error if the provided boundaries are all full circles and the parameter to move the end nodes in the span direction is set to true.
2.39.82The system shall throw an error if an input boundary does not exist in the input mesh.
2.39.83
The system shall be able to generate a 2D quad-element mesh
1. for a mesh coarsening test with a uniformly refined mesh,
2. for a mesh coarsening test with a non-uniformly refined mesh,
3. for a mesh coarsening test with twice-refined elements,
4. for a mesh coarsening test with an external boundary refined,
5. and for a mesh coarsening test with an internal boundary refined.
2.39.84
The system shall support the ability to coarsen quadrilateral
1. elements within a non-uniformly refined mesh,
2. elements within multiple blocks within a multi-domain mesh,
3. elements within multiple blocks, both refined and unrefined, within a multi-domain mesh,
4. elements within multiple blocks at multiple levels of coarsening within a multi-domain mesh,
5. elements near a refined external boundary,
6. elements near a refined internal boundary.
2.39.85
The system shall be able to generate a 3D hexahedral-element mesh
1. for a mesh coarsening test with a uniformly refined mesh,
2. for a mesh coarsening test with a non-uniformly refined mesh,
3. for a mesh coarsening test with twice-refined elements,
4. for a mesh coarsening test with an external boundary refined,
5. and for a mesh coarsening test with an internal boundary refined.
2.39.86
The system shall support the ability to coarsen hexahedral
1. elements within a non-uniformly refined mesh,
2. elements within multiple blocks within a multi-domain mesh,
3. elements within multiple blocks, both refined and unrefined, within a multi-domain mesh,
4. elements within multiple blocks at multiple levels of coarsening within a multi-domain mesh,
5. elements near a refined external boundary,
6. elements near a refined internal boundary.
2.39.87
The system shall report an error if
1. attempting to coarsen a block that does not exist in the mesh, and
2. if specifying a vector of coarsening levels that does not match the vector of subdomains to coarsen,
3. the coarsening starting element is not in the block to coarsen the most.
2.39.88
The system shall support the ability to combine multiple meshes:
1. using a single input mesh at multiple positions,
2. using a single input mesh at multiple positions obtained from a file,
3. using multiple meshes at multiple positions, and
4. using multiple meshes at multiple positions obtained from a file, and
5. using multiple meshes with no positions, and
6. while keeping name(s) of sidesets intact, and
7. not merging subdomains, and
8. not merging boundaries.
2.39.89
The system shall report an error when trying to combine multiple meshes,
1. but only one input is supplied with no positions, or
2. but only one input is supplied with no positions file, or
3. the number of meshes and the number of positions is mismatched, or
4. the number of meshes and the number of positions in the file is mismatched.
2.39.90The system shall support arbitrary transforms of node positions in 2D.
2.39.91The system shall support arbitrary transforms of node positions in 3D.
2.39.92The system shall have the capability to generate a mesh pattern consisting of concentric circles contained within a square.
2.39.93The winding order of the elements created by the mesh generator shall be uniform.
2.39.94
The system shall be able to
1. cut a 3D mesh consisting of only HEX8 elements with the cut face id automatically assigned.
2. cut a 3D mesh consisting of only HEX8 elements using a cutting plane overlapped with some element faces.
3. cut a 3D mesh consisting of only PRISM6 elements with the cut face id specified by the user.
4. cut a 3D mesh consisting of only PYRAMID5 elements with the cut face id automatically assigned and cut face name specified.
5. cut a 3D mesh consisting of only TET4 elements with the cut face id and name automatically assigned to be the same as an existing boundary.
6. cut a 3D mesh with mixed element types.
2.39.95
The system shall throw an error
1. if the input mesh to be cut is not a replicated mesh.
2. if the input mesh to be cut contains non-3D elements.
3. if the input mesh to be cut contains high-order elements.
4. if the specified cut face id and names are inconsistent with the input mesh.
2.39.96The system shall be able to give a clear error message about a cyclic graph in mesh generation.
2.39.97The system shall support the generation of meshes in a data-driven mode, where not each step in the generation tree is required to produce a physical mesh and can instead only produce metadata
2.39.98The system shall support the generation of subgenerators of the data-driven generator without data only mode
2.39.99
The system shall report a reasonable error when generating a mesh with data-driven capabilities when
1. the specified data-driven generator does not exist
2. the parent generators do not support data-driven mode
3. a generator that is supposed to be data-only is also set to be output
4. a mesh generator is requested to generate data that does not have a data generation implementation
5. the application does not allow data-driven generation
2.39.100The system shall support the generation of meshes for both reference and displaced mesh configurations.
2.39.101The system shall support mesh adaptivity on a distributed generated displaced mesh.
2.39.102The system shall support mesh adaptivity with periodic boundary conditions on a distributed generated displaced mesh.
2.39.103
The system shall support a scalable mesh adaptivity with periodic boundary conditions on a distributed generated displaced mesh
1. without and with
2. automatic scaling.
2.39.104The system shall be able to generate 2D Quad4 mesh in parallel.
2.39.105The system shall be able to check if or not users ask for too many layers of ghosting elements.
2.39.106The system shall be able to generate 1D EDGE2 mesh in parallel.
2.39.107The system shall be able to generate 3D HEX8 mesh in parallel.
2.39.108The system shall be able to generate 3D HEX8 mesh in parallel using ptscotch partitioner
2.39.109The system shall be able to generate 3D HEX8 mesh in parallel using hierarch partitioner
2.39.110The system shall be able to generate a first-order hexahedral mesh in parallel using a small number of cores for the graph partitioner.
2.39.111The system shall report an error if the number of cores for partition is larger than the total number of cores.
2.39.112The system shall be able to adapt a mesh generated in parallel.
2.39.113The system shall generate an arbitrary number of layers of side neighbors using DistributedRectilinearMeshGenerator.
2.39.114The system shall be able to generate a squarish partition for a 2D distributed generated mesh using 3 processors.
2.39.115The system shall be able to generate a squarish partition for a 2D distributed generated mesh using 4 processors.
2.39.116The system shall be able to generate a squarish partition for a 2D distributed generated mesh using 6 processors.
2.39.117The system shall be able to generate a squarish partition for a 1D distributed generated mesh using 3 processors.
2.39.118The system shall be able to generate a squarish partition for a 1D distributed generated mesh using 4 processors.
2.39.119The system shall be able to generate a squarish partition for a 3D distributed generated mesh using 3 processors.
2.39.120The system shall be able to generate a squarish partition for a 3D distributed generated mesh using 4 processors.
2.39.121The system shall be able to generate a squarish partition for a 3D distributed generated mesh using 8 processors.
2.39.122The system shall convert all the input elements into first-order elements.
2.39.123The system shall convert all the input elements into complete-order elements.
2.39.124The system shall convert all the input elements into full-second-order elements.
2.39.125The system shall convert all the input elements into second-order (nonfull) elements.
2.39.126
The system shall support the ability to create a mesh element-wise by specifying points, element types, and connectivity,
1. resulting in a single element mesh, or
2. resulting in a mesh with multiple disconnected elements.
2.39.127
The system shall support assigning subdomain identifiers
1. given a list of ids for each element; and
2. given a list of elements and ids for quadrilateral and
3. triangular elements.
2.39.128
The system shall be able to
1. convert a 3D mesh consisting of only HEX8 elements.
2. convert a 3D mesh consisting of only PRISM6 elements.
3. convert a 3D mesh consisting of only PRISM18 elements.
4. convert a 3D mesh consisting of only TET4 elements.
5. accept a 3D mesh consisting of only TET10 elements.
6. convert a 3D mesh with mixed element types.
2.39.129
The system shall be able to
1. convert a 3D mesh consisting of only HEX8 elements.
2. convert a 3D mesh consisting of only PRISM6 elements.
3. convert a 3D mesh consisting of only PYRAMID5 elements.
4. convert a 3D mesh consisting of only TET4 elements.
5. convert a 3D mesh with mixed element types.
2.39.130
The system shall throw an error
1. if the input mesh to be converted is not a replicated mesh.
2. if the input mesh to be converted contains non-3D elements.
3. if the input mesh to be converted contains high-order elements.
2.39.131
The system shall be able to create a patch test mesh with:
1. quad4 elements,
2. quad8 elements,
3. hex8 elements, and
4. hex20 elements.
2.39.132
The system shall have the ability to break all element-element interfaces within given subdomains both
1. in 2D, and
2. in 3D.
2.39.133The system shall report an error if the subdomain to explode was not found in the mesh
2.39.134The system shall have the ability to add extra mesh node sets based on existing node IDs.
2.39.135The system shall have the ability to add extra mesh node sets based on node coordinates.
2.39.136The system shall have the ability to add extra mesh node sets based on multiple node coordinates.
2.39.137The system shall report an error on assigning boundary identifiers if the supplied location is outside of the domain.
2.39.138The system shall have the ability to add the node closest to a point to a nodeset.
2.39.139The system shall have the ability to generate a mesh by reading it from a file.
2.39.140The system shall have the ability to assign element extra integers with elemental variables in an Exodus mesh file.
2.39.141The system shall have the ability to read IsoGeometric Analysis meshes with rational bases and output spline results in VTK format.
2.39.142The system shall have the ability to read IsoGeometric Analysis meshes with rational bases and output spline results in ExodusII format.
2.39.143The system shall have the ability to remove spline nodes from IsoGeometric Analysis meshes and output Bernstein-Bezier results in VTK format.
2.39.144The system shall have the ability to remove spline nodes from IsoGeometric Analysis meshes and output Bernstein-Bezier results in ExodusII format.
2.39.145The system shall have the ability to read IsoGeometric Analysis meshes with 3D elements and sidesets in ExodusII format.
2.39.146The system shall have the ability to extract discontinuous Bezier-Bernstein elements from IsoGeometric Analysis meshes.
2.39.147The system shall have the ability to reproduce exact discrete solutions on discontinuous Bezier-Bernstein edges from IsoGeometric Analysis meshes.
2.39.148The system shall have the ability to find continuous PDE solutions on discontinuous Bezier-Bernstein edges from IsoGeometric Analysis meshes.
2.39.149The system shall have the ability to apply externally defined constraint matrices to 3D isoparametric meshes.
2.39.150The system shall have the ability to apply externally defined constraint matrices to 1D isoparametric meshes.
2.39.151The system shall have the ability to find continuous PDE solutions on discontinuous Bezier-Bernstein quads from IsoGeometric Analysis meshes.
2.39.152The system shall have the ability to output checkpoint files along with the mesh meta data.
2.39.153The system shall have the ability to load the mesh from checkpoint files.
2.39.154The system shall generate a mesh that fills between two coplanar curves.
2.39.155The system shall generate a mesh that fills between two coplanar curves and keeps nodesets defined on these curves.
2.39.156The system shall generator a bow-shape transition layer based on the two input point vectors using TRI3 elements.
2.39.157The system shall generator a bow-shape transition layer with a provided bias growth factor based on the two input point vectors using TRI3 elements.
2.39.158The system shall generator a bow-shape transition layer with automatically generated bias growth factors based on the two input point vectors using TRI3 elements.
2.39.159The system shall generator a bow-shape transition layer based on the two input point vectors using QUAD4 elements.
2.39.160The system shall throw an error if either input vector of points include points that are not in XY plane.
2.39.161The system shall throw an error if either input vector of points include less than 2 points.
2.39.162The system shall throw an error if the two input vectors have different length and QUAD4 elements option is selected.
2.39.163The system shall be able to generate a connector transition layer based on the two input meshes and boundaries.
2.39.164The system shall be able to generate a connector transition layer based on the two input meshes and boundaries and stitch it with the input meshes.
2.39.165The system shall be able to generate a connector transition layer with manual biasing based on the two input meshes and boundaries.
2.39.166The system shall be able to generate a connector transition layer with automatic biasing based on the two input meshes and boundaries.
2.39.167The system shall throw an error if the two input meshes are the same.
2.39.168The system shall throw an error if one of the input boundary to generate a mesh in-between has multiple segments.
2.39.169The system shall throw an error if one of the input boundary to generate a mesh in-between is a closed loop.
2.39.170
The system shall support using a directed acyclic graph of objects to generate a mesh where multiple possible end points may be explicitly selected:
1. the first of two targets
2. and the second of two targets.
2.39.171The system shall support selecting an earlier generation state of the mesh generator system used to generate the final mesh for a simulation.
2.39.172
The system shall generate an error when the objects used to generate a mesh results in an ambiguous end point
1. due to a single graph with multiple end points, or
2. due to multiple independent trees.
2.39.173The system shall support switching the normal orientation of a sideset in a two-dimensional mesh
2.39.174The system shall support switching the normal orientation of a sideset in a three-dimensional mesh
2.39.175The system shall produce a reasonable error when switching the normal orientation of a sideset if the sideset does not exist
2.39.176The system shall produce a reasonable error when switching the normal orientation of a sideset if the sideset cannot be flipped
2.39.177The system shall be able to use libmesh mesh generation tools.
2.39.178The system shall be able to use libmesh mesh generation tools and shift node/sideset ids by a constant offset.
2.39.179
The system shall include mesh generation tools and allow adding a name prefix to the node/sideset names and maintain the
1. id and
2. include the added name.
2.39.180
The system shall include mesh generation tools and shift node/sideset ids by a constant offset while also adding a name prefix to them and maintain the
1. the shifted id and
2. include the added name.
2.39.181The system shall generate a warning if Mesh Generators are used with a mesh type that does not accept them
2.39.182The system shall be able to assign subdomain IDs for the (cartesian) generated mesh generator.
2.39.183The system shall be able to assign a subdomain name for the (cartesian) generated mesh generator.
2.39.184
The system shall error when unphysical input combinations are provided to the generated mesh generator, including when
1. the specified maximum X-coordinate is less than the minimum X-coordinate, and
2. the specified maximum Y-coordinate is less than the minimum Y-coordinate, and
3. the specified maximum Z-coordinate is less than the minimum Z-coordinate.
2.39.185The system shall support the ability to import meshes written using the General Mesh Viewer format.
2.39.186The system shall have the ability to read boundary information from Gmsh formatted mesh files.
2.39.187The system shall be able to read in an image.
2.39.188
The system shall support creating subdomains from
1. 2D and
2. 3D images.
2.39.189
The system shall be able to create different subdomains (with first order elements)
1. using boundary ids.
2. using boundary names.
2.39.190The system shall support the creation of lower dimensional elements on an existing sideset of second-order elements.
2.39.191
The system shall report an error
1. if refinement generators are executed before lower dimensional elements are added,
2. if a non-existing sideset is specified as the sideset to create a lower-dimensional block from.
2.39.192The system shall provide an interface function to get the relation of two extra element integers.
2.39.193The system shall be able to combine multiple meshes into a single unconnected mesh.
2.39.194
The system shall be able to diagnostize potential issues in a mesh, such as
1. element overlapping,
2. inconsistently oriented sidesets between subdomains,
3. inconsistently oriented sidesets between two neighbor sides within the sideset,
4. 2D meshed square missing a sideset on one side
5. 3D meshed cube missing a sideset on one side
6. non-conformality in two dimensions,
7. non-conformality in three dimensions,
8. different element types in a single subdomain,
9. elements above a certain volume,
10. elements below a certain volume,
11. non-planar sides on elements,
12. elements with negative Jacobians
2.39.195
The system shall be able to recognize non-conformalities created by uniform mesh refinements for
1. quadrilateral elements,
2. quadrilateral elements of second order,
3. quadrilateral elements refined twice near an unrefined quadrilateral element,
4. hexahedral elements,
5. hexahedral elements of second order,
6. hexahedral elements refined twice near an unrefined quadrilateral element,
7. triangle elements,
8. triangle elements of second order,
9. triangle elements of third order,
10. triangle elements refined twice near an unrefined triangle element,
11. tetrahedral elements,
12. tetrahedral elements of second order,
13. tetrahedral elements of third order,
2.39.196
The system shall be able to recognize that non-conformalities are not created by uniform mesh refinements in the case of
1. quadrilateral elements refined in only one direction,
2.39.197
The system shall report an error if
1. a diagnostics object is created but no diagnostics are requested.
2.39.198
The system shall have the capability of extruding a lower dimensional mesh to create a higher dimensional mesh
1. from 2D quads to 3D hexes,
2. 2D triangular elements;
3. where newly created elements can be assigned a new subdomain IDs based on old IDs,
4. where newly created elements can be assigned a new subdomain IDs based on a pattern,
5. where the extrusion direction is not orthogonal to the original line or plane of elements, and
6. where the extrusion occurs based on another generated mesh,
7. while making sure to preserve existing side set names.
2.39.199The system shall report an error if the existing subdomain does not exist in the mesh
2.39.200The system shall be able to merge overlapping nodes.
2.39.201The system shall be able to flip the orientation of negative-volume elements.
2.39.202The system shall be able to split blocks across their element's type.
2.39.203The system shall be able to merge boundaries with the same names but different boundary IDs.
2.39.204The system shall support the ability for mesh generators to save attributes to a stateful data store available for use when recovering a simulation.
2.39.205The system shall issue an error when mesh meta-data properties are requested but never declared.
2.39.206The system shall report an error if a invalid identifier is supplied when attempting to retrieve a restart meta data object.
2.39.207The system shall support the ability to save mesh meta data generated by mesh generators when splitting the mesh.
2.39.208The system shall support the ability to use the mesh meta data when using the split mesh.
2.39.209
The system shall support the ability to modify node(s) coordinates
1. in a mesh with a single first order element
2. in a Cartesian 3D mesh
3. in a mesh with a single first order element moved by shifts.
2.39.210The system shall report an error if the node to be moved cannot be found in the mesh.
2.39.211The system shall report an error if the node position and node id arrays do not match in size
2.39.212The system shall report an error if both shifts and positions are specified
2.39.213The system shall be able to create node sets from all side sets.
2.39.214
The system shall support the modification of the mesh
1. without restriction to the order of the supplied inputs with
2.39.215
The system shall support the file output of intermediate generated meshes in
1. the exodus file format
2. the nemesis file format
2.39.216The system shall support the file output of intermediate generated meshes with a final generator defined that is not a dependency of the intermediate meshes
2.39.217The system shall be able to create in a distributed manner a rectilinear mesh overlaying a given mesh.
2.39.218The system shall generate a 2D open curve mesh.
2.39.219The system shall generate a 3D open curve mesh.
2.39.220The system shall generate a 2D open curve mesh with nodesets on both ends.
2.39.221The system shall generate a closed loop curve mesh with starting and ending points coincident.
2.39.222The system shall generate a closed loop curve mesh with starting and ending points separated.
2.39.223The system shall generate a closed loop curve mesh with starting and ending points separated using a section that contains multiple elements.
2.39.224The system shall generate closed 2D curve meshes that can be used as inputs to Delaunay triangulation mesh generators.
2.39.225The system shall throw an error if the starting and ending points of a section are overlapped while the section is supposed to be open.
2.39.226The system shall throw an error if the oversampling algorithm exceeds its designated maximum sampling number.
2.39.227The system shall throw an error if there are repeated elements in the user-specified curve abscissas.
2.39.228The system shall throw an error if the user specifies to force closing a parsed curve, but it is already closed as the starting and ending points of the curve are overlapped.
2.39.229The system shall throw an error if the user specifies to force closing a parsed curve but the curve to be generated is also specified to be open.
2.39.230The system shall throw an error if the abscissa used to generate the curve is specified non-monotonically.
2.39.231The system shall throw an error if the number of curve segments is not consistent with the number of abscissa ranges.
2.39.232The system shall throw an error if the parsed expression for the x coordinate cannot be parsed as a function.
2.39.233The system shall throw an error if the parsed expression for the y coordinate cannot be parsed as a function.
2.39.234The system shall throw an error if the parsed expression for the z coordinate cannot be parsed as a function.
2.39.235The system shall have the ability to remove elements based on their vertex average position.
2.39.236The system shall have the ability to remove elements based on their volume.
2.39.237The system shall be able to assign extra ids to elements based on a parsed expression evaluated at the element centroids
2.39.238The system shall have the ability to assign mesh node sets based on parsed spatial functions, with a restriction on nodes that are in a given subdomain id.
2.39.239The system shall have the ability to assign mesh node sets based on parsed spatial functions, with a restriction on nodes that are also part of another nodeset.
2.39.240The system shall have the ability to assign mesh node sets based on parsed spatial functions, excluding nodes that are also part of another nodeset.
2.39.241The system shall have the ability to assign mesh node sets based on parsed spatial functions, with a restriction on using nodes that are on the exterior of the mesh only.
2.39.242The system shall have the ability to assign mesh node sets based on parsed spatial functions, and replace existing nodesets for the nodes involved.
2.39.243
The system shall report an error
1. if the expression defining the new nodeset cannot be parsed.
2.39.244
The system shall report an error
1. if one of the included subdomains does not exist in the mesh,
2. if one of the included nodesets does not exist in the mesh,
3. if one of the excluded nodesets does not exist in the mesh,
2.39.245
The system shall report an error
1. if a nodeset appears in both the list of nodesets to include and to exclude.
2. if the nodeset to create appears in the list of nodesets to include.
3. if the nodeset to create appears in the list of nodesets to exclude.
2.39.246The system shall have the ability to assign mesh side sets based on parsed spatial functions.
2.39.247The system shall have the ability to filter by neighboring subdomain id in ParsedGenerateSideset.
2.39.248The system shall have the ability to assign mesh side sets based on parsed spatial functions, with a restriction on sides that are also part of another sideset.
2.39.249The system shall have the ability to assign mesh side sets based on parsed spatial functions, excluding sides that are also part of another sideset.
2.39.250The system shall have the ability to assign mesh side sets based on parsed spatial functions, with a restriction on using sides that are on the exterior of the mesh only.
2.39.251
The system shall report an error
1. if one of the included subdomains does not exist in the mesh,
2. if one of the included neighbors does not exist in the mesh,
3. if one of the included sidesets does not exist in the mesh,
4. if one of the excluded sidesets does not exist in the mesh,
2.39.252The system shall report an error if a sideset appears in both the list of sidesets to include and to exclude.
2.39.253The system shall report an error if the sideset to create appears in the list of sidesets to include.
2.39.254The system shall report an error if the sideset to create appears in the list of sidesets to exclude.
2.39.255The system shall have the ability to assign mesh subdomains based on parsed spatial functions.
2.39.256The system shall have the ability to assign mesh subdomains based on parsed functions of extra element integers.
2.39.257The system shall report an error if a specified subdomain does not exist in the mesh.
2.39.258The system shall have the ability to stitch multiple input meshes together into a new mesh based upon a user-defined pattern.
2.39.259The system shall have the ability to stitch multiple input meshes with differing boundary ids together into a new mesh based upon a user-defined pattern.
2.39.260
The system shall report a reasonable error when stitching meshes together from a user-defined pattern when
1. the boundary name does not exist
2.39.261The system shall provide a method for deleting mesh elements lying on one side of a user-defined plane.
2.39.262
The system shall support the generation of plane IDs for 2D Cartesian grid
1. by taking x-direction as the plane axis
2. by taking y-direction as the plane axis
2.39.263The system shall support the generation of plane IDs for 3D extruded mesh
2.39.264
The system shall report an error if
1. the user provides coordinates that are not in increasing order for the ID planes,
2. the user provides a plane axis that is going outside the mesh,
3. the user provides non-matching inputs for the number of planes and the ids to set between planes,
4. the user does not provide enough planes,
5. the planes cut the elements despite the allowed tolerance,
6. some elements are outside the regions between the planes specified.
2.39.265
The system shall have the capability of generating a polyline geometry mesh
1. from user-specified points
2. optionally connecting points in a loop
3. refining a line if requested
4. refining a loop if requested
2.39.266The system shall set a boundary name or id if requested.
2.39.267
The system shall support the ability to refine
1. a single block within a multi-domain mesh,
2. a single block within a multi-domain mesh by requesting a maximum element size,
3. multiple blocks within a multi-domain mesh,
4. and multiple blocks within a multi-domain mesh, with neighbor refinement enabled.
2.39.268
The system shall report an error if
1. attempting to refine a block that does not exist in the mesh, and
2. if specifying a vector of refinement levels that does not match the vector of subdomains to refine.
2.39.269
The system shall support the ability to refine
1. neighboring elements of an external boundary along a mesh
2. neighboring elements of a specified boundary along a mesh
3. both the neighboring elements of, and the elements along, a specified boundary
2.39.270
The system shall report an error if
1. the specified boundary to be refined does not exist, and
2. if specifying a vector of refinement levels that does not match the vector of boundaries to refine.
2.39.271
The system shall be able to rename or renumber mesh blocks by:
1. identifying both old and new blocks by ID,
2. identifying old blocks by ID and new blocks by name,
3. identifying old blocks by name and new blocks by ID, and
4. identifying both old and new blocks by name,
5. and by identifying blocks by both id and name.
2.39.272The system shall be able to merge blocks in a mesh.
2.39.273
The system shall throw a reasonable error:
1. when old blocks are provided that do not exist within the mesh
2. and when the provided old and new blocks are not the same length.
2.39.274
The system shall be able to rename or renumber mesh blocks using old syntax by
1. identifying blocks by ID
2. identifying blocks by name
2.39.275
The system shall report a reasonable error when renaming or renumbering blocks using deprecated syntax when
1. both old block IDs and old block names are provided
2. both new block IDs and new block names are provided
3. the deprecated syntax for old block id and the new syntax for old block is used
4. the deprecated syntax for old block name and the new syntax for old block is used
5. the deprecated syntax for new block id and the new syntax for new block is used
6. the deprecated syntax for new block name and the new syntax for new block is used
2.39.276
The system shall be able to rename or renumber mesh boundaries by:
1. identifying both old and new boundaries by ID,
2. identifying old boundaries by ID and new boundaries by name,
3. identifying old boundaries by name and new boundaries by ID, and
4. identifying both old and new boundaries by name,
5. identifying boundaries by both id and name,
6. and by changing both id and name for old boundaries where the id and name match.
2.39.277The system shall be able to merge boundaries in a mesh.
2.39.278
The system shall throw a reasonable error:
1. when old boundaries are provided that do not exist within the mesh
2. when the provided old and new boundaries are not the same length.
3. when the user requests new boundary IDs outside the valid range of type BoundaryID.
2.39.279The system shall support the ability to create a mesh for a "Ringleb" geometry.
2.39.280The system shall be able to output detailed mesh information about generated meshes.
2.39.281
The system shall have the ability to create new mesh side sets around subdomains:
1. for a subdomain contained completely within a larger domain,
2. on specific sides of a subdomain based upon the normal to that side,
3. around multiple subdomains within a larger domain,
4. around multiple subdomains but only along external boundaries,
5. around two blocks within a domain, and
6. for a subdomain contained completely within a larger domain but containing part of that subdomain's boundary.
2.39.282The system shall report an error if the subdomain to create sidesets around does not exist in the mesh
2.39.283
The system shall have the capability of extruding the sideset of a mesh in a given direction
1. and the output of the SideSetExtruderGenerator should match the equivalent sequence of mesh generators
2. in a simple case, extruding the right side of a square out at an upward angle
3. when extruding the top side of a cube in a direction not normal to the sideset
4. extruding an entangled block in a complicated 3d geometry
2.39.284
The system shall have the ability to create new side sets between adjacent subdomains:
1. on a mesh with several adjacent subdomains,
2. where some subdomains are adjacent and not where paired subdomains are not adjacent, and
3. between two subdomains in a mesh with two adjacent subdomains.
4. between two subdomains in an unprepared mesh.
5. only when the primary block exists in the mesh.
6. only when the paired block exists in the mesh.
2.39.285
The system shall have the ability to generate side sets based upon bounding boxes:
1. a bounding box contained within the domain,
2. multiple bounding boxes contained within the domain,
3. multiple bounding boxes contained within a 3D domain, and
4. where bounding boxes perfectly overlap but create unique ids.
5. with only elements located outside of the bounding boxes.
2.39.286
The system shall issue an error when attempting to create side sets from a bounding box:
1. when no elements are located within the specified bounding box,
2. when the bounding box is larger than the domain so that no new side set is created, and
3. when the bounding box fails to span over any nodes.
4. if the incorrect boundary inputs are supplied.
2.39.287
The system shall support assigning boundary identifiers based the bounding box of a subdomain
1. if existing boundaries overlap and
2. error if no nodes are located in the given bounding box.
2.39.288The system shall be able to generate mesh side sets for all external surfaces on the mesh for each unique normal.
2.39.289The system must be able to replace the side sets when applying side sets during mesh generation.
2.39.290The system shall be able to create side sets from all node sets.
2.39.291
The system shall support the generation of multiple mesh side sets on the exterior surfaces of a mesh grouped by normal:
1. where the normal varies within a tolerance from element to element,
2. where the normal is fixed within a specified tolerance.
2.39.292The system shall be able to create sidesets.
2.39.293The system shall return errors if it detects ambiguous sideset specifications
2.39.294The system shall be able to use libmesh mesh modification tools.
2.39.295The system shall be able to generate a sphere volume mesh.
2.39.296The system shall be able to generate a sphere volume mesh with smoothing.
2.39.297The system shall be able to generate a sphere volume mesh with HEX27 elements.
2.39.298The system shall be able to create a spiral annular mesh with triangle elements (TRI3 or TRI6).
2.39.299
The system shall be able to generate meshes by stacking up existing meshes in
1. two and
2. three dimensions and
3. error if the dimensions of the meshes to be stacked are not consistent.
2.39.300
The system shall support stitching two interface boundaries
1. in 2D, and
2. in 3D.
2.39.301
The system shall support the creation of a finite element mesh from existing meshes
1. by 'stitching' them together,
2. by preventing boundary merging based on ids during stitching and
3. be able to utilize the resulting mesh in a simulation.
2.39.302The system shall warn the user if boundary ID renumbering is disabled and it detects the same ID with different boundary names on the two meshes
2.39.303The system shall include the ability to assign subdomain identifiers for elements within a regular bounding box.
2.39.304The system shall include the ability to assign subdomain identifiers for elements outside of a regular bounding box.
2.39.305The system shall include the ability to assign subdomain identifiers for elements within an arbitrarily oriented bounding box.
2.39.306The system shall include the ability to assign subdomain identifiers for elements outside an arbitrarily oriented bounding box.
2.39.307The system shall include the ability to assign subdomain identifiers for elements with a regular bounding box that is restricted to only modify elements with specific subdomain identifiers.
2.39.308The system shall include the ability to assign extra element integers within a regular bounding box.
2.39.309The system shall report an error if a restricted subdomain of the bounding box subdomain generation does not exist in the mesh
2.39.310The system shall have the ability to change or overwrite the subdomain IDs of all elements in a mesh.
2.39.311The system mesh generation capability shall be extensible to allow composition of existing mesh generators.
2.39.312The system shall include the ability to mirror a finite element mesh and stitch the mirrored mesh with the starting mesh.
2.39.313
The system shall report a reasonable error generating meshes when
1. requesting an input mesh generator by parameter and the parameter is not valid
2. requesting an input mesh generator parameter and the parameter is of the wrong type
3. requesting an input mesh generator by name and the name is not valid
4. requesting input mesh generators by parameter and the parameter is of the wrong type
5. requesting an input mesh at an unallowed time
6. building a sub generator at an unallowed time
7. declaring a property on the mesh at an unallowed time
8. requesting an input mesh generator by parameter that does not exist
9. requesting input mesh generators by parameter that do not exist
10. requesting an input mesh generator by name that does not exist
11. requesting input mesh generators by name that do not exist
12. failing to properly manage the memory of an input mesh generator
13. declaring a property on the mesh multiple times
14. coupling an input mesh generator in a parameter for a sub generator but not using said dependency
15. coupling an input mesh generator in a sub generator but not declaring it as a dependency
16. coupling an input mesh generator in a parameter but not using said mesh generator
17. getting a mesh generator that does not exist
18. forcibly setting the final mesh when said mesh does not exist
19. an input mesh is not found because its dependencies are not properly declared
20. a mesh was not generated
2.39.314The system shall support declaration of a name that can be used as an unused name for input meshes when generating meshes
2.39.315The system shall include the ability to create a finite element mesh by tiling existing meshes.
2.39.316
The system shall support the ability to create a mesh element-wise by specifying corners, edge types, generating parameters and/or point distribution,
1. resulting in a quadrilateral mesh, or
2. resulting in a mesh with an arc circle side,
3. or a section of an annulus,
4. which can also be prescribed by providing a midpoint.
5. Sides can be provided as discrete points,
6. or symbolic expressions.
7. Also, PARSED can be used for polar coordinates parametrizations,
8. and all cases allow for non-equidistant point distributions.
2.39.317The system shall include the ability to rotate and scale a finite element mesh.
2.39.318
The system shall include the ability to translate a finite element mesh in a manner that
1. is defined by the user,
2. places the center of the mesh at the origin, or
3. places the minimum of the mesh at the origin.
2.39.319
The system shall be shall support the generation of new extra element ID by parsing the existing extra element IDs
1. with the default option for new id value setting
2. with the new id value setting rule option
3. with domain cutting using PlaneDeletionGenerator
2.39.320
The system shall have the capability of triangulating a polyline boundary
1. within an input polyline
2. returning errors if the polyline is not closed
3. returning errors if the polyline is disconnected
4. taking the boundary of a 2D input mesh
5. taking a specified subset of an input polyline set
6. taking a specified subset of a 2D input boundary
7. respecting any specified interior 'hole' meshes
8. assigning user-provided hole boundary names
9. selectively stitching 'hole' meshes into the final mesh
10. allowing deep nesting of triangulations within triangulations
11. with optional Laplacian mesh smoothing.
12. with optional non-uniform refinement based on a custom function.
13. with optional non-uniform refinement based on an automatically generated function.
14. with quadratic TRI3 elements using a non-stitched quadratic hole mesh.
15. with quadratic TRI6 elements.
16. with quadratic TRI7 elements.
17. selectively stitching linear 'hole' meshes into the final quadratic TRI6 mesh after increasing the hole mesh element order
18. selectively stitching linear 'hole' meshes into the final quadratic TRI7 mesh after increasing the hole mesh element order
2.39.321
The system shall throw an error when triangulating a polyline boundary
1. if the input hole meshes contain subdomain name maps with conflicts
2. if more than one element area limiting methods are specified by the user
3. if the user specifies parameters for the auto area function when it is not used
4. if the input hole meshes
2.39.322The system shall be able to cut a simple one-subdomain mesh using the triangle element cutting method.
2.39.323The system shall be able to cut a simple one-subdomain mesh using the node moving method.
2.39.324The system shall be able to cut a multi-subdomain mesh using the triangle element cutting method.
2.39.325The system shall be able to cut a multi-subdomain mesh using the element cutting method and improve the quality of triangular elements on the boundary.
2.39.326The system shall be able to cut a multi-subdomain mesh using the node moving method.
2.39.327The system shall be able to cut a multi-subdomain mesh using the node moving method with interface boundaries that need to conform.
2.39.328
The system shall error
1. if the input mesh is not 2D,
2. if the given name of the triangle element block, created during mesh line cutting, already exists in the input mesh, in the element cutting mode,
3. if the given name of the triangular element block, created during mesh line cutting, already exists in the input mesh in the node moving mode,
4. if the input mesh does not contain the user-specified external boundary,
5. if the input mesh does not contain the user-specified boundary to conform,
6. if the size of the cut line parameters is not three,
7. if the cut line parameters is not valid to define a line,
8. if the external boundary id is not provided when the node moving method is used,
9. if the triangle element improvement is enabled under the node moving mode.
2.39.329
The system shall have the capability of tetrahedralizing a triangulated boundary
1. within an input boundary mesh
2. respecting any specified interior 'hole' meshes
3. selectively stitching 'hole' meshes into the final mesh
4. allowing deep nesting of tetrahedralizations within tetrahedralizations
5. with optional Laplacian mesh smoothing.
2.39.330
The system shall throw an error when tetrahedralizing a triangulated boundary
1. if the input hole meshes contain subdomain name maps with conflicts

framework: Meshmodifiers
2.40.1
The framework shall include the ability to change element subdomain during simulation
1. reversibly,
2. irreversibly,
3. run in parallel,
4. with solution,
5. with a displaced mesh,
6. and stateful material properties properly initialized.
2.40.2
The framework shall update the boundary over elements that change subdomain, with the ability to
1. update a given boundary,
2. choose which subdomain to add the element sides from,
3. add the external sides of elements,
4. update a boundary that covers part of a subdomain,
5. continue updating the boundary if it temporarily contains no element sides,
2.40.3
The framework shall include the ability to change element subdomain during simulation with reinitialization of
1. all the changed elements,
2. none of the changed elements,
3. only the elements that change into particular subdomains,
4. only the elements that change from outside of to into particular subdomains,
2.40.4The framework shall include the ability to change element subdomain for a steady state simulation
2.40.5The system shall only apply subdomain changes when the userobject is finalized to avoid subdomain id mismatches
2.40.6The framework shall support adaptive mesh refinement in the element subdomain modifier
2.40.7The framework shall support adaptive mesh refinement in the element subdomain modifier for 3D problems
2.40.8The framework shall support applying nodal BCs on the moving boundary with AMR in the element subdomain modifier
2.40.9The framework shall support applying integral BCs on the moving boundary with AMR in the element subdomain modifier
2.40.10The system shall produce an error when a boundary preserved marker is used with distributed mesh.
2.40.11The system shall be able to change element subdomain IDs based on the average coupled variable value in the element.
2.40.12When the desired value is not present in the subdomain ID list, the closest existing subdomain ID value will be assigned to the element with a warning.
2.40.13
The system shall be able to move elements between blocks at user specified times
1. listed in the input file,
2. listed in a CSV file.
2.40.14The system shall be able to dynamically update sidesets including on mesh boundaries.
2.40.15The system shall be able to dynamically update sidesets excluding on mesh boundaries.

framework: Minimal App
2.41.1The system shall support the programmatic creation of a simulation tools without the need of an input file.

framework: Misc
2.42.1The system shall compute a curvature close to unity for a unit sphere.
2.42.2The system shall compute a curvature close to minus unity for a unit circle.
2.42.3We shall be able to call AD variable methods on an auxiliary variable in a transient simulation and not hit assertions for both regular and neighbor calculations
2.42.4Coupling an auxiliary variable into a DGKernel shall not destroy the Jacobian
2.42.5We shall be able to do NL variable coupling into a DGKernel
2.42.6We shall be able to do NL variable coupling into a DGKernel and have a good Jacobian
2.42.7The compiled application shall be capable of returning the name used for registering objects.
2.42.8The system shall be able to run a specific application by passing a command line option.
2.42.9The system shall be able to run a kernel on the displaced mesh with blocks that are a superset of the displacement variable blocks.
2.42.10The system shall report an error when a material property is not defined on a boundary.
2.42.11The system shall report an error when a material property requested by a UserObject is not defined on a boundary.
2.42.12The system shall report an error when a material property requested by a DGKernel is not defined on a boundary.
2.42.13The system shall report an error when a material property requested by a DGKernel is not defined on a subdomain.
2.42.14The system shall verify that objects that use subdomain restricted variables are defined on a subset of the restricted domain area.
2.42.15The system shall produce an error when an object's discretization area is explicitly set to a value greater than the area of the underlying variable used by the object.
2.42.16The system shall produce an error when an object's discretization area is greater than the area of the underlying variable used by the object.
2.42.17The system shall produce an error when an object's discretization area is explicitly set to a different area than the area of a coupled variable used by the object.
2.42.18The system shall produce an error when an object's discretization area is different than an explicitly set variable on only defined on a different portion of the mesh.
2.42.19The system shall produce an error when an object's discretization area is covers the whole mesh but a coupled variable only exists on a portion of the mesh.
2.42.20
The system shall report an error if a boundary restricted object depends on a variable that is not defined on any portion of the boundary. These boundary restricted objects include
1. nodal auxiliary kernels
2. nodal user objects
3. nodal boundary conditions
4. integrated boundary conditions
5. side user objects
6. elemental auxiliary kernels
2.42.21The system shall report an error if a variable is coupled into a boundary restricted object, along whose boundary the variable is only partially defined.
2.42.22The system shall report an error if an object restricted on an internal boundarydepends on a variable that is not defined on any portion of the boundary.
2.42.25The system shall report an error when a null pointer-checked parameter is retrieved from the InputParameters object.
2.42.26The system shall report an error when multiple AuxVariables are added to the system with conflicting types.
2.42.27The system shall report an error when multiple Scalar AuxVariables are added to the system with conflicting types.
2.42.28The system shall report an error when multiple AuxVariables are added to the system with conflicting block-restriction.
2.42.29The system shall report an error when an attempt is made to instantiate a non-existent BoundaryCondition object.
2.42.30The system shall report an error when a non-existent nonlinear variable name is used by a MooseObject.
2.42.31The system shall report an error message when an invalid enumeration is supplied in any MooseEnum type.
2.42.32The system shall report an error message when an invalid Executioner is specified.
2.42.33The system shall report an error message when an invalid Kernel is specified.
2.42.34The system shall report an error message when a Kernel object attempts to access a non-existent variable.
2.42.35The system shall report an error when an invalid Material is specified.
2.42.36The system shall report an error when a previously undeclared variable is used in a parsed function expression.
2.42.37The system shall report an error when a first order element is used with a second order discretization.
2.42.38The system shall report an error message when a deprecated input file block is used.
2.42.39The system shall report a warning when a deprecated parameter with a default value is explicitly set by the user.
2.42.40The system shall report a warning when an optional deprecated parameter is explicitly set by the user.
2.42.41The system shall report an error when conflicting domain restrictions are applied to a single object.
2.42.42The system shall report an error when the number of ids and corresponding block names are mismatched.
2.42.43The system shall report an error when a duplicate name is provided for a set of unique block ids.
2.42.44The system shall report an error when the number of ids and corresponding boundary names are mismatched.
2.42.45The system shall report an error when a duplicate name is provided for a set of unique boundary ids.
2.42.46The system shall report an error when the linear interpolation utility is supplied with bad domain values.
2.42.47The system shall report an error when the Piecewise utility encounters an unexpected column data format.
2.42.48The system shall report an error when the Piecewise utility encounters an unexpected row data format.
2.42.49The system shall report an error when the Piecewise utility encounters inconsistent domain and range data.
2.42.50The system shall report an error when an invalid enumeration is supplied in the Piecewise utility.
2.42.51The system shall report an error when the Piecewise data is over-specified with the data file option.
2.42.52The system shall report an error when the Piecewise data is over-specified with row/column data.
2.42.53The system shall report an error when either the domain or range is missing when using the domain/range option in the Piecewise utility.
2.42.54The system shall report and error if the supplied domain/range pairs are not even in the Piecewise utility.
2.42.55The system shall report an error if no function is supplied in the Piecewise utility.
2.42.56The system shall report an error if the xy_data is supplied but the function is missing in the Piecewise utility.
2.42.57The system shall report an error when the number of columns appears incorrect in the Piecewise utility.
2.42.58The system shall report an error when an out of range y-column index is supplied in the Piecewise utility.
2.42.59The system shall report an error when an out of range x-column index is supplied in the Piecewise utility.
2.42.60The system shall report an error if too many rows are supplied when the data is expected to contain row information.
2.42.61The system shall report an error when an out of range x-row index is supplied in the Piecewise utility.
2.42.62The system shall report an error when an out of range y-row index is supplied in the Piecewise utility.
2.42.63The system shall report an error when the x and y index in file are equal in the Piecewise utility.
2.42.64The system shall report an error if one or more domain blocks do not have any active Kernels objects assigned.
2.42.65The system shall report an error if one or more variables do not have any active Kernel objects assigned.
2.42.66The system shall report an error if one or more domain blocks do not have any active FVKernels objects assigned.
2.42.67The system shall report an error if one or more variables do not have any active FVKernel objects assigned.
2.42.68The system shall report an error when an elemental variable (no $C_0$ continuity) is coupled to a variable with $C_0$ continuity.
2.42.69The system shall report an error when an active input block section is specified but missing.
2.42.70The system shall report an error when a material property is requested but not supplied on a mesh block.
2.42.71The system shall report an error when a coupled variable is supplied that was not added as a valid parameter.
2.42.72The system shall report an error when the data file is non-existent or not-readable in the Piecewise utility.
2.42.73The system shall report an error when the coupled function does not exist or can not be parsed by a piecewise utility.
2.42.74The system shall report an error when one or more material properties are missing from any mesh block.
2.42.75The system shall report an error when a material property is supplied on some blocks but missing on other blocks where it is requested.
2.42.76The system shall report an error when only "old" properties are supplied but current properties are requested.
2.42.77The system shall report an error when only "older" properties are supplied but current properties are requested.
2.42.78The system shall report an error when the mesh file cannot be found.
2.42.79The system shall report an error when a required parameter is not supplied in an Action.
2.42.80The system shall report an error when a specific mesh required parameter is not supplied.
2.42.81The system shall report an error when the special "type" parameter is not supplied for a MooseObject.
2.42.82The system shall report an error when a required parameter is not supplied in a MooseObject.
2.42.83The system shall report an error when the variable parameter is missing from a residual object
2.42.84The system shall report an error when a required coupling parameter is missing.
2.42.85The system shall report an error when more than one preconditioner block is supplied.
2.42.86The system shall abort the solve and report a floating point error when a NaN is produced during user computation with the Steady executioner.
2.42.87The system shall abort the solve and report a floating point error when a NaN is produced during user computation with the Transient executioner.
2.42.88The system shall report an error when a nodal AuxKernel attempts to access a material property.
2.42.89The system shall report an error when the same named parameter appears multiple times in the same input file.
2.42.90The system shall report an error when the coordinate transformation conflicts with the underlying element types.
2.42.91The system shall report an error when solver and auxiliary variables are declared with the same name.
2.42.92The system shall report an error when an AuxKernel is applied outside of the domain where a restricted variable exists.
2.42.93The system shall report an error when a Kernel is applied outside of the domain where a restricted variable exists.
2.42.94The system shall report an error when an unused parameter is provided through the input file or an Action.
2.42.95The system shall report an error when an unused parameter is supplied on the command line.
2.42.96The system shall include the option to report a warning instead of an error for an unused parameter set in input.
2.42.97The system shall include the option to report a warning instead of an error for an unused parameter set in command line arguments
2.42.98The system shall report an error when a UserObject and a Postprocessor are added with the same names.
2.42.99The system shall report and error when a UserObject and a VectorPostprocessor are added with the same names.
2.42.100The system shall report an error when an input file block associated with a pluggable system is asked to build an object from a different system.
2.42.101The system shall report an error when an input file block associated with a pluggable system is misspelled.
2.42.102The system shall report a standard Unix usage statement when an invalid command line switch is used.
2.42.103The system shall report an error when a required variable is missing from the ICs input file block.
2.42.104The system shall report an error when a boundary restriction is applied to a non-nodal variable discretization.
2.42.105The system shall report an error when coupling to old temporal solution vectors in a Steady (no time) Executioner.
2.42.106The system shall report an error when coupling to a time derivative solution vector in a Steady (no time) Executioner.
2.42.107The system shall report an error when an older scalar solution variable is accessed in a Steady (no time) Executioner.
2.42.108The system shall report an error when an older time derivative scalar solution variable is accessed in a Steady (no time) Executioner.
2.42.109The system shall report an error when a coupled variable is not defined in the same region as the variable performing the coupling.
2.42.110The system shall report the successful parsing and interpretation of input file syntax when using the "–check-input" command line flag.
2.42.111The system shall report an error when performing nodal constraints when there is a mismatch in the number of constrained nodes.
2.42.112The system shall report an error when requested to check the syntax in an input file but no input file is supplied.
2.42.113The system shall report an error when multiple time schemes are specified in the same input file.
2.42.114The system shall report an error when there is a mismatch between the parameter for an object and the type of object are mismatched.
2.42.115The system shall report an error when the variables representing displacement are of a lower order than the mesh.
2.42.116The system shall report an error when the name of a function could be misinterpreted because it could also be evaluated (e.g. a function name of "x").
2.42.117The system shall report an error when floating point input parameter types fail to parse as floating point numbers.
2.42.118The system shall report an error when a scalar variable is used where a spatial variable is expected.
2.42.119The system shall report an error when a field variable is used where a scalar variable is expected.
2.42.120The system shall report an error when an invalid coupled spatial variable is requested.
2.42.121The system shall report an error when an invalid coupled scalar variable is requested.
2.42.122The system shall report an error when an attempt is made to couple a variable with itself.
2.42.123The system shall report an error when an attempt is made to couple a variable with itself in coupled force term using automated differentiation.
2.42.124The system shall report an error when an input file cannot be opened and read.
2.42.125The system shall report an error when a Kernel attempts to use an auxiliary variable.
2.42.126The system shall report an error when a boundary condition object attempts to use an auxiliary variable.
2.42.127The system shall report an error when an AuxKernel specifies a non-existent variable.
2.42.128The system shall report an error when a scalar Kernel specifies a non-existent variable.
2.42.129The system shall report an error when a nodal Kernel attempts to use an auxiliary variable.
2.42.130The system shall report an error when a constraint attempts to use an auxiliary variable.
2.42.131The system shall report an error when a scalar auxiliary Kernel attempts to use a solution variable.
2.42.132The system shall report an error when a DiracKernel attempts to use an auxiliary variable.
2.42.133The system shall report an error when a discontinuous Galerkin Kernel attempts to use an auxiliary variable.
2.42.134The system shall report an error when an interface Kernel attempts to use an auxiliary variable.
2.42.135The system shall report an error when a Kernel attempts to retrieve an empty string variable.
2.42.136The system shall report an error when a vector Kernel attempts to use a scalar solution variable.
2.42.137The system shall report an error when a Kernel attempts to use a vector solution variable.
2.42.138The system shall report an error if users try to get nodal values of non-nodal variables.
2.42.139The system shall report an error if users try to get old nodal values of non-nodal variables.
2.42.140The system shall report an error if users try to get older nodal values of non-nodal variables.
2.42.141The system shall report an error if an object tries to get the name of a coupled constant.
2.42.142The system shall have an integrity check that ensures an Executioner object exists in the system.
2.42.143The system shall report an error when nodal boundary condition is applied on a non-nodal variable.
2.42.144The system shall report an error when a git-lfs file pointer is encountered for the mesh file.
2.42.145The system shall report an error when a git-lfs file pointer is encountered for the mesh for a mesh generator.
2.42.146The system shall report a helpful error when the dump parameter does not match any valid parameters
2.42.147The system shall support the ability for actions to query the existence of a mesh attribute (meta data).
2.42.148The system shall be to find data files in designated directories, regardless of the source repository or install location.
2.42.149The system shall throw an exception if a data file cannot be found in any of the designated directories.
2.42.150The system shall support the output a processor id field for the purposes of debugging
2.42.151The system shall produce a warning when non-expired deprecated code is executed.
2.42.152The system shall produce a warning when expired deprecated code is executed.
2.42.153The system shall produce an error when the –no-deprecated-flag is passed and deprecated code is executed.
2.42.154The system shall produce a warning indicating a possible replacement when deprecated code is superseded.
2.42.155The system shall be able to deprecate parameter names, while enabling user code to only use the new, blessed name
2.42.156The system shall be able to deprecate coupled variable names, while enabling user code to only use the new, blessed name
2.42.157The system shall not give a deprecation warning if the user uses the blessed coupled variable name instead of the deprecated coupled variable name.
2.42.158The system shall output one warning per deprecated parameter, regardless of how many deprecated parameters are in the system.
2.42.159The system shall produce a warning only once indicating a possible replacement of an object when deprecated code is superseded.
2.42.160
The system allow coupling between variables on or off displaced meshes
1. not using automatic differentiation methods
2. using automatic differentiation methods
2.42.161The system shall add ghost entries to residual vectors when needed
2.42.162The system shall not add ghost entries to residual vectors when not needed
2.42.163The system shall support throwing an exception during the residual calculation, which will cut back the time step.
2.42.164The system shall support throwing an exception during the residual calculation on a non-zero rank, which will cut back the time step.
2.42.165The system shall support throwing an exception during the Jacboain calculation, which will cut back the time step.
2.42.166The system shall support throwing an exception during the Jacobian calculation on a non-zero rank, which will cut back the time step.
2.42.167The system shall support throwing an exception during the initial condition calculation, which will terminate the solve.
2.42.168The system shall support throwing an error during a residual calculation, which will terminate the solve.
2.42.169The system shall support throwing an error during a Jacobian calculation, which will terminate the solve.
2.42.170The system shall allow users to skip exception checks to avoid global communication.
2.42.171The system shall interrupt a solve immediately as soon as an exception is thrown.
2.42.172The system shall maintain a flag available for inspection indicating the current "execution stage" enumeration.
2.42.173
The hit find command shall be able to find
1. files with specific parameters,
2. files not containing a specified parameter,
3. parameters set to an exact specified value,
4. parameters not set to an exact specified value,
5. parameters with additional pattern constraints,
6. parameters with additional inverted pattern constraints.
2.42.174The hit merge command shall be able to combine input files.
2.42.175
The hit diff command shall be able to
1. show differences between input files,
2. show differences between input files marked up using terminal colors,
3. show differences between input files with verbose explanations,
4. show differences between input files with verbose explanations marked up using terminal colors,
5. show common parameters/value pairs between input files,
2.42.176The system shall verify equality among the current, old, and older solution vectors prior to running the simulation.
2.42.177The system shall support a testing mechanism that fails intermittently.
2.42.178We shall be able the scrape the DOFMapOutput and determine when the Jacobian is slightly off
2.42.179We shall be able the scrape the DOFMapOutput and determine when the Jacobian is questionable
2.42.180We shall throw no errors if the off-diagonal Jacobian is wrong if we are only testing the on-diagonal Jacobian
2.42.181If use_displaced_mesh = false then MOOSE will not throw an exception if elements are inverted to produce a negative element Jacobian, in 3D simulations
2.42.182A 3D simulation shall throw an exception if there is a zero element Jacobian, when use_displaced_mesh = true
2.42.183A 3D simulation shall throw an exception if there is a negative element Jacobian, when use_displaced_mesh = true
2.42.184If use_displaced_mesh = false then MOOSE will not throw an exception if elements are inverted to produce a negative element Jacobian, in 2D simulations
2.42.185If use_displaced_mesh = false then MOOSE will not throw an exception if elements are distored to produce a zero element Jacobian, in 2D simulations
2.42.186A 2D simulation shall throw an exception if there is a zero element Jacobian, when use_displaced_mesh = true
2.42.187The PETSc Jacobian test shall reveal nans if there are nans in the matrix
2.42.188The system shall support embedding a 1D block inside of a 3D block.
2.42.189The maximum number of degrees of freedom for a single variable on a 1D EDGE2 elem shall be 2
2.42.190The maximum number of degrees of freedom for a single variable on a 2D QUAD4 elem shall be 4
2.42.191The maximum number of degrees of freedom for a single variable on a 2D QUAD9 elem shall be 9
2.42.192The maximum number of degrees of freedom for a single variable on a 2D TRI3 elem shall be 3
2.42.193The maximum number of degrees of freedom for a single variable on a 2D TRI6 elem shall be 6
2.42.194The maximum number of degrees of freedom for a single variable on a 2D TRI7 elem shall be 7
2.42.195The maximum number of degrees of freedom for a single variable on a 3D HEX8 elem shall be 8
2.42.196
The system shall report an error if the user provides inconsistent parameter values to the mesh and problem for the parameters related to
1. subdomain blocks
2. coordinate system types
2.42.197
The software shall be able to solve a system of equations in which one variable depends on another by
1. segregating the solves; first the independent variable is solved for, and second the dependent variable is solved for using the solution of the first
2. segregating the solves using finite volume discretization; first the independent variable is solved for, and second the dependent variable is solved for using the solution of the first
3. solving the equations monolothically; both the independent and dependent variable equations are solved in a single large system
2.42.198
The system shall be able to perform a segregated solve using AD objects and
1. match the results of a segregated solve using hand-coded Jacobian objects
2. show a perfect Jacobian for both solves
2.42.199The system shall be able to perform a segregated solve using objects with hand-coded Jacobians and show perfect Jacobians for those objects.
2.42.200
The software shall allow having a different number of variables in nonlinear systems within the same problem when the action of the Jacobian is provided by
1. an assembled matrix, or
2. a matrix-free approximation.
2.42.201The system shall be able to output postprocessor data after solving multiple solver systems.
2.42.202
The system shall be able to restart multiple nonlinear variables from different nonlinear systems from an exodus file
1. using problem_out.e as a starting point, slightly modify the BCs and rerun
2.42.203The testing system shall support the ability to disable geometrical mapping of mesh elements for comparison purposes.
2.42.204The system shall use the default PETSc option database in the parent app to handle system-level PETSc parameters
2.42.205The system shall warn the user of unused options if and only if they are not valid moose options.
2.42.206The system shall print an understandable message when a user-specified path/file does not exist.
2.42.207
The system shall allow application developers, in derived classes, to rename
1. parameters
2. coupled field variables
3. coupled scalar variables
4. functors
5. material properties
6. postprocessors
2.42.208The system shall set vector and matrix types from the PETSc command line option parameters within an input file.
2.42.209
The system shall be capable of storing residual contributions as an auxiliary field variable for
1. continuous Galerkin and
2. discontinuous Galerkin methods.
2.42.210
The system shall report an error if the residual calculation contribution is assigned to the incorrect variable for
1. on-diagonal and
2. off-diagonal terms.
2.42.211The system shall be able to compute the same value for a block-restricted save-in variable regardless of the number of processes used to run a simulation.
2.42.212The system shall only reinitialize variables values that are consumed by other active objects in the system.
2.42.213The system shall make a serialized solution vector available when requested by objects in the system.
2.42.214The system shall make a serialized solution vector available when requested by objects in the system when uniform refinement is active.
2.42.215The system shall make a serialized solution vector available when requested by objects in the system when adaptivity is active.
2.42.216The test system shall have the ability to execute a specific input file.
2.42.217The test system shall have the ability to run a test that neither clears expected outputs or runs the expected executeable for multiple output testing.
2.42.218The app should write out a checkpoint file at any time by sending a signal to it.
2.42.219The app should be able to recover from the autosaved checkpoint created by a signal.
2.42.220The app, recovered from a signal-created checkpoint, should produce an accurate solution.
2.42.221The app should write out a parallel checkpoint file at any time by sending a signal to it.
2.42.222The app should be able to recover from a parallel autosaved checkpoint created by a signal.
2.42.223The app, recovered from a parallel signal-created checkpoint, should produce an accurate solution.
2.42.224The app should write out a checkpoint file at any time by sending a signal to it, in a debug build.
2.42.225The app should be able to recover from the autosaved checkpoint created by a signal, in a debug build.
2.42.226The app, recovered from a signal-created checkpoint, should produce an accurate solution in a debug build.
2.42.227The system shall not accept a converged solution if the solution has been tagged as invalid.
2.42.228The system shall allow overriding the solution validity checks.
2.42.229
The system shall be able to count warnings through the solution invalidity interface and report them,
1. unless the user specifies to silence them,
2. and otherwise both in the console window and a json file.
2.42.230The system shall be able to output to screen immediately a detailed reason as to why a solution is invalid
2.42.231The system shall be able to output detailed reasons and occurrences as to why a solution is invalid to file
2.42.232The system shall be able to output detailed information about why a solution is invalid to a file in transient simulations
2.42.233The system shall be able to handle a solution invalidity happening on just one processor in a parallel run
2.42.234The system shall be able to handle a solution invalidity occurs in the previous time step and recover in the next time step
2.42.235
The system shall be able to support
1. outputting of checkpoint files
2. restarting from the output data
2.42.236The system shall support pausing execution for the purpose of attaching a debugger after launch.
2.42.237The system shall support running a user-defined subroutine each time a subdomain change occurs when iterating over the mesh.
2.42.238The application executable shall report the version with the –version command line argument.
2.42.239The application executable shall report the version with the -v command line argument.

framework: Mortar
2.43.1The system shall support the use of constrains using the mortar method in 1D.
2.43.2We shall be able to enforce periodic boundary conditions on 3d domains using mortar constraints.
2.43.3The system shall assemble primary/secondary AD mortar constraints coupled to scalar variables.
2.43.4The system shall assemble lower variable AD mortar constraints coupled to scalar variables.
2.43.5The system shall assemble primary/secondary AD mortar constraints coupled to 3d scalar variables.
2.43.6The system shall assemble lower variable AD mortar constraints coupled to 3d scalar variables.
2.43.7AD mortar surfaces coupled with scalar variables can handle nonuniform conductivity.
2.43.8The system shall assemble AD mortar constraints with multiple distinct coupled scalar variables.
2.43.9
The system shall be able to compute the gap between secondary and primary bodies using the mortar method and auxiliary kernels
1. when the gap auxiliary variable and mesh are both first order
2. when the gap auxiliary variable is first order and the mesh is second order
3. when the gap auxiliary variable and mesh are both second order
2.43.10The system shall be able to run mortar auxiliary kernels when no constraints are present in the simulation.
2.43.11The system shall be able to construct a mortar mesh when coincident nodes exist on one or more mortar boundaries.
2.43.12We shall be able to enforce solution continuity on a conforming mesh for one variable
2.43.13We shall be able to enforce solution gradient continuity on a conforming mesh for one variable
2.43.14We shall be able to enforce solution continuity on a conforming mesh for two variables
2.43.15We shall be able to enforce solution continuity on a conforming mesh for one variable using second order shape functions for both primal and lagrange variables. Note that this may be a relatively unstable discretization
2.43.16We shall be able to produce the expected result for a solution continuity test case using the mortar method, e.g. the primal variable values across the mortar interface shall be the same.
2.43.17We shall be able to produce the expected result for a solution continuity test case using the first order dual basis.
2.43.18We shall be able to produce the expected result for a solution continuity test case using the second order dual basis.
2.43.19We shall be able to produce the expected result for a fine mesh solution continuity test case using the mortar method, e.g. the primal variable values across the mortar interface shall be the same.
2.43.20The Jacobian for the solution continuity test case shall be perfect
2.43.21We shall be able to produce the expected result for a solution continuity test case using the Petrov-Galerkin approach for mortar.
2.43.22The system shall be able to prolong and restrict stateful material properties because of mesh adaptivity in the presense of lower dimensional subdomains that do not have materials and when stateful properties are needed on boundaries (because of integrated boundary conditions)
2.43.23We shall be able to produce the expected result for a solution continuity test case with the first order dual basis using VCP.
2.43.24We shall be able to produce the expected result for a solution continuity test case with the second order dual basis using VCP.
2.43.25The system shall be able to produce the expected result for a solution continuity test case using the mortar method on a HEX8 mesh with curved geometry, e.g. the primal variable values across the mortar interface shall be the same.
2.43.26The system shall be able to produce the expected result for a solution continuity test case using the mortar method on a HEX20 mesh with curved geometry, e.g. the primal variable values across the mortar interface shall be the same.
2.43.27The system shall be able to produce the expected result for a solution continuity test case using the mortar method on a HEX27 mesh with curved geometry, e.g. the primal variable values across the mortar interface shall be the same.
2.43.28The system shall generate a debug mortar mesh the parameter debug_mesh is passed to a mortar constraint
2.43.29The system shall be able to produce the expected result for a solution continuity test case using the mortar method on a TET4 conforming mesh, e.g. the primal variable values across the mortar interface shall be the same.
2.43.30The system shall be able to produce the expected result for a solution continuity test case using the mortar method on a TET10 conforming mesh, e.g. the primal variable values across the mortar interface shall be the same.
2.43.31The system shall be able to produce the expected result for a solution continuity test case using the mortar method on a TET14 conforming mesh, e.g. the primal variable values across the mortar interface shall be the same.
2.43.32The system shall be able to produce the expected result for a solution continuity test case using the mortar method on a TET4 non-conforming mesh, e.g. the primal variable values across the mortar interface shall be the same.
2.43.33The system shall be able to produce the expected result for a solution continuity test case using the mortar method on a mesh with mixed element types, e.g. the primal variable values across the mortar interface shall be the same.
2.43.34The system shall be able to produce the expected result for a solution continuity test case using the penalty-based mortar method on a TET4 conforming mesh, e.g. the primal variable values across the mortar interface shall be the same.
2.43.35The system shall be able to produce the expected result for a solution continuity test case using the penalty-based mortar method on a TET10 conforming mesh, e.g. the primal variable values across the mortar interface shall be the same.
2.43.36The system shall be able to produce the expected result for a solution continuity test case using the penalty-based mortar method on a TET14 conforming mesh, e.g. the primal variable values across the mortar interface shall be the same.
2.43.37The system shall be able to produce the expected result for a solution continuity test case using the penalty-based mortar method on a HEX8 mesh with curved geometry, e.g. the primal variable values across the mortar interface shall be the same.
2.43.38The system shall be able to produce the expected result for a solution continuity test case using the penalty-based mortar method on a HEX20 mesh with curved geometry, e.g. the primal variable values across the mortar interface shall be the same.
2.43.39The system shall be able to produce the same result using the penalty-based mortar method with and without automatic differentiation.
2.43.40The system shall be able to demonstrate asymptotically correct convergence rates of 2 and 1 for a mortar solution continuity problem with conforming and non-conforming (HEX8) geometric discretization when using a first order basis for the temperature variable and a zeroth order basis for the Lagrange multiplier.
2.43.41The system shall be able to demonstrate asymptotically correct convergence rates of 2 and 2 for a mortar solution continuity problem with conforming and non-conforming (HEX8) geometric discretization when using a first order basis for the temperature variable and a first order basis for the Lagrange multiplier.
2.43.42The system shall be able to demonstrate asymptotically correct convergence rates of 2 and 1.5 for a mortar solution continuity problem with conforming and non-conforming (HEX8) geometric discretization when using a first order basis for the temperature variable and a first order dual basis for the Lagrange multiplier.
2.43.43The system shall be able to demonstrate asymptotically correct convergence rates of 3 and 1 for a mortar solution continuity problem with conforming and non-conforming (HEX27) geometric discretization when using a second order basis for the temperature variable and a zeroth order basis for the Lagrange multiplier.
2.43.44The system shall be able to demonstrate asymptotically correct convergence rates of 3 and 2 for a mortar solution continuity problem with conforming and non-conforming (HEX27) geometric discretization when using a second order basis for the temperature variable and a first order basis for the Lagrange multiplier.
2.43.45The system shall be able to demonstrate asymptotically correct convergence rates of 3 and 3 for a mortar solution continuity problem with conforming and non-conforming (HEX27) geometric discretization when using a second order basis for the temperature variable and a second order basis for the Lagrange multiplier.
2.43.46
The system shall be able to perform gap heat transfer to couple conduction equations, on either side of the mortar interface, discretized with the finite volume method with
1. first order accuracy
2. second order accuracy
2.43.47The system shall be able to demonstrate asymptotically correct convergence rates of 3 and 3 for a mortar gap-conductance problem with equal, coarse-secondary, and coarse-primary geometric discretizations when using a second order basis for the temperature variable and a second order basis for the Lagrange multiplier.
2.43.48The system shall be able to demonstrate asymptotically correct convergence rates of 3 and 2 for a mortar gap-conductance problem with equal, coarse-secondary, and coarse-primary geometric discretizations when using a second order basis for the temperature variable and a first order basis for the Lagrange multiplier.
2.43.49The system shall be able to demonstrate asymptotically correct convergence rates of 2 and 1 for a mortar gap-conductance problem with equal, coarse-secondary, and coarse-primary geometric discretizations when using a second order basis for the temperature variable and a zeroth order basis for the Lagrange multiplier.
2.43.50The system shall be able to demonstrate asymptotically correct convergence rates of 2 and 2 for a mortar gap-conductance problem with equal, coarse-secondary, and coarse-primary geometric discretizations when using a first order basis for the temperature variable and a first order basis for the Lagrange multiplier.
2.43.51The system shall be able to demonstrate asymptotically correct convergence rates of 2 and 1 for a mortar gap-conductance problem with equal, coarse-secondary, and coarse-primary geometric discretizations when using a first order basis for the temperature variable and a zeroth order basis for the Lagrange multiplier.
2.43.52The system shall be able to demonstrate asymptotically correct convergence rates of 3 and 3 for a mortar solution continuity problem with an equal geometric discretization when using a second order basis for the temperature variable and a second order basis for the Lagrange multiplier.
2.43.53The system shall be able to demonstrate asymptotically correct convergence rates of 3 and 2 for a mortar solution continuity problem with an equal geometric discretization when using a second order basis for the temperature variable and a first order basis for the Lagrange multiplier.
2.43.54The system shall be able to demonstrate asymptotically correct convergence rates of 2 and 1 for a mortar solution continuity problem with an equal geometric discretization when using a second order basis for the temperature variable and a zeroth order basis for the Lagrange multiplier.
2.43.55The system shall be able to demonstrate asymptotically correct convergence rates of 2 and 2 for a mortar solution continuity problem with an equal geometric discretization when using a first order basis for the temperature variable and a first order basis for the Lagrange multiplier.
2.43.56The system shall be able to demonstrate asymptotically correct convergence rates of 2 and 1 for a mortar solution continuity problem with an equal geometric discretization when using a first order basis for the temperature variable and a zeroth order basis for the Lagrange multiplier.
2.43.57We shall be able to couple variables between boundary auxiliary kernels and mortar constraints.
2.43.58We shall be able to use boundary-restricted material properties in mortar constraints.
2.43.59
We shall be able to do gap conductance on a dynamic mesh using auxiliary displacements, computing the residual and Jacobian
1. separately
2. together
2.43.60
The Jacobian for the dynamic aux displacement gap conductance test case shall be perfect when computing the residual and Jacobian
1. separately
2. together
2.43.61We shall be able to do gap conductance on a dynamic mesh using auxiliary displacements on a fine mesh
2.43.62We shall generate the exact expected analytic solution for the gap conductance problem
2.43.63We shall be able to produce the expected result for a gap conductance test case using the mortar method. Specifically, this test yields lagrange multipliers that are correctly proportional to the delta of temperature across the gap, e.g. the heat flux
2.43.64The Jacobian for the gap conductance test case shall be perfect
2.43.65We shall be able to produce the expected result for a gap conductance test case using the mortar method on a fine mesh. Specifically, this test yields lagrange multipliers that are correctly proportional to the delta of temperature across the gap, e.g. the heat flux
2.43.66The system shall give access to the locations in physical space of mortar segment element quadrature points.
2.43.67The system shall compute an exact Jacobian for a simulation involving the physical space location of mortar quadrature points.
2.43.68We shall be able to enforce periodic boundary conditions on a non-uniform mesh using the mortar method
2.43.69The Jacobian for mortar enforcement of periodic boundary conditions shall be perfect
2.43.70The system shall assemble primary/secondary mortar constraints coupled to scalar variables in a two dimensional problem.
2.43.71The penalty periodic segmental constraint is independent of the designation of primary and secondary surfaces.
2.43.72The system shall assemble lower dimensional variable mortar constraints coupled to scalar variables in a two dimensional problem.
2.43.73The system shall assemble primary/secondary mortar constraints coupled to scalar variables in a three dimensional problem.
2.43.74The system shall assemble lower variable mortar constraints coupled to scalar variables in a three dimensional problem.
2.43.75The system shall allow field split preconditioning with scalar variables and produce the same results as a non-split linear solve.
2.43.76The coupled scalar variable for mortar surfaces can be an auxiliary variable for debugging.
2.43.77Mortar surfaces coupled with scalar variables can handle nonuniform conductivity.
2.43.78Mortar surfaces coupled with scalar variables can handle nonuniform conductivity using Lagrange multipliers.
2.43.79The system shall be able to assemble mortar constraints with multiple distinct coupled scalar variables.
2.43.80The system shall report an error if a nonlinear variable is applied for sigma instead of an auxiliary variable.

framework: Multiapps
2.44.1
The system shall support running a multiapp simulation
1. without using the Application system input block
2. with explicitly specifying application type in the Application system input block.
2.44.2
The system shall return an error
1. when the input application type is not registered in main app
2. when the input application type is not registered in sub app
3. when a command line option is used to set the application type for a child application.
2.44.3The system shall allow use of automatic differentiation and automatic scaling in sub-applications.
2.44.4The system shall support running a transient simulation with sub-applications that can fail and re-execute with smaller timesteps until the execution times for the parent and sub-applications are equivalent.
2.44.5The system shall include the ability to execute a sub-application at the centroid of every element within the finite element mesh.
2.44.6The system shall optionally allow the first sub-app to fully initialize before initializing all the remaining child apps in parallel.
2.44.7The system shall detect input file problems with sub app input files.
2.44.8The system shall CLI argument problems related to sub app input files.
2.44.9The system show error when the number of input files is great than one and doesn't match the number of provided sub app positions.
2.44.10The system show error when the number of input files is great than one and doesn't match the number of provided sub app positions when using CLI overrides.
2.44.11The system shall report an error when the number of sub app input files doesn't match the number of provided positions files.
2.44.12The system shall report an error when both positions are provided in the input file along with a separate file of positions.
2.44.13The system shall report an error when the multiapp positions file is malformed.
2.44.14The system shall report an error when the Multiapp parameter sub_cycling and catch_up are both set to true.
2.44.15The system shall support reading command-line arguments from a file with multiple lines
2.44.16The system shall support reading command-line arguments from a file with a single line
2.44.17The system shall support reading command-line arguments from multiple files
2.44.18The system shall support reading command-line arguments from a file with multiple parameters separated semicolon
2.44.19The system shall not support commandLine arguments from a file and an input at the same time
2.44.20The system shall make sure the number of commandLine argument files either be only one or match the number of input files
2.44.21The system shall provide at least one commandLine argument file when use parameter 'cli_args_files'
2.44.22The system shall not use an empty commandLine argument file
2.44.23The system shall the total number of commandLine argument strings be only one or match the total number of sub apps
2.44.24The system shall the total number of commandLine argument strings from a file be only one or match the total number of positions
2.44.25
The system shall be able to clone the mesh created in parent application into its sub-application(s) for geometries in
1. XY-cartesian coordinates,
2. RZ-cylindrical coordinates, and
3. R-spherical coordinates.
2.44.26The MultiApp system shall include the ability to set command line parameters for each sub application from the input file.
2.44.27The MultiApp system shall include the ability to set common command line parameters for all sub applications from the input file.
2.44.28The MultiApp system shall include the ability to set common command line vector parameters, using double quotes, for all sub applications from the input file.
2.44.29The MultiApp system shall include the ability to set common command line vector parameters, using single quotes, for all sub applications from the input file.
2.44.30The MultiApp system shall include the ability to set command line vector parameters, using double quotes, distributed among all sub applications from the input file.
2.44.31The MultiApp system shall include the ability to set command line vector parameters, using single quotes, distributed among all sub applications from the input file.
2.44.32The MultiApp system shall error when the number of command line arguments supplied in the input file differs from the number if sub apps.
2.44.33The system shall include the ability to halt the execution of sub-applications when steady-state is detected.
2.44.34
The system shall be capable of executing a sub-application from a Steady executioner on
1. initial and
2. final.
2.44.35
The system shall be capable of executing a sub-application from a Eigenvalue executioner on
1. initial and
2. final.
2.44.36
When sub-application solve does not converge, the system shall be able to either
1. abort run,
2. throw error if error_on_dtmin is not set, or
3. continue run.
2.44.37
The system shall be able to use the solution of a coarse mesh as the initial guess for a fine mesh solution for a
1. diffusion problem and a
2. variational inequality problem resulting in a significantly reduced number of nonlinear iterations to solve the fine mesh problem
2.44.38The system shall be able to solve a fine mesh variational inequality problem without grid sequencing but with a lot more nonlinear iterations
2.44.39The system shall report an error if the execution of a sub-application fails during the initial execution.
2.44.40The system shall support creating a Multiapp that is not initially enabled
2.44.41The system shall allow forcibly evaluating general user objects on the initial timestep before applying initial conditions.
2.44.42The system shall be able to keep the auxiliary solution during fixed point iterations.
2.44.43
The system shall support the ability for a sub-application to adaptive modify the time step of the parent application when the sub-application operates at the
1. beginning and
2. end of a timestep.
2.44.44The system shall support limiting the number of processors for sub-applications.
2.44.45
The system shall support the ability to re-position sub-applications at a specified time
1. for single and
2. multi-level sub-applications.
2.44.46
The system shall support the ability to re-position and reset sub-applications at a specified time
1. for single and
2. multi-level sub-applications.
2.44.47
The system shall support evaluating multi-level sub-applications:
1. where the parent application controls the time step for all sub-applications;
2. where the parent application controls the time step via a function for all sub-applications; and
3. where the sub-application controls the time step for the parent application,
2.44.48The system shall support writing screen output from multi-level sub-applications to a file.
2.44.49The system shall be capable of running multiple sub-applications that are defined by input and position file pairs.
2.44.50
The system shall support outputting sub-application data in a specified position
1. for single and
2. multi-level sub-applications.
2.44.51The MultiApp system shall allow overriding the cliArgs function to provide parameters to the subapp programmatically.
2.44.52The system shall support the the ability to set solver options within sub-applications.
2.44.53The system shall allow transient multiapps to use Picard iterations to rerun the time step
2.44.54The system shall support adaptive time stepping for transient multiapps with Picard iterations controlled by tolerances
2.44.55The system shall reject the solve if the maximum number of Picard iterations is reached without converging
2.44.56The system shall allow transient multiapps with Picard iterations controlled by relative tolerances
2.44.57The system shall allow transient multiapps with Picard iterations controlled by absolute tolerances
2.44.58The system shall allow function-defined time stepping for transient multiapps
2.44.59The system shall allow steady-state Picard iteration with multiapps
2.44.60The system shall allow fixed number of Picard iterations
2.44.61The system shall allow steady-state Picard iteration with pseudo-transient multiapps
2.44.62The system shall allow convergence check with user defined postprocessor directly.
2.44.63The system shall allow convergence check with the convergence of a user defined postprocessor.
2.44.64The system shall show the Multiapp coupling convergence history of a user defined postprocessor that is used for convergence check.
2.44.65
The system shall support performing iterative solves of sub-applications that perform additional time steps to maintain time step consistency with the parent application
1. resetting the initial condition for every coupling
2. or re-using the previous solution as the initial condition for subsequent iterations.
2.44.66Multiapps shall be able to be restored when a subapp encounters a solve failure.
2.44.67CSV file writing should remain unaffected when a subapp encounters a solve failure.
2.44.68Multiapps shall be able to cut the parent app time step when any subapp encounters a solve failure.
2.44.69The system should be able to restart from the latest solution
2.44.70The system should be able to check if users provide valid parameter to restart app using the latest solution
2.44.71The system shall support Picard iteration with a FullSolveMultiApp at the root with multiple multiapp levels.
2.44.72The system shall be able to run multiple timesteps of a multi-level multi-app simulation, handling the case when Picard coupling between two levels fails to converge.
2.44.73The system shall be able to uniformly cut the time-step across levels of a multi-app solve, even when there is no Picard coupling between two levels.
2.44.74The system shall support Picard iteration with multiple levels of Multiapps.
2.44.75The system shall support the evaluation of TIMESTEP_BEGIN and TIMESTEP_END norms even when there are not active Multiapps on both of those execute_on times.
2.44.76
The system shall allow multiapp steady-state simulations coupled by a postprocessor transfer using Picard iterations
1. with a steady-state sub-application,
2. and with pseudo-transient sub-applications.
2.44.77
The system shall allow transient multiapp simulations coupled by a postprocessor transfer using Picard iterations
1. with a failed timestep,
2. with adaptive timestepping,
3. with a subapp using a smaller timestep,
4. with the sub-app and the postprocessor transfers executed at the beginning of each time step,
5. with the sub-app executed at the beginning of each time step and postprocessor transfers executed at the end of each timestep,
6. with the sub-app executed at the end of each time step and postprocessor transfers executed at the beginning of each timestep,
7. with the sub-app and the postprocessor transfers executed at the end of each time step.
8. for updating the subapp postprocessor with the sub-app and the variable transfers executed at the beginning of each time step,
9. for updating the subapp postprocessor with the sub-app executed at the beginning of each time step and variable transfers executed at the end of each timestep,
10. for updating the subapp postprocessor with the sub-app executed at the end of each time step and variable transfers executed at the beginning of each timestep,
11. and for updating the subapp postprocessor with the sub-app and the variable transfers executed at the end of each time step.
2.44.78The system shall support performing iterative solves of sub-applications that used smaller time steps than parent application.
2.44.79The system shall support evaluating sub-applications at spatial positions specified in a file.
2.44.80The system shall include the ability to execute a sub-application at the quadrature points on every element within the finite element mesh.
2.44.81The system shall provide an ability to perform iterative solves with sub-applications.
2.44.82The system shall provide an ability to relax solutions with iterative solves with sub-applications.
2.44.83The system shall provide an ability to relax sub-applications solutions along with the parent solution for during iterative solves.
2.44.84The system shall provide an ability to relax solutions of array variables with iterative solves with sub-applications.
2.44.85The system shall report an error if provided relaxation factor that is less than or equal to 0 or greater than or equal to 2.
2.44.86
The system shall support the ability to reset a sub-application at a specified time during the simultation
1. for single and
2. multi-level sub-applications.
2.44.87The system shall support the ability to reset a sub-application at multiple specified times during the simultation
2.44.88The system shall report an error if the reset times specified for a multiapp are not sorted, as this likely indicates a user error in their input
2.44.89
The system shall support simulations that
1. that execute sub-applications, which
2. are capable of being restarted from a previous simulation.
2.44.90
The system shall support simulations that
1. that execute with multi-level sub-applications, which
2. are capable of being restarted from a previous simulation.
2.44.91
The system shall support simulations that
1. that executes sub-applications, which
2. can restart from a previous simulation and project the initial condition from the previous solution to the current, restarted simulation.
2.44.92
The system shall support executing sub-applications in a specified position and/or with the specified frame of reference transformation
1. with a scaled, rotated, translated child application
2. with a scaled, rotated, translated parent application exchanging information with a translated child application
2.44.93
The system shall report an error if
1. both outputting in position and displacing applications are requested at the same time, as displaced apps are already output in position
2. a translation is requested on a spherical or cylindrical coordinate mesh, as this is not expected to be a valid transformation
3. displacing applications and moving applications at a certain time are both requested as this combination of features is not implemented
2.44.94
The system shall allow multiapp simulations coupled by a variable transfer transformed using the Secant method for transient problems
1. with a failed timestep,
2. with adaptive timestepping,
3. coupled with a subapp using a smaller timestep,
4. with the sub-app and the variable transfers executed at the beginning of each time step,
5. with the sub-app executed at the beginning of each time step and variable transfers executed at the end of each timestep,
6. with the sub-app executed at the end of each time step and variable transfers executed at the beginning of each timestep,
7. with the sub-app and the variable transfers executed at the end of each time step.
8. and when updating the subapp variables with the sub-app and the variable transfers executed at the beginning of each time step,
9. for when updating the subapp variables with the sub-app executed at the beginning of each time step and variable transfers executed at the end of each timestep,
10. for updating the subapp variables with the sub-app executed at the end of each time step and variable transfers executed at the beginning of each timestep,
11. and for updating the subapp variables with the sub-app and the variable transfers executed at the end of each time step.
2.44.95
The system shall allow multiapp steady-state simulations coupled by a postprocessor transfer using the secant method
1. with a steady-state sub-application,
2. and with pseudo-transient sub-applications.
2.44.96
The system shall allow transient multiapp simulations coupled by a postprocessor transfer using the secant method
1. with a failed timestep,
2. with adaptive timestepping,
3. with a subapp using a smaller timestep,
4. with the sub-app and the postprocessor transfers executed at the beginning of each time step,
5. with the sub-app executed at the beginning of each time step and postprocessor transfers executed at the end of each timestep,
6. with the sub-app executed at the end of each time step and postprocessor transfers executed at the beginning of each timestep,
7. with the sub-app and the postprocessor transfers executed at the end of each time step.
8. for updating the subapp postprocessor with the sub-app and the variable transfers executed at the beginning of each time step,
9. for updating the subapp postprocessor with the sub-app executed at the beginning of each time step and variable transfers executed at the end of each timestep,
10. for updating the subapp postprocessor with the sub-app executed at the end of each time step and variable transfers executed at the beginning of each timestep,
11. and for updating the subapp postprocessor with the sub-app and the variable transfers executed at the end of each time step.
2.44.97MultiApps shall be properly identified in the PerfGraph
2.44.98The system shall support executing sub-applications that operate with smaller time steps then the parent application that include material properties that are based on previous time steps.
2.44.99
The system shall allow multiapp simulations coupled by a variable transfer transformed using Steffensen's method for transient problems
1. with a failed timestep,
2. with adaptive timestepping,
3. coupled with a subapp using a smaller timestep,
4. with the sub-app and the variable transfers executed at the beginning of each time step,
5. with the sub-app executed at the beginning of each time step and variable transfers executed at the end of each timestep,
6. with the sub-app executed at the end of each time step and variable transfers executed at the beginning of each timestep,
7. with the sub-app and the variable transfers executed at the end of each time step.
8. and when updating the subapp variables with the sub-app and the variable transfers executed at the beginning of each time step,
9. for when updating the subapp variables with the sub-app executed at the beginning of each time step and variable transfers executed at the end of each timestep,
10. for updating the subapp variables with the sub-app executed at the end of each time step and variable transfers executed at the beginning of each timestep,
11. and for updating the subapp variables with the sub-app and the variable transfers executed at the end of each time step.
2.44.100
The system shall allow multiapp steady-state simulations coupled by a postprocessor transfer using Steffensen's method
1. with a steady-state sub-application,
2. and with pseudo-transient sub-applications.
2.44.101
The system shall allow transient multiapp simulations coupled by a postprocessor transfer using Steffensen's method
1. with a failed timestep,
2. with adaptive timestepping,
3. with a subapp using a smaller timestep,
4. with the sub-app and the postprocessor transfers executed at the beginning of each time step,
5. with the sub-app executed at the beginning of each time step and postprocessor transfers executed at the end of each timestep,
6. with the sub-app executed at the end of each time step and postprocessor transfers executed at the beginning of each timestep,
7. with the sub-app and the postprocessor transfers executed at the end of each time step.
8. for updating the subapp postprocessor with the sub-app and the variable transfers executed at the beginning of each time step,
9. for updating the subapp postprocessor with the sub-app executed at the beginning of each time step and variable transfers executed at the end of each timestep,
10. for updating the subapp postprocessor with the sub-app executed at the end of each time step and variable transfers executed at the beginning of each timestep,
11. and for updating the subapp postprocessor with the sub-app and the variable transfers executed at the end of each time step.
2.44.102
The system shall support the execution of sub-applications that operate with smaller time steps then the parent application:
1. with a sub-application that continues to the end time of the parent application and
2. with a sub-application that specifies and completion time prior to the parent application.
2.44.103The system shall support the output of sub-application data that operate with smaller time steps then the parent application.
2.44.104The system shall support the execution of sub-application that operate with adaptive time steps that differ from the parent application.
2.44.105The system shall support sub-cycling with negative times by particularly ensuring that the sub-app does not advance further than the main app.
2.44.106
The system shall support the failure of sub-application that operates with differing time steps than the parent application.
1. The simulation shall continue by reducing the time step and
2. support the failure and the ability to limit the number of processors for the sub-application.
2.44.107The system shall support a time offset between the parent and a subapp when using the Multiapp system.
2.44.108The system shall issue a warning if the parent app and the child app time become de-synchronized, except when using sub-cycling or resetting mechanisms which naturally handle or create desynchronization
2.44.109
The system shall support the execution of sub-applications:
1. with a time step governed by the sub-application and
2. with a time step governed by the parent application.
2.44.110The system shall support negative times by particularly ensuring that the sub-app properly updates its time without sub-cycling.

framework: Nodalkernels
2.45.1
The system shall include ability to include contributions to the residual nodes of a finite element mesh
1. on a single and
2. multiple threads.
2.45.2
The system shall be able to enforce a lower bound on a variable using nodal NCP, nodal application of resultant forces,
1. have no oscillations in the solution, and
2. have a non-singular matrix
2.45.3
The system shall be able to enforce an upper bound on a variable using nodal NCP, nodal application of resultant forces,
1. have no oscillations in the solution, and
2. have a non-singular matrix
2.45.4
The system shall be able to enforce an upper and lower bound on a variable using nodal NCP, nodal application of resultant forces,
1. have no oscillations in the solution, and
2. work with automatic differentiation, and
3. have a non-singular matrix, and
4. be incompataible with algebraic multigrid
2.45.5
The system shall be able to enforce an upper and lower bound on a variable using a variational inequality
1. reduced space active set solver, which
2. is compatible with algebraic multigrid, and
3. a semi-smooth solver, which
4. is also compatible with algebraic multigrid
5. The reduced space active set method shall work with a matrix-free approximation of the Jacobian, and the function evaluations corresponding to the nonlinear residual and the base for finite-differencing shall be equivalent.
2.45.6The system shall show violation of bounds when a non-variational-inequality solver is used
2.45.7The system shall support the use of Crank-Nicolson time integration scheme.
2.45.8The system shall include ability to include contributions to the residual nodes of a finite element mesh using an LU preconditioner.
2.45.9
The system shall include ability to include contributions to the residual nodes of a finite element mesh and compute the correct Jacobian terms for
1. subdomain and
2. boundary restricted terms.
2.45.10The system shall not duplicate computation of kernels on a node that is shared between two subdomains.
2.45.11The system shall support the application of Dirichlet type boundary conditions using the penalty method for nodesets.
2.45.12The system shall apply scaling to residuals and Jacobians for volumetric PDE terms applied at nodes

framework: Outputs
2.46.1The system shall support the ability to append the date to output filenames.
2.46.2
The system shall support outputting of checkpoint files:
1. at a specific interval while only maintaining a specified number of recent files and
2. be capable of restarting a simulation from previously exported data at this interval.
2.46.3
The system shall support outputting of checkpoint files, using a simplified input format:
1. at every timestep while maintaining the most recent two files and
2. be capable of restarting a simulation from the output data.
3. at specified wall time intervals and
4. be capable of restarting a simulation from the wall time checkpoint.
5. with an option to disable wall time checkpoints and
6. not recover.
7. catching invalid values of output-wall-time-interval.
8. at specified wall time intervals smaller than the time required to output a checkpoint
9. ensuring that wall time checkpoints are not written at the subapp level if not explicitly requested.
2.46.4
The system shall support outputting of checkpoint files, using a complete input block:
1. at every timestep while maintaining the most recent two files and
2. be capable of restarting a simulation from the output data.
3. at specified wall time intervals
4. be capable of restarting a simulation from the wall time checkpoint.
5. with an option to disable wall time checkpoints and
6. not recover.
7. catching invalid values of execute_on
2.46.5The system shall be capable of throwing an error when multiple checkpoints are defined
2.46.6The system shall be capable of throwing an error when multiple checkpoints are defined, including the shortcut syntax
2.46.7
The system shall support outputting checkpoint files at the subapp level with checkpoints disabled in the main app:
1. for transient simulations
2. for steady-state simulations
2.46.8The system shall support outputting of simulation data using the ExodusII format using simplified input file syntax.
2.46.9
The system shall by default display data on the console from:
1. the Postprocessor system and
2. the scalar variable system.
2.46.10The system shall output a running list of coupling iteration residual norms during multiapp coupling iterations.
2.46.11The system shall only output the coupling iteration residual TIMESTEP_BEGIN norms when there are no TIMESTEP_END Multiapps.
2.46.12The system shall only output the coupling iteration TIMESTEP_END norms when there are no TIMESTEP_BEGIN Multiapps.
2.46.13The system shall output the coupling iteration residual norm for TIMESTEP_BEGIN and TIMESTEP_END Multiapps when both exist in the simulation.
2.46.14The system shall run a simulation without producing any file-based output.
2.46.15The system shall support outputting table based Postprocessor data.
2.46.16The system shall output Scalar Variables on the console in a table to the screen.
2.46.17The system shall warning when multiple console outputs attempt to write to the screen simultaneously.
2.46.18The system shall support outputting console information to a file.
2.46.19The system shall support outputting head processor console information to a file when run in parallel.
2.46.20The system shall support outputting all processors' console information to separate files when run in parallel with the –keep-cout command line option.
2.46.21The system shall output Scalar Variables on the console in a table to a file.
2.46.22The system shall support outputting Scalar Variables to a file.
2.46.23The system shall support writing the console solve log to an output file.
2.46.24The system shall support writing norms to the console for each nonlinear variable in the simulation.
2.46.25The system shall output a Performance log based on a command line flag.
2.46.26The system shall support writing negative time information in the console.
2.46.27The system shall support outputting the Performance Log at user specified intervals.
2.46.28The system shall support writing time information in DTIME format in the console.
2.46.29The system shall support writing time information in minutes in the console.
2.46.30The system shall support writing time information in hours in the console.
2.46.31The system shall support writing time information in days in the console.
2.46.32The system shall support writing to a buffered console object from every MooseObject-derived object.
2.46.33The system shall support writing to a buffered console object from const methods in MooseObject-derived objects.
2.46.34The system shall support outputting a transformed input file to the screen.
2.46.35The system shall support disabling the linear residual output.
2.46.36The system shall output a Performance Log based on a single input file parameter.
2.46.37The system shall override Performance Log output when conflicting values appear on the command line and input file.
2.46.38The system shall support adding an additional output time option without clobbering existing default options.
2.46.39The system shall output a "final" label at the end of the simulation before additional screen output occurs.
2.46.40The system shall report an error when specifying an invalid table fit width option.
2.46.41The system shall support the output of postprocessors and scalars to CSV files for steady state problems.
2.46.42The system shall support the output of postprocessors and scalars to CSV files for transient propblems.
2.46.43The system shall support the output of postprocessors and scalars to CSV files for transient problems without a time column.
2.46.44The system shall support the output of postprocessors and scalars to Exodus files for transient problems.
2.46.45
The system shall support the output of CSV data:
1. with checkpoint enabled and
2. when restarted creates a new output file or
3. optionally appends the existing file from the first part.
2.46.46The system shall support CSV output aligned columns and a custom delimiter.
2.46.47The system shall support CSV output to the console that is sorted by the variable name.
2.46.48The system shall support CSV output to files on linear iterations, generating unique filenames containing the time step, current nonlinear and linear iteration numbers.
2.46.49The system shall support CSV output to files on nonlinear iterations, generating unique filenames containing the time step and current nonlinear iteration number.
2.46.50The system shall report an error if post-processors and scalar variables have different CSV output frequency.
2.46.51The system shall report an error if post-processors and reporters have different CSV output frequency.
2.46.52The CSV output object shall create a symlink to the final output with a '_FINAL' suffix for VectorPostprocessor data when there are execute flags in addition to FINAL.
2.46.53The CSV output object shall create a symlink to the final output with a '_FINAL' suffix for VectorPostprocessor data when the execute flag is set to FINAL.
2.46.54The CSV output object 'create_final_symlink' parameter shall be able to disable the creation of the final symlink.
2.46.55The CSV output object shall create a symlink to the most recent output with a '_LATEST' suffix for VectorPostprocessor data.
2.46.56The CSV output object 'create_latest_symlink' parameter shall be able to disable the creation of the latest symlink.
2.46.57The system shall include the ability to display variable residual norms.
2.46.58The system shall include debug syntax that includes the ability to enable variable residual norm output.
2.46.59The system shall include the ability to display material property information.
2.46.60The system shall include debug syntax that includes the ability to enable material property information output.
2.46.61The system shall include the ability to display residual information for variables.
2.46.62The system shall include debug syntax that includes the ability to enable variable residual information.
2.46.63The system shall include the ability to display residual information for variables that is limited to non-linear iterations.
2.46.64The system shall include the ability to display residual information for scalar variables.
2.46.65The system shall include debug syntax that includes material property consumption information.
2.46.66The system shall be able to output debug information for functors and objects requesting functors
2.46.67
The system shall include the ability to output the execution order of
1. objects contributing to the residual and Jacobian, notably regular kernels,
2. objects contributing to the residual and Jacobian, notably boundary conditions,
3. elemental dampers,
4. interface kernels,
5. Dirac kernels,
6. discontinuous Galerkin kernels,
7. finite volume flux objects contributing to the residual and Jacobian, notably finite volume flux kernels and flux boundary conditions,
8. finite volume elemental kernels,
9. finite volume interface kernels,
10. finite volume elemental kernels when combining both jacobian and residual computations,
11. linear finite volume elemental kernels,
12. linear finite volume flux kernels,
13. nodal objects contributing to the residual, notably nodal kernels and boundary conditions,
14. nodal dampers,
15. user objects, including postprocessors, executed at the beginning of the simulation,
16. user objects, including postprocessors, executed at the beginning and end of each time step,
17. nodal user objects,
18. domain user objects,
19. general user objects,
20. threaded general user objects,
21. user objects, including postprocessors, executed on transfers between applications,
22. each step of the adaptive refinement process, including side-based indicators,
23. each step of the adaptive refinement process, including element-based indicators,
24. initial conditions of variables,
25. auxiliary kernels intermingled with initial conditions and user objects, and
26. boundary restricted auxiliary kernels.
2.46.68
The system shall include the ability to output block-restriction of objects
1. when requested via debug parameter.
2. when requested as output-block.
2.46.69The system shall be able to output the ~~displaced~~ mesh for a model with adaptive mesh refinement.
2.46.70If the user requested the output of a displaced problem and there is none present, the system shall fallback to using the non-displaced problem.
2.46.71If the user asks for no displaced mesh to be created, even though displacements are provided in the mesh block, the system shall not create a displaced mesh
2.46.72The Output system shall be capable of applying displacements directly to the outputted mesh for steady problems.
2.46.73The Output system shall be capable of applying displacements directly to the outputted mesh for transient problems with Kernels using the displaced configuration.
2.46.74The Output system shall be capable of applying displacements directly to the outputted mesh for transient problems.
2.46.75
The system shall support the ability to output the degree-of-freedom information:
1. to a json file,
2. to the screen,
3. with uniform refinement, and
4. with transient adaptivity.
2.46.76The system shall report an error when two outputs with the same name are created.
2.46.77The system shall report an error when two outputs produce a file with the same name.
2.46.78
The system shall reserve names for output objects:
1. "none" and
2. "all."
2.46.79The system shall support ExodusII output.
2.46.80The system ExodusII output shall not use HDF5 unless requested.
2.46.81The system shall support including the executed input file within the ExodusII output.
2.46.82The system shall support inclusion of initial condition data within the ExodusII output.
2.46.83The system shall support writing non-linear, auxililary, scalar, and postprocessor variables to ExodusII format.
2.46.84The system shall support the exclusion of non-linear, scalar, and postprocessor variables from ExodusII output.
2.46.85The system shall support outputting elemental and scalar variables as nodal variables within ExodusII output.
2.46.86The system shall support outputting discontinuous finite element types with the ExodusII format.
2.46.87The system shall support outputting side-discontinuous edge element data with the ExodusII format.
2.46.88The system shall support outputting side-discontinuous quad element data with the ExodusII format.
2.46.89The system shall support outputting extra element id data defined on the input mesh with the ExodusII format.
2.46.90The system shall support restricting which extra element id data defined on the input mesh are outputted with the ExodusII format.
2.46.91
The system shall report an error if
1. the supplied names for including or excluding variables is invalid.
2. a file base is supplied for a child app when there are multiple instances.
2.46.92The system shall support Nemesis output.
2.46.93The system shall support GMV output.
2.46.94The system shall be able to dump YAML data.
2.46.95The system shall only give Executioner output once.
2.46.96The system shall support Tecplot output.
2.46.97The system shall support Tecplot output given in Tecplot binary format if the Tecplot API is available.
2.46.98The system shall support Tecplot output given in ASCII format if the Tecplot API is not available.
2.46.99The system shall be able to generate gnuplot PostScript output.
2.46.100The system shall be able to generate gnuplot PNG output.
2.46.101The system shall be able to generate gnuplot GIF output.
2.46.102The system shall warn the user if a postprocessor utilizes the "outputs" parameter but postprocessor output is disabled for the console object.
2.46.103The system shall print parameters when the --show-input flag is used on the command line.
2.46.104The system shall support solution history output.
2.46.105The system shall support XDR output.
2.46.106The system shall be able to dump input file syntax in JSON format.
2.46.107The system shall be able to dump input file syntax in JSON format and exclude test object syntax.
2.46.108The system shall be able to dump a subset of JSON formatted syntax.
2.46.109The system shall dump line information along with JSON formatted syntax.
2.46.110The system shall not include RESIDUAL and JACOBIAN template arguments in the JSON syntax format.
2.46.111The system shall be able to dump input file (HIT) syntax.
2.46.112The system shall be able to dump a subset of input file (HIT) syntax.
2.46.113The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check InputChoices
2.46.114The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check ChildAtLeastOne
2.46.115The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check ValEnums
2.46.116The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check active parameter
2.46.117The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check normal_sub
2.46.118The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check type_sub
2.46.119The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check default type
2.46.120The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check MinValInc
2.46.121The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check default types child parameter promotion
2.46.122The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check default subblock_types child parameter promotion
2.46.123The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check Mesh file parameter requirement removal
2.46.124The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check Boolean type ValEnums choices
2.46.125The system shall be able to convert a JsonSyntaxTree into Standard Object Notation (SON) for use by the NEAMS workbench. Check beginning and ending markers
2.46.126The system shall support outputting data to the general mesh viewer format.
2.46.127The system shall support limiting vector postrocessor data to a specific CSV output object.
2.46.128The system shall support the ability to control the output of an aggregate calculation via a parameter of the object itself.
2.46.129The system shall support specifying an output interval for an output input file block.
2.46.130The system shall support specifying an output interval for all outputs.
2.46.131The system shall support limiting output to the final timestep of a simulation.
2.46.132The system shall support output at specific simulation times.
2.46.133The system shall support output at times defined by the function.
2.46.134The system shall support multiple output objects that have different simulation synchronization times specified.
2.46.135The system shall support specifying an minimum time difference between successive outputs.
2.46.136The system shall support the disabling of an output object by restricting the execution settings.
2.46.137The system shall support the ability to limit output objects only at the beginning and end of a simulation.
2.46.138The system shall not output the same information multiple times when an output object is defined to operate on the end of each timestep and the final timestep.
2.46.139The system shall support output during linear and non-linear iterations during transient simulations using the ExodusII format.
2.46.140
The system shall support output during linear and non-linear iterations during steady simulations using the ExodusII format:
1. in a single file or
2. in a sequence of files.
2.46.141The system shall support output during linear and non-linear iterations during transient simulations using the VTK format.
2.46.142The system shall support output during linear and non-linear iterations during transient simulations using the CSV format.
2.46.143
The system shall support output during linear and non-linear iterations during transient simulations:
1. with both the start and end times defined,
2. with only the start time defined,
3. with the start and end timestep provided,
4. with the start timestep given, and
5. with the end timestep provided.
2.46.144The system shall support JSON output for data.
2.46.145
The system shall include the ability to output simulation data in JSON format:
1. that produces multiple files for parallel distributed data and
2. for parallel replicated data in a single file.
2.46.146The system shall support creating unique JSON output files per timestep.
2.46.147The system shall provide an API for retrieving an output object by type and name.
2.46.148The system shall provide an API for retrieving all output objects of a type.
2.46.149The system shall provide an API for retrieving output objects for the given names and type.
2.46.150The system shall provide an API for retrieving all output object names of a type.
2.46.151The system shall support the naming of output files based on the input file block name.
2.46.152The Nemesis Output object shall output separate files per process for visualization purposes.
2.46.153The Nemesis Output object shall support writing elemental variables.
2.46.154The Nemesis Output object shall support writing elemental variables with the same numbering on DistributedMesh.
2.46.155The Nemesis Ouput object shall support writing scalar variables.
2.46.156The Nemesis Ouput object shall support writing scalar variables when using DistributedMesh.
2.46.157The system shall support the ability to specify the output dimension when outputting in ExodusII format.
2.46.158The system shall support the ability to limit output to certain sub-applications based on name.
2.46.159
The system shall include the ability to limit automatic output of adaptivity objects, including
1. indicators and
2. markers.
2.46.160The system shall allow the user to select different console output intervals.
2.46.161The system shall display active output information with corresponding execute flags.
2.46.162
The system shall provide a system for outputting solution variables with a uniformly refined mesh:
1. with a shift in output position,
2. with a custom filename,
3. with mesh adaptivity,
4. with a generated mesh,
5. with a file mesh, and
6. with second order elements from a file mesh.
2.46.163
The system shall include an example demonstrating the use of oversampling.
1. without and
2. with mesh adaptivity.
2.46.164The system shall include the ability to overwrite existing timesteps when writing ExodusII format.
2.46.165
The system shall output a performance log information for sub-applications
1. that are transient,
2. use differing time steps from the main, and
3. execute an entire simulation.
2.46.166The system shall have the ability to output a detailed performance log
2.46.167
The system shall be able to produce png images:
1. for 2D square images,
2. arbitrary shapped domains,
3. and complex shapes with periodic boudary conditions.
2.46.168The system shall support offseting the spatial position of a domain during output.
2.46.169The system shall support the ability to specify the output object for postprocessor data from within the input file block defining the postprocessor.
2.46.170The system shall report an error if an invalid output name is provided within the postprocessor input file block.
2.46.171The system shall support limiting postprocessor output to the screen.
2.46.172The system shall support limiting postprocessor output to from within the input file syntax of an output object.
2.46.173The system shall report an error if a postprocessor variable is listed for suppression and inclusion within an output object block in the input file.
2.46.174
The system shall support limiting the output of comma seperated value data to the final timestep:
1. for all scalar data and
2. for postprocessor data only.
2.46.175The system shall support the ability to output single value aggregate calculations to JSON format.
2.46.176The system shall support printing a progress bar that indicates the fraction of total simulation time passed.
2.46.177The system shall support using a shortcut to set up a progress bar output.
2.46.178Correctly set up initial recover files for the part2 test.
2.46.179A simulation executed using the "–recover" flag successfully runs a simulation using the specified recover file argument.
2.46.180Correctly set up initial recover files for the part2_latest test.
2.46.181A simulation executed using the "–recover" flag with a file argument using the placeholder "LATEST" successfully runs a simulation using most recent checkpoint/recover file from the specified directory.
2.46.182Correctly set up initial recover files for the nemesis part2 test.
2.46.183A simulation executed using the "–recover" flag successfully runs a simulation using most recent checkpoint/recover file from the specified directory and correctly appends to the nemesis output.
2.46.184
The system shall automatically output values to a comma separated (CSV) file in
1. root/replicated mode
2. and distributed mode.
2.46.185The system shall support the ability to output the residual norms of individual nodal variables.
2.46.186The system shall support the ability to output the residual norms of individual elemental variables.
2.46.187The system shall not output linear residuals when requested.
2.46.188The system shall not output non-linear residuals when requested.
2.46.189The system shall support writing file to sub-directories.
2.46.190The system shall allow output to occur at times provided by a times object.
2.46.191The system shall report an error if output is specified to use a times object with changing times.
2.46.192The system shall print the various components of the simulation information header to the screen
2.46.193The system shall print the mesh information to the screen when the mesh changes
2.46.194The system shall print the auxiliary system information to the screen when the mesh changes
2.46.195The system shall print the nonlinear system information to the screen when the mesh changes
2.46.196The system shall support writing ASCII Tecplot output.
2.46.197The system shall support appending Tecplot output files.
2.46.198The system shall optionally support writing binary Tecplot files.
2.46.199
The system shall guarantee that scalar variables are in the proper state for output when outputting:
1. ExodusII format and
2. CSV format.
2.46.200The system shall support outputting field and scalar data to the ExodusII format.
2.46.201The system shall report an error if a variable is marked for output and output suppression.
2.46.202The system shall report an error if a variable is perscribed for output but does not exist.
2.46.203The system shall test that output of an auxiliary field can be disabled within the input block defining the variable.
2.46.204The system shall support a system for including or suppressing output variables the operates when only a single variable for each type exists.
2.46.205The system shall support a system for including or suppressing output variables.
2.46.206The variables specified in an Output object's 'hide = ' list shall not appear in the output file.
2.46.207The system shall support the ability to output vector aggregate calculations to JSON format.
2.46.208
The system shall optionally support output of files using the VTK format:
1. in serial and
2. in parallel.
2.46.209
The system shall support the output of data using native libMesh formats:
1. in XDA (ASCII) format and
2. in XDR (binary) format.
2.46.210The system shall support simultaneous output of the ASCII and binary forms of the libMesh native format.
2.46.211
The system shall support XML output for vector data that is
1. replicated or
2. distributed in parallel.
2.46.212The system shall support XML output for vector data during nonlinear solve.

framework: Parser
2.47.1The system shall support active/inactive parameters to selectively enable/disable subblocks within all input file blocks.
2.47.2The system shall produce an error when the active parameter refers to a non-exiseant block.
2.47.3The system shall produce an error when the inactive parameter refers to a non-existent block.
2.47.4The system shall produce an error when both the active and inactive parameters are present in the same block.
2.47.5The system shall honor the active or inactive parameters at the top (root) level.
2.47.6The system shall support the ability to override input file parameters from the command line.
2.47.7The system shall support the ability to globally change MultiApp input file syntax from the command line.
2.47.8The system shall support the ability to change a whole MultiApp's (multiple SubApps) input file syntax from the command line.
2.47.9The system shall support the ability to change individual SubApp input file syntax from the command line.
2.47.10The system shall produce an error when a SubApp command line override index is not valid.
2.47.11The system shall output all registered objects in HIT format.
2.47.12The system shall output all registered objects in single line format.
2.47.13The system shall report an error if the supplied input file is not formatted correctly.
2.47.14The system shall support including other input files in an input file
2.47.15The system shall be able to read input file syntax and write into map parameters.
2.47.16The system shall report an error if a user supplies an odd number of entries, implying an unbalanced key-value set, to a map parameter.
2.47.17The system shall report an error if a user supplies syntax in a map parameter that cannot be cast to the requested mapped type.
2.47.18
The system shall support for multiple input files, which are merged into one input specification for a simulation
1. where no parameters overlap
2. where input files may override parameters in previous inputs
3. while locating input errors in the correct file
4. and inform the user of parameters from earlier files being overidden by later files
2.47.19The system shall raise an error if no input files were specified after the -i option
2.47.20The system shall support parameter duplication check for multiple input files, which are later merged into one.
2.47.21The system shall support parameter substitution in input files using command line variable expressions.
2.47.22The system shall support parameter substitution in input files using variable expressions from within the same input file.
2.47.23The system shall support unit conversion in input files using variable expressions.
2.47.24The system shall report the unit conversions performed at parse time when running in debug mode.
2.47.25The system shall support reading in jagged double-indexed arrays from the input file using two delimiters for columns and rows respectively.
2.47.26The system shall support reading in jagged triple-indexed arrays from the input file using two delimiters for columns and rows respectively.
2.47.27The system shall support reading in a vector of size-3 vectors.
2.47.28The system shall throw an exception if the given input cannot be parsed into a vector of size-3 vectors.
2.47.29The system shall support vectors of MultiMooseEnums as input parameters.
2.47.30The system shall return a usage message when the vector of MultiMooseEnums includes an empty entry.
2.47.31The system shall return an error message when an invalid entry is supplied in a vector of MultiMooseEnums.
2.47.32
The system shall support vector size checking on input parameter vectors:
1. for ints,
2. for Reals.
2.47.33
The system shall support vector element checking:
1. against constant expressions,
2. against other unsigned int vector elements,
3. against other long vector elements,
4. against other int vector elements, and
5. against other Real vector elements.
2.47.34The system shall support vector bounds checking on input parameter vectors.
2.47.35The system shall support checking for non-empty input parameter vectors.

framework: Partitioners
2.48.1
The system shall support a block-weighted partitioner
1. when using ReplicatedMesh
2. and when using DistributedMesh.
2.48.2
The block-weighted partitioner shall report a reasonable error when
1. the input blocks do not match the size of the input weights
2. an input block is not found in the mesh
2.48.3The system shall allow custom partitioners to work with mesh generators
2.48.4The system shall allow skipping partitioning after loading a mesh
2.48.5The system shall provide a simple regular grid-based partitioner
2.48.6The system shall have the ability to do hierarchical partitioning based on a regular grid.
2.48.7Make MOOSE support ptscotch via PETSc
2.48.8ptscotch shall support element-weighted graphs for balancing workload
2.48.9ptscotch shall support side-weighted graphs for minimizing communication
2.48.10ptscotch shall take both side weights and element weights into consideration
2.48.11Make MOOSE support parmetis via PETSc
2.48.12Parmetis shall support element-weighted graphs for balancing workload
2.48.13Parmetis shall support side-weighted graphs for minimizing communication
2.48.14Parmetis shall take side weights and element weights into consideration
2.48.15Parmetis shall support presplit
2.48.16The system shall support a serial partitioner Chaco
2.48.17The system shall support a serial partitioner party
2.48.18The system shall provide a random partitioner
2.48.19The system shall allow restricting apps to just one MPI rank
2.48.20The system shall report an error if an out of range rank is given to SingleRankPartitioner

framework: Phi Zero
2.50.1The system shall be able to construct zero objects for shape functions and shape function gradients consistent with the maximum number ofshape functions and quadrature points in the simulation.
2.50.2The system shall be able to construct zero objects for shape functions and shape function gradients consistent with the maximum number ofshape functions and quadrature points in the simulation. This test checks the size of zero objects when using second-order elements and second order-variables.

framework: Physics
2.51.1The system shall error if the physics is specified as a transient, when the executioner is designed for steady solves.
2.51.2The system shall be able to solve a source-less diffusion equation with a continuous Galerkin discretization with a shorthand syntax.
2.51.3The system shall be able to solve a source-less diffusion equation with a continuous Galerkin discretization with automatic differentiation with a shorthand syntax.
2.51.4The system shall be able to solve a source-less diffusion equation with a cell-centered finite volume discretization with a shorthand syntax.

framework: Positions
2.52.1The system shall be able to create multiapps from positions objects.
2.52.2The system shall be able to create multiapps from positions objects using their initial positions.
2.52.3
The system shall report an error if
1. the positions objects to use for creating multiapps are not initialized, or
2. the size of the current positions does not match the number of initial positions.
2.52.4
The system shall be able to load positions from
1. a parameter in the input file,
2. a text file,
3. element centroids from a mesh, with or without block restriction,
4. default element quadrature points from a mesh, with or without block restriction,
5. centroids of groups of elements in the mesh,
6. a reporter with data in the expected vector of points format,
7. triplets on functors that are evaluated to obtain positions,
8. one or more multiapp positions,
9. and one or more multiapp mesh centroids.
2.52.5
The system shall be able to perform
1. simple linear operations such as scaling, translation and rotation to positions, and
2. a distribution, through translations, of positions from one set of positions onto another.

framework: Postprocessors
2.53.1The AreaPostprocessor shall compute the "area" or dimension - 1 "volume" of sides.
2.53.2
The system shall be able to compute volume-weighted norms of the difference of a variable between nonlinear iterations and time steps
1. for a steady executioner.
2. for a transient executioner.
2.53.3
The system shall compute the average value of a field variable over time
1. at the end of a time step and
2. and at the beginning of the time step.
2.53.4The system shall compute the average value of a quantity along the axis of rotation in an axisymmetric coordinate system.
2.53.5
The system shall support calculating the value change overFixedPoint
1. with respect to the previous calculation and
2. with respect to the initial calculation.
2.53.6
The system shall issue an error when the dependent "change ofFixedPoint" calculation
1. "with respect to initial" isn't calculated at the initial step and
2. "with respect to previous" isn't calculated at the previous step.
2.53.7
The system shall support calculating the value change over time
1. with respect to the previous calculation and
2. with respect to the initial calculation.
2.53.8
The system shall issue an error when the dependent "change of time" calculation
1. "with respect to initial" isn't calculated at the initial step and
2. "with respect to previous" isn't calculated at the previous step.
2.53.9The system shall allow the value of a postprocessor to be controllable.
2.53.10The system shall allow for the retrieval of raw elemental degree-of-freedom values directly for elemental evaluations.
2.53.11The system shall have the ability to accumulate a scalar value over time.
2.53.12
The system shall the substitution of a constant value in place of an optional Postprocessor coupling value
1. when that value is supplied as a default in the coupling declaration
2. or when that value is supplied in the input file.
2.53.13The system shall support computing the difference between two scalar Postprocessor values.
2.53.14The system shall execute dependent Postprocessors first when computing the difference between two Postprocessors.
2.53.15
The system shall support running Postprocessors on the the mesh containing displacements:
1. elemental and
2. side.
2.53.16The system shall compute the the average value of a non-AD material property over the domain.
2.53.17The system shall compute the the average value of an AD material property over the domain.
2.53.18
The system shall contain a "Postprocessor" that computes the average value of a variable
1. one a single block and
2. on multiple blocks.
2.53.19The system shall compute the extreme (min/max) values of a functor evaluated at each element over the domain.
2.53.20The system shall compute the value of a functor at the element where a proxy functor reaches the extreme (max/min) value over the domain.
2.53.21The system shall compute the the extreme (min/max) values of a non-AD material property over the domain.
2.53.22The system shall compute the the extreme (min/max) values of an AD material property over the domain.
2.53.23The system shall compute the extreme (min/max) values of an elemental field variable over the domain.
2.53.24The system shall compute the value of a variable at the point where a proxy variable reaches the extreme (max/min) value over the domain.
2.53.25The system shall compute the H1-seminorm between a field variable and a analytical function.
2.53.26The system shall compute the element integral of a functor
2.53.27
The system shall compute the element integral of a variable
1. over the whole domain, and
2. over a subset of the domain,
3. and also optionally, using the absolute variable value.
2.53.28The system shall compute the average integral quantity over an element of a scalar material property.
2.53.29
The system shall support computing the integral of a variable quantity over the domain on the mesh
1. during the initial setup step
2. and at the end of each time step, for FE variables
3. and FV variables.
2.53.30The system shall compute the L1 error between an elemental field variable and an analytical function.
2.53.31The system shall compute the element-wise L2 difference between two field variables.
2.53.32The system shall compute the L2-error (Euclidean) between a field variable and a analytical function.
2.53.33The system shall compute the volumetric L2 norm of a variable over the mesh.
2.53.34The system shall compute the average time derivative of a solution value computed per element in 2D.
2.53.35The system shall compute the average time derivative of a solution value computed per element in 1D.
2.53.36The system shall support sampling a specific quantity integrated over a single element.
2.53.37The system shall support sampling a specific quantity integrated over a single element with finite volume variables.
2.53.38The system shall compute the Vector L2 Error of three scalar variables simultaneously as three orthogonal components of a vector.
2.53.39Postprocessor objects shall be able to execute and output after the simulation is complete.
2.53.40The system shall support an attribute (scalar value) reporter through the "Execution" system.
2.53.41The system shall be capable of find a value on a monotonically changing line.
2.53.42The system shall report and error when the target value is lower than one of the sampled endpoints.
2.53.43The system shall report and error when the target value is greater than one of the sampled endpoints.
2.53.44The system shall return the default flag value when the target value is lower than one of the sampled endpoints and error_if_not_found is false.
2.53.45The system shall return the default flag value when the target value is greater than one of the sampled endpoints and error_if_not_found is false.
2.53.46The system shall return user specified flag value when the target value is lower than one of the sampled endpoints and error_if_not_found is false.
2.53.47The system shall return user specified flag value when the target value is greater than one of the sampled endpoints and error_if_not_found is false.
2.53.48The system shall report and error when the sampling line extends beyond the mesh bounding box.
2.53.49The system shall report and error when the line sampling algorithm fails to converge within the desired depth.
2.53.50The system shall be able to average functions over volume.
2.53.51The system shall integrate functions over volume.
2.53.52The system shall be able to average functions over a boundary.
2.53.53The system shall compute the integral of a function over a boundary.
2.53.54The system shall support evaluating a function of space and time at a single point as a Postprocessor value.
2.53.55The system shall support evaluating a function of space and time with values provided by postprocessors.
2.53.56The system shall be able to integrate the contributions from finite volume flux boundary conditions on sidesets.
2.53.57
The system shall throw an error message
1. when the user inputs a boundary condition with the wrong type to SideFVFluxBCIntegral postprocessor.
2.53.58The system shall be able to correctly compute the volume of blocks and the area of sidesets in 3D.
2.53.59The system shall be able to correctly compute the area of blocks and the perimeterof sidesets in 2D and appropriately handle boundary conditions applied to sidesetscreated with respect to different bodies.
2.53.60
The system shall be able to compute the integral of the diffusive flux at an interface
1. with finite element variables,
2. and with finite volume variables.
3. with finite volume variables and harmonic interpolation for the diffusion coefficient.
2.53.61
The system shall be able to compute the average diffusive flux at an interface
1. with finite element variables,
2. and with finite volume variables.
2.53.62Testing the implementation of the InterfaceAverageVariableValuePostprocessor By design at the end of the first step we should observe: an average material property of 7, an average material property absolute jump to 6,a signed material property jump (primary minus secondary) of 6, a signed material propertyjump (secondary minus primary) of -6, a material property value on the primary side of 10, a material property value on the primary side of 4
2.53.63Testing the implementation of the InterfaceIntegralVariableValuePostprocessor By design at the end of the first step we should observe: an integral material property of 21, an integral material property absolute jump to 18,a signed integral material property jump (primary minus secondary) of 18, a signed integral material propertyjump (secondary minus primary) of -18, a material integral property value on the primary side of 30, a material integral property value on the primary side of 12
2.53.64Testing the implementation of the InterfaceAverageVariableValuePostprocessor for finite volume variables.By design at the end of the first step we should observe: an average material property of 7, an average material property absolute jump to 6,a signed material property jump (primary minus secondary) of 6, a signed material propertyjump (secondary minus primary) of -6, a material property value on the primary side of 10, a material property value on the primary side of 4
2.53.65Testing the implementation of the InterfaceIntegralVariableValuePostprocessor for finite volume variables.By design at the end of the first step we should observe: an integral material property of 21, an integral material property absolute jump to 18,a signed integral material property jump (primary minus secondary) of 18, a signed integral material propertyjump (secondary minus primary) of -18, a material integral property value on the primary side of 30, a material integral property value on the primary side of 12
2.53.66The system shall support computing the integral of a variable quantity over internal sides on the mesh.
2.53.67The system shall support computing the integral of a finite volume variable quantity over internal sides on the mesh.
2.53.68The system shall support retrieving solution values from neighboring elements for use in internal side calculations.
2.53.69The system shall support the ability to compute a linear combination of scalar values (Postprocessors).
2.53.70The system shall allow a mix of postprocessor names and real numbers to be provided to PostprocessorName parameters.
2.53.71The system shall provide a postprocessor to measure physical and virtual memory usage and the major page fault count, depending on the operating system's ability to make those values available
2.53.72The system shall provide a vectorpostprocessor to, on each rank, measure physical and virtual memory usage, major page fault count, and total available ram available, depending on the operating system's ability to make those values available
2.53.73The system shall verify calculations using the method of manufactured solutions using a higher order polynomial function for linear elements.
2.53.74
The system shall verify calculations using the method of manufactured solutions using sine functions for linear elements:
1. on a 3D mesh
2. verified with an analytical 3D solution and
3. on a 2D mesh
4. verified with an analytical 2D solution.
2.53.75The system shall verify calculations using the method of manufactured solutions using a functional form of an equation outside of the shape function space.
2.53.76The system shall have the capability to compute the nearest node number to a given point.
2.53.77The system shall have the capability to compute the nearest node number to a given point, and will choose the smallest node number if more than one node is equidistant.
2.53.78The system shall have the capability to compute the nearest node number to a given point, including when the mesh is adapting
2.53.79The system shall compute the extreme (min/max) values of a nodal field variable over the domain.
2.53.80The system shall compute the value of a variable at the point at which a proxy variable reaches the extreme (min/max) value.
2.53.81
The system shall compute the maximum value of a field variable by sampling nodes
1. over the whole domain and
2. within a subdomain.
2.53.82
The system shall compute the sum of nodal values of a variable
1. on the whole domain,
2. on a subset of the domain, and
3. on multiple overlapping blocks visiting some nodes multiple times.
2.53.83
The system shall report the value of a variable at a specified node
1. for auxiliary variables and
2. for primary (nonlinear) variables.
2.53.84
The system shall support selecting the output for a single Postprocessor
1. to a file and
2. to the console.
2.53.85The system shall be capable of running multiple adaptivity cycles in a single solve step.
2.53.86They system shall be capable of toggling adaptivity at the start of the simulation.
2.53.87They system shall be capable of toggling adaptivity during the simulation.
2.53.88The NumDOFs Postprocessor shall report the number of degrees of freedom (DOFS) from one or more equations systems in the simulation.
2.53.89The NumElements Postprocessor shall report the number of elements (active or total) in the simulation.
2.53.90The NumElements Postprocessor shall report the number of elements (active or total) in the simulation when using distributed (pre-split) mesh.
2.53.91
The system shall count the number of failed timesteps when prompted
1. with the single time stepper,
2. with a composition time stepper.
2.53.92
The system shall support time integration schemes that compute a consistent number of nonlinear and linear iterations for
1. four stage, A-stable DIRK;
2. explicit Euler;
3. lumped explicit Euler;
4. lumped and preconditioned explicit Euler;
5. second-order backward difference;
6. Crank-Nicloson;
7. quasi explicit Euler;
8. explicit midpoint;
9. two-stage TVD Runge-Kutta;
10. Heun;
11. implicit Euler;
12. implicit midpoint;
13. two-stage, L-stable DIRK;
14. three stage, L-stable DIRK;
15. four stage, L-stable DIRK;
16. and Ralston methods.
2.53.93The NumNodes Postprocessor shall report the number of nodes (replicated or distributed) in the simulation.
2.53.94The NumNodes Postprocessor shall report the number of nodes in the simulation when using distributed (pre-split) mesh.
2.53.95The system shall be capable of outputting the number of Residual evaluations
2.53.96The NumVars Postprocessor shall report the number of variables from one or more equation systems in the simulation.
2.53.97
The system shall support the ability to retrieve previously computed Postprocessor values within a Postprocessor calculation:
1. old (one timestep back) and
2. older (two timesteps back).
2.53.98The VectorPostprocessor system shall provide a mechanism to retrieve references to old vectors.
2.53.99The VectorPostprocessor system shall provide a mechanism to retrieve references to old vectors while maintaining vector history.
2.53.100The system shall be able to compute a postprocessor based on a parsed expression of other postprocessors.
2.53.101The system shall have the abililty to pull information from the PerfGraph into a Postprocessor
2.53.102The system shall report a reasonable error when trying to obtain information from the PerfGraph for a section that does not exist
2.53.103The system shall support the ability to sample a field variable value anywhere within the domain.
2.53.104The system shall report an error when a field variable sample location is outside of the domain.
2.53.105
The system shall include the ability to compare post-processor data and return a boolean value for
1. greater than operator and the
2. less than operator.
2.53.106The system shall support evaluating Postprocessors (UserObjects) in the following order: Elemental, Side, Internal Side, Nodal, and General.
2.53.107
The system shall support outputting the scalar Postprocessor values at specific intervals
1. to a file and
2. to the console.
2.53.108The system shall support outputting the scalar Postprocessor values to multiple locations with different intervals.
2.53.109The system shall have the ability to output performance data to a file.
2.53.110The system shall calculate performance time when the data is only used by a Postprocessor.
2.53.111The system shall calculate performance time even when the performance graph isn't printed to any output format.
2.53.112The system shall be able to use the SER method to compute its next time step.
2.53.113The system shall be able to use the RDM method to compute its next time step.
2.53.114The system shall be able to use the EXP method to compute its next time step.
2.53.115
The system shall compute parallel-agnostic random numbers in the Postprocessor system
1. when running a complete simulation, or
2. when running the first half of the simulation and
3. running the second half of the simulation with recovery and receiving the same values.
2.53.116The system shall support the ability to report an input parameter on the screen or to an input file.
2.53.117
The system shall report an error when a requested parameter for reporting does not exist
1. with a wildcard in the name and
2. a complete name/
2.53.118
The system shall support the ability to report a scalar value set by arbitrary objects in the simulation
1. with an initial default value and
2. with a default previous (older) value.
2.53.119
The system shall support computing the relative difference between two scalar values (Postprocessors)
1. when values are non-zero, and
2. when values are approximately zero.
2.53.120The system shall be capable of computing the relative norm of the solution difference between two consecutive time steps.
2.53.121The system shall be able to report the nonlinear residual norm at each nonlinear iteration.
2.53.122The system shall support coupling in a scalar variable to the Postprocessing system for calculating values.
2.53.123The system shall support reporting scalar variables as Postprocessor (scalar output) values.
2.53.124The system shall support the scaling of a post processor quantity by another post processor quantity.
2.53.125
The system shall be able to output the integral of a component of an advective flux vector for problems
1. with continous finite element variable and
2. with finite volume variable
3. error out for discontinous finite element family.
2.53.126The system shall compute the area-weighted average of the integral of a variable over a side.
2.53.127
The system shall support computing the average of a material property over a side on the mesh.
1. if the material property is of Real type
2. if the material property is of RealVectorValue type
3. if the material property is of std::vector<Real> type
4. if the material property is of RankTwoTensor type
5. if the material property is of RankThreeTensor type
6. if the material property is of RankFourTensor type
7. And shall error out if the index components do not match the dimension of the supplied property
2.53.128The system shall compute the area-weighted average of the integral of a functor over a side.
2.53.129The system shall be capable of computing the average diffusive flux through a specified boundary on the mesh.
2.53.130The system shall be capable of computing the average of the diffusive flux integral of a finite volume variable through a specified boundary on the mesh.
2.53.131
The system shall be capable of computing the integral of the diffusive flux through a specified boundary on the mesh
1. with a scalar diffusivity,
2. with an anisotropic vector diffusivity.
2.53.132
The system shall be capable of computing the integral of the diffusive flux integral of a finite volume variable through a specified boundary on the mesh
1. with a scalar diffusivity,
2. with a vector diffusivity.
2.53.133The system shall yield equivalent results when vector material properties are computed with pre-initialized data or computed on-the-fly.
2.53.134The system shall be able to postprocess results from a linear finite volume solver and produce accurate aggregate fluxes and values and auxiliary fields.
2.53.135
The system shall compute the extreme (min/max) values over a side
1. for a nonlinear variable.
2. for a nonlinear variable using a proxy variable.
3. for a aux nodal variable.
4. for a aux elemental variable.
2.53.136The system shall support computing the integral of a variable quantity over a side on the mesh.
2.53.137The system shall support computing the integral of a finite volume variable quantity over a side on the mesh.
2.53.138
The system shall support computing the integral of a material property over a side on the mesh.
1. if the material property is of Real type
2. if the material property is of RealVectorValue type
3. if the material property is of RankTwoTensor type
4. And shall error out if the index components do not match the dimension of the supplied property
2.53.139
The system shall
1. support computing the integral of a functor over one or more sides on the mesh.
2. support computing the integral of a functor over a functor domain boundary inside a mesh.
3. support computing the integral of a functor over one or more evenly refined sides on the mesh.
4. support computing the integral of a functor using quadrature points instead of side faces
5. report an error if face info integration is chosen to compute the integral of a functor when there is no face info in the mesh.
2.53.140The system shall compute an aggregate scalar quantity when applied along multiple boundaries.
2.53.141The TableOutput object shall allow the user to override tolerance checks when determining whether new rows should be added (independent variable delta)
2.53.142The system shall have the ability to record a minimum or maximum value of a field variable over time.
2.53.143The system shall have the ability to return the time at which a minimum or maximum value of a field variable over time occurred.
2.53.144The system shall include the ability to compute the inner product of two variables.
2.53.145The system shall compute the difference between the test and trial functions (Residual) for a specified variable.
2.53.146
Vector post-processor values shall be able to be compared and return a boolean value for
1. greater than or equal,
2. greater than,
3. less than, or
4. equal.
2.53.147The system shall provide a Postprocessor that returns a single specified component of a VectorPostprocessor
2.53.148The Postprocessor that returns a single specified component of a VectorPostprocessor shall generate an error if the requested component is out of the range of the vector
2.53.149The system shall provide a Postprocessor that performs min, max, sum, and average operation on a VectorPostprocessor
2.53.150The system shall have the capability of computing the volume of the mesh domain.

framework: Preconditioners
2.54.1The system shall support the disabling of an automatically created preconditioning object when performing a Newton solve.
2.54.2The system shall automatically create the correct preconditioning object when performing a Newton solve.
2.54.3The system shall output the PETSc preconditioner type requested in the executioner options.
2.54.4The system shall produce a perfect coloring for the Jacobian when using the finite difference preconditioner.
2.54.5The system shall produce a perfect Jacobian when using the stadard finite difference preconditioner.
2.54.6The system shall detect missing off-diagonal Jacobian entries when using a full finite different preconditioner.
2.54.7
The system shall support the use of field split preconditioner on
1. a single subdomain and
2. multiple subdomains.
3. vector variables
4. array variables
2.54.8The system shall report an error if a user has forgotten a variable in their field splits.
2.54.9The system shall support nested field splits.
2.54.10The system shall error if there is an inconsistent covering of degrees of freedom in a nested field split.
2.54.11The system shall be able to selectively remove degrees of freedom from a field spit by variable by boundary.
2.54.12The system shall support the use of HMG (high performance MG)
2.54.13The system shall support the use of HMG (high performance MG) for 3D problems
2.54.14The system shall support the use of strumpack (sparse direct solver) for 3D problems
2.54.15The system shall support the ability to use multiple cycles within hypre during preconditioning with PETSc.
2.54.16
The system shall support the use of a physics based preconditioner
1. without and
2. with mesh adaptivity.
2.54.17The system shall support the ability to add arbitrary options to the solver when using a physics based precondioner.
2.54.18The system shall support the ability to control the variable solve order when using a physics base preconditioner.
2.54.19The system shall support the ability to use the conjugate gradient method for preconditioning with PETSc.
2.54.20Convergence matches previous version of MOOSE without the preconditioner reuse system
2.54.21Preconditioner is reused until the linear iterations exceed the value of reuse_preconditioner_max_its upon which the system recalculates the preconditioner
2.54.22A new preconditioner is formed if the system of equations changes for example here through mesh refinement
2.54.23
The system shall support the use of a single matrix preconditioner
1. without and
2. with mesh adaptivity.
2.54.24The system shall support the ability to group variables when using a single matrix preconditioner.
2.54.25The system shall converge when using the VCP interface with AMG as the preconditioner.
2.54.26The system shall converge while computing the full inverse of the coupling matrix.
2.54.27The system shall converge while using LU as the solver.

framework: Predictors
2.55.1The system shall include a means for predicting future solution based on previous solutions.
2.55.2The system shall include a means for predicting future solution based on previous solutions and print the scale factor to the output stream.
2.55.3
The system shall support the ability to skip performing solution predictions
1. using solution times or
2. previous solution times.
2.55.4The system shall support the ability to skip a prediction after a failed time step
2.55.5The system shall support the ability to output pre-SMO residual
2.55.6The system shall support the ability to use the Execitioner timestep tolerance to determine if a prediction should be peformed.

framework: Problems
2.56.1The system shall allow the creation of a custom problem through a user-defined Action.
2.56.2The system shall support the creation of a custom problem with parameters in Problem block.
2.56.3The system shall report an error when Problem block type is not specified.
2.56.4The system shall support the creation of a custom problem through Problem block with type specified.
2.56.5The system shall support the ability to extend the basic "Problem" interface.
2.56.6The system shall have a capability to dump the equivalent input file syntax for all objects added by a given action.
2.56.7The system shall have a capability to dump the equivalent input file syntax for all objects created by the problem.
2.56.8
The system shall include the support for Eigen value calculations that utilize
1. an array of residual contributions;
2. multiple variables; and
3. multiple variables with Eigen values include in preconditioning matrix.
2.56.9Eigenvalue system should support standard eigenvalue problems
2.56.10Eigenvalue system should support generalized eigenvalue problems
2.56.11Eigenvalue system should support IntegratedBC
2.56.12Eigenvalue system should not allow users to use inhomogeneous nodal boundary conditions
2.56.13Eigenvalue system should use homogeneous boundary conditions only
2.56.14Eigenvalue system requires SLEPc installed
2.56.15Eigenvalue system should be able to solve a nonlinear eigenvalue problem
2.56.16Eigenvalue system should be able to solve a nonlinear eigenvalue problem using Newton
2.56.17The system shall be able to solve nonlinear eigenvalue problems with hanging node constraints.
2.56.18Eigenvalue system should be able to solve a deficient eigenvalue problem
2.56.19Eigenvalue system should be able to compute a nonlinear eigenvalue problem
2.56.20Eigenvalue system should be able to compute a coupled nonlinear eigenvalue problem
2.56.21Eigenvalue system should be able to handle scalar kernels
2.56.22Eigenvalue system should be able to handle DG kernels
2.56.23Eigenvalue system shall support Picard iteration using eigenvalue executioner as a parent.
2.56.24Eigenvalue system shall support Picard iteration using eigenvalue executioner as a parent and output eigen vectors as an exodus file.
2.56.25Eigenvalue system shall support Picard iteration using eigenvalue executioner as a sub app.
2.56.26Eigenvalue system shall support Picard iteration using eigenvalue executioner as a sub app and output eigen vectors as an exodus file.
2.56.27Eigenvalue system should be able scale eigenvector such that postprocessor is a certain value
2.56.28The system shall be able to automatically condition a nonlinear eigen-solve based on diagonal entries in the preconditioning matrix.
2.56.29The system shall be able to automatically scale a nonlinear eigen-solve based on entries in the non-eigen residual vector.
2.56.30The system shall error if a user requests a standard eigenvalue solve when there are objects marked to contribute to the Bx vector or B matrix.
2.56.31The system shall provide an initial guess to Newton if users request.
2.56.32The system shall support eigenvalue execution without free power iterations.
2.56.33The system shall provide an option to output the eigenvalue as its inverse.
2.56.34The system shall provide an option to output the eigenvalue on screen as its inverse.
2.56.35The system shall support extra power iterations.
2.56.36The system shall support extra power iterations and check eigenvalue.
2.56.37The system shall support eigenvalue calculations with an initial condition including the initial solution vector and the initial eigenvalue.
2.56.38The system shall support eigenvalue calculations with an initial condition set by restarting a checkpoint file.
2.56.39The system shall support use of matrix-vector multiplication as residual evaluation for eigenvalue calculations
2.56.40The system shall support use of matrix-vector multiplication as residual evaluation for eigenvalue calculations when hanging nodes (constraints) are present.
2.56.41The system shall support evaluation of auxiliary variables on linear with the matrix-only eigenvalue solve type
2.56.42The system shall support use of matrix-vector multiplication as residual evaluation for eigenvalue calculations with constant matrices
2.56.43The system shall support compatibility of solve type and constant-matrices flag
2.56.44The system shall support use of matrix-vector multiplication as residual evaluation for coupled eigenvalue problems
2.56.45The system shall support use of matrix-vector multiplication with full-coupled matrices (by default) as residual evaluation for coupled eigenvalue problems
2.56.46The system shall support use of matrix-vector multiplication as residual evaluation for non-homogeneous problems
2.56.47Eigen solver should work with a physics-based preconditioner
2.56.48The system shall support a physics-based preconditioner with using JFNK
2.56.49Eigen solver should work with a physics-based preconditioner with a shell preconditioning matrix
2.56.50Eigen solver should work with a physics-based preconditioner with a PETSc shell matrix
2.56.51Eigen solver should work with a physics-based preconditioner with including eigen kernels in the preconditioning matrix
2.56.52The system shall support an code coupling interface that can trigger external solves.
2.56.53The system shall support an code coupling interface that can trigger external solves for transient simulations.
2.56.54
The system shall be able to update the ghosted auxiliary solution from an externally defined problem such that there will be up-to-date solution values in objects like
1. auxiliary kernels
2. postprocessors
2.56.55The system shall support different coordinate systems on different subdomains within the mesh.
2.56.56The system shall support the ability to disable the check for PDE operators in all or some parts of the domain.
2.56.57The system shall support the ability to limit the check for active kernels to only some parts of the domain.
2.56.58The system shall support the ability to disable the check for active kernels in some parts of the domain.
2.56.59The system shall support the ability to disable the check for active materials in all parts of the domain.
2.56.60The system shall support the ability to enable the check for active materials only in some parts of the domain.
2.56.61The system shall support the ability to disable the check for active materials in some parts of the domain.
2.56.62The system shall support the ability to disable the check for the existence of all dependent properties within a domain.
2.56.63The system shall have the ability to disable the actual nonlinear system solve in a simulation.
2.56.64The system shall inform the user when the nonlinear-eigen system solve failed.
2.56.65The system shall have the ability to disable the nonlinear-eigen system solve in a simulation.
2.56.66The system shall have the ability to base convergence on the comparison of individual variables to reference quantities of those variables.
2.56.67The system shall fail to find a converged solution when basing convergence on individual variable reference quantities with poor scaling.
2.56.68The system shall have the ability to automatically scale a originally poorly scaled problem and achieve convergence based on individual reference quantities
2.56.69The system shall have the ability to base system convergence on the convergence of a subset of variables.
2.56.70The system shall require all grouped variables to be included in the convergence check.
2.56.71The system shall support wildcards for choosing the variables to base convergence on.
2.56.72The system shall have the ability to base convergence on the comparison of L2 normalization of the residual for individual variables to the sum of the L2 normalization of the absolute value of the residual contributions of those variables.
2.56.73The system shall have the ability to base convergence on the comparison of L2 normalization of the residual for individual variables to the sum of the L2 normalization of the absolute value of the residual contributions of those variables using an acceptable tolerance past a given number of nonlinear iterations.
2.56.74The system shall have the ability to base convergence on the comparison of L2 normalization of the residual for individual variables locally divided by the absolute value of the residual contributions of those variables.
2.56.75The system shall have the ability to base convergence on the comparison of Linf normalization of the residual for individual variables locally divided by the absolute value of the residual contributions of those variables.
2.56.76The system shall have the ability to base convergence on the comparison of Linf normalization of the residual for individual variables to the sum of the Linf normalization of the absolute value of the residual contributions of those variables.
2.56.77The system shall have the ability to base convergence on the comparison of L2 normalization of the residual for individual variables to the sum of the L2 normalization of the absolute value of the residual contributions of those variables using AD.
2.56.78The system shall have the ability to default to the traditional convergence checks if no reference vector is provided in ReferenceResidualProblem.
2.56.79The system shall treat convergence with a zero reference residual value as requiring zero residual value for convergence.
2.56.80The system shall treat convergence with a zero reference residual value as converged if the residual is below the relative tolerance.
2.56.81
When using ReferenceResidualProblem the system shall throw an error
1. if the reference tag is not a residual vector tag.
2. if the reference tag does not exist.
3. if the reference vector is not provided when using local normalization.
4. if the reference vector is provided is not a residual vector tag.
2.56.82The system shall be able to output to console which object it is creating.

framework: Quadrature
2.57.1The system shall support the use of Gauss-Lobatto quadrature for numerical integration.
2.57.2The system shall support the ability to manually increase the quadrature order used for numerical integration on the entire mesh.
2.57.3The system shall support the ability to manually specify the quadrature order used for numerical integration on a per-block basis with face quadrature between blocks preferring the higher-order between the two sides.
2.57.4The system shall ensure that for per-block specified quadrature orders exactly one order is given per specified block.
2.57.5The system shall support the ability for objects to increase quadrature order in code during runtime.
2.57.6The system shall support the ability to control the volumetric and side quadrature orders used for numerical integration on the entire mesh.
2.57.7The system shall support the ability to allow object code to increase the quadrature order used for numerical integration on a per-block basis.
2.57.8The system shall support the ability to force positive quadrature weights.

framework: Relationship Managers
2.58.1The CouplingFunctorCheckAction shall add a default coupling functor if it's needed and hasn't already been added by another Action
2.58.2The system shall be able to indicate when libMesh Ghosting Functors are in use.
2.58.3The system shall ghost additional solution information when running in parallel with an active RelationshipManager
2.58.4The system shall ghost additional neighboring elements surrounding a partition when running in parallel with DistributedMesh
2.58.5The system shall ghost additional neighboring elements surrounding a partition when running in parallel with DistributedMesh with 3D
2.58.6The system shall be able to ghost elements for algebraic relationships.
2.58.7The system shall ghost additional neighboring elements without also supplying solution information when a developer registers a RelationshipManager with an optional second argument to restrict functionality
2.58.8The system shall ghost additional neighboring elements without also supplying solution information when a developer registers a RelationshipManager with an optional second argument to restrict functionality in 3D
2.58.9The system shall not add a relationship manager ghosting boundaries that are a subset of the boundaries ghosted by another relationship manager.
2.58.10
The system shall allow multiple active objectsto manage ghosting for the same object using
1. replicated and
2. distributed parallelism of the mesh.

framework: Reporters
2.59.1The system shall be able to accumulate reporter values over time steps into a vector reporter value.
2.59.2The system shall have a system for computing and retrieving aggregate values of arbitrary type.
2.59.3The system shall report an error if an invalid name is provided when retrieving aggregate value.
2.59.4
The system shall report a reasonable error when declaring a Reporter value and
1. the parameter that contains the name was not found,
2. the parameter that contains the name is not of the correct type,
3. a Reporter with the same name has already been declared, and
4. a Reporter with the same name but a different type has been requested.
2.59.5The system shall support the mixing of computing and retreiving aggregate values of arbitrary types with the Postprocessor and VectorPostprocessor system.
2.59.6The system shall be able to produce arbitrary integer, real number, dof_id_types and string scalar/vector values for use in other calculations.
2.59.7
The system shall throw an error when producing constant reporter values if
1. no values are specified,
2. no names are specified,
3. or the number of values and names are not equal.
2.59.8
The system shall output aggregate simulation information to JSON format
1. when the aggregate value is declared after object construction
2. and with other values declared at construction time.
2.59.9The system shall support getting a reference to an aggregate calculation before it is created.
2.59.10The system shall be able to produce elememental statistics of a variable for use in other calculations.
2.59.11
The system shall be able to report the variable integral parsed by extra IDs to the JSON format:
1. single variable integral with single extra ID
2. single variable integral with multiple extra IDs
3. multiple variable integrals with multiple extra IDs
2.59.12
The system shall include the ability to report iteration information:
1. that outputs all information be default;
2. that outputs specific information;
3. automatically disables items based on execution;
2.59.13
The system shall include the ability to report mesh information:
1. that outputs all information be default and
2. that outputs specific information.
2.59.14The system shall support the output of mesh metadata in a human-readable form.
2.59.15The system shall be able to produce nodal statistics of a variable for use in other calculations.
2.59.16
The system shall include the ability to report performance information
1. in JSON format
2. and shall provide a tool to post process said information
2.59.17The system shall include the ability to serialize report performance information with the recover system
2.59.18
The system shall include the ability to report performance information from a recovered solve
1. in JSON format
2. and shall provide a tool to post process said information
2.59.19The system shall support the output of restartable data in a human-readable form.
2.59.20The system shall support excluding names when outputting restartable data in a human-readable form.
2.59.21The system shall support omitting data values for data that is missing an output method when outputting restartable data in human-readable form.
2.59.22The system shall support reporting a reasonable error when trying to output restartable data in human-readable form for a data type that does not have an output specialization
2.59.23The system shall support a detailed output including state flags when outputting restartable data in a human-readable form.
2.59.24The system shall support the output of restartable meta data in a human-readable form.

framework: Restart
2.60.1The system shall be able to generate a checkpoint of stateful material properties that supports the advanced restart of the properties
2.60.2
The system shall report a reasonable error when using advanced stateful restart when
1. a stateful property for a single material object is removed
2. a stateful property for a single material object is added
3. a previously checkpointed stateful property is declared in a new material
4. the type of a restored stateful property has changed
5. the requested state of a restored stateful property has changed
2.60.3The system shall support reading and writing solutions on meshes containing duplicate or overlapping mesh nodes.
2.60.4
The system shall support the ability to
1. perform residual calculations that accumulate state and
2. restart the calculation using the accumulated state.
2.60.5
The system shall support the ability to
1. to name problem objects in a simulation and
2. restart the calculation using the defined name.
2.60.6
The system shall report an error when
1. a simulation is started with multiple processors but
2. restarted with a different number processors.
2.60.7
The system shall report an error when
1. a simulation is started with multiple threads but
2. restarted with a different number threads.
2.60.8The system shall support running a transient test for the purposed of changing a restart time step size.
2.60.9The system shall support changing the time step size during a recover operation.
2.60.10The system shall produce an error when an attempt is made to serialize a type without a serialization (dataStore) routine when that data is declared as restartable.
2.60.11The system shall store a custom type that contains a data serialization routine that is declared as restartable.
2.60.12The system shall produce an error when an attempt is made to deserialize a type without a deserialization (dataLoad) routine when that data is declared as restartable during a restart or recover operation.
2.60.13The system shall support the checkpointed output of postprocessors.
2.60.14The system shall support loading a postprocessor into another postprocessor during restart.
2.60.15The systen shall support running and saving off a transient solution with stateful material properties for a restart test.
2.60.16The systen shall support restart with a solution containing only a subset of the variables in the restart simulation.
2.60.17
The system shall support outputting a mesh from a simulation
1. with uniform refinement to ExodusII format,
2. start a new simulation that adds additional refinement,
3. which can be used in an third simulation.
2.60.18The system shall support outputting a mesh to checkpoint format for restart testing.
2.60.19The system shall support starting a transient simulation from a steady simulation result.
2.60.20The system shall support renaming a variable read from a solution file upon restart.
2.60.21The system shall support writing out several timesteps to a solution file to test reading from a specific point.
2.60.22The system shall support restarting from the last timestep using the keyword "LATEST".
2.60.23The system shall issue a useful error message stating the valid options when a user requests an invalid time step number or keyword.
2.60.24The system shall issue a useful error message stating that initial conditions should not be used when restarting.
2.60.25The system shall support running and saving off a transient solution for using in a steady state restart.
2.60.26The system shall support restarting a steady state solve from a transient simulation solution.
2.60.27The system shall support solving a transient problem as a reference solution for a two part multiapp solve.
2.60.28The system shall support writing out checkpoint directly from a subapp, a subtree of the multiapp tree of the parent solve.
2.60.29The system shall support restarting a subapp, a subtree of the multiapp tree of a parent solve without restarting the parent application.
2.60.30The system shall support storing the solution of an eigenvalue solve such that it can be restarted later into a non-eigenvalue solve.
2.60.31The system shall support loading the restarted solution from an eigenvalue solve into a transient solve.
2.60.32
The system shall support executing a
1. a steady-state problem
2. and restarting a transient simulation from the previous solution.
2.60.33The system shall support generating checkpoint files for restart testing with sub apps.
2.60.34The system shall support restarting a transient simulation from a steady solution file with sub apps.
2.60.35The system shall support generating checkpoint files for restart testing with multiple sub apps.
2.60.36The system shall support restarting a transient simulation from a steady solution file with multiple sub apps.
2.60.37The system shall support generating checkpoint files for transient to transient restart testing with multiple sub apps.
2.60.38The system shall support restarting a transient simulation from a pseudo-transient solution file with multiple sub apps.
2.60.39
The system shall be capable, on a single process, of
1. writing data to a restart file
2. and restarting the simulation from the restart file.
2.60.40
The system shall be capable, in parallel, of
1. writing data to a restart file
2. and restarting the simulation from the restart file.
2.60.41
The system shall be able to restart a scalar variable in the presence of other variables with the standard sequence of:
1. run initial input
2. run restart input
2.60.42The system shall support outputting a mesh to checkpoint format for restart testing with "start_time".
2.60.43The system shall use the the final time as the "start_time" from the restart file.
2.60.44The system shall support resetting "start_time" when restarting from a checkpoint mesh format.
2.60.45The system shall support overriding "start_time" when restarting from a checkpoint mesh format to an arbitrary time.

framework: Restrictable
2.61.1The system shall include an interface to allow objects to be restricted to subdomains.
2.61.2The system shall report an error if an object is restricted to a set of subdomains that differs from a dependant object.
2.61.3
The system shall include an interface that provides a method for returning all associated subdomains:
1. as a list of names or
2. as a list of ids.
2.61.4
The system shall include an interface that provides methods for indicating if the supplied subdomain identifier(s) exists on the object:
1. if a single subdomain is supplied ant the object is not restricted;
2. if a single subdoman is supplied and the object is restricted to a set of subdomains; and
3. if multiple boundaries are supplied and the object is restricted to a set of subdomains.
2.61.5
The system shall include an interface that provides a method for indicating if the supplied material property exists on the same subdomains as the object:
1. the method shall return true if the property subdomains match with the object subdomains and
2. the method shall return false if the property subdomains dot not match with the object subdomains.
2.61.6
The system shall include an interface that provides a method for returning all associated boundaries:
1. as a list of names or
2. as a list of ids.
2.61.7
The system shall include an interface that provides methods for indicating if the supplied boundary identifier(s) exists on the object:
1. if a single boundary is supplied and the object is restricted to a set of boundaries and
2. if multiple boundaries are supplied.
2.61.8
The system shall include an interface that provides a method for indicating if the supplied material property exists on the same boundaries as the object:
1. the method shall return true if the property boundaries match with the object boundaries and
2. the method shall return false if the property boundaries dot not match with the object boundaries.
2.61.9
The system shall report an error if an object restricted to subdomains is created without valid data
1. regarding the problem being solved or
2. information regarding the finite element mesh.
2.61.10The system shall support the ability to restrict user defined calculations to sides of a subdomain.
2.61.11The system shall issue an error when a referenced subdomain does not exist in the mesh.

framework: Samplers
2.62.1
The system shall include a random number sampling system that operates in parallel
1. with threads,
2. MPI, and
3. that operates with a row-based iteration scheme.
2.62.2
The system shall include a random number sampling system that creates replicated and/or distribute sample data that is consistent:
1. on a single processor,
2. on a two processors,
3. on a three processors,
4. on a one processor with random numbers,
5. on two processor with random numbers, and
6. on thre processor with random numbers.
2.62.3
The system shall include a random number sampling system that errors
1. if the number of rows is altered during sample access,
2. if the number of columns is altered during sample access,
3. if the number of random number generator seeds is set after object construction,
4. if the number of rows is set to zero,
5. if the number of columns is set to zero,
6. if the number of random number generator seeds is set to zero,
7. if the number of entries in the global sample matrix exceeds the maximum allowed,
8. if the number of entries in the local sample matrix exceeds the maximum allowed, and
9. if the number of entries in the local sample matrix row exceeds the maximum allowed.
2.62.4
The system shall report an error when the expected size of a sampler is altered and accessed prior to initialization by accessing the
1. the global sample matrix;
2. the local sample matrix;
3. the local sample matrix row;
4. the total row count;
5. the local row count;
6. the first local row index;
7. the last local row index;
8. the column count.
2.62.5
The system shall include a random number sampling system
1. that distributes samples in parallel and
2. demonstrates efficient parallel scaling of memory use.

framework: Scalar Kernels
2.63.1We shall be able to couple a scalar variable into AD objects and do some meaningful physics: depleting boundary source diffusion problem
2.63.2We shall be able to couple a scalar variable into AD objects and get the correct Jacobian
2.63.3The system shall be able to correctly compute the Jacobian of an ADScalarKernel using automatic differentiation.
2.63.4
The system shall provide the ability to compute the time derivative of a scalar variable and have its Jacobian computed using automatic differentiation, and
1. applied using standard kernel variable interfaces, or
2. applied using coupling interfaces.

framework: Scaling
2.64.1The system shall be able to include array variables in automatic scaling calculations.
2.64.2The system shall ignore particular variable automatic scaling factors
2.64.3The system shall not allow ignoring of particular variable automatic scaling factors if they are grouped with other variables for scaling
2.64.4
The system shall be able to automatically compute scaling factors based on Jacobian
1. data solely along the diagonal
2. data both on- and off-diagonal
2.64.5The system shall be able to produce the same results without automatic scaling as with automatic scaling.
2.64.6
The system shall be able to automatically scale variables and produce a good condition number from a naturally ill-conditioned system using
1. automatic and
2. manual prescribed settings.
2.64.7The system shall display a very poor condition number for an ill-conditioned system.
2.64.8
When using scaling, the system shall
1. compute the correct results when the residual and Jacobian are computed separately
2. compute the correct results when the residual and Jacobian are computed together
3. compute the correct Jacobian when the residual and Jacobian are computed separately
4. compute the correct Jacobian when the residual and Jacobian are computed together
2.64.9
The system shall be able to conduct residual based automatic scaling such that the largest residual vector component corresponding to each variable has magnitude unity
1. in a one variable problem
2. and in a two variable problem.
2.64.10
The system shall be able to conduct jacobian based automatic scaling such that the largest jacobian diagonal component corresponding to each variable has magnitude unity
1. in a one variable problem
2. and in a two variable problem
2.64.11The system shall be able to include scalar variables in automatic scaling grouping calculations.
2.64.12The system shall print current variable automatic scaling factors

framework: Tag
2.66.1
The system shall support the ability for a specific calculation to fill a labeled or "tagged"
1. numeric vector,
2. numeric vector (without the variable scaling),
3. numeric matrix,
4. numeric matrix (without the variable scaling),
5. multiple numeric vectors simultaneously, or
6. multiple numeric matrices simultaneously.
2.66.2The system shall throw an error when the variable orders and families for the tagged and the auxiliary output variables do not match.
2.66.3The system shall be able to accumulate tagged vectors individually with multiple residual computations.
2.66.4
The system shall support filling in labeled or "tagged" vectors or matrices from:
1. the scalar kernel system,
2. the scalar kernel system (without the variable scaling),
3. the discontinous Galerkin system,
4. integrated boundary conditions,
5. the interface kernels system,
6. the Dirac kernel system,
7. the nodal kernel system,
8. the eigen system, and
9. the legacy eigen system.
2.66.5Cached Active object state will be maintained correctly even when objects' active state changes during runtime.
2.66.6The system shall be able to populate auxiliary variables using the residual components of nonlinear array variables.
2.66.7The system shall be able to populate auxiliary variable values using the residual components of nonlinear array variables.
2.66.8An error will be thrown when the different number of array components are used in the aux and coupled varibles.
2.66.9An error will be thrown when the different FE family are used in the aux and coupled varibles.
2.66.10The system shall be able to populate auxiliary variable values using the residual components of nonlinear array variable gradient.
2.66.11The system shall be able to populate auxiliary array variable values using the components of gradient of time derivative of coupled array variable.
2.66.12The system shall be able to retrieve tagged vector values for multiple coupled variables using a single interface.
2.66.13The system shall be able to index solution vectors and residual vectors using the degree of freedom indices of a finite volume variable.
2.66.14
The system shall be able to use matrix tagging to compute a mass matrix
1. for a finite volume variable, and
2. for a finite element variable.

framework: Time Integrators
2.67.1The system shall include an option that aborts the solve immediately if a solve fails.
2.67.2
The system shall support the use of explicit solvers, including
1. first-order, forward Euler,
2. with mass lumping, and
3. with mass lumping and preconditioning.
2.67.3
The system shall report an error if an explicit solver fails to converge with
1. first-order, forward Euler,
2. with mass lumping, and
3. with mass lumping and preconditioning.
2.67.4
The system shall correctly solve a time dependent Laplace equation using an explicit first-order, forward Euler scheme with:
1. for a 1D problem using linear Lagrange elements and Dirichlet boundary conditions;
2. for a 1D problem using second-order Lagrange elements and Dirichlet boundary conditions;
3. for a 1D problem using second-order Lagrange elements and Neumann boundary conditions;
4. for a 2D problem using linear Lagrange elements and Dirichlet boundary conditions;
5. for a 2D problem using linear Lagrange elements, Dirichlet boundary conditions, and mesh adaptivity;
6. for a 2D problem using second-order Lagrange elements and Dirichlet boundary conditions;
2.67.5The system shall correctly solve a time dependent ordinary differential equation using an explicit first-order, forward Euler scheme.
2.67.6The system shall support the use of the Adams Bashforth predictor for time integration.
2.67.7
The system shall support the second-order backward difference method for time integration
1. with and
2. without mesh adaptivity.
2.67.8The CentralDifference time integrator shall correctly compute the first and second time derivatives.
2.67.9A central differencing time integrator shall correctly compute the second time derivative of an automatic differentiation variable.
2.67.10
The system shall include explicit time integration using the Heun method and converge at the theoretical rate with
1. a full timestep,
2. a half timestep, and
3. a quarter timestep.
2.67.11
The system shall include explicit time integration using the Ralston method and converge at the theoretical rate with
1. a full timestep,
2. a half timestep, and
3. a quarter timestep.
2.67.12
The system shall include explicit time integration using the midpoint method and converge at the theoretical rate with
1. a full timestep,
2. a half timestep, and
3. a quarter timestep.
2.67.13
The system shall include explicit time integration using the Euler method and converge at the theoretical rate with
1. a full timestep,
2. a half timestep, and
3. a quarter timestep.
2.67.14
The system shall include implicit time integration using the Midpoint method and converge at the theoretical rate with
1. a full timestep,
2. a half timestep, and
3. a quarter timestep.
2.67.15
The system shall include implicit time integration using the L-stable DIRK3 method and converge at the theoretical rate with
1. a full timestep,
2. a half timestep, and
3. a quarter timestep.
2.67.16
The system shall include implicit time integration using the L-stable DIRK4 method and converge at the theoretical rate with
1. a full timestep,
2. a half timestep, and
3. a quarter timestep.
2.67.17
The system shall include implicit time integration using the A-stable DIRK4 method and converge at the theoretical rate with
1. a full timestep,
2. a half timestep, and
3. a quarter timestep.
2.67.18
The system shall include implicit time integration using the A-stable DIRK4 method (bootstrapped with L-stable DIRK) and converge at the theoretical rate with
1. a full timestep,
2. a half timestep, and
3. a quarter timestep.
2.67.19
The system shall support the second-order Crank-Nicolson method for time integration
1. with and
2. without mesh adaptivity.
2.67.20
The system shall support the L-stable DIRK method for time integration
1. with and
2. without mesh adaptivity.
2.67.21The system shall be able to use a finite difference preconditioner with two-stage L-stable DIRK time integration.
2.67.22The system shall be able to use a finite difference preconditioner with three-stage L-stable DIRK time integration.
2.67.23The system shall be able to use a finite difference preconditioner with four-stage L-stable DIRK time integration.
2.67.24
The system shall support the use of quasi-explicit Euler solver with
1. 1D elements with first order shape functions and Dirichlet boundary conditions;
2. 1D elements with second order shape functions and Dirichlet boundary conditions;
3. 1D elements with second order shape functions and Neumann boundary conditions;
4. 2D elements with first order shape functions and Dirichlet boundary conditions;
5. 2D elements with second order shape functions and Dirichlet boundary conditions; and
6. 2D elements with second order shape functions and Neumann boundary conditions.
2.67.25
The system shall include the strong-stability-preserving Runge-Kutta method of
1. 1st order
2. 2nd order
3. 3rd order
2.67.26The system shall provide an informative error message when a user uses an invalid solve type for an explicit time integrator.
2.67.27
The system shall support the use of an implicit Euler solver with
1. with and
2. without mesh adaptivity.
2.67.28The system shall support the use of an implicit Euler solver with discontinuous (first-order Monomial) shape functions.
2.67.29Multi-stage time integrators shall check convergence for all stages
2.67.30The system shall support having multiple time integrators in the same input file and yield the same results across thread counts, process counts, and mesh modes.
2.67.31The system shall support having multiple time integrators in the same input file and yield the expected temporal convergence rates for each variable.
2.67.32The system shall have an exact Jacobian when running with multiple time integrators.
2.67.33The NewmarkBeta time integrator shall correctly compute the first and second time derivatives of a variable using the default beta and gamma parameters.
2.67.34The NewmarkBeta time integrator shall correctly compute the first and second time derivatives of a variable using user provided beta and gamma parameters.
2.67.35The NewmarkBeta time integrator shall correctly use the inactive_tsteps parameter.
2.67.36A Newmark-beta method time integrator shall correctly compute the second time derivative of an automatic differentiation variable using the default beta and gamma parameters.
2.67.37
The system shall support the use of an explicit midpoint time integration scheme for
1. 1D elements with linear finite element shape functions and
2. 2D elements with quadratic finite element shape functions.
2.67.38
The system shall compute the Jacobian during explicit midpoint time integration for
1. 1D elements with linear finite element shape functions and
2. 2D elements with quadratic finite element shape functions.
2.67.39
The system shall support th used of Crank-Nicolson time integration method for scalar variables with
1. scalar variables within and ordinary differential equations including
2. stiff and
3. nonlinear systems.
2.67.40
The system shall support the use of an total variation diminishing Runge-Kutta time integration schemefor
1. 1D elements with linear finite element shape functions and
2. 2D elements with quadratic finite element shape functions.
2.67.41
The system shall compute the Jacobian during total variation diminishing Runge-Kutta time integration for
1. 1D elements with linear finite element shape functions and
2. 2D elements with quadratic finite element shape functions.

framework: Time Steppers
2.68.1
The system shall calculate the time step size based one the number of steps and the end time of the simulation when the initial time step size is not supplied:
1. when the start time is not supplied, and
2. when the start time is supplied.
2.68.2The system shall include a means for performing simulations with a constant time step.
2.68.3The system shall report an error if trying to take a negative time step.
2.68.4The system shall support the ability to regrow a time step that has been previously cut due to a solve failure.
2.68.5The system shall support how time step size is cut, using user-specified cutback_factor_at_failure, due to a solve failure. Here, the original time step size is specified as a constant value.
2.68.6The system shall support how time step size is cut, using user-specified cutback_factor_at_failure, due to a solve failure. Here, the original time step size is specified as a function of time.
2.68.7The system shall be able to increase the time step size when the simulation converges with a number of fixed point iterations below the target window.
2.68.8The system shall be able to decrease the time step size when the simulation converges with a number of fixed point iterations above the target window.
2.68.9
The system shall report an error for the fixed point iteration adaptive time stepper
1. if it is used in an application with no sub-applications.
2. if the specified target iteration window lies outside the executioner iteration window.
2.68.10The system shall suppport the ability to sample a piecewise linear function for time step sizes while supporting a minimum time step size.
2.68.11The system shall support the ability to sample a piecewise constant function for time step sizes choosing either the left or right values between adjacent constants.
2.68.12The system shall support the ability to force time steps consistent with points specified in a function.
2.68.13The system shall check that a timestep limiting function has been defined when a user specifies the 'force_step_every_function_point' parameter as true.
2.68.14The system shall check that a timestep limiting function has been defined when a user specifies a value for the 'max_function_change' parameter.
2.68.15The system shall support the ability to grow the time step size when specifying the initial value of dt in the TimeStepper.
2.68.16The system shall support the ability to grow the time step size when specifying the initial value of dt in the TimeStepper after a restart.
2.68.17The system shall support the ability to grow the time step size when specifying the values of t and dt in the TimeStepper.
2.68.18The system shall support the ability to grow the time step size when specifying the values of t and dt in the TimeStepper after a restart.
2.68.19The system shall support the ability to limit the time step size based on the optimal iterations and linear_iteration ratio.
2.68.20The system shall support the ability to limit the time step size based on the optimal iterations and linear_iteration ratio after a restart.
2.68.21The system shall support the ability to limit the time step size based on a postprocessor value.
2.68.22The system shall support the ability to limit the time step size based on multiple postprocessor values.
2.68.23The system shall support the ability to reject a time step based on a threshold value for the ratio of the ideal step size to the limit.
2.68.24The system shall support the ability to force time steps to resolve sudden changes in piecewise linear functions.
2.68.25The system shall support the ability to force time steps to match changes in piecewise constant functions.
2.68.26The system shall support the ability to force time steps to hit all nodes in a set of piecewise linear functions.
2.68.27The system shall support the ability to force time steps to resolve sudden changes in multiple piecewise linear functions.
2.68.28The system shall support the ability to force time steps to hit all nodes in a set of piecewise linear and constant functions.
2.68.29The system shall support the ability to set a new time step size after syncing the previous time step with piecewise linear and constant functions.
2.68.30
The system shall check that
1. the postprocessors limiting the timesteps do not become negative
2.68.31The system shall support the ability to select a time step size based upon a scaled log-constant calculation.
2.68.32The system shall support the ability to use a scalar value computed after a solve to be used as a scaled time step size.
2.68.33The system shall support the ability to select time step sizes based upon the ratio of the real (wall) time of the solve and the size of the time step.
2.68.34
The system shall support the ability to use multiple time steppers
1. using the minimum time step size of input time steppers,
2. with specific times to hit and still hit all of them,
3. AB2PredictorCorrector as one of the input time steppers,
4. and provide a (usually growing) lower bound of the time step size,
5. and allow the user to activate/deactivate timesteppers using control block,
2.68.35
The system shall support the ability to run a calculation for the purpose of creating a time sequence recover file:
1. when writing the checkpoint file,
2. restart from the checkpoint file.
2.68.36
The system shall provide meaningful error message when:
1. time stepper name(s) provided for lower_bound dosen't exist,
2. no time steppers are active to compute a timestep,
3. the syntax for multiple time steppers is used without an additional nested block for the time stepper
4. the corresponding rejectStep() function is called when solve fails
2.68.37
The system shall support the ability to choose time step sizes based on a sequence of increasing numbers:
1. beginning at the default start time,
2. beginning at an earlier time than the sequence numbers,
3. beginning at a time somewhere in-between existing sequence numbers, and
4. when reading the sequence from an ExodusII formatted input file.
5. that must be sorted in ascending order,
6. that must be sorted in strictly ascending order,
7. when reading the sequence from a comma-separated input file, and
8. allowing the last time step size to be used past the final time in the sequence.
2.68.38The system shall support the ability to override time sequence time step sizes when solves fail.
2.68.39
The system shall support the ability to run a calculation for the purpose of creating a time sequence restart file:
1. when writing the checkpoint file,
2. when restarting where the time sequence is identical, and
3. when restarting where the time sequence is different after the point of the checkpoint.
2.68.40
The system shall support the ability to run a calculation for the purpose of creating a time sequence restart file suitable for failure:
1. when writing the checkpoint file,
2. when restarting where the time sequence is different prior to the failure.
2.68.41The system shall report an error if the initial time step size is calculated to be zero.

framework: Times
2.69.1
The system shall be able to gather times from
1. a parameter in the input file,
2. a fixed time interval between the transient start and end times, including the end time,
3. a fixed time interval between the transient start and end times, excluding the end time,
4. a fixed time interval between custom start and end times,
5. a functor evaluated at the element containing the origin,
6. a CSV file,
7. multiple exodus files,
8. a reporter with data in the expected floating point vector format, and
9. the time steps taken by the simulation.
2.69.2
The system shall report an error when
1. times are gathered with a fixed time interval with no start and end times provided, while using a steady executioner.

framework: Transfers
2.70.1The system shall output a warning if a transfer that only matches node ids is used in combinated with a coordinate transformation.
2.70.2The system shall be able to perform interpolation transfers between main and sub applications that both have non-identity transformations into the reference space.
2.70.3The system shall be able to perform mesh function transfers between main and sub applications that both have non-identity transformations into the reference space.
2.70.4The system shall be able to map nearest node transfers between main and sub applications that both have non-identity transformations into the reference space.
2.70.5The system shall report a warning when transferring a variable (for main app) and postprocessor (for subapp) for applications that both have non-identity transformations into the reference space.
2.70.6The system shall be able to perform projection transfers between main and sub applications that both have non-identity transformations into the reference space.
2.70.7The system shall be able to transfer data computed by a user object to a field, in either the child or the main app, in the presence of non-unity frame of reference transformations between the two applications.
2.70.8The system shall be able to transfer information between three-dimensional and two-dimensional axisymmetric simulations in which the cylinder axis lies along the z-axis in three-dimensional space.
2.70.9The system shall be able to solve a diffusion problem with a coupled force provided by another variable.
2.70.10The system shall be able to transfer information from a scaled, rotated, translated application into another application and reproduce the results from an equivalent single-application simulation with the transforms applied in the sub application.
2.70.11The system shall be able to transfer information from a scaled, rotated, translated application into another application and reproduce the results from an equivalent single-application simulation with the transforms applied in the main application.
2.70.12The system shall report an error if the user does not provide sufficient information to determine the originator and destination of transfer information.
2.70.13The system shall report an error if the user provides a mix of non-deprecated and deprecated parameters.
2.70.14The system shall report an error if the user provides nonsensical direction parameters.
2.70.15The system shall support the transfer of data from a completed solve within sub-application to the parent application.
2.70.16
The system shall support nearest-node transfers between multiapps
1. between nodal variables,
2. between elemental variables,
3. from elemental to nodal variables,
4. from nodal to elemental variables,
5. when one multiapp is run in serial,
6. with block restricted variables of matching types,
7. with block restricted variables of different types.
2.70.17
The system shall be able to transfer variables using the value from the nearest node in the origin mesh, limiting the transfer to boundaries,
1. such as certain source boundaries, for variables of the same type,
2. such as certain target boundaries, for variables of the same type,
3. for variables of arbitrary types with higher order on the receiving app,
4. for nodal variables of arbitrary types with higher order on the sending app,
5. for internal boundaries,
6. limiting the transfer to certain blocks as well
2.70.18The system shall be able to map nearest location transfers between main and sub applications that both have non-identity transformations into the reference space.
2.70.19The system shall be able to transfer information between three-dimensional and two-dimensional axisymmetric simulations in which the cylinder axis lies along the z-axis in three-dimensional space, using the general field version of the nearest-location transfers.
2.70.20The system shall be able to transfer information from a scaled, rotated, translated application into another application and reproduce the results from an equivalent single-application simulation with the transforms applied in the sub application, using the general field version of the nearest-location transfers.
2.70.21The system shall be able to transfer information from a scaled, rotated, translated application into another application and reproduce the results from an equivalent single-application simulation with the transforms applied in the main application, using the general field version of the nearest-location transfers.
2.70.22The system shall be able to transfer both nodal and elemental fields to a child app from the parent app.
2.70.23The system shall be able to transfer both nodal and elemental fields from child apps to the parent app.
2.70.24The system shall be able to transfer values from child apps which set the displaced_source_mesh flag to true.
2.70.25The system shall be able to transfer values to multiple child apps from the parent app's boundary.
2.70.26The system shall be able to transfer values from a child app boundary to the parent app.
2.70.27The system shall be able to transfer values to multiple target boundaries in both the parent and child app.
2.70.28The system shall be able to transfer between an app and multiple child apps.
2.70.29The system shall be able to transfer in parallel between meshes with different spatial dimensions.
2.70.30The system shall be able to support target boundary-restriction for transfer
2.70.31The system shall be able to support source boundary-restriction for transfers
2.70.32The system shall be able to support source-and-target boundary-restriction for transfer
2.70.33
The system shall be able to leverage mesh divisions during nearest-location based transfers
1. to restrict the source domain for the transfered field,
2. to restrict the target domain for the transfered field,
3. to distribute field data restricted to divisions of the source mesh to matching divisions of the target mesh,
4. to distribute field data restricted by matching divisions of the source mesh to target applications with the same index as the divisions,
5. to distribute field data restricted by matching divisions of the source mesh to target applications with the same index as the divisions, with a custom algorithm for finding source applications.
2.70.34
The system shall emit a warning if
1. the mesh divisions that we asked to match do not have the same number of bins,
2. the number of bins in the source mesh division and the number of target subapps to match are not equal
3. the number of bins in the target mesh division and the number of source subapps to match are not equal.
2.70.35
The system shall error if the user passes parameters for
1. the technique used with source mesh divisions without specifying the source mesh division,
2. the technique used with target mesh divisions without specifying the target mesh division,
3. no algorithm has been selected for selecting the processes sending data,
4. the target mesh division is asked to match the source app number, but the source app is the parent app not a subapp,
5. the source mesh division is asked to match the target app number, but the target app is the parent app not a subapp,
6. the techniques for the target and source mesh divisions are incompatible.
2.70.36
The system shall be able to transfer a spatial field using a nearest-node (source) algorithm combined with a nearest-positions heuristic to limit the source of the origin values
1. for a 2D case with multiple subapps,
2. for a 2D case with a single child app split using the positions in multiple regions to transfer data from.
2.70.37The system shall be able to send data in a subapp to another subapp using a nearest-node algorithm nested within a nearest-positions algorithm.
2.70.38
The system shall report an error if
1. both nearest positions algorithm and asking for origin points to be contained within an app domain are requested as this is not supported.
2.70.39The system shall be able to detect indetermination in a transfer due to floating point decisions on which node is the nearest, even when using the nearest position option.
2.70.40
The system shall be able to transfer variables using the value from the nearest node in the origin mesh
1. for variables of the same type,
2. for variables of arbitrary types with higher order on the receiving app,
3. for nodal variables of arbitrary types with higher order on the sending app,
4. for array variables
5. while allowing for an user to set the size of the application bounding box directly
2.70.41
The system shall be able to detect indetermination in a transfer due to
1. equidistant source nearest nodes in different problems
2. the furthest of the nearest nodes desired being equidistant to the target point as the next furthest
2.70.42
The system shall be able to transfer variables using a nearest node algorithm, limiting the transfer to boundaries,
1. for variables of the same type,
2. with block restriction only in the origin mesh,
3. with block restriction only in the target mesh,
4. for variables of arbitrary types with higher order on the receiving app,
5. for variables of arbitrary types with higher order on the sending app,
2.70.43
The system shall be able to transfer variables by evaluating shape functions in the origin mesh between multiapps
1. between nodal variables,
2. between elemental variables,
3. from elemental to nodal variables,
4. from nodal to elemental variables,
5. when one multiapp is run in serial,
6. with block restricted variables of matching types,
7. with block restricted variables of different types.
2.70.44
The system shall be able to transfer variables by evaluating shape functions in the origin mesh when transfering from a single to multiple subapps
1. from nodal variables to nodal and elemental variables,
2. from elemental variables to nodal and elemental variables,
2.70.45
The system shall be able to transfer variables by evaluating shape functions in the origin mesh when transfering from an arbitrary number of subapps to an arbitrary number of subapps
1. from nodal variables to nodal and elemental variables,
2. from elemental variables to nodal and elemental variables,
2.70.46
The system shall be able to transfer variables by evaluating variable shape functions in the origin mesh,
1. limiting the transfer to certain target boundaries, for variables of the same type,
2. for variables of arbitrary types with higher order on the receiving app,
3. for nodal variables of arbitrary types with higher order on the sending app,
4. for internal boundaries,
5. for internal boundaries using element nodes to detect whether an element is part of a boundary,
6. limiting the transfer to certain blocks as well
2.70.47
The system shall return an error if
1. the user attempts transferring to a non-zeroth order elemental variables while restricting the transfer to a boundary
2.70.48The system shall be able to perform transfers by evaluating the local shape function of variables between main and sub applications that both have non-identity transformations into the reference space.
2.70.49The system shall be able to transfer from a source application that is being displaced.
2.70.50
The system shall support the transfer of data evaluating the finite element solution function:
1. to a sub-application,
2. from a sub-application,
3. from a deformed mesh to a sub-application,
4. from to a sub-application with a deformed mesh,
5. from a sub-application with deformed mesh, and
6. from a sub-application to a deformed mesh.
2.70.51
The system shall report an error if performing a transfer of data evaluating the finite element solution if:
1. the evaluation point does not exist
2.70.52
The system shall be able to leverage mesh divisions during variable shape evaluation transfers
1. to restrict the source domain for the transfered field,
2. to restrict the target domain for the transfered field,
3. and to distribute field data restricted by matching divisions of the source mesh to target applications with the same index as the divisions.
2.70.53
The system shall be able to transfer variables by evaluating shape functions in the origin problem
1. for variables of the same type,
2. for variables of arbitrary types with higher order on the receiving app,
3. for variables of arbitrary types with higher order on the sending app,
4. when specifying multiple variables in a single transfer
5. for array variables
6. when using the closest app rather than the first valid value to chose a value
2.70.54
The system shall return an error if
1. a different number of variables is specified for the source and target variables of the transfer.
2. the user forgot to input the component to transfer for the source array variable
3. the user forgot to input the component to transfer for the target array variable
4. the user specified a source variable component to transfer that is larger than the variable size
5. the user specified a target variable component to transfer to that is larger than the variable size
2.70.55
The system shall be able to detect indetermination in a transfer due to
1. overlapping origin child application, causing multiple shape evaluations to be valid
2. multiple source problems sending valid values for a given target point
3. when using the closest app rather than the first valid value to chose a value
2.70.56
The system shall be able to transfer variables using a shape function evaluation in the origin mesh, limiting the transfer to a few subdomains,
1. for variables of the same type,
2. with block restriction only in the origin mesh,
3. with block restriction only in the target mesh,
4. for variables of arbitrary types with higher order on the receiving app,
5. for variables of arbitrary types with higher order on the sending app,
2.70.57
The system shall be able to transfer user-defined spatial data on the origin mesh directly between multiapps
1. between nodal variables,
2. between elemental variables,
3. when one multiapp is run in serial,
4. with block restricted variables of matching types,
5. with block restricted variables of different types.
2.70.58
The system shall be able to transfer user-defined spatial data on the origin mesh,
1. limiting the transfer to certain target boundaries, for variables of the same type,
2. for variables of arbitrary types with higher order on the receiving app,
3. for internal boundaries,
4. for internal boundaries using element nodes to detect whether an element is part of a boundary,
5. limiting the transfer to certain blocks as well
2.70.59The system shall be able to transfer data computed by a user object to a field, in either the child or the main app, in the presence of non-unity frame of reference transformations between the two applications, using the general field formulation of the transfer.
2.70.60
The system shall provide an interface for transferring user-defined spatial data
1. to a parent application from sub-applications,
2. from a parent application to sub-applications,
3. from a parent application to sub-applications that have a deformed mesh, and
4. between a 3D parent application and 1D sub-applications.
2.70.61The system shall be able to transfer user-defined spatial data into block and boundary restricted nodal variables.
2.70.62The system shall be able to transfer user-defined spatial data into block and boundary restricted elemental variables.
2.70.63The system shall be able to allow skipping the bounding box test.
2.70.64The system shall report an error if a parent node/element is not contained within any sub application domains/meshes when this condition is explicitly requested by the user.
2.70.65
The system shall be able to transfer user-defined spatial data on the origin problem
1. and restrict the origin of the data using a nearest-app algorithm,
2. and restrict the origin of the data using a nearest-position algorithm.
2.70.66The system shall be able to send data from a user object in a subapp to another subapp while following a nearest-positions algorithm
2.70.67
The system shall emit a warning if
1. parameters meant for extrapolation of transfers are passed with no expansion of the bounding box, as this is likely unintended.
2.70.68
The system shall report an error if
1. a nearest-point algorithm is used for sending app-based data from a main app to multi-apps as the data naturally lives near only one of the positions,
2. a nearest-point algorithm is requested for use at the same time as nearest-app algorithm.
2.70.69
The system shall be able to transfer user-defined spatial data on the origin problem
1. for variables of the same type,
2. for variables of arbitrary types with higher order on the receiving app,
2.70.70
The system shall return an error if
1. more than one variable are specified as the transfer only takes.
2.70.71
The system shall be able to detect indetermination in a transfer due to
1. overlapping origin child application, causing multiple shape evaluations to be valid
2.70.72
The system shall be able to transfer user-defined spatial data on the origin mesh, limiting the transfer to a few subdomains,
1. for variables of the same type,
2. with block restriction only in the origin mesh,
3. with block restriction only in the target mesh,
4. for variables of arbitrary types with higher order on the receiving app
2.70.73
The system shall report an error if
1. source block restriction is used at the same time as an extrapolation option, without explicitly specifying an extrapolation constant, as both are semantically incompatible so the user must explicitly request it to allow it.
2.70.74The system shall include an interface for retrieving objects that pertain to transferring data between applications.
2.70.75The system shall support conservative transfers
2.70.76The system shall check execute_on for PP in sub app
2.70.77The system shall support conservative transfers using regular postprocessors
2.70.78The system shall check execute_on for PP in parent app
2.70.79The system shall support conservative transfers with nearestpoint VectorPostprocessors
2.70.80The system shall check execute_on for vector PP in parent app
2.70.81The system shall be able to output the adjusting values in conservative transfers
2.70.82The system shall support conservative transfers in MultiAppUserObjectTransfer
2.70.83The system shall be able to output the adjusting values in conservative transfers for MultiAppUserObjectTransfer
2.70.84The systen shall allow adjustment if both from and to adjuster are negative.
2.70.85The systen shall allow to skip adjustments without throwing an error if from/to adjusters do not satisfy conditions.
2.70.86The system shall support direct copy of array variables from a sub-application to the main application.
2.70.87
The system shall support the transfer of auxiliary field variables between identical meshes:
1. from a sub-application and
2. to a sub-application.
2.70.88
The system shall report an error if a variable, during a direct copy of auxiliary field variables, does not exist
1. in the sub-application when transferring form it and
2. in the parent application when transferring for it.
2.70.89
The system shall support the transfer of an auxiliary field variable to a primary variable between identical meshes:
1. from a sub-application and
2. to a sub-application.
2.70.90
The system shall support the transfer of auxiliary field variables between identical meshes:
1. between two subapps
2.70.91
The system shall support the transfer of elemental field variables between identical meshes:
1. with a block-restriction on the origin mesh
2. with a block-restriction on the target mesh
2.70.92
The system shall report an error if a nodal variable is requested to be transfered
1. with block-restriction on the origin mesh.
2. with block restriction on the target mesh.
2.70.93
The system shall report an error if a variable is required to be transferred
1. with an invalid source block for the to_multiapp direction.
2. with an invalid source block for the from_multiapp direction.
3. with an invalid target block for the to_multiapp direction.
4. with an invalid target block for the from_multiapp direction.
2.70.94The system shall support direct copy of a constant monomial auxiliary variable from a sub-application to a constant monomial nonlinear variable in the main application.
2.70.95The system shall support direct copy of a constant monomial auxiliary variable from a the main application to a constant monomial nonlinear variable in the sub-application.
2.70.96The system shall report an error when the MultiAppCopyTransfer object is used on non-identical meshes.
2.70.97The system shall report an error when the MultiAppCopyTransfer object is used on meshes with different variable types.
2.70.98The system shall support direct copy of a linear Lagrange nonlinear variable from a sub-application to the main application.
2.70.99The system shall support direct copy of a linear Lagrange nonlinear variable to a sub-application from the main application.
2.70.100The system shall support the direct copy transfer of linear finite volume variables.
2.70.101The system shall support direct copy of multiple nonlinear variables from a sub-application to the main application.
2.70.102The system shall support direct copy of a second-order Lagrange nonlinear variable from a sub-application to the main application.
2.70.103The system shall support direct copy of a second-order Lagrange nonlinear variable to a sub-application from the main application.
2.70.104The system shall support the transfer of field variables with solution vectors indicated by tags.
2.70.105The system shall support direct copy of a third-order monomial auxiliary variable from a sub-application to a third-order monomial nonlinear variable in the main application.
2.70.106The system shall support direct copy of a third-order auxiliary variable from a the main application to a third-order monomial nonlinear variable in the sub-application.
2.70.107The system shall be able to transfer vector variables between identical meshes using a direct copy transfer.
2.70.108The system shall support mesh to mesh interpolation with the first order elemental variable
2.70.109The system shall support mesh to mesh interpolation with the first order elemental variable when a different mesh is used in sub
2.70.110The system shall support nearest node transfer with the first order elemental variable
2.70.111The system shall support interpolation transfer with the first order elemental variable
2.70.112The system shall support user object transfer with the first order elemental variable
2.70.113The system shall support conservative transfer with L2 nonlinear variable
2.70.114The system shall allow to interpolate variables from the parent app to the sub apps
2.70.115The system shall allow to interpolate variables from the sub apps to the parent app
2.70.116The system shall allow to interpolate block restricted variables from the sub apps to the parent app
2.70.117
The system shall support the transfer of data using the finite element solution function:
1. to a sub-application,
2. from a sub-application,
3. from a deformed mesh to a sub-application,
4. from to a sub-application with a deformed mesh,
5. from a sub-application with deformed mesh, and
6. from a sub-application to a deformed mesh.
2.70.118
The system shall report an error if performing a transfer of data using the finite element solution if:
1. the evaluation point does not exist and
2. if the execution settings do not match between the parent and sub-applications.
3. if the execution settings do not match with any of two sibling sub-applications.
2.70.119The system shall be able to cache nearest node mappings with multiple target subapps.
2.70.120The system shall transfer both nodal and elemental fields to a child app from the parent app.
2.70.121The system shall transfer both nodal and elemental fields from child apps to the parent app.
2.70.122The system shall transfer values from child apps which set the displaced_source_mesh flag to true.
2.70.123The system shall support the 'fixed_meshes' flag which allows caching of nearest neighbors.
2.70.124The system shall transfer values to multiple child apps from the parent app's boundary.
2.70.125The system shall transfer values from a child app boundary to the parent app.
2.70.126The system shall transfer values to multiple target boundaries in both the parent and child app.
2.70.127The system shall work when there are multiple child apps present.
2.70.128The system shall work in parallel between meshes with different spatial dimensions.
2.70.129The system shall support target boundary transfer when use multiple mpi ranks
2.70.130The system shall support source boundary transfer when use multiple mpi ranks
2.70.131The system shall support source-and-target boundary transfer when use multiple mpi ranks
2.70.132The system shall report an error if the specified source boundary was not found in the mesh for the from_multiapp direction.
2.70.133The system shall report an error if the specified target boundary was not found in the mesh for the from_multiapp direction.
2.70.134The system shall report an error if the specified source boundary was not found in the mesh for the to_multiapp direction.
2.70.135The system shall report an error if the specified target boundary was not found in the mesh for the to_multiapp direction.
2.70.136
The system shall support the transfer of scalars to a field variable between an application and sub-applications:
1. using a inverse distance algorithm,
2. if the destination variable is CONSTANT MONOMIAL,
3. using a radial basis algorithm,
4. with multi-level sub-applications,
5. with multiple sub-application files, and
6. with a single sub-application file.
2.70.137The system shall report an error if a data transfer is requested for a data variable that is not defined.
2.70.138The system shall report an error if a variable is specified that is not LINEAR LAGRANGE or CONSTANT MONOMIAL
2.70.139The system shall report an error if parameters for an unsupported direction are provided for the transfer between sub-app scalars and a main app field variablea.
2.70.140The system shall support the transfer of scalar post processing data to scalar auxiliary variables between multiapps
2.70.141
The system shall support the transfer of data between a parent and sub-applications for scalar unknowns and postprocessing data:
1. from the parent application to the sub-applications and
2. to the parent application from the sub-applications.
2.70.142
The system shall report an error during the transfer of scalar variable and postprocessor data if the number of sub-applications differs from the order of the scalar variable if
1. the order is too large and
2. the order is too small.
2.70.143The system shall support the transfer of scalar post processing data between multiapps
2.70.144
The system shall support the transfer of scalar post processing data:
1. from the parent application to sub-applications and
2. to the parent application from sub-applications.
2.70.145The system shall support the transfer of scalar post processing data from a single sub-application.
2.70.146
The system shall support the transfer of field data using L2 projection:
1. from the parent application to sub-applications and
2. to the parent application from sub-applications.
2.70.147The system shall support the transfer of field data using L2 projection for first order shaped monomial shape functions.
2.70.148The system shall support the transfer of field data using L2 projection and include optimization for non deforming meshes.
2.70.149The system shall support the transfer of reporter data between multiapps
2.70.150
The system shall support the ability to transfer reporter data from N child apps to 1 parent app, and from 1 parent app to N child app when
1. the number of procs per app is default,
2. the number of procs per app limited,
2.70.151
The system shall error if the reporter being transferred
1. is distributed in the main app,
2. or when the reporter being tranferred is distributed in the sub app.
2.70.152
The system shall support the ability to transfer reporter data in a vector scatter/gather fashion
1. from one main app to many subapps,
2. or from many subapps to one main app.
2.70.153
The system shall support the ability to transfer vectorpostprocessor data
1. from the main application to all sub-applications,
2. from the main application to a single sub-applications,
3. and from a sub-application to the main application.
2.70.154The system shall support the ability to transfer integer, real, vector, and string reporter data.
2.70.155
The system shall support the ability to transfer reporter data and error if an invalid sub-application number is supplied when transferring data
1. to a sub-application,
2. from a sub-application.
3. from multiple sub-applications.
2.70.156
The system shall support declaring reporter value clone on a main application and transferring sub-application data into it
1. in serial and
2. in parallel.
2.70.157
If processors do not contain a sub-application and reporter clone transfer is requested, the system shall
1. be able to transfer if reporter types are specified and
2. error if types are not specified.
2.70.158The system shall support the transfer of scalar variables to auxiliary scalar variables between multiapps.
2.70.159The system shall include the ability to transfer scalar variables to an applications from sub-applications.
2.70.160The system shall report an error if the variable order does not match when transferring scalar variables to an application from sub-applications.
2.70.161The system shall include the ability to transfer scalar variables from an applications to sub-applications.
2.70.162The system shall report an error if the variable order does not match when transferring scalar variables from an application to sub-applications.
2.70.163The system shall be able to create virtually translated points during MultiApp transfers.
2.70.164
The system shall support an interface for transferring user-defined spatial data
1. to a parent application from sub-applications,
2. to a parent application from the nearest sub-applications,
3. from a parent application to sub-applications,
4. from a parent application to sub-applications that have a deformed mesh, and
5. between a 3D parent application and 1D sub-applications.
2.70.165The system shall transfer user-defined spatial data into block and boundary restricted nodal variables.
2.70.166The system shall transfer user-defined spatial data into block and boundary restricted elemental variables.
2.70.167MultiAppUserObjectTransfer shall generate an error if a parent node/element is not contained within any sub application domains.
2.70.168MultiAppUserObjectTransfer shall allow skipping the bounding box test.
2.70.169The system shall report an error if an invalid block is specified for the to_multiapp direction.
2.70.170The system shall report an error if an invalid block is specified for the from_multiapp direction.
2.70.171The system shall report an error if an invalid boundary is specified for the to_multiapp direction.
2.70.172The system shall report an error if an invalid boundary is specified for the from_multiapp direction.
2.70.173The system shall include the ability to transfer a field variable sampled at a point to populate a field variable on the sub-application with the supplied value.
2.70.174The system shall include the ability to transfer a component of an array field variable sampled at a point to post processing variable on the sub-application.
2.70.175
The system shall include the ability to transfer all components of an array field variable sampled at groups of points to post-processor values on various sub-applications define by
1. user input or
2. element centroids.
2.70.176
The system shall throw an error when attempting to transfer all components of an array field variable sampled groups of points to sub-application post-processor values if
1. the source variable is not an array variable,
2. an array variable component is specified, and
3. the number of sub-applications is not divisible by the number array variable components.
2.70.177
The system shall include the ability to transfer a field variable sampled at a point to post processing variable on the sub-application
1. from a linear Lagrange source variable and
2. from a constant monomial source variable and
3. from a finite volume constant monomial source variable.
2.70.178The system shall support the ability to disable the use of parallel barriers when streaming text to the screen.
2.70.179The system shall guarantee that constant monomial variables transferred via MultiAppVariableValueSamplePostprocessorTransfer to the subapp are retrieved unchanged when transferred back using MultiAppVariableValueSamplePostprocessorTransfer in case the CentroidMultiApp is used.
2.70.180The systen shall error out if more than one sub-applications are in the same distance from an element.
2.70.181The systen shall error out if the MultiAppVariableValueSamplePostprocessorTransfer transfers postprocessor values on sub-applications to a primary variable on the main application.
2.70.182
The systen shall allow transferring CONSTANT MONOMIAL variables from the sub-applications
1. using block restriction in the CentroidMultiApp and
2. using block restriction in both the CentroidMultiApp and the variable.
2.70.183The system shall support the ability transfer vectors of post processing data between the parent application and sub-applications.
2.70.184The system shall support support the ability to perform interpolation between time steps when transferring field data between a parent application and sub-applications.
2.70.185The Transfer system shall support execution with the EXEC_FINAL flag.
2.70.186The system shall support transferring data between applications at the beginning of the fixed point iterations.
2.70.187The system shall support transferring data between applications at the end of the fixed point iterations.
2.70.188The system shall be able to transfer data to and from an application executed at the beginning of the fixed point iterations.
2.70.189The system shall be able to transfer data to and from an application executed at the end of the fixed point iterations.
2.70.190The system shall support the transfer of data between a parent application and sub-applications after a sub-application as been reset.

framework: Userobjects
2.72.1The system shall terminate the execution of a solve based on post-processing calculations performed within the simulation.
2.72.2The system shall abort the current step in a solve based on post-processing calculations performed within the simulation to cut the timestep.
2.72.3The system shall abort the current nonlinear or linear solve in a simulation based on post-processing calculations performed within the simulation to cut the timestep.
2.72.4The system shall be able to output a warning message if a given criterion is met based on post-processing calculations, with no additional consequences to the solve.
2.72.5The terminator system shall output a custom info, warning, or error message.
2.72.6The terminator system shall check the compatibility of the suplied parameters.
2.72.7The terminator system shall check that if a message is supplied, an appropriate error level for reporting that message is also used.
2.72.8The system shall check a criterion for early termination of the run, but continue with the regular simulation when that criterion is not met.
2.72.9The system shall check that postprocessors providing data for a terminator meant to force a failure in a solve or a time step are executed often enough to be able to update the criterion.
2.72.10The system shall support the use of data produced by a custom user object calculations within a kernel object.
2.72.11The system shall be able to execute user objects that perform operations on elements, boundaries, and internal sides.
2.72.12The system shall be able to execute user objects that perform operations on elements, boundaries, and interfaces.
2.72.13
The system shall evaluate the quality of all the mesh elements and report
1. a warning when the "warning" option is selected,
2. an error when the "error" option is selected, or
3. a message when the selected metric does not apply to the element type being examined.
2.72.14The system shall execute user objects in the same group in the order given in the design documentation.
2.72.15The system shall permit adding one new execution order group.
2.72.16The system shall correctly resolve dependencies within an execution order group.
2.72.17The system shall permit adding multiple new execution order groups.
2.72.18The system shall permit adding a new execution order group with a negative priority.
2.72.19
The system shall support overriding the inter-system dependency resolution to allow for developers to decide when specific calculations should be forced into a specific order,
1. by forcing a user object to execute before auxiliary kernels
2. by forcing a user object to execute after auxiliary kernels
2.72.20The system shall be able to integrate a function over layers
2.72.21The system shall support 'snapping' or moving new nodes in sidesets created by mesh adaptivity to the surface of a geometric sphere to capture high fidelity features on curved geometries.
2.72.22The system shall support 'snapping' or moving new nodes in lower dimensional subdomains created by mesh adaptivity to the surface of a geometric sphere to capture high fidelity features on curved geometries.
2.72.23Testing the implementation of the InterfaceQpValueUserObject. This test also shows the use of InterfaceValueUserObjectAux AuxKernel. InterfaceValueUserObjectAux use interface values computed and stored at each qp from the InterfaceQpValueUserObject and output them into an auxvaraible.Values on the interface are then computed via SideAverageValue PP.By design at the end of the first step we should observe: an average material property of 7, an average material property absolute jump fo 6, a singed material property jump (primary-secondary) of 6 a singed material propertyjump (secondary-primary) of -6 a material property value on the primary side of 10 a material property value on the primary side of 4
2.72.24The InterfaceUserObject system shall be able to get updated bulk, boundary and interface material property values.This test uses two specific test materials (e.g. LinearNonLinearIterationMaterial and LinearNonLinearIterationInterfaceMaterial) and one test userobject (e.g. InterfaceUserObjectTestGetMaterialProperty).This test will produce an error if the computed an retrived material property are not the same.
2.72.25Testing the implementation of the InterfaceQpValueUserObject when computing the variable rate or increment.
2.72.26Testing the implementation of the InterfaceQpMaterialPropertyRealUO.
2.72.27
The system shall support executing custom algorithms on all internal sides of the mesh where properties retrieved on that side come from:
1. the same subdomain, or
2. different subdomains.
2.72.28The system shall allow taking averages of variables along a coordinate axis in layers
2.72.29The system shall allow automatic specification of points to output the unique user object values
2.72.30The system shall be capable of computing layered averages of a variable given bounds.
2.72.31
The system shall report an error when computing layered averages of a variable if
1. the bounding box is set along with the number of layers or
2. sample interpolate and
3. if neither the bounds or number of layers are set.
2.72.32The system shall allow interpolating between layers for layered averages
2.72.33The system shall respect mesh displacements in layered average
2.72.34
The system shall be capable of computing layered averages of a variable
1. within a subdomain and
2. within a prescribed region in a subdomain.
2.72.35The system shall respect block restriction for layered averages even when using num_layers
2.72.36The system shall allow bounds for layered averages when using num_layers to come from a block different than the block restriction
2.72.37The system shall have the ability to maintain persistent generic user data stored in "layers" that may persist across invocations in the form of file data.
2.72.38The system shall allow taking the minimum of material properties along a coordinate axis in layers.
2.72.39The system shall allow taking the maximum of material properties along a coordinate axis in layers.
2.72.40
The system shall include the ability to computes volume integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z)
1. using 3 layers with
2. automatic specification of points to output unique values and
3. as a cumulative calculation and
4. as a cumulative calculation in the negative direction and
5. as an average calculation,
6. and using finite volume variables.
2.72.41The system shall compute layered side averages of a functor.
2.72.42The system shall correctly compute layered integrals along a specified boundary.
2.72.43The system shall allow automatic specification of points to output the unique user object values for a layered integral.
2.72.44The system shall correctly compute layered integrals of finite volume variables along a specified boundary.
2.72.45The system shall allow taking averages of variables along a coordinate axis in layers on a boundary.
2.72.46The system shall allow automatic specification of points to output the unique user object values for a layered average.
2.72.47The system shall allow taking averages of the diffusive flux of variables along a coordinate axis in layers on a boundary.
2.72.48The system shall allow taking averages of the diffusive flux of finite volume variables along a coordinate axis in layers on a boundary.
2.72.49The system shall not allow both the block and boundary parameter to be specified for layered side integrals.
2.72.50The system shall compute layered side integrals of a functor.
2.72.51The system shall support late binding of material properties to other objects so that those objects may be created first, or material property retrieval may be delayed until the system is initialized.
2.72.52
The system shall be able to print out a message to screen from the input file
1. print out the user-defined message
2.72.53
The system shall be able to execute a user object on a mortar interface and obtain gap computations that are equivalent to an auxiliary kernel evaluation
1. on a reference, undisplaced mesh, and
2. on a displaced mesh.
2.72.54The system shall compute averages computed from the closest values for a list of points
2.72.55The system shall compute layered averages that computed from the closest values for a list of points that are explicitly specified in an input file
2.72.56The system shall compute layered averages that computed from the closest values for a list of points that are specified in an external file
2.72.57The system shall report an error when points are not specified in an input file nor an external file when computing nearest point layered averages
2.72.58The system shall report an error when points are specified both in an input file and an external file when computing nearest point layered averages
2.72.59The system shall report an error when there is not enough coordinates specified in an external file specifing the point for computing nearest point layered averages
2.72.60The system shall compute layered averages for concentric cylindrical rings with equal thickness for a list of points that correspond to the average radius of each ring
2.72.61The system shall compute layered averages computed from the closest values for a list of points and output to a spatial vector postprocessor with one point per unique nearest point and layer
2.72.62The system shall compute radial layered averages computed from the closest values for a list of points and output to a spatial vector postprocessor with one point per unique nearest point and layer
2.72.63The system shall report an error if user-set direction bounds conflict with block-type bound specifications
2.72.64The system shall report an error if a direction bound is missing
2.72.65The system shall report an error if the maximum bound is lower than the minimum bound
2.72.66The system shall allow specification of direction bounds to skip bounding box calculation
2.72.67The system shall compute layered integrals that computed from the closest values for a list of points that are specified in an external file
2.72.68The system shall compute layered integrals computed from the closest values for a list of points and output to a spatial vector postprocessor with one point per unique nearest point and layer
2.72.69The system shall compute layered side averages that computed from the closest values for a list of points
2.72.70The system shall compute layered side averages of a functor that are computed from the closest values for a list of points.
2.72.71The system shall compute layered side averages of the diffusive flux that are computed based on the flux values closest to a list of points
2.72.72The system shall compute layered side integrals that computed from the closest values for a list of points
2.72.73The system shall compute layered side integrals of a functor that are computed from the closest values for a list of points.
2.72.74The system shall be able to construct nodal variables from material properties that are defined at quadrature points.
2.72.75The system shall be able to pointwise renormalize tuples of solution variables as a vector to a desired L2-norm
2.72.76The system shall be able to keep track of a postprocessor value associated with a sub-app at a geometrical location
2.72.77The system shall provide means to detect unresolved dependency in evaluations of user objects and auxiliary kernels
2.72.78The system shall consider that when auxkernel depends on a UO, the exec flag will be taken into consideration to determin when the UO must be executed preaux.
2.72.79
The system shall include a file reader for data stored in a CSV format
1. with the name of each CSV data file to read stored in a separate CSV file. At each user object execution, the next data file is read
2.72.80
The system shall error if
1. the user provides two parameters for the property file names,
2. the user supplied an empty vector for the property file names,
2.72.81
The system shall will compute a radial average of a material property that changes over time with
1. an equal weight for all material points
2. a weight factor that falls off linearly to zero with distance
3. a weight factor that falls off with a cosine profile with distance
2.72.82
The system shall execute objects associated with mesh entities corresponding to the number of times those objects appear:
1. once for general user objects,
2. for each element,
3. for each side,
4. for each internal side, and
5. for each node.
2.72.83The system shall support optionally initializing shape function data structures for use in custom algorithm (UserObject) calculations.
2.72.84
The system shall compute the proper shape functions which can be used to verify Residual and Jacobian calculations
1. of a single variable,
2. of two coupled variables with explicit off-diagonals requested,
3. of two coupled variables with a full Jacobian matrix
4. on the side of elements, and
5. for a full physics test.
2.72.85
The system shall report an error if a user attempts to use nonlocal residual objects without appropriate coupling specified in a preconditioning object. These residual objects include
1. kernels
2. boundary conditions
2.72.86
The system shall be able to perform automatic scaling in the presence of nonlocal residual objects such as
1. kernels
2. boundary conditions
2.72.87The system shall be able to use algebraic information associated with lower-dimensional elements in side user objects.
2.72.88The system shall report an error if the boundary is not specified when computing the average value of a variable on a boundary.
2.72.89The system shall check if the lower-d variable is properly defined on a boundary.
2.72.90The system shall report an error if the lower-d variable is not properly defined on a boundary.
2.72.91The system shall report an error if the side average value of a variable is requested on a boundary that is the centerline of an axisymmetric model.
2.72.92The system shall be capable of writing out a solution file with both continuous and discontinuous fields for the purpose of verifying that ability to read those solutions back into a new simulation.
2.72.93The system shall be capable of reading in field information and producing gradient values from both continuous and discontinuous fields.
2.72.94The system shall not create scalar variables from global variables that have a name that matches a field variables's name when importing a solution from an exodus file
2.72.95
The system shall support creating n-thread copies of user-defined objects (GeneralUserObjects) for the purpose of running multiple related calculations simultaneously, avoiding thread locks during common look-up operations, where individual thread ids may be used to calculate a quantity based on the number of threads for:
1. one thread,
2. two threads,
3. three threads,
4. four threads,
5. five threads,
6. six threads,
7. seven threads, and
8. eight threads.
2.72.96
The system shall support the ability to toggle mesh adaptivity:
1. off when it has been turned on in the input file,
2. off when we are using initial adaptivity in the input file,
3. off after a specific time, or
4. off after some number of steps.
2.72.97The system shall allow nodal user objects to obtain writable references to nodal variables.
2.72.98The system shall allow elemental user objects to obtain writable references to elemental variables.
2.72.99The system shall prevent nodal user objects from obtaining writable references to elemental variables.
2.72.100The system shall prevent elemental user objects from obtaining writable references to nodal variables.
2.72.101The system shall allow block restricted user objects to obtain a writable reference to a variable with a block restriction that includes the user object's blocks
2.72.102The system shall enforce that all variables an object obtains a writable reference to are defined on all of the object's blocks
2.72.103The system shall permit multiple objects to access a variable for writing if the objects have non-overlapping block restrictions
2.72.104The system shall report an error if multiple objects with overlapping block restrictions try to access a variable for writing
2.72.105The system shall report an error if multiple objects, of which at least one is not block restricted, try to access a variable for writing
2.72.106The system shall permit writing to variables from boundary restricted nodal user objects.
2.72.107The system shall make sure that variables written to by boundary restricted user objects are available along the entire boundary.

framework: Utils
2.73.1The system shall support a piecewise bilinear interpolation object to be constructed from x, y data read from an external file.
2.73.2The system shall support a piecewise bilinear interpolation object to be constructed from x, y data.
2.73.3The system shall report an error when a file and data are supplied simultaneously in the PiecewiseBilinear object.
2.73.4The system shall report an error when there is a mismatch in vector lengths in the PiecewiseBilinear object.
2.73.5The system shall report an error when there are insufficient parameters supplied for the PiecewiseBilinear object.
2.73.6The system shall provide a method for transferring common parameters from one object to another.
2.73.7The system shall prevent the user from copying InputParameters objects inside of MooseObject-derived objects.
2.73.8
The system shall throw an error while creating a LibtorchArtificialNeuralNet when encountering
1. an unsupported activation function;
2. the wrong number of activation functions;
3. a non-supported optimizer.
2.73.9
The system shall be able to create and evaluate a neural network with an activation function type of
1. rectified linear unit (ReLU);
2. sigmoid;
3. Gaussian Error Linear Unit (GELU);
4. Exponential Linear Unit (ELU);
5. linear;
2.73.10
The system shall be able to train a neural network with an optimizer type of
1. Adaptive Gradient (AdaGrad);
2. Adam;
3. Root Mean Squared Propagation (RMSProp);
4. Stochastic Gradient Descent (CGD);
2.73.11The system shall be able to evaluate a neural net with the same values as the python code which created the neural net.
2.73.12The system shall have a function that evaluates the polynomial and derivative of polyonimal of varying degree and arbitrary coefficients
2.73.13The system shall have a clamp function that returns a value limited to upper and lower bounds
2.73.14The system shall have a smootherstep function that returns a smooth transition value between an upper and lower bound
2.73.15The system shall support the use of the Dennis-Schnabel method for computing the finite difference parameter for matrix free finite difference solver.
2.73.16The system shall automatically report input errors when a required parameter is not specified.
2.73.17
The PerfGraph shall report a reasonable error when
1. registering a section without a name
2. registering a section without a live message
3. requesting the ID of a section that does not exist
4. requesting the section info for a section that does not exist
2.73.18The system shall allow for timing sections of code and having automated print-outs when they take too long.
2.73.19The system shall allow for nested code timing sections and having automated print-outs of the code section names when they are taking a long time.
2.73.20The system shall be able to display the automatic print-out of a timed section even when an external print happened before the threshold for the automatic print-out was met.
2.73.21The system shall allow for automatic print-outs of timing sections within multiapps.
2.73.22The system shall allow for automatic print-outs of nested timing sections within multiapps.
2.73.23The system shall allow for automatic print-outs of timing sections within nested multiapps.
2.73.24The system shall include a utility for swapping values within a vector of data.
2.73.25The system shall include a utility for shuffling values within a vector of data.
2.73.26The system shall include a utility for resampling values within a vector of data.
2.73.27The system shall include a utility for computing spline functions.
2.73.28
The system shall include a utility for computing bicubic spline functions
1. using the x-component, and
2. using the y-component.
3. using the z-component,

framework: Variables
2.74.1The system shall provide an ability to add array variables with constant initial conditions.
2.74.2The system shall be able to define an array variable with component size one.
2.74.3The system shall report a reasonable error when defining a variable with multiple components not as an array variable.
2.74.4The system shall support the automated creation of array variables.
2.74.5The system shall support direct calculation of field variables on multiple mesh subdomains.
2.74.6The system shall be able to solve a finite volume problem while caching variable gradients at cell centers.
2.74.7The system shall be able to solve a finite volume problem without caching any solution-related quantities.
2.74.8
The system shall support the ability to couple a scalar auxiliary calculation for use in a field auxiliary calculation:
1. using current scalar values,
2. using previously calculated scalar values (old), and
3. using values calculated from two steps back (older).
2.74.9The system shall support the ability to use a default value when an optional scalar coupling is requested but not supplied.
2.74.10The system shall support the ability to use the initial value of a scalar auxiliary calculation when it is coupled into another object that executes at the beginning of the simulation.
2.74.11The system shall support "curvilinear" elements (elements that contain curved edges.
2.74.12
The system shall support the hierarchical family of shape functions on mesh
1. in 1D,
2. in 2D, and
3. in 3D.
2.74.13
The system shall produce the correct convergence rate for third-order Hermite shape function discretizations as mesh refinement is performed:
1. when using periodic boundary conditions, and
2. when using Dirichlet boundary conditions.
2.74.14
The system shall support the hierarchical family of shape functions on mesh including:
1. first-order on 1D elements,
2. second-order on 1D elements,
3. third-order on 1D elements,
4. first-order on 2D elements,
5. second-order on 2D elements,
6. third-order on 2D elements,
7. first-order on 3D elements,
8. second-order on 3D elements, and
9. third-order on 3D elements.
2.74.15
The system shall support the constant Monomial family of shape functions on mesh elements:
1. in one dimension,
2. in two dimensions, and
3. in three dimensions.
2.74.16The system shall report an error if a user requests a constant monomial finite element variable type with either a non-monomial family or non-constant order.
2.74.17
The system shall support the direct retrieval of "elemental solution" or "degree of freedom" values without the need to sample the finite element shape function:
1. for current solution values,
2. for previous solution values (old), and
3. for solution values calculated two steps back (older).
2.74.18The system shall support second and third order Monomial family of shape functions.
2.74.19The system shall be able to evaluate linear finite volume variables with basic postprocessors.
2.74.20The system shall be able to use linear finite volume variables with basic aux kernels.
2.74.21The system shall support the ability to have mixed field variable orders on the same mesh.
2.74.22The system shall support the ability to have multiple independent block restricted variables in a mesh contain multiple blocks.
2.74.23Allow optional variable coupling where a default constant value is assumed when the user omits specifying a variable.
2.74.24Users are allowed to provide constant numeric values as input to an optionally coupled variable in addition to variable names that overrides the default constant value specified in code.
2.74.25Simulations with second derivative variable coupling shall not crash due to access to uninitialized data structures.
2.74.26
Coupleable shall provide an interface that allows providing default values for a variables that operates
1. with defaults or
2. a vector of coupled variables.
2.74.27The system shall report an error when users couple constant values and variables together
2.74.28
The system shall report an error when requested default vector value is out of range and
1. accessed by name or
2. accessed by index.
2.74.29The system shall support the ability to couple to a previous field variable calculation to produce another field such that there is no Jacobian contribution due to the lagged coupling.
2.74.30The system shall ensure that coupled second derivative calculations are only performed when requested and are only performed on the minimum required fields.
2.74.31The system shall initialize SIDE_HIERARCHIC variables as instructed
2.74.32The system shall compute time derivatives on a neighbor element for constant monomials

framework: Vectorpostprocessors
2.75.1Line sampling shall account for floating point precision error.
2.75.2The system shall be able to produce arbitrary vectors of values for use in other calculations.
2.75.3The system shall be able to produce multiple arbitrary vectors of values for use in other calculations.
2.75.4The system shall support the ability to read a comma separated file into an object and make it accessible through easy to use standard C++ containers.
2.75.5The system shall support the ability to read CSV data on only one processor and broadcast it to other ranks.
2.75.6The system shall report an error if the broadcast CSV data does not match on all ranks in a parallel job.
2.75.7The system shall support the ability to read a comma separated file into an object prior to initial setup.
2.75.8The system shall issue an error if the CSVReaderVectorPostprocessor is used in a UserObjectTransfer because the former does not have any notion of "spatial" information.
2.75.9The system shall support the computation of averages of variables over cylindrical shells.
2.75.10
The system shall support writing a vector of data
1. that is completely stored on a single processor or
2. distributed across many and
3. allows for the creation of symbolic links to the the most recent and final files on each processor.
2.75.11The system shall support dynamic numbers of sample points during the simulation.
2.75.12The system shall support dynamic numbers of sample points during the simulation with move semantics of the points vector.
2.75.13The system shall have the ability to retrieve element integers when visiting elements.
2.75.14The system shall have the ability to retrieve element integers when visiting elements only on certain subdomains.
2.75.15The system shall have the ability to retrieve element integers of attached elements when visiting sides of a side set.
2.75.16The system shall have the ability to retrieve element integers of attached elements on both sides when visiting internal interfaces.
2.75.17The system shall have the ability to retrieve element integers of attached elements on both sides when visiting all internal sides.
2.75.18The system shall be able to output material properties calculated at quadrature points on user-defined elements in a comma separated format.
2.75.19The system shall be able to output material properties calculated at quadrature points on all active elements.
2.75.20The system shall be able to output material properties calculated at quadrature points on all active elements within the specified subdomains.
2.75.21
The system shall issue an error if material output samples are attempted for elements:
1. but the material is restricted to a boundary, or
2. the material is restricted to a block not containing the desired elements, or.
3. the material does not exist on the mesh.
2.75.22
The system shall support sampling of a field variable at the centroid of every element in the domain
1. for elemental FE variables and
2. for FV variables,
3. for finite volume variables mixed with finite element variables,
4. but not for nodal variables.
2.75.23
The system shall be capable of locating the maximum distances (the element) between two field variables:
1. the true maximum involving a simple difference, and
2. the absolute maximum involving the difference between absolute values.
2.75.24The ElementsAlongLine VectorPostprocessor shall output the IDs of all elements intersected by a line on a 1D mesh
2.75.25The ElementsAlongLine VectorPostprocessor shall output the IDs of all elements intersected by a line on a 2D mesh
2.75.26The ElementsAlongLine VectorPostprocessor shall output the IDs of all elements intersected by a line on a 3D mesh
2.75.27The ElementsAlongPlane VectorPostprocessor shall output the IDs of all elements intersected by a plane on a 1D mesh
2.75.28The ElementsAlongPlane VectorPostprocessor shall output the IDs of all elements intersected by a plane on a 2D mesh
2.75.29The ElementsAlongPlane VectorPostprocessor shall output the IDs of all elements intersected by a plane on a 3D mesh
2.75.30
The system shall be able to integrate or average variables or material properties parsed by extra IDs
1. with a single variable integral and a single extra ID
2. with a single variable integral and multiple extra IDs
3. with multiple variable integrals and multiple extra IDs
4. with multiple variable and material property integrals and multiple extra IDs
5. with multiple variable and material property averages and multiple extra IDs
2.75.31The system shall be able to compute a histogram of each vector of data produced by a vector data producer (VectorPostprocessor).
2.75.32The histogram vector postprocessor shall generate an error if the vector postprocessor that it operates on does not have any declared vectors
2.75.33
The system shall support finding all of the elements intersected by a line:
1. in 1D,
2. in 2D, and
3. in 3D.
2.75.34The system shall have late binding producers of vector quantities (VectorPostprocessors) that may be declared after system initialization.
2.75.35The LeastSquaresFit vectorpostprocessor shall compute a least squares fit of a first-order polynomial sampled from a solution field using LineValueSampler with shifting and scaling parameters specified
2.75.36The LeastSquaresFit vectorpostprocessor shall compute a least squares fit of a zeroth-order polynomial with data provided by a CSVReaderVectorPostprocessor
2.75.37The LeastSquaresFit vectorpostprocessor shall compute a least squares fit of a first-order polynomial with data provided by a CSVReaderVectorPostprocessor
2.75.38The LeastSquaresFit vectorpostprocessor shall compute a least squares fit of a second-order polynomial with data provided by a CSVReaderVectorPostprocessor
2.75.39The LeastSquaresFit vectorpostprocessor shall generate an error if a fit for a third-order polynomial is requested and only three data points are provided
2.75.40The system shall support computing the least squares fit of a set of time values obtained from an aggregate operation defined by the developer.
2.75.41The system shall support sampling one or more spatial functions along a line with fixed sampling intervals.
2.75.42The system shall support the ability to sample a scalar material along an arbitrary line through the mesh domain.
2.75.43The system shall allow sampling of variables at equally spaced points for outputting.
2.75.44The system shall allow sampling of variables at equally spaced points in parallel.
2.75.45The system shall allow scaling the line value sampler with a postprocessor.
2.75.46The system shall allow sampling of auxvariables at equally spaced points with CSV delimiter and precision setting.
2.75.47The system shall support reduction of functors on a division of the mesh.
2.75.48
The system shall report an error if
1. a spatial value is requested from a reduction object that can return multiple spatial values, one for each input functor,
2. and if a spatial value is requested from a reduction object outside of the range of validity of the mesh division.
2.75.49
The system shall emit a warning if
1. a reduction is trying to obtain indexes into a mesh division for points that lie outside of the mesh division.
2.75.50The system shall compute integrals computed from the closest values for a list of points and output to a spatial vector postprocessor with one point per point
2.75.51The system shall support sampling of a field variable at every node in the domain.
2.75.52The system shall issue an error when a nodal sampler is used on a field that does not have values defined at the nodes.
2.75.53The system shall provide VectorPostprocessor results to all processors as scattered data.
2.75.54The system shall provide VectorPostprocessor results to all processors as replicated data.
2.75.55The system shall support the ability to sample field variables at user specified points.
2.75.56The system shall support the ability to sample field FV variables at user specified points.
2.75.57The system shall report an error when requested sample points do not fall within the mesh domain.
2.75.58
The system shall report a warning when variables requested are discontinuous and requested sample points are
1. on element faces and
2. on element nodes.
2.75.59
The system shall make a consistent choice as to which element value to report when variables requested are discontinuous and requested sample points are
1. on element faces and
2. on element nodes.
3. whether elements are renumbered or not and
4. on process domain boundaries.
2.75.60The VectorPostprocessor system takes a parameter "contains_complete_history" which guarentees the vector state is left alone between invocations resulting in a single CSV output file.
2.75.61The system shall support the ability to sample functors at points specified using a specific class to provide positions.
2.75.62The system shall be capable of sampling one or more field variables along a side/boundary at each quadrature point along the side.
2.75.63The system shall be capable of sampling one or more field variables along an internal side at each quadrature point along the side.
2.75.64
The system shall allow outputting relevant information about sidesets
1. on a regular mesh,
2. and on a displaced mesh.
2.75.65The system shall be able to query a spatial user object and aggregate the results into a vector postprocessor.
2.75.66The system shall report an error if the points are specified in more than one manner for a spatial vector postprocessor.
2.75.67The system shall support computing the spherical average of a variable as a function of radius throughout the mesh domain.
2.75.68The system shall support the ability to output a separate comma separated value file containing time and time time information corresponding to vector Postprocessor output.
2.75.69The system shall allow support the creation of histogram or binned data of volume fractions with respect to variable values.
2.75.70The system shall be able to aggregate an arbitrary set of scalar data producers (Postprocessors) into a single vector of Postprocessors.
2.75.71
The system shall have the ability to compute several statistics related to the balance of the mesh partitioning
1. on replicated meshes, and
2. on distributed meshes.

Usability Requirements

framework: Usability
2.71.1
The system will be operated using a command-line interface that
1. reports the available options when none are provided and
2. accepts defined command-line flags.
2.71.2
The system will be operated using
1. an input file and
2. command-line options.
2.71.3The system shall return usage messages when unidentified arguments or incorrectly used arguments are passed.
2.71.4The system shall provide diagnostics when the input file fails to parse, or the format is incorrect.
2.71.5The system will provide on screen information about the simulation characteristics of the solves under normal operating conditions.

Performance Requirements

framework: Performance
2.49.1
The system shall support the use of multiple processors using
1. distributed memory,
2. shared memory, and
3. both distributed and shared memory.
2.49.2
The system shall support execution on
1. macOS and
2. Linux operating systems.

System Interfaces

framework: System Interfaces
2.65.1The system shall support the use of message passing interface (MPI).
2.65.2
The system shall support the use of shared memory threads using
1. 'pthreads' or
2. OpenMP.
2.65.3
The system shall support the use of the following parallel mesh partitioners:
1. Chaco,
2. ParMETIS,
3. Party, and
4. PTScotch.
2.65.4
The system shall support the use of the following solver packages:
1. SuperLU,
2. MUMPS, and
3. SLEPc.
2.65.5
The system shall support the use of the following C++ libraries:
1. Visualization ToolKit (VTK) and
2. BOOST.
2.65.6
The system shall interface operate with the following C++ compilers:
1. Clang and
2. GCC.

System Operations

Human System Integration Requirements

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

Maintainability

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 framework in its entirety will be made publicly available under the GNU Lesser General Public License (LGPL) version 2.0 license.

Reliability

The regression test suite will cover at least 80% of all lines of code at all times. Known regressions will be recorded and tracked (see Maintainability) 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 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

MOOSE is software only with no associated physical media. See System Requirements for a description of the minimum required hardware necessary for running a MOOSE-based application.

Environmental Conditions

Not Applicable

System Security

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

Information Management

The core framework in its 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. Some MOOSE-based development teams follow the NQA-1 standards.

Packaging, Handling, Shipping and Transportation

No special requirements are needed for packaging or shipping any media containing MOOSE source code. However, some MOOSE-based applications 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