Phase Field Software Design Description

Introduction

The Software Design Description (SDD) for Phase Field is a description of the software product and serves as guideline that describes the architecture of the system and all of its parts.

Dependencies

The Phase Field application is developed using MOOSE and is based on various modules, as such the SDD for Phase Field is dependent upon the following documents.

• Framework System Design Description

Requirements Cross Reference

The following is a list of all design documents and the associated requirements for Phase Field.

• phase_field: ADCHSoretMobility
• F8.1.1A temperature gradient driving force for diffusion shall be added to the split form of the Cahn-Hilliard equation and solved using automatic differentiation.

  Specification: ADCHSoretDiffusion:simple_transient_diffusion_with_soret

  Design: ADCHSoretMobility

  Issue(s): #14396

  20
• F8.1.2The Jacobians for the automatic differentiation ADCHSplitChemicalPotential and ADCHSplitConcentration kernels shall be accurate.

  Specification: ADCHSoretDiffusion:simple_transient_diffusion_with_soret-jac

  Design: ADCHSoretMobility

  Issue(s): #14396

  20

• phase_field: ADCHSplitChemicalPotential
• F8.2.1ADCHSplitChemicalPotential and ADCHSplitConcentration shall solve a simple Cahn-Hilliard problem using automatic differentiation.

  Specification: ADCHSplitChemicalPotential:simple_transient_diffusion

  Design: ADCHSplitChemicalPotentialADCHSplitConcentration

  Issue(s): #14396

  20
• F8.2.2The Jacobians for the automatic differentiation ADCHSplitChemicalPotential and ADCHSplitConcentration kernels shall be accurate.

  Specification: ADCHSplitChemicalPotential:simple_transient_diffusion-jac

  Design: ADCHSplitChemicalPotentialADCHSplitConcentration

  Issue(s): #14396

  20

• phase_field: ADCHSplitConcentration
• F8.2.1ADCHSplitChemicalPotential and ADCHSplitConcentration shall solve a simple Cahn-Hilliard problem using automatic differentiation.

  Specification: ADCHSplitChemicalPotential:simple_transient_diffusion

  Design: ADCHSplitChemicalPotentialADCHSplitConcentration

  Issue(s): #14396

  20
• F8.2.2The Jacobians for the automatic differentiation ADCHSplitChemicalPotential and ADCHSplitConcentration kernels shall be accurate.

  Specification: ADCHSplitChemicalPotential:simple_transient_diffusion-jac

  Design: ADCHSplitChemicalPotentialADCHSplitConcentration

  Issue(s): #14396

  20

• phase_field: GBAnisotropy
• F8.3.1A material shall be provided to compute anisotropic grain boundary energies and mobilities.

  Specification: GBAnisotropy:test1

  Design: GBAnisotropy

  Issue(s): #4580

  20
• F8.3.2A material shall be provided to compute anisotropic grain boundary energies and mobilities.

  Specification: GBAnisotropy:test2

  Design: GBAnisotropy

  Issue(s): #4580

  20
• F8.3.3A material shall be provided to compute anisotropic grain boundary energies and mobilities with an inclination dependence.

  Specification: GBAnisotropy:test3

  Design: GBAnisotropy

  Issue(s): #4580

  20

• phase_field: GBWidthAnisotropy
• F8.3.4The anisotropic grain boundary system shall allow the user to specify grain boundary widths independently for each interface between grains.

  Specification: GBAnisotropy:testwidth1

  Design: GBWidthAnisotropy

  Issue(s): #8079

  20

• phase_field: GrandPotentialKernelAction
• F8.4.1MOOSE shall provide classes to implement a Grand Potential phase field formulation

  Specification: GrandPotentialPFM:GrandPotentialPFM

  Design: GrandPotentialKernelAction

  Issue(s): #6977

  20
• F8.11.18The GrandPotentialAction shall have the ability to generate kernels

  Specification: actions:grand_potential_kernels

  Design: GrandPotentialKernelAction

  Issue(s): #11386

  20

• phase_field: ACSwitching
• F8.4.2MOOSE shall provide a Grand Potential based multiphase model

  Specification: GrandPotentialPFM:GrandPotentialMultiphase

  Design: ACSwitching

  Issue(s): #8213

  20

• phase_field: ACInterface2DMultiPhase1
• F8.4.3MOOSE shall provide a Grand Potential based dendritic solidification capability in 2D

  Specification: GrandPotentialPFM:GrandPotentialAnisotropy

  Design: ACInterface2DMultiPhase1ACInterface2DMultiPhase2InterfaceOrientationMultiphaseMaterial

  Issue(s): #11802#12554

  20

• phase_field: ACInterface2DMultiPhase2
• F8.4.3MOOSE shall provide a Grand Potential based dendritic solidification capability in 2D

  Specification: GrandPotentialPFM:GrandPotentialAnisotropy

  Design: ACInterface2DMultiPhase1ACInterface2DMultiPhase2InterfaceOrientationMultiphaseMaterial

  Issue(s): #11802#12554

  20

• phase_field: InterfaceOrientationMultiphaseMaterial
• F8.4.3MOOSE shall provide a Grand Potential based dendritic solidification capability in 2D

  Specification: GrandPotentialPFM:GrandPotentialAnisotropy

  Design: ACInterface2DMultiPhase1ACInterface2DMultiPhase2InterfaceOrientationMultiphaseMaterial

  Issue(s): #11802#12554

  20

• phase_field: GrandPotentialInterface
• F8.4.4MOOSE shall provide a material to automatically compute grand potential model interface parameters based on provided interfacial free energies and widths

  Specification: GrandPotentialPFM:GrandPotentialInterface

  Design: GrandPotentialInterface

  Issue(s): #12147

  20

• phase_field: AntitrappingCurrent
• F8.4.5MOOSE shall provide a Grand Potential based dendritic solidification capability for alloy with antitrapping current

  Specification: GrandPotentialPFM:GrandPotentialAnisotropyAntitrap

  Design: AntitrappingCurrent

  Issue(s): #13373

  20

• phase_field: DerivativeParsedMaterial
• F8.5.1The Kim-Kim-Suzuki model implementation shall use free energy densities provided by DerivativeParsedMaterials

  Specification: KKS_system:derivative_parsed_material

  Design: DerivativeParsedMaterial

  Issue(s): #4835

  20

• phase_field: KKSCHBulk
• F8.5.2A non-split version of the Kim-Kim-Suzuki shall be provided

  Specification: KKS_system:kks_example

  Design: KKSCHBulk

  Issue(s): #4835

  20

• phase_field: KKSSplitCHCRes
• F8.5.3A split version of the Kim-Kim-Suzuki shall be provided

  Specification: KKS_system:kks_example_split

  Design: KKSSplitCHCRes

  Issue(s): #4835

  20
• F8.5.4The split version of the Kim-Kim-Suzuki shall be yield the correct results with asymmetric free energies

  Specification: KKS_system:kks_example_offset

  Design: KKSSplitCHCRes

  Issue(s): #10315

  20
• F8.5.5A multi component Kim-Kim-Suzuki model shall be implemented

  Specification: KKS_system:kks_xevac

  Design: KKSSplitCHCRes

  Issue(s): #4879

  20

• phase_field: KKSMultiACBulkC
• F8.5.6A multi component Kim-Kim-Suzuki model shall be implemented

  Specification: KKS_system:kks_multiphase

  Design: KKSMultiACBulkC

  Issue(s): #7007

  20

• phase_field: DerivativeTwoPhaseMaterial
• F8.6.1Moose shall provide a material to combine two free energies materials into a WBM two phase free energy

  Specification: MultiPhase:derivativetwophasematerial

  Design: DerivativeTwoPhaseMaterial

  Issue(s): #4035

  20

• phase_field: SwitchingFunctionMaterial
• F8.6.2Moose shall provide a materials to generate barrier and switching function in a WBM multiphase model

  Specification: MultiPhase:orderparameterfunctionmaterial

  Design: SwitchingFunctionMaterial

  Issue(s): #4355

  20

• phase_field: ThirdPhaseSuppressionMaterial
• F8.6.3Moose shall provide a free energy penalty class that suppresses the formation of a third phase in grain boundaries

  Specification: MultiPhase:thirdphasesuppressionmaterial

  Design: ThirdPhaseSuppressionMaterial

  Issue(s): #6279

  20

• phase_field: MultiBarrierFunctionMaterial
• F8.6.4Moose shall provide a material for computing barrier values in multiphase systems

  Specification: MultiPhase:multibarrierfunction

  Design: MultiBarrierFunctionMaterial

  Issue(s): #4545

  20

• phase_field: CrossTermBarrierFunctionMaterial
• F8.6.5Moose shall provide a material for computing independent barrier values for each phase pair in a multiphase system

  Specification: MultiPhase:crosstermbarrierfunction

  Design: CrossTermBarrierFunctionMaterial

  Issue(s): #5192

  20

• phase_field: AsymmetricCrossTermBarrierFunctionMaterial
• F8.6.6Moose shall provide a material for computing independent barrier values for each phase pair in a multiphase system with asymmetric interface profiles

  Specification: MultiPhase:asymmetriccrosstermbarrierfunction

  Design: AsymmetricCrossTermBarrierFunctionMaterial

  Issue(s): #6584

  20

• phase_field: SwitchingFunctionConstraintLagrange
• F8.6.7Moose shall provide a lagrange multiplier based constraint for keeping the sum of all phase order parameters equal to one

  Specification: MultiPhase:lagrangemult

  Design: SwitchingFunctionConstraintLagrange

  Issue(s): #4545

  20
• F8.6.8Moose shall provide a penalty based constraint for keeping the sum of all phase order parameters equal to one

  Specification: MultiPhase:penalty

  Design: SwitchingFunctionConstraintLagrange

  Issue(s): #4723

  20

• phase_field: CrossTermGradientFreeEnergy
• F8.6.9Moose shall provide aan AuxKernel to compute the free energy contribution form pairwise phase barrier functions

  Specification: MultiPhase:crosstermfreeenergy

  Design: CrossTermGradientFreeEnergy

  Issue(s): #4710

  20

• phase_field: ACMultiInterface
• F8.6.10Moose shall provide an Allen-Cahn gradient energy kernel with cross term contributions

  Specification: MultiPhase:acmultiinterface

  Design: ACMultiInterface

  Issue(s): #4545

  20
• F8.6.11Moose shall provide an Allen-Cahn gradient energy kernel with cross term contributions, and some order parameters may be aux variables

  Specification: MultiPhase:acmultiinterface_aux

  Design: ACMultiInterface

  Issue(s): #4545

  20

• phase_field: SwitchingFunction3PhaseMaterial
• F8.6.12Moose shall provide switching functions for three-phase KKS phase-field model

  Specification: MultiPhase:switchingfunction3phasematerial

  Design: SwitchingFunction3PhaseMaterial

  Issue(s): #6857

  20

• phase_field: SwitchingFunctionMultiPhaseMaterial
• F8.6.13Moose shall provide switching functions for multi-phase KKS phase-field model

  Specification: MultiPhase:switchingfunctionmultiphasematerial

  Design: SwitchingFunctionMultiPhaseMaterial

  Issue(s): #8113

  20

• phase_field: MixedSwitchingFunctionMaterial
• F8.6.14Moose shall provide mixed switching functions with order 234 and 246 and an adjustable weight

  Specification: MultiPhase:mixedswitchingfunctionmaterial

  Design: MixedSwitchingFunctionMaterial

  Issue(s): #9042

  20

• phase_field: BarrierFunctionMaterial
• F8.6.15Moose shall provide order 246 polynomials in the two phase barrier function

  Specification: MultiPhase:barrierfunctionmaterial

  Design: BarrierFunctionMaterial

  Issue(s): #9301

  20

• phase_field: MultiSmoothCircleIC
• F8.7.1We shall be able to generate multiple smooth circle initial conditions with uniform radius variation type

  Specification: MultiSmoothCircleIC:multi_test

  Design: MultiSmoothCircleIC

  20
• F8.7.2We shall be able to generate multiple smooth circle initial conditions with normal radius variation type

  Specification: MultiSmoothCircleIC:multi_normal_test

  Design: MultiSmoothCircleIC

  15

• phase_field: LatticeSmoothCircleIC
• F8.7.3We shall be able to produce a lattice of smooth circle initial conditions, allowing the circles to exist on the simulation cell boundaries and using a uniform radius variation type

  Specification: MultiSmoothCircleIC:lattice_bounds

  Design: LatticeSmoothCircleIC

  20
• F8.7.4We shall be able to produce a lattice of smooth circle initial conditions, using a uniform radius variation type

  Specification: MultiSmoothCircleIC:lattice_test

  Design: LatticeSmoothCircleIC

  20
• F8.7.5We shall be able to produce a lattice of smooth circle initial conditions using a normal radius variation type

  Specification: MultiSmoothCircleIC:lattice_normal_test

  Design: LatticeSmoothCircleIC

  20
• F8.7.6We shall be able to create multiple SpecifiedSmoothCircleICs with a small invalue

  Specification: MultiSmoothCircleIC:lattice_small_invalue_test

  Design: LatticeSmoothCircleIC

  20

• phase_field: SpecifiedSmoothCircleIC
• F8.7.7We shall be able to create several SpecifiedSmoothCircleICs with a standard invalue

  Specification: MultiSmoothCircleIC:specified_test

  Design: SpecifiedSmoothCircleIC

  20

• phase_field: DiscreteNucleation
• F8.8.1The nucleation material shall generate a free energy contribution proportional to the map value

  Specification: Nucleation:material

  Design: DiscreteNucleation

  Issue(s): #5472

  20
• F8.8.3The nucleation system shall recoverable

  Specification: Nucleation:material_recover1

  Design: DiscreteNucleation

  Issue(s): #5472

  20
• F8.8.4The nucleation system shall recoverable

  Specification: Nucleation:material_recover2

  Design: DiscreteNucleation

  Issue(s): #5472

  20

• phase_field: DiscreteNucleationInserter
• F8.8.2The nucleation system shall insert nuclei in a manner independen of the domain decomposition and parallelization

  Specification: Nucleation:parallel

  Design: DiscreteNucleationInserter

  Issue(s): #5472

  20
• F8.8.5The nucleation system shall recoverable

  Specification: Nucleation:parallel_recover1

  Design: DiscreteNucleationInserter

  Issue(s): #5472

  20
• F8.8.6The nucleation system shall recoverable

  Specification: Nucleation:parallel_recover2

  Design: DiscreteNucleationInserter

  Issue(s): #5472

  20

• phase_field: DiscreteNucleationMap
• F8.8.7The map shall provide the capability of defining soft interfaces for initial nuclei

  Specification: Nucleation:soft

  Design: DiscreteNucleationMap

  Issue(s): #5526

  20

• phase_field: DiscreteNucleationMarker
• F8.8.8The marker shall trigger refinement of the nucleus insertion area

  Specification: Nucleation:marker

  Design: DiscreteNucleationMarker

  Issue(s): #12099

  20

• phase_field: DiscreteNucleationTimeStep
• F8.8.9The nucleation time step porocessor shall return a timestep limit that can be applied to cut the simulation timestep as new nuclei are inserted

  Specification: Nucleation:timestep

  Design: DiscreteNucleationTimeStep

  Issue(s): #12104

  20

• phase_field: DiscreteNucleationData
• F8.8.10The nucleation data porocessor shall return the number of currently active nuclei or whether a change to the nucleus list has occurred

  Specification: Nucleation:data

  Design: DiscreteNucleationData

  Issue(s): #12114

  20

• phase_field: DiscreteNucleationAux
• F8.8.11The nucleation auxkernel evaluates the nucleation map onto an elemental aux variable

  Specification: Nucleation:auxkernel

  Design: DiscreteNucleationAux

  Issue(s): #12114

  20
• F8.8.12The nucleation force kernel returns a forcing function based on the nucleation map

  Specification: Nucleation:force

  Design: DiscreteNucleationAux

  Issue(s): #12114

  20

• phase_field: DiscreteNucleationFromFile
• F8.8.13The discrete nucleation system shall provide a deterministic nucleus inserter that uses tabulated time and location data from a file

  Specification: Nucleation:file

  Design: DiscreteNucleationFromFile

  Issue(s): #12262

  20

• phase_field: SoretDiffusion
• F8.9.1A temperature gradient driving force for diffusion shall be added to the split form of the Cahn-Hilliard equation.

  Specification: SoretDiffusion:split

  Design: SoretDiffusion

  Issue(s): #5324

  20
• F8.9.2A temperature gradient driving force for diffusion shall be added to the split form of the Cahn-Hilliard equation, where temperature is a coupled non-linear variable

  Specification: SoretDiffusion:split_temp

  Design: SoretDiffusion

  Issue(s): #5324

  20
• F8.9.3A temperature gradient driving force for diffusion shall be added to the non-split form of the Cahn-Hilliard equation.

  Specification: SoretDiffusion:direct

  Design: SoretDiffusion

  Issue(s): #5324

  20
• F8.9.4A temperature gradient driving force for diffusion shall be added to the non-split form of the Cahn-Hilliard equation, where temperature is a coupled non-linear variable

  Specification: SoretDiffusion:direct_temp

  Design: SoretDiffusion

  Issue(s): #5324

  20

• phase_field: TotalFreeEnergy
• F8.10.1We shall be able to calculate the free energy (with one variable) using an AuxKernel

  Specification: TotalFreeEnergy:TotalFreeEnergy

  Design: TotalFreeEnergy

  Issue(s): #4413

  20
• F8.10.2We shall be able to calculate the free energy (with two variables) using an AuxKernel

  Specification: TotalFreeEnergy:2var

  Design: TotalFreeEnergy

  Issue(s): #4413

  20

• phase_field: NonconservedAction
• F8.11.1The phase field module shall provide an action to set up an Allen-Cahn problem

  Specification: actions:Nonconserved_1var

  Design: NonconservedAction

  Issue(s): #9336

  20
• F8.11.2The NonconservedAction shall correctly set up Allen-Cahn problems with higher order elements

  Specification: actions:Nonconserved_highorder

  Design: NonconservedAction

  Issue(s): #9336

  20
• F8.11.3The NonconservedAction shall correctly set up Allen-Cahn problems with variable dependent mobilities

  Specification: actions:Nonconserved_variableL

  Design: NonconservedAction

  Issue(s): #9336

  20
• F8.11.4The NonconservedAction shall correctly set up Allen-Cahn problems with multiple order parameters

  Specification: actions:Nonconserved_2vars

  Design: NonconservedAction

  Issue(s): #9336

  20
• F8.11.10The phase field module NonconservedAction and ConservedAction can be combined to construct a coupled Allen-Chan and split Cahn-Hilliard problem

  Specification: actions:both_split_2vars

  Design: ConservedActionNonconservedAction

  Issue(s): #9336

  20
• F8.11.11The phase field module NonconservedAction and ConservedAction can be combined to construct a coupled Allen-Chan and non-split Cahn-Hilliard problem

  Specification: actions:both_direct_2vars

  Design: ConservedActionNonconservedAction

  Issue(s): #9336

  20

• phase_field: ConservedAction
• F8.11.5The phase field module shall provide an action to set up a non-split Cahn-Hilliard problem

  Specification: actions:conserved_direct_1var

  Design: ConservedAction

  Issue(s): #9336

  20
• F8.11.6The phase field module shall provide an action to set up a reverse split Cahn-Hilliard problem

  Specification: actions:conserved_split_1var

  Design: ConservedAction

  Issue(s): #9336

  20
• F8.11.7The phase field module shall provide an action to set up a reverse split Cahn-Hilliard problem with higher order elements

  Specification: actions:conserved_split_1var_high_order

  Design: ConservedAction

  Issue(s): #9336

  20
• F8.11.8The phase field module shall provide an action to set up a non-split Cahn-Hilliard problem with variable dependent mobilities

  Specification: actions:conserved_direct_1var_variable_mob

  Design: ConservedAction

  Issue(s): #9336

  20
• F8.11.9The phase field module shall provide an action to set up a reverse split Cahn-Hilliard problem with variable dependent mobilities

  Specification: actions:conserved_split_1var_variable_mob

  Design: ConservedAction

  Issue(s): #9336

  20
• F8.11.10The phase field module NonconservedAction and ConservedAction can be combined to construct a coupled Allen-Chan and split Cahn-Hilliard problem

  Specification: actions:both_split_2vars

  Design: ConservedActionNonconservedAction

  Issue(s): #9336

  20
• F8.11.11The phase field module NonconservedAction and ConservedAction can be combined to construct a coupled Allen-Chan and non-split Cahn-Hilliard problem

  Specification: actions:both_direct_2vars

  Design: ConservedActionNonconservedAction

  Issue(s): #9336

  20
• F8.11.12The phase field module shall provide an action to set up a forward split Cahn-Hilliard problem

  Specification: actions:conserved_forward_split_1var

  Design: ConservedAction

  Issue(s): #9378

  20

• phase_field: GrainGrowthAction
• F8.11.13The phase field module shall provide an action to set up grain growth problems

  Specification: actions:grain_growth

  Design: GrainGrowthAction

  Issue(s): #9485

  20
• F8.11.14The action to set up grain growth problems shall be able to set up an AD version of the problem which yields the same results as the non-AD version

  Specification: actions:ad_grain_growth

  Design: GrainGrowthAction

  Issue(s): #13539

  20
• F8.11.15The action to set up grain growth problems shall be able to set up an AD version of the problem which yields the same results as the non-AD version

  Specification: actions:ad_grain_growth-jac

  Design: GrainGrowthAction

  Issue(s): #13539

  14
• F8.11.16The grain growth action shall have the ability to set up problems with a pinning particle

  Specification: actions:grain_growth_with_c

  Design: GrainGrowthAction

  Issue(s): #9485

  20
• F8.11.17The grain growth action shall have the ability to set up problems with a temperature gradient

  Specification: actions:grain_growth_with_T_grad

  Design: GrainGrowthAction

  Issue(s): #9485

  20
• F8.22.4A capability to initialize polycrystal phase field variables from a file mesh shall be provided through the GrainGrowth action

  Specification: new_initial_conditions:GrainGrowth_initial_from_file

  Design: GrainGrowthAction

  Issue(s): #13624

  20

• phase_field: CahnHilliardAniso
• F8.12.1A split Cahn-Hilliard kernel with an anisotropic mobility shall be provided

  Specification: anisotropic_mobility:split

  Design: CahnHilliardAniso

  Issue(s): #5596

  20

• phase_field: SplitCHWResAniso
• F8.12.2A non-split Cahn-Hilliard kernel with an anisotropic mobility shall be provided

  Specification: anisotropic_mobility:nonsplit

  Design: SplitCHWResAniso

  Issue(s): #5596

  20

• phase_field: MatAnisoDiffusion
• F8.12.3A Diffusion kernel with an anisotropic material property diffusivity shall be provided

  Specification: anisotropic_mobility:diffusion

  Design: MatAnisoDiffusion

  Issue(s): #5841

  20

• phase_field: ADMatAnisoDiffusion
• F8.12.4AD Diffusion with an anisotropic material property diffusivity shall agree with the non-AD version

  Specification: anisotropic_mobility:ad_diffusion

  Design: ADMatAnisoDiffusion

  Issue(s): #13632

  20
• F8.12.5AD Diffusion with an anisotropic material property diffusivity shall have a perfect Jacobian

  Specification: anisotropic_mobility:ad_diffusion_jac

  Design: ADMatAnisoDiffusion

  Issue(s): #13632

  20

• phase_field: ADMatReaction
• F8.13.1MOOSE shall provide an automatic differentiation mat reaction kernel

  Specification: automatic_differentiation:admatreaction

  Design: ADMatReaction

  Issue(s): #13484

  20
• F8.13.2The Jacobian for the automatic differentiation mat reaction kernel shall be perfect

  Specification: automatic_differentiation:admatreaction-jac

  Design: ADMatReaction

  Issue(s): #13484

  20

• phase_field: FeatureVolumeVectorPostprocessor
• F8.14.1The FeatureVolumeVectorPostprocessor shall capture volume information of individual features.

  Specification: boundary_intersecting_features:boundary_intersecting_features

  Design: FeatureVolumeVectorPostprocessor

  Issue(s): #7755

  13
• F8.14.2The FeatureVolumeVectorPostprocessor shall capture whether any feature intersects the boundary, even when the non-root rank doesn't own a part of the feature that intersects the boundary.

  Specification: boundary_intersecting_features:boundary_intersecting_features_flipped

  Design: FeatureVolumeVectorPostprocessor

  Issue(s): #7755

  13
• F8.16.1The FeatureVolumeVectorPostprocessor shall output individual centroid locations when requested.

  Specification: feature_volume_vpp_test:centroid_output_test

  Design: FeatureVolumeVectorPostprocessor

  Issue(s): #11395

  20
• F8.16.2The FeatureVolumeVectorPostprocessor shall output individual centroid locations when requested.

  Specification: feature_volume_vpp_test:centroid_output_test_parallel

  Design: FeatureVolumeVectorPostprocessor

  Issue(s): #11395

  20
• F8.16.3The FeatureVolumeVectorPostprocessor shall output whether a percolated pathway exists between specified primary_percolation_boundaries and secondary_percolation_boundaries.

  Specification: feature_volume_vpp_test:percolation_test

  Design: FeatureVolumeVectorPostprocessor

  Issue(s): #13169

  20
• F8.16.4The FeatureVolumeVectorPostprocessor shall output whether a percolated pathway exists between specified primary_percolation_boundaries and secondary_percolation_boundaries.

  Specification: feature_volume_vpp_test:percolation_test_parallel

  Design: FeatureVolumeVectorPostprocessor

  Issue(s): #13169

  20
• F8.16.5The FeatureVolumeVectorPostprocessor shall calculate coverage of a supplied boundary by each feature by integrating the corresponding order parameter on the boundary.

  Specification: feature_volume_vpp_test:boundary_area_2D_test

  Design: FeatureVolumeVectorPostprocessor

  Issue(s): #13202

  20
• F8.16.6The FeatureVolumeVectorPostprocessor shall calculate coverage of a supplied boundary by each feature by calulating the area/length of boundary elements.

  Specification: feature_volume_vpp_test:boundary_area_2D_single_test

  Design: FeatureVolumeVectorPostprocessor

  Issue(s): #13202

  20
• F8.16.7The FeatureVolumeVectorPostprocessor shall calculate coverage of a supplied boundary by each feature by integrating the corresponding order parameter on the boundary.

  Specification: feature_volume_vpp_test:boundary_area_3D_test

  Design: FeatureVolumeVectorPostprocessor

  Issue(s): #13202

  20
• F8.16.8The FeatureVolumeVectorPostprocessor shall calculate coverage of a supplied boundary by each feature by calulating the area/length of boundary elements.

  Specification: feature_volume_vpp_test:boundary_area_3D_single_test

  Design: FeatureVolumeVectorPostprocessor

  Issue(s): #13202

  20

• phase_field: ../Nucleation/conservednoise_include.html
• F8.15.1A system to supply a noise field with a domain integral of zero shall be provided

  Specification: conserved_noise:integral

  Design: ../Nucleation/conservednoise_include.html

  Issue(s): #4763

  20
• F8.15.2A system to supply a normal distributed noise field with a domain integral of zero shall be provided

  Specification: conserved_noise:normal

  Design: ../Nucleation/conservednoise_include.html

  Issue(s): #4763

  20
• F8.15.3A system to supply a uniformly distributed noise field with a domain integral of zero shall be provided

  Specification: conserved_noise:uniform

  Design: ../Nucleation/conservednoise_include.html

  Issue(s): #4763

  20
• F8.15.4A system to supply a normal distributed noise field with an amplitude mask and a domain integral of zero shall be provided

  Specification: conserved_noise:integral_normal_masked

  Design: ../Nucleation/conservednoise_include.html

  Issue(s): #4763

  20
• F8.15.5The conserved noise kernel shall error out with a helpful message if a 'seed' parameter is supplied

  Specification: conserved_noise:seed_error

  Design: ../Nucleation/conservednoise_include.html

  Issue(s): #14368

  20

• phase_field: FourierNoise
• F8.17.1A function that returns a new periodic random field with a lower wavelength cut-off shall be provided.

  Specification: functions:fourier_noise

  Design: FourierNoise

  Issue(s): #13316

  20

• phase_field: PolycrystalKernelAction
• F8.18.1MOOSE shall provide a polycrystalline material model with grain growth

  Specification: grain_growth:test

  Design: PolycrystalKernelAction

  Issue(s): 98e22eda8bfaa1f6ded00c127145d832542aff70

  20
• F8.18.2A flat grain boundary shall not move along a temperature gradient

  Specification: grain_growth:temperature_gradient

  Design: PolycrystalKernelAction

  Issue(s): #9507

  20
• F8.18.8The grain boundary evolution model shall provide off-diagonal Jacobians

  Specification: grain_growth:off-diagonal

  Design: PolycrystalKernelAction

  Issue(s): 98e22eda8bfaa1f6ded00c127145d832542aff70

  20
• F8.18.9The grain growth model shall work with explicit time integration

  Specification: grain_growth:explicit

  Design: PolycrystalKernelAction

  Issue(s): 98e22eda8bfaa1f6ded00c127145d832542aff70

  20

• phase_field: ThumbIC
• F8.18.3A thumb shaped grain IC shall be provided for direct comparison to grain boundary mobility experiments

  Specification: grain_growth:thumb

  Design: ThumbIC

  Issue(s): 98e22eda8bfaa1f6ded00c127145d832542aff70

  20

• phase_field: PolycrystalHex
• F8.18.4A hexagonal grain structure IC shall be provided

  Specification: grain_growth:hex

  Design: PolycrystalHex

  Issue(s): #8810

  20

• phase_field: BicrystalBoundingBoxICAction
• F8.18.5A bicrystal grain IC shall be provided to set up a rectangular grain in a matrix

  Specification: grain_growth:boundingbox

  Design: BicrystalBoundingBoxICAction

  Issue(s): 98e22eda8bfaa1f6ded00c127145d832542aff70

  20

• phase_field: GBEvolution
• F8.18.6The grain boundary evolution model shall be able to compute the grain boundary mobility based on an activation energy

  Specification: grain_growth:evolution

  Design: GBEvolution

  Issue(s): 98e22eda8bfaa1f6ded00c127145d832542aff70

  20
• F8.18.7The grain boundary evolution model shall permit specifying a constant mobility

  Specification: grain_growth:constant_mobility

  Design: GBEvolution

  Issue(s): 98e22eda8bfaa1f6ded00c127145d832542aff70

  20

• phase_field: PolycrystalVoronoi
• F8.18.10A voronoi tesselation grain structure IC shall be provided

  Specification: grain_growth:voronoi

  Design: PolycrystalVoronoi

  Issue(s): #8810

  20
• F8.18.11A columnar grain IC shall be provided based on a 2D voronoi tesselation

  Specification: grain_growth:voronoi_columnar_3D

  Design: PolycrystalVoronoi

  Issue(s): #8810

  20

• phase_field: ACGBPoly
• F8.18.12The grain boundary evolution model shall provide coupling to conserved order parameters

  Specification: grain_growth:particle

  Design: ACGBPoly

  Issue(s): 98e22eda8bfaa1f6ded00c127145d832542aff70

  20

• phase_field: GrainTracker
• F8.19.1The system shall properly create and track grains when using the Nodal mode of the GrainTracker algorithm.

  Specification: grain_tracker_test:test_nodal

  Design: GrainTracker

  Issue(s): #4765

  20
• F8.19.2The system shall properly create and track grains when using the Elemental mode of the GrainTracker algorithm.

  Specification: grain_tracker_test:test_elemental

  Design: GrainTracker

  Issue(s): #4881

  15
• F8.19.3The PolycrystalVoronoi object shall create a valid coloring for a given number of grains and order parameters.

  Specification: grain_tracker_test:test_advanced_op_assignment

  Design: GrainTracker

  Issue(s): #7005#9018

  20
• F8.19.6The GrainTracker/PolycrystalUserObject base class shall support having only a grain halo bleeding over a periodic edge.

  Specification: grain_tracker_test:test_halo_periodic_bc

  Design: GrainTracker

  Issue(s): #6713#8926

  15
• F8.19.7The GrainTracker object shall support remapping order parameter values.

  Specification: grain_tracker_test:test_remapping_serial

  Design: GrainTracker

  Issue(s): #1298

  14
• F8.19.8The FeatureFloodCount object shall distribute the merging of features when the processor count exceeds number of order parameters for efficiency.

  Specification: grain_tracker_test:test_remapping_parallel

  Design: GrainTracker

  Issue(s): #11805

  12
• F8.19.9The GrainTracker object shall properly checkpoint unique grain information in serial.

  Specification: grain_tracker_test:test_recovery_serial_part1

  Design: GrainTracker

  Issue(s): #6713#12427

  14
• F8.19.10The GrainTracker object shall properly recover unique grain information in serial.

  Specification: grain_tracker_test:test_recovery_serial_part2

  Design: GrainTracker

  Issue(s): #6713#12427

  14
• F8.19.11The GrainTracker object shall properly checkpoint unique grain information in parallel.

  Specification: grain_tracker_test:test_recovery_parallel_part1

  Design: GrainTracker

  Issue(s): #6713#12427

  12
• F8.19.12The GrainTracker object shall properly recover unique grain information in parallel.

  Specification: grain_tracker_test:test_recovery_parallel_part2

  Design: GrainTracker

  Issue(s): #6713#12427

  12
• F8.19.14The GrainTracker shall support maintaining reserve order parameters for simulations where new grains can form.

  Specification: grain_tracker_test:remapping_with_reserve

  Design: GrainTracker

  Issue(s): #7605

  15
• F8.19.15The GrainTracker shall support beginning a simulation with no active grain structure.

  Specification: grain_tracker_test:start_with_zero_grains

  Design: GrainTracker

  Issue(s): #12200

  15
• F8.19.18The GrainTracker shall support handling the splitting of a grain during a simulation.

  Specification: grain_tracker_test:split_grain

  Design: GrainTracker

  Issue(s): #7875

  15
• F8.19.19The AverageFeatureVolume Postprocessor shall calculate the average volume of each active grain in a simulation.

  Specification: grain_tracker_test:changing_avg_volume

  Design: GrainTracker

  Issue(s): #11822

  14
• F8.19.20The GrainTracker shall support a mode where it can continue even when it fails to remap for post-modern analysis and debugging.

  Specification: grain_tracker_test:tolerate_remap_failure

  Design: GrainTracker

  Issue(s): #11843

  14
• F8.19.22The system shall properly handle a single feature or grain taking up the entire domain.

  Specification: grain_tracker_test:one_grain

  Design: GrainTracker

  Issue(s): #12216

  20
• F8.19.23The system shall grain tracking behavior even when the number of grains equals the number of order parameters when using mode Nodal.

  Specification: grain_tracker_test:test_faux_nodal

  Design: GrainTracker

  Issue(s): #5453

  20
• F8.19.24The system shall grain tracking behavior even when the number of grains equals the number of order parameters when using mode Elemental.

  Specification: grain_tracker_test:test_faux_element

  Design: GrainTracker

  Issue(s): #5453

  15
• F8.19.25The system shall output individual grain tracker volumes.

  Specification: grain_tracker_test:grain_tracker_volume

  Design: GrainTracker

  Issue(s): #7769

  20
• F8.19.26The system shall output individual grain tracker volumes assigning each element to only one grain (conservative).

  Specification: grain_tracker_test:grain_tracker_volume_single

  Design: GrainTracker

  Issue(s): #7769

  20
• F8.19.27The system shall output individual grain tracker volumes when the number of order parameters equals the number of grains.

  Specification: grain_tracker_test:feature_flood_volume

  Design: GrainTracker

  Issue(s): #5453

  20

• phase_field: Polycrystal Initial Conditions
• F8.19.4The PolycrystalUserObject base class shall error when a valid coloring cannot be found when using the simple back-tracking algorithm.

  Specification: grain_tracker_test:test_advanced_op_assignment_bt_error

  Design: Polycrystal Initial Conditions

  Issue(s): #7005#8804

  20
• F8.19.5The PolycrystalUserObject base class shall error when a valid coloring cannot be found when using the built-in PETSc based stochastic algorithms.

  Specification: grain_tracker_test:test_advanced_op_assignment_petsc_error

  Design: Polycrystal Initial Conditions

  Issue(s): #7005#8804

  20
• F8.19.13The GrainTracker shall support reusing the data structures from the PolycrystalUserObjectBase after the initial condition for efficiency.

  Specification: grain_tracker_test:test_poly_ic_handoff

  Design: Polycrystal Initial Conditions

  Issue(s): #8810

  14
• F8.19.16The GrainTracker shall support reading EBSD data to create initial conditions.

  Specification: grain_tracker_test:test_ebsd

  Design: Polycrystal Initial Conditions

  Issue(s): #5067#9060

  20
• F8.19.17The GrainTracker shall support reading EBSD data to create initial conditions while supporting initial condition refinement.

  Specification: grain_tracker_test:test_ebsd_adapt

  Design: Polycrystal Initial Conditions

  Issue(s): #5067#9060

  20
• F8.19.21The system shall properly create PolycrystalICs with halo extensions (elements) when using DistributedMesh.

  Specification: grain_tracker_test:distributed_poly_ic

  Design: Polycrystal Initial Conditions

  Issue(s): #12216

  20
• F8.20.1The system shall support a ramp or linear initial condition in one dimension.

  Specification: initial_conditions:RampIC

  Design: Polycrystal Initial Conditions

  Issue(s): #6858#5816#7358#8721#12000#6655#9174

  20
• F8.20.2The system shall support the creation of a smooth cross initial condition.

  Specification: initial_conditions:CrossIC

  Design: Polycrystal Initial Conditions

  Issue(s): #6858#5816#7358#8721#12000#6655#9174

  20
• F8.20.3The system shall support ellipsoidal phase-field initial conditions:
  1. bimodal inverse superellipsoidal structures,
  2. bimodal superellipsoidal structures,
  3. smooth superellipsoidal structures,
  4. smooth superellipsoidal structures specified from a file,
  5. smooth superellipsoidal structures in 3D,
  6. multiple smooth superellipsoidal structures in 2D, and
  7. multiple smooth superellipsoidal structures in 3D.

  Specification: initial_conditions:ellipsoids

  Design: Polycrystal Initial Conditions

  Issue(s): #6858#5816#7358#8721#12000#6655#9174

  20202020202020
• F8.20.4The system shall support polycrystal phase-field initial conditions:
  1. large polycrystal structure with voids,
  2. polycrystal structure with voids,
  3. polycrystal structure with voids on a periodic domain,
  4. polycrystal structure with voids with centroids specified from a file,
  5. polycrystal structure with centroids specified from a file,
  6. polycrystal circles specified from a file,
  7. and polycrystal circles specified from an input vector,
  8. hexagonal structure, and
  9. smooth interface in a triple junction.

  Specification: initial_conditions:polycrystal

  Design: Polycrystal Initial Conditions

  Issue(s): #6858#5816#7358#8721#12000#6655#9174

  202020152020201520
• F8.20.5The system shall support initial adaptivity based on GB locations:
  1. polycrystal structure with IC specifying the GB locations

  Specification: initial_conditions:GB_adaptivity

  Design: Polycrystal Initial Conditions

  Issue(s): #9668

  20
• F8.20.6The system shall support phase-field initial conditions consisting of circle patterns:
  1. smooth interface circles,
  2. smooth interface spheres,
  3. smooth interface circles specified from a file, and
  4. smooth interface circles with random noise.

  Specification: initial_conditions:circles

  Design: Polycrystal Initial Conditions

  Issue(s): #6858#5816#7358#8721#12000#6655#9174

  20202020
• F8.20.7The system shall support phase-field initial conditions consisting of close pack particle patterns:
  1. in 2D, and
  2. in 3D.

  Specification: initial_conditions:close_pack

  Design: Polycrystal Initial Conditions

  Issue(s): #6858#5816#7358#8721#12000#6655#9174

  2015
• F8.20.8The system shall support phase-field initial conditions consiting of box patterns:
  1. bounding boxes,
  2. bounding boxes with random noise,
  3. multiple bounding boxes in 1D,
  4. multiple bounding boxes in 2D, and
  5. multiple bounding boxes in 3D.
  6. Diffused interface can be assigned for isolated bounding boxes in 2D,
  7. 3D,
  8. nested bounding boxes in 2D, and
  9. 3D.
  10. Using IsolatedBoundingBoxIC to create overlapping boxes will throw an error.

  Specification: initial_conditions:boxes

  Design: Polycrystal Initial Conditions

  Issue(s): #6858#5816#7358#8721#12000#6655#9174

  20202020202020202020

• phase_field: TimeStepMaterial
• F8.21.1A material shall be implemented that provides dt, time, and time step number as material properties

  Specification: misc:timestepmaterial

  Design: TimeStepMaterial

  Issue(s): #7621

  20

• phase_field: VariableGradientMaterial
• F8.21.2A material shall be implemented that computes the magnitude of the gradient of a given variable

  Specification: misc:variablegradientmaterial

  Design: VariableGradientMaterial

  Issue(s): #7621

  20

• phase_field: InterfaceDiffusionFluxMatch
• F8.21.3An interface kernel shall be implemented to match gradients between two subdomains

  Specification: misc:interface_grad

  Design: InterfaceDiffusionFluxMatch

  Issue(s): #8211

  20

• phase_field: InterfaceDiffusionBoundaryTerm
• F8.21.4Demonstrate an InterfaceKernel (InterfaceDiffusionFlux) that can replace a pair of integrated DiffusionFluxBC boundary conditions.

  Specification: misc:interface_flux

  Design: InterfaceDiffusionBoundaryTerm

  Issue(s): #8211

  20

• phase_field: EqualGradientLagrangeInterface
• F8.21.5An InterfaceKernel set shall be implemnted that can enforce the componentwise continuity of the gradient of a variable using the Lagrange multiplier method

  Specification: misc:equal_gradient_lagrange

  Design: EqualGradientLagrangeInterface

  Issue(s): #8211

  20

• phase_field: SmoothCircleIC
• F8.22.1A smooth circle initial condition with a hyperbolic tangent profile shall be provided

  Specification: new_initial_conditions:SmoothCircleIC_tanh

  Design: SmoothCircleIC

  Issue(s): #12143

  20

• phase_field: PolycrystalVariablesAction
• F8.22.2A capability to initialize polycrystal phase field variables from a file mesh shall be provided

  Specification: new_initial_conditions:prepare_mesh

  Design: PolycrystalVariablesAction

  Issue(s): #12294

  20
• F8.22.3A capability to initialize polycrystal phase field variables from a file mesh shall be provided through the PolycrystalVariables action

  Specification: new_initial_conditions:PolycrystalVariables_initial_from_file

  Design: PolycrystalVariablesAction

  Issue(s): #12294

  20

• phase_field: CHPFCRFF
• F8.23.1The system shall support a tolerance approach to handing the natural log when using the Cahn-Hilliard RFF kernel

  Specification: phase_field_crystal/PFCRFF:tolerance_test

  Design: CHPFCRFF

  Issue(s): #5338

  20
• F8.23.2The system shall support a cancelation approach to handing the natural log when using the Cahn-Hilliard RFF kernel

  Specification: phase_field_crystal/PFCRFF:cancelation_test

  Design: CHPFCRFF

  Issue(s): #5338

  20
• F8.23.3The system shall support an expansion approach to handing the natural log when using the Cahn-Hilliard RFF kernel

  Specification: phase_field_crystal/PFCRFF:expansion_test

  Design: CHPFCRFF

  Issue(s): #5338

  20

• phase_field: CahnHilliard
• F8.24.1MOOSE shall provide a non-split Cahn-Hilliard formalism

  Specification: phase_field_kernels:CahnHilliard

  Design: CahnHilliard

  Issue(s): #3356

  20

• phase_field: SplitCHParsed
• F8.24.2MOOSE shall provide a split Cahn-Hilliard formalism

  Specification: phase_field_kernels:SplitCahnHilliard

  Design: SplitCHParsed

  Issue(s): #3356

  20

• phase_field: ADSplitCHParsed
• F8.24.3MOOSE shall provide an AD version of the split Cahn-Hilliard formalism

  Specification: phase_field_kernels:ADSplitCahnHilliard

  Design: ADSplitCHParsed

  Issue(s): #13138

  20
• F8.24.4The Jacobian for the AD split Cahn-Hilliard problem shall be perfect

  Specification: phase_field_kernels:ADSplitCahnHilliard-jac

  Design: ADSplitCHParsed

  Issue(s): #13138

  20

• phase_field: SplitCHWRes
• F8.24.5MOOSE shall provide a kernel option to implement transport terms for the off-diagonal Onsager matrix components

  Specification: phase_field_kernels:SplitCHWRes

  Design: SplitCHWRes

  Issue(s): #14140

  20

• phase_field: AllenCahn
• F8.24.6A Allen-Cahn phase field formulation shall be provided

  Specification: phase_field_kernels:AllenCahn

  Design: AllenCahn

  Issue(s): #3816

  20
• F8.24.7The Allen-Cahn model shall have perfect Jacobians

  Specification: phase_field_kernels:analyzejacobian_AllenCahn

  Design: AllenCahn

  Issue(s): #3816

  16
• F8.24.8A Allen-Cahn phase field formulation with a variable dependent mobility shall be provided

  Specification: phase_field_kernels:AllenCahnVariableL

  Design: AllenCahn

  Issue(s): #3816

  20

• phase_field: ADAllenCahn
• F8.24.9An AD version of the Allen-Cahn phase field formulation shall be provided

  Specification: phase_field_kernels:ADAllenCahn

  Design: ADAllenCahn

  Issue(s): #13197

  20
• F8.24.10The Jacobian for the AD Allen-Cahn problem shall be perfect

  Specification: phase_field_kernels:ADAllenCahn-jac

  Design: ADAllenCahn

  Issue(s): #13197

  20
• F8.24.11An AD version of the Allen-Cahn phase field formulation with a variable dependent mobility shall be provided

  Specification: phase_field_kernels:ADAllenCahnVariableL

  Design: ADAllenCahn

  Issue(s): #13197

  20
• F8.24.12The Jacobian for the AD Allen-Cahn problem with a variable dependent mobility shall be perfect

  Specification: phase_field_kernels:ADAllenCahnVariableL-jac

  Design: ADAllenCahn

  Issue(s): #13197

  20

• phase_field: CoupledAllenCahn
• F8.24.13A coupled Allen-Cahn formulation shall be provided

  Specification: phase_field_kernels:CoupledAllenCahn

  Design: CoupledAllenCahn

  Issue(s): #6194

  20
• F8.24.14A coupled Allen-Cahn formulation with a user defined prefactor shall be provided

  Specification: phase_field_kernels:CoupledCoefAllenCahn

  Design: CoupledAllenCahn

  Issue(s): #6265

  20

• phase_field: MatGradSquareCoupled
• F8.24.15A coupled gradient square kernel shall be provided

  Specification: phase_field_kernels:MatGradSquareCoupled

  Design: MatGradSquareCoupled

  Issue(s): #10721

  20

• phase_field: SimpleSplitCHWRes
• F8.24.16A suite of simple to understand phase field kernels shall be provided for novice users

  Specification: phase_field_kernels:SimpleSplitCHWRes

  Design: SimpleSplitCHWRes

  Issue(s): #6910

  20

• phase_field: SimpleCHInterface
• F8.24.17A suite of simple to understand phase field kernels shall be provided for novice users

  Specification: phase_field_kernels:SimpleCHInterface

  Design: SimpleCHInterface

  Issue(s): #6910

  20

• phase_field: ACInterfaceStress
• F8.24.18A free energy contribution from elastic stresses in interfaces shall be provided

  Specification: phase_field_kernels:ACInterfaceStress

  Design: ACInterfaceStress

  Issue(s): #9658

  20
• F8.24.19The free energy contribution from elastic stresses in interfaces shall shall have a perfect Jacobian

  Specification: phase_field_kernels:analyzejacobian_ACInterfaceStress

  Design: ACInterfaceStress

  Issue(s): #9658

  2

• phase_field: ACBarrierFunction
• F8.24.20The barrier height and gradient energy parameter must be permitted to depend on non-linear variables

  Specification: phase_field_kernels:nonuniform_barrier_coefficient

  Design: ACBarrierFunction

  Issue(s): #11829

  20

• phase_field: EulerAngleVariables2RGBAux
• F8.25.1The system shall output an RGB field that can be interpreted as either a component or a combined Euler angle given a grain structure.

  Specification: reconstruction:EulerAngleVariables2RGBAux

  Design: EulerAngleVariables2RGBAux

  Issue(s): #7332

  20

• phase_field: Reading EBSD Data
• F8.25.2The system shall support reading EBSD data and initializing a Polycrystal grain structure with that data.

  Specification: reconstruction:1phase_reconstruction

  Design: Reading EBSD Data

  Issue(s): #9110

  20
• F8.25.3The system shall support reading EBSD data to initalized Polycrystal grain structures while supporting reduced order parameter IC assignment.

  Specification: reconstruction:1phase_reconstruction_40x40

  Design: Reading EBSD Data

  Issue(s): #9110

  20
• F8.25.4The system shall support grain evolution when beginning from EBSD ICs.

  Specification: reconstruction:1phase_evolution

  Design: Reading EBSD Data

  Issue(s): #9110

  20
• F8.25.5The system shall support reading a single phase of EBSD data at a time to initialize PolycrystalICs.

  Specification: reconstruction:2phase_reconstruction

  Design: Reading EBSD Data

  Issue(s): #9110#5920

  20
• F8.25.6The system shall support reading a single phase of EBSD data at a time to initialize PolycrystalICs while supporting reduced order parameter IC assignment.

  Specification: reconstruction:2phase_reconstruction2

  Design: Reading EBSD Data

  Issue(s): #9110#5920

  20
• F8.25.7The system shall support reading EBSD data to initialize PolycrystalICs with discontinuous numbering.

  Specification: reconstruction:2phase_reconstruction3

  Design: Reading EBSD Data

  Issue(s): #9110#5920

  20
• F8.25.8The system shall support reading a single phase of EBSD data at a time to initialize PolycrystalICs while supporting reduced order parameter IC assignment and display the coloring.

  Specification: reconstruction:2phase_reconstruction4

  Design: Reading EBSD Data

  Issue(s): #9110#5920

  20
• F8.25.9The system shall support reading a single phase of EBSD data at a time to initialize PolycrystalICs and support regions within the domain that contain no grains at all.

  Specification: reconstruction:regions_without_grains

  Design: Reading EBSD Data

  Issue(s): #9110#5920

  20

• phase_field: EBSDReader
• F8.25.10The system shall support grain evolution when beginning from EBSD ICs and compute average orientation of non-uniformly oriented grains.

  Specification: reconstruction:average_orientation

  Design: EBSDReader

  Issue(s): #13869

  15

[./simple_transient_diffusion_with_soret]
  type = 'Exodiff'
  input = 'simple_transient_diffusion_with_soret.i'
  exodiff = 'simple_transient_diffusion_with_soret_out.e'
  requirement = 'A temperature gradient driving force for diffusion shall be added to the split form of the Cahn-Hilliard equation and solved using automatic differentiation.'
[../]

[./simple_transient_diffusion_with_soret-jac]
  type = 'PetscJacobianTester'
  input = 'simple_transient_diffusion_with_soret.i'
  run_sim = true
  difference_tol = 1e-7
  cli_args = 'Outputs/exodus=false'
  allow_test_objects = true
  requirement = 'The Jacobians for the automatic differentiation ADCHSplitChemicalPotential and ADCHSplitConcentration kernels shall be accurate.'
[../]

[./simple_transient_diffusion]
  type = 'Exodiff'
  input = 'simple_transient_diffusion.i'
  exodiff = 'simple_transient_diffusion_out.e'
  requirement = 'ADCHSplitChemicalPotential and ADCHSplitConcentration shall solve a simple Cahn-Hilliard problem using automatic differentiation.'
[../]

[./simple_transient_diffusion-jac]
  type = 'PetscJacobianTester'
  input = 'simple_transient_diffusion.i'
  run_sim = true
  difference_tol = 1e-7
  cli_args = 'Outputs/exodus=false'
  allow_test_objects = true
  requirement = 'The Jacobians for the automatic differentiation ADCHSplitChemicalPotential and ADCHSplitConcentration kernels shall be accurate.'
[../]

[./simple_transient_diffusion]
  type = 'Exodiff'
  input = 'simple_transient_diffusion.i'
  exodiff = 'simple_transient_diffusion_out.e'
  requirement = 'ADCHSplitChemicalPotential and ADCHSplitConcentration shall solve a simple Cahn-Hilliard problem using automatic differentiation.'
[../]

[./simple_transient_diffusion-jac]
  type = 'PetscJacobianTester'
  input = 'simple_transient_diffusion.i'
  run_sim = true
  difference_tol = 1e-7
  cli_args = 'Outputs/exodus=false'
  allow_test_objects = true
  requirement = 'The Jacobians for the automatic differentiation ADCHSplitChemicalPotential and ADCHSplitConcentration kernels shall be accurate.'
[../]

[./test1]
  type = 'Exodiff'
  input = 'test1.i'
  exodiff = 'test1_out.e'
  issues = '#4580'
  design = 'GBAnisotropy.md'
  requirement = 'A material shall be provided to compute anisotropic grain boundary energies and mobilities.'
[../]

[./test2]
  type = 'Exodiff'
  input = 'test2.i'
  exodiff = 'test2_out.e'
  issues = '#4580'
  design = 'GBAnisotropy.md'
  requirement = 'A material shall be provided to compute anisotropic grain boundary energies and mobilities.'
[../]

[./test3]
  type = 'Exodiff'
  input = 'test3.i'
  exodiff = 'test3_out.e'
  issues = '#4580'
  design = 'GBAnisotropy.md'
  requirement = 'A material shall be provided to compute anisotropic grain boundary energies and mobilities with an inclination dependence.'
[../]

[./testwidth1]
  type = 'Exodiff'
  input = 'testwidth1.i'
  exodiff = 'testwidth1_out.e'
  issues = '#8079'
  design = 'GBWidthAnisotropy.md'
  requirement = 'The anisotropic grain boundary system shall allow the user to specify grain boundary widths independently for each interface between grains.'
[../]

[./GrandPotentialPFM]
  type = 'Exodiff'
  input = 'GrandPotentialPFM.i'
  exodiff = 'GrandPotentialPFM_out.e'
  issues = '#6977'
  design = '/GrandPotentialKernelAction.md'
  requirement = 'MOOSE shall provide classes to implement a Grand Potential phase field formulation'
[../]

[./grand_potential_kernels]
  # Test
  type = Exodiff
  input = 'gpm_kernel.i'
  exodiff = 'gpm_kernel_out.e'
  issues = '#11386'
  design = 'action/GrandPotentialKernelAction.md'
  requirement = 'The GrandPotentialAction shall have the ability to generate kernels'
[../]

[./GrandPotentialMultiphase]
  type = 'Exodiff'
  input = 'GrandPotentialMultiphase.i'
  exodiff = 'GrandPotentialMultiphase_out.e'
  issues = '#8213'
  design = '/ACSwitching.md'
  requirement = 'MOOSE shall provide a Grand Potential based multiphase model'
[../]

[./GrandPotentialAnisotropy]
  type = 'Exodiff'
  input = 'GrandPotentialAnisotropy.i'
  exodiff = 'GrandPotentialAnisotropy_out.e'
  abs_zero = 1e-8
  issues = '#11802 #12554'
  design = '/ACInterface2DMultiPhase1.md /ACInterface2DMultiPhase2.md /InterfaceOrientationMultiphaseMaterial.md'
  requirement = 'MOOSE shall provide a Grand Potential based dendritic solidification capability in 2D'
[../]

[./GrandPotentialAnisotropy]
  type = 'Exodiff'
  input = 'GrandPotentialAnisotropy.i'
  exodiff = 'GrandPotentialAnisotropy_out.e'
  abs_zero = 1e-8
  issues = '#11802 #12554'
  design = '/ACInterface2DMultiPhase1.md /ACInterface2DMultiPhase2.md /InterfaceOrientationMultiphaseMaterial.md'
  requirement = 'MOOSE shall provide a Grand Potential based dendritic solidification capability in 2D'
[../]

[./GrandPotentialAnisotropy]
  type = 'Exodiff'
  input = 'GrandPotentialAnisotropy.i'
  exodiff = 'GrandPotentialAnisotropy_out.e'
  abs_zero = 1e-8
  issues = '#11802 #12554'
  design = '/ACInterface2DMultiPhase1.md /ACInterface2DMultiPhase2.md /InterfaceOrientationMultiphaseMaterial.md'
  requirement = 'MOOSE shall provide a Grand Potential based dendritic solidification capability in 2D'
[../]

[./GrandPotentialInterface]
  type = 'CSVDiff'
  input = 'GrandPotentialInterface.i'
  csvdiff = 'GrandPotentialInterface_out_mat_0001.csv'
  issues = '#12147'
  design = '/GrandPotentialInterface.md'
  requirement = 'MOOSE shall provide a material to automatically compute grand potential model interface parameters based on provided interfacial free energies and widths'
[../]

[./GrandPotentialAnisotropyAntitrap]
  type = 'Exodiff'
  input = 'GrandPotentialAnisotropyAntitrap.i'
  exodiff = 'GrandPotentialAnisotropyAntitrap_out.e'
  issues = '#13373'
  design = '/AntitrappingCurrent.md'
  requirement = 'MOOSE shall provide a Grand Potential based dendritic solidification capability for alloy with antitrapping current'
[../]

[./derivative_parsed_material]
  type = 'Exodiff'
  input = 'derivative_parsed_material.i'
  exodiff = 'derivative_parsed_material.e'
  issues = '#4835'
  design = 'DerivativeParsedMaterial.md'
  requirement = 'The Kim-Kim-Suzuki model implementation shall use free energy densities provided by DerivativeParsedMaterials'
[../]

[./kks_example]
  type = 'Exodiff'
  input = 'kks_example.i'
  exodiff = 'kks_example.e'
  issues = '#4835'
  design = 'KKSCHBulk.md'
  requirement = 'A non-split version of the Kim-Kim-Suzuki shall be provided'
[../]

[./kks_example_split]
  type = 'Exodiff'
  input = 'kks_example_split.i'
  exodiff = 'kks_example_split.e'
  issues = '#4835'
  design = 'KKSSplitCHCRes.md'
  requirement = 'A split version of the Kim-Kim-Suzuki shall be provided'
[../]

[./kks_example_offset]
  type = 'Exodiff'
  input = 'kks_example_offset.i'
  exodiff = 'kks_example_offset.e'
  issues = '#10315'
  design = 'KKSSplitCHCRes.md'
  requirement = 'The split version of the Kim-Kim-Suzuki shall be yield the correct results with asymmetric free energies'
[../]

[./kks_xevac]
  type = 'Exodiff'
  input = 'kks_xevac.i'
  exodiff = 'kks_xevac.e'
  design = 'KKSSplitCHCRes.md'
  issues = '#4879'
  requirement = 'A multi component Kim-Kim-Suzuki model shall be implemented'
[../]

[./kks_multiphase]
  type = 'Exodiff'
  input = 'kks_multiphase.i'
  exodiff = 'kks_multiphase_out.e'
  issues = '#7007'
  design = 'KKSMultiACBulkC.md'
  requirement = 'A multi component Kim-Kim-Suzuki model shall be implemented'
[../]

[./derivativetwophasematerial]
  type = 'Exodiff'
  input = 'derivativetwophasematerial.i'
  exodiff = 'derivativetwophasematerial_out.e'
  fparser_jit = True
  requirement = 'Moose shall provide a material to combine two free energies materials into a WBM two phase free energy'
  design = 'DerivativeTwoPhaseMaterial.md'
  issues = '#4035'
[../]

[./orderparameterfunctionmaterial]
  type = 'Exodiff'
  input = 'orderparameterfunctionmaterial.i'
  exodiff = 'orderparameterfunctionmaterial_out.e'
  design = 'SwitchingFunctionMaterial.md'
  requirement = 'Moose shall provide a materials to generate barrier and switching function in a WBM multiphase model'
  issues = '#4355'
[../]

[./thirdphasesuppressionmaterial]
  type = 'Exodiff'
  input = 'thirdphasesuppressionmaterial.i'
  exodiff = 'thirdphasesuppressionmaterial_out.e'
  design = 'ThirdPhaseSuppressionMaterial.md'
  requirement = 'Moose shall provide a free energy penalty class that suppresses the formation of a third phase in grain boundaries'
  issues = '#6279'
[../]

[./multibarrierfunction]
  type = 'Exodiff'
  input = 'multibarrierfunction.i'
  exodiff = 'multibarrierfunction_out.e'
  design = 'MultiBarrierFunctionMaterial.md'
  requirement = 'Moose shall provide a material for computing barrier values in multiphase systems'
  issues = '#4545'
[../]

[./crosstermbarrierfunction]
  type = 'Exodiff'
  input = 'crosstermbarrierfunction.i'
  exodiff = 'crosstermbarrierfunction_out.e'
  design = 'CrossTermBarrierFunctionMaterial.md'
  requirement = 'Moose shall provide a material for computing independent barrier values for each phase pair in a multiphase system'
  issues = '#5192'
[../]

[./asymmetriccrosstermbarrierfunction]
  type = 'Exodiff'
  input = 'asymmetriccrosstermbarrierfunction.i'
  exodiff = 'asymmetriccrosstermbarrierfunction_out.e'
  design = 'AsymmetricCrossTermBarrierFunctionMaterial.md'
  requirement = 'Moose shall provide a material for computing independent barrier values for each phase pair in a multiphase system with asymmetric interface profiles'
  issues = '#6584'
[../]

[./lagrangemult]
  type = 'Exodiff'
  input = 'lagrangemult.i'
  exodiff = 'lagrangemult_out.e'
  fparser_jit = True
  requirement = 'Moose shall provide a lagrange multiplier based constraint for keeping the sum of all phase order parameters equal to one'
  design = 'SwitchingFunctionConstraintLagrange.md'
  issues = '#4545'
[../]

[./penalty]
  type = 'Exodiff'
  input = 'penalty.i'
  exodiff = 'penalty_out.e'
  requirement = 'Moose shall provide a penalty based constraint for keeping the sum of all phase order parameters equal to one'
  design = 'SwitchingFunctionConstraintLagrange.md'
  issues = '#4723'
[../]

[./crosstermfreeenergy]
  type = 'Exodiff'
  input = 'crosstermfreeenergy.i'
  exodiff = 'crosstermfreeenergy_out.e'
  requirement = 'Moose shall provide aan AuxKernel to compute the free energy contribution form pairwise phase barrier functions'
  design = 'CrossTermGradientFreeEnergy.md'
  issues = '#4710'
[../]

[./acmultiinterface]
  type = 'Exodiff'
  input = 'acmultiinterface.i'
  exodiff = 'acmultiinterface_out.e'
  requirement = 'Moose shall provide an Allen-Cahn gradient energy kernel with cross term contributions'
  design = 'ACMultiInterface.md'
  issues = '#4545'
[../]

[./acmultiinterface_aux]
  type = 'Exodiff'
  input = 'acmultiinterface_aux.i'
  exodiff = 'acmultiinterface_aux_out.e'
  requirement = 'Moose shall provide an Allen-Cahn gradient energy kernel with cross term contributions, and some order parameters may be aux variables'
  design = 'ACMultiInterface.md'
  issues = '#4545'
[../]

[./switchingfunction3phasematerial]
  type = 'Exodiff'
  input = 'switchingfunction3phasematerial.i'
  exodiff = 'switchingfunction3phasematerial_out.e'
  requirement = 'Moose shall provide switching functions for three-phase KKS phase-field model'
  design = 'SwitchingFunction3PhaseMaterial.md'
  issues = '#6857'
[../]

[./switchingfunctionmultiphasematerial]
  type = 'Exodiff'
  input = 'switchingfunctionmultiphasematerial.i'
  exodiff = 'switchingfunctionmultiphasematerial_out.e'
  requirement = 'Moose shall provide switching functions for multi-phase KKS phase-field model'
  design = 'SwitchingFunctionMultiPhaseMaterial.md'
  issues = '#8113'
[../]

[./mixedswitchingfunctionmaterial]
  type = 'Exodiff'
  input = 'mixedswitchingfunctionmaterial.i'
  exodiff = 'mixedswitchingfunctionmaterial_out.e'
  requirement = 'Moose shall provide mixed switching functions with order 234 and 246 and an adjustable weight'
  design = 'MixedSwitchingFunctionMaterial.md'
  issues = '#9042'
[../]

[./barrierfunctionmaterial]
  type = 'Exodiff'
  input = 'barrierfunctionmaterial.i'
  exodiff = 'barrierfunctionmaterial_out.e'
  requirement = 'Moose shall provide order 246 polynomials in the two phase barrier function'
  design = 'BarrierFunctionMaterial.md'
  issues = '#9301'
[../]

[./multi_test]
  type = 'Exodiff'
  input = 'multismoothcircleIC_test.i'
  exodiff = 'multismoothcircleIC_test_out.e'
  scale_refine = 1
  valgrind = 'HEAVY'
  rel_err = 4e-5
  design = 'MultiSmoothCircleIC.md'
  requirement = 'We shall be able to generate multiple smooth circle initial conditions with uniform radius variation type'
[../]

[./multi_normal_test]
  type = 'Exodiff'
  input = 'multismoothcircleIC_normal_test.i'
  exodiff = 'multismoothcircleIC_normal_test_out.e'
  scale_refine = 1
  valgrind = 'HEAVY'
  method = '!DBG' # Uses nodal feature flood count - probably should be revamped
  max_parallel = 1 # See #9886
  rel_err = 2e-5
  design = 'MultiSmoothCircleIC.md'
  requirement = 'We shall be able to generate multiple smooth circle initial conditions with normal radius variation type'
[../]

[./lattice_bounds]
  type = 'Exodiff'
  input = 'latticesmoothcircleIC_bounds.i'
  exodiff = 'latticesmoothcircleIC_bounds_out.e'
  valgrind = 'HEAVY'
  design = 'LatticeSmoothCircleIC.md'
  requirement = 'We shall be able to produce a lattice of smooth circle initial conditions, allowing the circles to exist on the simulation cell boundaries and using a uniform radius variation type'
[../]

[./lattice_test]
  type = 'Exodiff'
  input = 'latticesmoothcircleIC_test.i'
  exodiff = 'latticesmoothcircleIC_test_out.e'
  scale_refine = 1
  valgrind = 'HEAVY'
  max_parallel = 1 # See #9886
  design = 'LatticeSmoothCircleIC.md'
  requirement = 'We shall be able to produce a lattice of smooth circle initial conditions, using a uniform radius variation type'
[../]

[./lattice_normal_test]
  type = 'Exodiff'
  input = 'latticesmoothcircleIC_normal_test.i'
  exodiff = 'latticesmoothcircleIC_normal_test_out.e'
  scale_refine = 1
  valgrind = 'HEAVY'
  max_parallel = 1 # See #9886
  design = 'LatticeSmoothCircleIC.md'
  requirement = 'We shall be able to produce a lattice of smooth circle initial conditions using a normal radius variation type'
[../]

[./lattice_small_invalue_test]
  type = 'Exodiff'
  input = 'latticesmoothcircleIC_small_invalue_test.i'
  exodiff = 'latticesmoothcircleIC_small_invalue_test_out.e'
  scale_refine = 1
  valgrind = 'HEAVY'
  design = 'LatticeSmoothCircleIC.md'
  requirement = 'We shall be able to create multiple SpecifiedSmoothCircleICs with a small invalue'
[../]

[./specified_test]
  type = 'Exodiff'
  input = 'specifiedsmoothcircleIC_test.i'
  exodiff = 'specifiedsmoothcircleIC_test_out.e'
  scale_refine = 1
  valgrind = 'HEAVY'
  design = 'SpecifiedSmoothCircleIC.md'
  requirement = 'We shall be able to create several SpecifiedSmoothCircleICs with a standard invalue'
[../]

[./material]
  type = 'Exodiff'
  input = 'material.i'
  exodiff = 'material_out.e'
  requirement = "The nucleation material shall generate a free energy contribution proportional to the map value"
  design = 'materials/DiscreteNucleation.md'
  issues = '#5472'
[../]

[./material_recover1]
  type = 'CheckFiles'
  input = 'material.i'
  check_files = 'material_recover_cp/0005.xdr'
  cli_args = 'Executioner/num_steps=5 Outputs/recover/type=Checkpoint Outputs/recover/file_base=material_recover'
  prereq = 'material'
  recover = false
  requirement = "The nucleation system shall recoverable"
  design = 'materials/DiscreteNucleation.md'
  issues = '#5472'
[../]

[./material_recover2]
  # Recover the solve from part1 with a specified file
  type = 'Exodiff'
  input = 'material.i'
  exodiff = 'material_out.e'
  cli_args = '--recover material_recover_cp/0005'
  prereq = 'material_recover1'
  delete_output_before_running = false
  recover = false
  requirement = "The nucleation system shall recoverable"
  design = 'materials/DiscreteNucleation.md'
  issues = '#5472'
[../]

[./parallel]
  type = 'CSVDiff'
  input = 'parallel.i'
  csvdiff = 'parallel_out.csv'
  min_parallel = 4
  max_parallel = 4
  rel_err = 1e-3
  requirement = "The nucleation system shall insert nuclei in a manner independen of the domain decomposition and parallelization"
  design = 'userobjects/DiscreteNucleationInserter.md'
  issues = '#5472'
[../]

[./parallel_recover1]
  type = 'CheckFiles'
  input = 'parallel.i'
  check_files = 'parallel_recover_cp/0005.xdr'
  cli_args = 'Executioner/num_steps=5 Outputs/recover/type=Checkpoint Outputs/recover/file_base=parallel_recover'
  prereq = 'parallel'
  recover = false
  requirement = "The nucleation system shall recoverable"
  design = 'userobjects/DiscreteNucleationInserter.md'
  issues = '#5472'
[../]

[./parallel_recover2]
  # Recover the solve from part1 with a specified file
  type = 'CSVDiff'
  input = 'parallel.i'
  csvdiff = 'parallel_out.csv'
  rel_err = 1e-3
  cli_args = '--recover parallel_recover_cp/0005'
  prereq = 'parallel_recover1'
  delete_output_before_running = false
  recover = false
  requirement = "The nucleation system shall recoverable"
  design = 'userobjects/DiscreteNucleationInserter.md'
  issues = '#5472'
[../]

[./soft]
  type = 'Exodiff'
  input = 'soft.i'
  exodiff = 'soft_out.e'
  recover = false
  requirement = "The map shall provide the capability of defining soft interfaces for initial nuclei"
  design = 'userobjects/DiscreteNucleationMap.md'
  issues = '#5526'
[../]

[./marker]
  type = 'Exodiff'
  input = 'marker.i'
  exodiff = 'marker_out.e-s002'
  requirement = "The marker shall trigger refinement of the nucleus insertion area"
  design = 'markers/DiscreteNucleationMarker.md'
  issues = '#12099'
[../]

[./timestep]
  type = 'CSVDiff'
  input = 'timestep.i'
  csvdiff = 'timestep_out.csv'
  requirement = "The nucleation time step porocessor shall return a timestep limit that can be applied to cut the simulation timestep as new nuclei are inserted"
  design = 'postprocessors/DiscreteNucleationTimeStep.md'
  issues = '#12104'
[../]

[./data]
  type = 'CSVDiff'
  input = 'data.i'
  csvdiff = 'data_out.csv'
  requirement = "The nucleation data porocessor shall return the number of currently active nuclei or whether a change to the nucleus list has occurred"
  design = 'postprocessors/DiscreteNucleationData.md'
  issues = '#12114'
[../]

[./auxkernel]
  type = 'Exodiff'
  input = 'auxkernel.i'
  exodiff = 'auxkernel_out.e'
  requirement = "The nucleation auxkernel evaluates the nucleation map onto an elemental aux variable"
  design = 'auxkernels/DiscreteNucleationAux.md'
  issues = '#12114'
[../]

[./force]
  type = 'Exodiff'
  input = 'force.i'
  exodiff = 'force_out.e'
  requirement = "The nucleation force kernel returns a forcing function based on the nucleation map"
  design = 'auxkernels/DiscreteNucleationAux.md'
  issues = '#12114'
[../]

[./file]
  type = 'Exodiff'
  input = 'file.i'
  exodiff = 'file_out.e'
  requirement = "The discrete nucleation system shall provide a deterministic nucleus inserter that uses tabulated time and location data from a file"
  design = 'userobjects/DiscreteNucleationFromFile.md'
  issues = '#12262'
[../]

[./split]
  type = 'Exodiff'
  input = 'split.i'
  exodiff = 'split_out.e'
  requirement = 'A temperature gradient driving force for diffusion shall be added to the split form of the Cahn-Hilliard equation.'
[../]

[./split_temp]
  type = 'Exodiff'
  input = 'split_temp.i'
  exodiff = 'split_temp_out.e'
  requirement = 'A temperature gradient driving force for diffusion shall be added to the split form of the Cahn-Hilliard equation, where temperature is a coupled non-linear variable'
[../]

[./direct]
  type = 'Exodiff'
  input = 'direct.i'
  exodiff = 'direct_out.e'
  requirement = 'A temperature gradient driving force for diffusion shall be added to the non-split form of the Cahn-Hilliard equation.'
[../]

[./direct_temp]
  type = 'Exodiff'
  input = 'direct_temp.i'
  exodiff = 'direct_temp_out.e'
  requirement = 'A temperature gradient driving force for diffusion shall be added to the non-split form of the Cahn-Hilliard equation, where temperature is a coupled non-linear variable'
[../]

[./TotalFreeEnergy]
  type = 'Exodiff'
  input = 'TotalFreeEnergy_test.i'
  exodiff = 'TotalFreeEnergy_test_out.e'
  max_parallel = 1 # -pc_type lu
  requirement = 'We shall be able to calculate the free energy (with one variable) using an AuxKernel'
[../]

[./2var]
  type = 'Exodiff'
  input = 'TotalFreeEnergy_2var_test.i'
  exodiff = 'TotalFreeEnergy_2var_test_out.e-s004'
  fparser_jit = True
  rel_err = 1e-5
  requirement = 'We shall be able to calculate the free energy (with two variables) using an AuxKernel'
[../]

[./Nonconserved_1var]
  type = Exodiff
  input = 'Nonconserved_1var.i'
  exodiff = 'Nonconserved_1var_out.e'
  issues = '#9336'
  design = 'action/NonconservedAction.md'
  requirement = 'The phase field module shall provide an action to set up an Allen-Cahn problem'
[../]

[./Nonconserved_highorder]
  type = Exodiff
  input = 'Nonconserved_highorder.i'
  exodiff = 'Nonconserved_highorder_out.e'
  issues = '#9336'
  design = 'action/NonconservedAction.md'
  requirement = 'The NonconservedAction shall correctly set up Allen-Cahn problems with higher order elements'
[../]

[./Nonconserved_variableL]
  type = Exodiff
  input = 'Nonconserved_variableL.i'
  exodiff = 'Nonconserved_variableL_out.e'
  issues = '#9336'
  design = 'action/NonconservedAction.md'
  requirement = 'The NonconservedAction shall correctly set up Allen-Cahn problems with variable dependent mobilities'
[../]

[./Nonconserved_2vars]
  type = Exodiff
  input = 'Nonconserved_2vars.i'
  exodiff = 'Nonconserved_2vars_out.e'
  issues = '#9336'
  design = 'action/NonconservedAction.md'
  requirement = 'The NonconservedAction shall correctly set up Allen-Cahn problems with multiple order parameters'
[../]

[./both_split_2vars]
  type = Exodiff
  input = 'both_split_2vars.i'
  exodiff = 'both_split_2vars_out.e'
  issues = '#9336'
  design = 'action/ConservedAction.md action/NonconservedAction.md'
  requirement = 'The phase field module NonconservedAction and ConservedAction can be combined to construct a coupled Allen-Chan and split Cahn-Hilliard problem'
[../]

[./both_direct_2vars]
  type = Exodiff
  input = 'both_direct_2vars.i'
  exodiff = 'both_direct_2vars_out.e'
  issues = '#9336'
  design = 'action/ConservedAction.md action/NonconservedAction.md'
  requirement = 'The phase field module NonconservedAction and ConservedAction can be combined to construct a coupled Allen-Chan and non-split Cahn-Hilliard problem'
[../]

[./conserved_direct_1var]
  type = Exodiff
  input = 'conserved_direct_1var.i'
  exodiff = 'conserved_direct_1var_out.e'
  issues = '#9336'
  design = 'action/ConservedAction.md'
  requirement = 'The phase field module shall provide an action to set up a non-split Cahn-Hilliard problem'
[../]

[./conserved_split_1var]
  type = Exodiff
  input = 'conserved_split_1var.i'
  exodiff = 'conserved_split_1var_out.e'
  issues = '#9336'
  design = 'action/ConservedAction.md'
  requirement = 'The phase field module shall provide an action to set up a reverse split Cahn-Hilliard problem'
[../]

[./conserved_split_1var_high_order]
  type = Exodiff
  input = 'conserved_split_1var_high_order.i'
  exodiff = 'conserved_split_1var_high_order_out.e'
  issues = '#9336'
  design = 'action/ConservedAction.md'
  requirement = 'The phase field module shall provide an action to set up a reverse split Cahn-Hilliard problem with higher order elements'
[../]

[./conserved_direct_1var_variable_mob]
  type = Exodiff
  input = 'conserved_direct_1var_variable_mob.i'
  exodiff = 'conserved_direct_1var_variable_mob_out.e'
  issues = '#9336'
  design = 'action/ConservedAction.md'
  requirement = 'The phase field module shall provide an action to set up a non-split Cahn-Hilliard problem with variable dependent mobilities'
[../]

[./conserved_split_1var_variable_mob]
  type = Exodiff
  input = 'conserved_split_1var_variable_mob.i'
  exodiff = 'conserved_split_1var_variable_mob_out.e'
  abs_zero = 1e-9
  issues = '#9336'
  design = 'action/ConservedAction.md'
  requirement = 'The phase field module shall provide an action to set up a reverse split Cahn-Hilliard problem with variable dependent mobilities'
[../]

[./both_split_2vars]
  type = Exodiff
  input = 'both_split_2vars.i'
  exodiff = 'both_split_2vars_out.e'
  issues = '#9336'
  design = 'action/ConservedAction.md action/NonconservedAction.md'
  requirement = 'The phase field module NonconservedAction and ConservedAction can be combined to construct a coupled Allen-Chan and split Cahn-Hilliard problem'
[../]

[./both_direct_2vars]
  type = Exodiff
  input = 'both_direct_2vars.i'
  exodiff = 'both_direct_2vars_out.e'
  issues = '#9336'
  design = 'action/ConservedAction.md action/NonconservedAction.md'
  requirement = 'The phase field module NonconservedAction and ConservedAction can be combined to construct a coupled Allen-Chan and non-split Cahn-Hilliard problem'
[../]

[./conserved_forward_split_1var]
  type = Exodiff
  input = 'conserved_forward_split_1var.i'
  exodiff = 'conserved_forward_split_1var_out.e'
  issues = '#9378'
  design = 'action/ConservedAction.md'
  requirement = 'The phase field module shall provide an action to set up a forward split Cahn-Hilliard problem'
[../]

[./grain_growth]
  type = Exodiff
  input = 'grain_growth.i'
  exodiff = 'grain_growth_out.e'
  issues = '#9485'
  design = 'action/GrainGrowthAction.md'
  requirement = 'The phase field module shall provide an action to set up grain growth problems'
[../]

[./ad_grain_growth]
  type = Exodiff
  input = 'grain_growth.i'
  exodiff = 'grain_growth_out.e'
  issues = '#13539'
  design = 'action/GrainGrowthAction.md'
  requirement = 'The action to set up grain growth problems shall be able to set up an AD version of the problem which yields the same results as the non-AD version'
  cli_args = 'Modules/PhaseField/GrainGrowth/use_automatic_differentiation=true'
  prereq = 'grain_growth'
[../]

[./ad_grain_growth-jac]
  type = 'PetscJacobianTester'
  input = 'grain_growth.i'
  issues = '#13539'
  design = 'action/GrainGrowthAction.md'
  method = 'OPT' # this is too slow for anything but opt
  ratio_tol = 5e-8
  difference_tol = 5e-5
  run_sim = True
  requirement = 'The action to set up grain growth problems shall be able to set up an AD version of the problem which yields the same results as the non-AD version'
  cli_args = 'Modules/PhaseField/GrainGrowth/use_automatic_differentiation=true Executioner/num_steps=1 Mesh/nx=10 Mesh/ny=10'
  prereq = 'ad_grain_growth'
[../]

[./grain_growth_with_c]
  type = Exodiff
  input = 'grain_growth_with_c.i'
  exodiff = 'grain_growth_with_c_out.e'
  issues = '#9485'
  design = 'action/GrainGrowthAction.md'
  requirement = 'The grain growth action shall have the ability to set up problems with a pinning particle'
[../]

[./grain_growth_with_T_grad]
  type = Exodiff
  input = 'grain_growth_with_T_grad.i'
  exodiff = 'grain_growth_with_T_grad_out.e'
  issues = '#9485'
  design = 'action/GrainGrowthAction.md'
  requirement = 'The grain growth action shall have the ability to set up problems with a temperature gradient'
[../]

[./GrainGrowth_initial_from_file]
  type = Exodiff
  input = 'GrainGrowth_initial_from_file.i'
  exodiff = 'GrainGrowth_initial_from_file_out.e'
  prereq = prepare_mesh
  requirement = 'A capability to initialize polycrystal phase field variables from a file mesh shall be provided through the GrainGrowth action'
  design = 'action/GrainGrowthAction.md'
  issues = '#13624'
[../]

[./split]
  type = 'Exodiff'
  input = 'split.i'
  exodiff = 'split_out.e'
  requirement = 'A split Cahn-Hilliard kernel with an anisotropic mobility shall be provided'
  design = "/CahnHilliardAniso.md"
  issues = "#5596"
[../]

[./nonsplit]
  type = 'Exodiff'
  input = 'nonsplit.i'
  exodiff = 'nonsplit_out.e'
  requirement = 'A non-split Cahn-Hilliard kernel with an anisotropic mobility shall be provided'
  design = "/SplitCHWResAniso.md"
  issues = "#5596"
[../]

[./diffusion]
  type = 'Exodiff'
  input = 'diffusion.i'
  exodiff = 'diffusion_out.e'
  requirement = 'A Diffusion kernel with an anisotropic material property diffusivity shall be provided'
  design = "/MatAnisoDiffusion.md"
  issues = "#5841"
[../]

[./ad_diffusion]
  type = 'Exodiff'
  input = 'ad_diffusion.i'
  exodiff = 'ad_diffusion_out.e'
  requirement = 'AD Diffusion with an anisotropic material property diffusivity shall agree with the non-AD version'
  design = "/ADMatAnisoDiffusion.md"
  issues = "#13632"
[../]

[./ad_diffusion_jac]
  type = 'PetscJacobianTester'
  input = 'ad_diffusion.i'
  ratio_tol = 1e-8
  difference_tol = 1e-7
  run_sim = True
  requirement = 'AD Diffusion with an anisotropic material property diffusivity shall have a perfect Jacobian'
  design = "/ADMatAnisoDiffusion.md"
  issues = "#13632"
[../]

[./admatreaction]
  type = Exodiff
  input = 'admatreaction.i'
  exodiff = 'admatreaction_out.e'
  allow_test_objects = true
  requirement = 'MOOSE shall provide an automatic differentiation mat reaction kernel'
[../]

[./admatreaction-jac]
  type = 'PetscJacobianTester'
  input = 'admatreaction.i'
  run_sim = 'True'
  cli_args = 'Outputs/exodus=false'
  allow_test_objects = true
  requirement = 'The Jacobian for the automatic differentiation mat reaction kernel shall be perfect'
[../]

[./boundary_intersecting_features]
  type = CSVDiff
  input = boundary_intersecting_features.i
  csvdiff = boundary_intersecting_features_out_grain_volumes_0000.csv
  # This test requires VTK because it uses the ImageFunction class
  vtk = true

  requirement = "The FeatureVolumeVectorPostprocessor shall capture volume information of individual features."
[../]

[./boundary_intersecting_features_flipped]
  type = CSVDiff
  input = boundary_intersecting_features.i
  cli_args = 'Mesh/file=sixteenth_image001_cropped3_closing_298_flipped.png Outputs/file_base=boundary_intersecting_features_flipped'
  csvdiff = boundary_intersecting_features_flipped_grain_volumes_0000.csv
  # This test requires VTK because it uses the ImageFunction class
  vtk = true

  requirement = "The FeatureVolumeVectorPostprocessor shall capture whether any feature intersects the boundary,  even when the non-root rank doesn't own a part of the feature that intersects the boundary."
[../]

[./centroid_output_test]
  type = 'CSVDiff'
  input = 'feature_volume_vpp_test.i'
  csvdiff = 'feature_volume_vpp_test_out_features_0000.csv'

  issues = "#11395"
  requirement = "The FeatureVolumeVectorPostprocessor shall output individual centroid locations when requested."
  design = "/FeatureVolumeVectorPostprocessor.md"
[../]

[./centroid_output_test_parallel]
  type = 'CSVDiff'
  input = 'feature_volume_vpp_test.i'
  csvdiff = 'feature_volume_vpp_test_out_features_0000.csv'

  issues = "#11395"
  requirement = "The FeatureVolumeVectorPostprocessor shall output individual centroid locations when requested."
  design = "/FeatureVolumeVectorPostprocessor.md"

  min_parallel = 2
  prereq = 'centroid_output_test'
[../]

[./percolation_test]
  type = 'CSVDiff'
  input = 'percolation_test.i'
  csvdiff = 'percolation_test_out_features_0000.csv'

  issues = "#13169"
  requirement = "The FeatureVolumeVectorPostprocessor shall output whether a percolated pathway exists between
                    specified primary_percolation_boundaries and secondary_percolation_boundaries."
  design = "/FeatureVolumeVectorPostprocessor.md"
[../]

[./percolation_test_parallel]
  type = 'CSVDiff'
  input = 'percolation_test.i'
  csvdiff = 'percolation_test_out_features_0000.csv'

  issues = "#13169"
  requirement = "The FeatureVolumeVectorPostprocessor shall output whether a percolated pathway exists between
                    specified primary_percolation_boundaries and secondary_percolation_boundaries."
  design = "/FeatureVolumeVectorPostprocessor.md"

  min_parallel = 2
  prereq = 'percolation_test'
[../]

[./boundary_area_2D_test]
  type = 'CSVDiff'
  input = 'boundary_area_2D.i'
  csvdiff = 'boundary_area_2D_out_features_0000.csv'

  issues = "#13202"
  requirement = "The FeatureVolumeVectorPostprocessor shall calculate coverage of a supplied boundary
                    by each feature by integrating the corresponding order parameter on the boundary."
  design = "/FeatureVolumeVectorPostprocessor.md"

  min_parallel = 2
[../]

[./boundary_area_2D_single_test]
  type = 'CSVDiff'
  input = 'boundary_area_2D_single.i'
  csvdiff = 'boundary_area_2D_single_out_features_0000.csv'

  issues = "#13202"
  requirement = "The FeatureVolumeVectorPostprocessor shall calculate coverage of a supplied boundary
                    by each feature by calulating the area/length of boundary elements."
  design = "/FeatureVolumeVectorPostprocessor.md"

  min_parallel = 2
[../]

[./boundary_area_3D_test]
  type = 'CSVDiff'
  input = 'boundary_area_3D.i'
  csvdiff = 'boundary_area_3D_out_features_0000.csv'

  issues = "#13202"
  requirement = "The FeatureVolumeVectorPostprocessor shall calculate coverage of a supplied boundary
                    by each feature by integrating the corresponding order parameter on the boundary."
  design = "/FeatureVolumeVectorPostprocessor.md"

  min_parallel = 2
[../]

[./boundary_area_3D_single_test]
  type = 'CSVDiff'
  input = 'boundary_area_3D_single.i'
  csvdiff = 'boundary_area_3D_single_out_features_0000.csv'

  issues = "#13202"
  requirement = "The FeatureVolumeVectorPostprocessor shall calculate coverage of a supplied boundary
                    by each feature by calulating the area/length of boundary elements."
  design = "/FeatureVolumeVectorPostprocessor.md"

  min_parallel = 2
[../]

[./integral]
  type = 'CSVDiff'
  input = 'integral.i'
  csvdiff = 'integral.csv'
  issues = '#4763'
  design = '/Nucleation/conservednoise_include.md'
  requirement = 'A system to supply a noise field with a domain integral of zero shall be provided'
[../]

[./normal]
  max_parallel = 1
  type = 'Exodiff'
  input = 'normal.i'
  exodiff = 'normal.e'
  issues = '#4763'
  design = '/Nucleation/conservednoise_include.md'
  requirement = 'A system to supply a normal distributed noise field with a domain integral of zero shall be provided'
[../]

[./uniform]
  max_parallel = 1
  type = 'Exodiff'
  input = 'uniform.i'
  exodiff = 'uniform.e'
  issues = '#4763'
  design = '/Nucleation/conservednoise_include.md'
  requirement = 'A system to supply a uniformly distributed noise field with a domain integral of zero shall be provided'
[../]

[./integral_normal_masked]
  type = 'CSVDiff'
  input = 'normal_masked.i'
  csvdiff = 'normal_masked.csv'
  issues = '#4763'
  design = '/Nucleation/conservednoise_include.md'
  requirement = 'A system to supply a normal distributed noise field with an amplitude mask and a domain integral of zero shall be provided'
[../]

[./seed_error]
  type = 'RunException'
  input = 'integral.i'
  cli_args = 'Kernels/conserved_langevin/seed=1234'
  expect_err = "This parameter has no effect in this kernel. The noise is generated in the user object"
  issues = '#14368'
  design = '/Nucleation/conservednoise_include.md'
  requirement = "The conserved noise kernel shall error out with a helpful message if a 'seed' parameter is supplied"
[../]

[./fourier_noise]
  type = 'Exodiff'
  input = 'fourier_noise.i'
  exodiff = 'fourier_noise_out.e'
  issues = '#13316'
  design = '/FourierNoise.md'
  requirement = 'A function that returns a new periodic random field with a lower wavelength cut-off shall be provided.'
[../]

[./test]
  type = 'Exodiff'
  input = 'test.i'
  exodiff = 'test_out.e-s005'
  group = 'adpative'
  requirement = 'MOOSE shall provide a polycrystalline material model with grain growth'
  design = 'PolycrystalKernelAction.md'
  issues = '98e22eda8bfaa1f6ded00c127145d832542aff70'
[../]

[./temperature_gradient]
  type = 'Exodiff'
  input = 'temperature_gradient.i'
  exodiff = 'temperature_gradient_out.e'
  requirement = 'A flat grain boundary shall not move along a temperature gradient'
  design = 'PolycrystalKernelAction.md'
  issues = '#9507'
[../]

[./off-diagonal]
  type = 'Exodiff'
  input = 'off-diagonal.i'
  exodiff = 'off-diagonal_out.e-s002'
  group = 'adaptive'
  requirement = 'The grain boundary evolution model shall provide off-diagonal Jacobians'
  design = 'PolycrystalKernelAction.md'
  issues = '98e22eda8bfaa1f6ded00c127145d832542aff70'
[../]

[./explicit]
  type = 'Exodiff'
  input = 'explicit.i'
  exodiff = 'explicit_out.e'
  requirement = 'The grain growth model shall work with explicit time integration'
  design = 'PolycrystalKernelAction.md'
  issues = '98e22eda8bfaa1f6ded00c127145d832542aff70'
[../]

[./thumb]
  type = 'Exodiff'
  input = 'thumb.i'
  exodiff = 'thumb_out.e-s006'
  group = 'adaptive'
  requirement = 'A thumb shaped grain IC shall be provided for direct comparison to grain boundary mobility experiments'
  design = 'ThumbIC.md'
  issues = '98e22eda8bfaa1f6ded00c127145d832542aff70'
[../]

[./hex]
  type = 'Exodiff'
  input = 'hex.i'
  exodiff = 'hex_out.e'
  requirement = 'A hexagonal grain structure IC shall be provided'
  design = 'PolycrystalHex.md'
  issues = '#8810'
[../]

[./boundingbox]
  type = 'Exodiff'
  input = 'boundingbox.i'
  exodiff = 'boundingbox_out.e-s003'
  requirement = 'A bicrystal grain IC shall be provided to set up a rectangular grain in a matrix'
  design = 'BicrystalBoundingBoxICAction.md'
  issues = '98e22eda8bfaa1f6ded00c127145d832542aff70'
[../]

[./evolution]
  type = 'Exodiff'
  input = 'evolution.i'
  exodiff = 'evolution_out.e'
  requirement = 'The grain boundary evolution model shall be able to compute the grain boundary mobility based on an activation energy'
  design = 'GBEvolution.md'
  issues = '98e22eda8bfaa1f6ded00c127145d832542aff70'
[../]

[./constant_mobility]
  type = 'Exodiff'
  input = 'constant_mobility.i'
  exodiff = 'constant_mobility_out.e'
  requirement = 'The grain boundary evolution model shall permit specifying a constant mobility'
  design = 'GBEvolution.md'
  issues = '98e22eda8bfaa1f6ded00c127145d832542aff70'
[../]

[./voronoi]
  type = 'Exodiff'
  input = 'voronoi.i'
  exodiff = 'voronoi_out.e'
  requirement = 'A voronoi tesselation grain structure IC shall be provided'
  design = 'PolycrystalVoronoi.md'
  issues = '#8810'
[../]

[./voronoi_columnar_3D]
  type = 'Exodiff'
  input = 'voronoi_columnar_3D.i'
  exodiff = 'voronoi_columnar_3D_out.e'
  requirement = 'A columnar grain IC shall be provided based on a 2D voronoi tesselation'
  design = 'PolycrystalVoronoi.md'
  issues = '#8810'
[../]

[./particle]
  type = 'Exodiff'
  input = 'particle.i'
  exodiff = 'particle_out.e-s005'
  custom_cmp = 'particle_out.cmp'
  requirement = 'The grain boundary evolution model shall provide coupling to conserved order parameters'
  design = 'ACGBPoly.md'
  issues = '98e22eda8bfaa1f6ded00c127145d832542aff70'
[../]

[./test_nodal]
  type = 'Exodiff'
  input = 'grain_tracker_nodal.i'
  exodiff = 'grain_tracker_nodal_out.e'

  # integer based maps can shift slightly in parallel
  max_parallel = 1
  valgrind = 'HEAVY'
  max_time = 500

  requirement = 'The system shall properly create and track grains when using the Nodal mode of the GrainTracker algorithm.'
  issues = '#4765'
  design = 'GrainTracker.md'
[../]

[./test_elemental]
  type = 'Exodiff'
  input = 'grain_tracker_test_elemental.i'
  exodiff = 'grain_tracker_test_elemental_out.e-s002'
  method = '!DBG' # slow test
  valgrind = 'HEAVY'
  max_time = 500

  requirement = 'The system shall properly create and track grains when using the Elemental mode of the GrainTracker algorithm.'
  issues = '#4881'
  design = 'GrainTracker.md'
[../]

[./test_advanced_op_assignment]
  type = 'CSVDiff'
  input = 'grain_tracker_advanced_op.i'
  csvdiff = 'grain_tracker_advanced_op_out.csv'
  recover = false # No solve
  max_parallel = 1

  requirement = "The PolycrystalVoronoi object shall create a valid coloring for a given number of grains and order parameters."
  issues = '#7005 #9018'
  design = "GrainTracker.md"
[../]

[./test_halo_periodic_bc]
  type = 'Exodiff'
  input = 'grain_halo_over_bc.i'
  exodiff = 'grain_halo_over_bc_out.e'
  method = '!DBG' # slow test
  valgrind = 'HEAVY'
  max_parallel = 1

  requirement = "The GrainTracker/PolycrystalUserObject base class shall support having only a grain halo bleeding over a periodic edge."
  issues = '#6713 #8926'
  design = "GrainTracker.md"
  abs_zero = 1e-7
  rel_err = 4e-5
[../]

[./test_remapping_serial]
  type = 'CSVDiff'
  input = 'grain_tracker_remapping_test.i'
  csvdiff = 'grain_tracker_remapping_test_out.csv'
  method = '!DBG' # slow test
  valgrind = 'NONE' # Exact same test used elsewhere
  # This test uses a coloring algorithm that requires PETSc >= 3.5.0.
  petsc_version = '>=3.5.0'

  requirement = "The GrainTracker object shall support remapping order parameter values."
  issues = '#1298'
  design = "GrainTracker.md"
[../]

[./test_remapping_parallel]
  type = 'CSVDiff'
  input = 'grain_tracker_remapping_test.i'
  csvdiff = 'grain_tracker_remapping_test_out.csv'

  method = '!DBG' # slow test
  valgrind = 'HEAVY'
  # This test uses a coloring algorithm that requires PETSc >= 3.5.0.
  petsc_version = '>=3.5.0'
  prereq = 'test_remapping_serial'

  min_parallel = 8 # Test distributed merge work with grain tracker

  requirement = "The FeatureFloodCount object shall distribute the merging of features when the processor count exceeds number of order parameters for efficiency."
  issues = '#11805'
  design = "GrainTracker.md"
[../]

[./test_recovery_serial_part1]
  type = 'RunApp'
  input = 'grain_tracker_remapping_test.i'
  cli_args = 'Outputs/file_base=gt_recover_serial_out Outputs/checkpoint=true --half-transient'

  method = '!DBG'
  valgrind = 'NONE'
  petsc_version = '>=3.5.0'

  requirement = "The GrainTracker object shall properly checkpoint unique grain information in serial."
  issues = "#6713 #12427"
  design = "GrainTracker.md"
[../]

[./test_recovery_serial_part2]
  type = 'CSVDiff'
  input = 'grain_tracker_remapping_test.i'
  csvdiff = 'gt_recover_serial_out.csv'
  cli_args = 'Outputs/file_base=gt_recover_serial_out --recover'
  prereq = 'test_recovery_serial_part1'
  delete_output_before_running = false

  method = '!DBG'
  valgrind = 'NONE'
  petsc_version = '>=3.5.0'

  requirement = "The GrainTracker object shall properly recover unique grain information in serial."
  issues = "#6713 #12427"
  design = "GrainTracker.md"
[../]

[./test_recovery_parallel_part1]
  type = 'RunApp'
  input = 'grain_tracker_remapping_test.i'
  cli_args = 'Outputs/file_base=gt_recover_parallel_out Outputs/checkpoint=true --half-transient'

  min_parallel = 8 # Test distributed merge work with grain tracker

  method = '!DBG'
  valgrind = 'NONE'
  petsc_version = '>=3.5.0'

  requirement = "The GrainTracker object shall properly checkpoint unique grain information in parallel."
  issues = "#6713 #12427"
  design = "GrainTracker.md"
[../]

[./test_recovery_parallel_part2]
  type = 'CSVDiff'
  input = 'grain_tracker_remapping_test.i'
  csvdiff = 'gt_recover_parallel_out.csv'
  cli_args = 'Outputs/file_base=gt_recover_parallel_out --recover'
  prereq = 'test_recovery_parallel_part1'
  delete_output_before_running = false

  min_parallel = 8 # Test distributed merge work with grain tracker

  method = '!DBG'
  valgrind = 'NONE'
  petsc_version = '>=3.5.0'

  requirement = "The GrainTracker object shall properly recover unique grain information in parallel."
  issues = "#6713 #12427"
  design = "GrainTracker.md"
[../]

[./remapping_with_reserve]
  type = 'Exodiff'
  input = 'grain_tracker_reserve.i'
  exodiff = 'grain_tracker_reserve_out.e'
  abs_zero = 1e-6 # Remapping can cause more significant diffs
  method = '!DBG' # slow test
  valgrind = 'HEAVY'

  requirement = "The GrainTracker shall support maintaining reserve order parameters for simulations where new grains can form."
  issues = '#7605'
  design = "GrainTracker.md"
[../]

[./start_with_zero_grains]
  type = 'Exodiff'
  input = 'grain_tracker_reserve.i'
  exodiff = 'start_with_zero_grains_out.e'
  abs_zero = 1e-6
  cli_args = 'ICs/inactive=gr0 Outputs/file_base=start_with_zero_grains_out'

  method = '!DBG' # slow test
  valgrind = 'HEAVY'

  requirement = "The GrainTracker shall support beginning a simulation with no active grain structure."
  issues = "#12200"
  design = "GrainTracker.md"
[../]

[./split_grain]
  type = 'CSVDiff'
  # Make sure that this simulation hits the "split grain" logic branch
  expect_out = 'Split Grain Detected'
  input = 'split_grain.i'
  csvdiff = 'split_grain_out.csv'
  max_time = 500
  method = '!DBG' # slow test
  valgrind = 'HEAVY'
  # This test uses a coloring algorithm that requires PETSc >= 3.5.0.
  petsc_version = '>=3.5.0'

  requirement = "The GrainTracker shall support handling the splitting of a grain during a simulation."
  issues = '#7875'
  design = "GrainTracker.md"

[../]

[./changing_avg_volume]
  type = 'CSVDiff'
  input = 'grain_tracker_volume_changing.i'
  csvdiff = 'grain_tracker_volume_changing_out.csv'
  rel_err = 1e-4
  method = '!DBG' # slow test
  valgrind = 'HEAVY'
  # This test uses a coloring algorithm that requires PETSc >= 3.5.0.
  petsc_version = '>=3.5.0'

  requirement = "The AverageFeatureVolume Postprocessor shall calculate the average volume of each active grain in a simulation."
  issues = '#11822'
  design = "GrainTracker.md"
[../]

[./tolerate_remap_failure]
  type = 'RunApp'
  input = 'grain_tracker_remapping_test.i'
  cli_args = 'UserObjects/grain_tracker/tolerate_failure=true UserObjects/voronoi/grain_num=16 Executioner/num_steps=6 UserObjects/voronoi/coloring_algorithm=bt Outputs/exodus=false Outputs/csv=false'
  expect_out = "Unable to find any suitable order parameters for remapping"
  allow_warnings = true
  valgrind = 'NONE'
  method = '!DBG' # slow test
  min_parallel = 2

  requirement = "The GrainTracker shall support a mode where it can continue even when it fails to remap for post-modern analysis and debugging."
  issues = '#11843'
  design = "GrainTracker.md"
[../]

[./one_grain]
  type = 'CSVDiff'
  input = 'one_grain.i'
  csvdiff = 'one_grain_out.csv'
  recover = false # no solve

  requirement = 'The system shall properly handle a single feature or grain taking up the entire domain.'
  issues = '#12216'
  design = 'GrainTracker.md'
[../]

[./test_faux_nodal]
  type = 'Exodiff'
  input = 'grain_tracker_nodal.i'
  cli_args = 'Outputs/file_base=gt_faux_nodal_out UserObjects/grain_tracker/type=FauxGrainTracker'

  exodiff = 'gt_faux_nodal_out.e'
  valgrind = 'HEAVY'
  max_time = 500

  requirement = "The system shall grain tracking behavior even when the number of grains equals the number of order parameters when using mode Nodal."
  issues = '#5453'
  design = 'GrainTracker.md'
[../]

[./test_faux_element]
  type = 'Exodiff'
  input = 'grain_tracker_test_elemental.i'
  cli_args = 'Outputs/file_base=gt_faux_elemental_out UserObjects/grain_tracker/type=FauxGrainTracker'

  exodiff = 'gt_faux_elemental_out.e-s002'
  method = '!DBG' # slow test
  valgrind = 'HEAVY'
  max_time = 500

  requirement = "The system shall grain tracking behavior even when the number of grains equals the number of order parameters when using mode Elemental."
  issues = '#5453'
  design = 'GrainTracker.md'
[../]

[./grain_tracker_volume]
  type = 'CSVDiff'
  input = 'grain_tracker_volume.i'
  csvdiff = 'grain_tracker_volume_out_grain_volumes_0000.csv grain_tracker_volume_out.csv'
  rel_err = 1.e-3

  # Lots of adaptivity, slower test
  min_parallel = 6

  requirement = "The system shall output individual grain tracker volumes."
  issues = '#7769'
  design = 'GrainTracker.md'
[../]

[./grain_tracker_volume_single]
  type = 'CSVDiff'
  input = 'grain_tracker_volume_single.i'
  csvdiff = 'grain_tracker_volume_single_out_grain_volumes_0000.csv'
  rel_err = 1.e-3

  # Lots of adaptivity, slower test
  min_parallel = 6

  requirement = "The system shall output individual grain tracker volumes assigning each element to only one grain (conservative)."
  issues = '#7769'
  design = 'GrainTracker.md'
[../]

[./feature_flood_volume]
  type = 'CSVDiff'
  input = 'grain_tracker_volume.i'
  cli_args = 'Postprocessors/grain_tracker/type=FeatureFloodCount'
  csvdiff = 'grain_tracker_volume_out_grain_volumes_0000.csv grain_tracker_volume_out.csv'
  prereq = grain_tracker_volume
  rel_err = 1.e-3

  # Lots of adaptivity, slower test
  min_parallel = 6

  requirement = "The system shall output individual grain tracker volumes when the number of order parameters equals the number of grains."
  issues = '#5453'
  design = 'GrainTracker.md'
[../]

[./test_advanced_op_assignment_bt_error]
  type = 'RunException'
  input = 'grain_tracker_advanced_op.i'
  expect_err = "Unable to find a valid grain to op coloring"
  recover = false # No solve
  cli_args = 'GlobalParams/op_num=4 Outputs/csv=false'

  requirement = "The PolycrystalUserObject base class shall error when a valid coloring cannot be found when using the simple back-tracking algorithm."
  issues = '#7005 #8804'
  design = "PolycrystalICs.md"
[../]

[./test_advanced_op_assignment_petsc_error]
  type = 'RunException'
  input = 'grain_tracker_advanced_op.i'
  expect_err = "Unable to find a valid grain to op coloring"
  recover = false # No solve
  cli_args = 'UserObjects/voronoi/coloring_algorithm=jp GlobalParams/op_num=7 Outputs/csv=false'

  requirement = "The PolycrystalUserObject base class shall error when a valid coloring cannot be found when using the built-in PETSc based stochastic algorithms."
  issues = '#7005 #8804'
  design = "PolycrystalICs.md"
[../]

[./test_poly_ic_handoff]
  type = 'CSVDiff'
  input = 'grain_tracker_remapping_test.i'
  csvdiff = 'test_poly_ic_handoff_out.csv'

  cli_args = 'Executioner/Adaptivity/initial_adaptivity=1 Executioner/Adaptivity/refine_fraction=0.7 Executioner/Adaptivity/max_h_level=2 Executioner/num_steps=1 Outputs/file_base=test_poly_ic_handoff_out'

  method = '!DBG' # slow test
  valgrind = 'NONE' # Exact same test used elsewhere
  # This test uses a coloring algorithm that requires PETSc >= 3.5.0.
  petsc_version = '>=3.5.0'

  requirement = "The GrainTracker shall support reusing the data structures from the PolycrystalUserObjectBase after the  initial condition for efficiency."
  issues = '#8810'
  design = "PolycrystalICs.md"
[../]

[./test_ebsd]
  type = 'Exodiff'
  input = 'grain_tracker_ebsd.i'
  exodiff = 'grain_tracker_ebsd_out.e'

  requirement = "The GrainTracker shall support reading EBSD data to create initial conditions."
  issues = '#5067 #9060'
  design = "PolycrystalICs.md"
[../]

[./test_ebsd_adapt]
  type = 'Exodiff'
  input = 'grain_tracker_ebsd.i'
  exodiff = 'grain_tracker_ebsd_adapt_out.e'
  cli_args = 'Executioner/Adaptivity/initial_adaptivity=1 Executioner/Adaptivity/refine_fraction=0.7 Executioner/Adaptivity/max_h_level=1 Outputs/file_base=grain_tracker_ebsd_adapt_out'

  requirement = "The GrainTracker shall support reading EBSD data to create initial conditions while supporting initial condition refinement."
  issues = '#5067 #9060'
  design = "PolycrystalICs.md"
[../]

[./distributed_poly_ic]
  type = 'CSVDiff'
  input = 'distributed_poly_ic.i'
  csvdiff = 'distributed_poly_ic_out.csv'

  # This test uses a coloring algorithm that requires PETSc >= 3.5.0.
  allow_test_objects = true
  petsc_version = '>=3.5.0'

  requirement = 'The system shall properly create PolycrystalICs with halo extensions (elements) when using DistributedMesh.'
  issues = '#12216'
  design = 'PolycrystalICs.md'
[../]

[RampIC]
  type = Exodiff
  input = 'RampIC.i'
  exodiff = 'RampIC_out.e'

  requirement = 'The system shall support a ramp or linear initial condition in one dimension.'
[]

[CrossIC]
  type = Exodiff
  input = 'CrossIC.i'
  exodiff = 'CrossIC_out.e'
  scale_refine = 1

  requirement = 'The system shall support the creation of a smooth cross initial condition.'
[]

[ellipsoids]
  requirement = 'The system shall support ellipsoidal phase-field initial conditions:'

  [BimodalInverseSuperellipsoidsIC]
    type = Exodiff
    input = 'BimodalInverseSuperellipsoidsIC.i'
    exodiff = 'BimodalInverseSuperellipsoidsIC_out.e'
    scale_refine = 1

    detail = 'bimodal inverse superellipsoidal structures,'
  []

  [BimodalSuperellipsoidsIC]
    type = Exodiff
    input = 'BimodalSuperellipsoidsIC.i'
    exodiff = 'BimodalSuperellipsoidsIC_out.e'
    scale_refine = 1

    detail = 'bimodal superellipsoidal structures,'
  []

  [SmoothSuperellipsoidIC]
    type = Exodiff
    input = 'SmoothSuperellipsoidIC.i'
    exodiff = 'SmoothSuperellipsoidIC_out.e'
    scale_refine = 1
    valgrind = 'HEAVY'

    detail = 'smooth superellipsoidal structures,'
  []

  [SpecifiedSmoothSuperellipsoidIC]
    type = Exodiff
    input = 'SpecifiedSmoothSuperellipsoidIC.i'
    exodiff = 'SpecifiedSmoothSuperellipsoidIC_out.e'
    scale_refine = 1
    valgrind = 'HEAVY'

    detail = 'smooth superellipsoidal structures specified from a file,'
  []

  [SmoothSuperellipsoidIC_3D]
    type = Exodiff
    input = 'SmoothSuperellipsoidIC_3D.i'
    exodiff = 'SmoothSuperellipsoidIC_3D_out.e'
    scale_refine = 1
    valgrind = 'HEAVY'

    detail = 'smooth superellipsoidal structures in 3D,'
  []

  [MultiSmoothSuperellipsoidIC_2D]
    type = Exodiff
    input = 'MultiSmoothSuperellipsoidIC_2D.i'
    exodiff = 'MultiSmoothSuperellipsoidIC_2D_out.e'

    detail = 'multiple smooth superellipsoidal structures in 2D, and'
  []

  [MultiSmoothSuperellipsoidIC_3D]
    type = Exodiff
    input = 'MultiSmoothSuperellipsoidIC_3D.i'
    exodiff = 'MultiSmoothSuperellipsoidIC_3D_out.e'

    detail = 'multiple smooth superellipsoidal structures in 3D.'
  []
[]

[polycrystal]
  requirement = 'The system shall support polycrystal phase-field initial conditions:'

  [PolycrystalVoronoiVoidIC_moregrains]
    type = 'Exodiff'
    input = 'PolycrystalVoronoiVoidIC_moregrains.i'
    exodiff = 'PolycrystalVoronoiVoidIC_moregrains_out.e'

    detail = 'large polycrystal structure with voids,'
  []

  [PolycrystalVoronoiVoidIC_notperiodic]
    type = 'Exodiff'
    input = 'PolycrystalVoronoiVoidIC_notperiodic.i'
    exodiff = 'PolycrystalVoronoiVoidIC_notperiodic_out.e'

    detail = 'polycrystal structure with voids,'
  []

  [PolycrystalVoronoiVoidIC_periodic]
    type = 'Exodiff'
    input = 'PolycrystalVoronoiVoidIC_periodic.i'
    exodiff = 'PolycrystalVoronoiVoidIC_periodic_out.e'

    detail = 'polycrystal structure with voids on a periodic domain,'
  []

  [PolycrystalVoronoiVoidIC_periodic_fromfile]
    type = 'Exodiff'
    input = 'PolycrystalVoronoiVoidIC_periodic_fromfile.i'
    exodiff = 'PolycrystalVoronoiVoidIC_periodic_fromfile_out.e'
    method = '!DBG'

    detail = 'polycrystal structure with voids with centroids specified from a file,'
  []

  [PolycrystalVoronoi_FromFile]
    type = Exodiff
    input = 'PolycrystalVoronoi_fromfile.i'
    exodiff = 'PolycrystalVoronoi_fromfile_out.e'
    # This test uses a coloring algorithm that requires PETSc >= 3.5.0.
    petsc_version = '>=3.5.0'

    detail = 'polycrystal structure with centroids specified from a file,'
  []

  [PolycrystalCircles_FromFile]
    type = Exodiff
    input = 'polycrystalcircles_fromfile.i'
    exodiff = 'polycrystalcircles_fromfile_out.e'
    # This test uses a coloring algorithm that requires PETSc >= 3.5.0.
    petsc_version = '>=3.5.0'

    detail = 'polycrystal circles specified from a file,'
  []

  [PolycrystalCircles_FromVector]
    type = Exodiff
    input = 'polycrystalcircles_fromvector.i'
    exodiff = 'polycrystalcircles_fromvector_out.e'
    # This test uses a coloring algorithm that requires PETSc >= 3.5.0.
    petsc_version = '>=3.5.0'

    detail = 'and polycrystal circles specified from an input vector,'
  []

  [HexPolycrystalIC]
    type = Exodiff
    input = HexPolycrystalIC.i
    exodiff = HexPolycrystalIC_out.e
    # Testing optimal hex coloring with a backtracking algorithm
    method = '!DBG'

    detail = 'hexagonal structure, and'
  []

  [TricrystalTripleJunctionIC]
    type = Exodiff
    input = 'TricrystalTripleJunctionIC.i'
    exodiff = 'TricrystalTripleJunctionIC_out.e'

    detail = 'smooth interface in a triple junction.'
  []

[]

[GB_adaptivity]
  requirement = 'The system shall support initial adaptivity based on GB locations:'
  issues = '#9668'

  [polycrystal_BndsCalcIC]
    type = 'Exodiff'
    input = 'polycrystal_BndsCalcIC.i'
    exodiff = 'polycrystal_BndsCalcIC_out.e polycrystal_BndsCalcIC_out.e-s002'

    detail = 'polycrystal structure with IC specifying the GB locations '
  []

[]

[circles]
  requirement = "The system shall support phase-field initial conditions consisting of circle patterns:"

  [SmoothCircleIC]
    type = Exodiff
    input = 'SmoothCircleIC.i'
    exodiff = 'SmoothCircleIC_out.e'
    scale_refine = 1
    valgrind = 'HEAVY'

    detail = 'smooth interface circles,'
  []

  [SmoothCircleIC_3D]
    type = Exodiff
    input = 'SmoothCircleIC_3D.i'
    exodiff = 'SmoothCircleIC_3D_out.e'
    scale_refine = 1
    valgrind = 'HEAVY'

    detail = 'smooth interface spheres,'
  []

  [SmoothCirclesFromFile]
    type = Exodiff
    input = 'circles_from_file_ic.i'
    exodiff = 'circles_from_file_ic_out.e'

    detail = 'smooth interface circles specified from a file, and'
  []

  [RndSmoothCircleIC]
    type = Exodiff
    input = 'RndSmoothCircleIC.i'
    exodiff = 'RndSmoothCircleIC_out.e'
    scale_refine = 1
    valgrind = 'HEAVY'
    max_parallel = 1
    max_threads = 1

    detail = 'smooth interface circles with random noise.'
  []
[]

[close_pack]
  requirement = "The system shall support phase-field initial conditions consisting of close pack particle patterns:"

  [ClosePackIC]
    # Test close pack ic generator (2D)
    type = Exodiff
    input = ClosePackIC.i
    exodiff = ClosePackIC_out.e

    detail = 'in 2D, and'
  []

  [ClosePackIC_3D]
    # Test close pack ic generator (3D)
    type = Exodiff
    input = ClosePackIC_3D.i
    exodiff = ClosePackIC_3D_out.e
    method = '!dbg' # This test is too slow in debug

    detail = 'in 3D.'
  []
[]

[boxes]
  requirement = "The system shall support phase-field initial conditions consiting of box patterns:"

  [BoundingBoxIC]
    type = Exodiff
    input = 'BoundingBoxIC.i'
    exodiff = 'BoundingBoxIC_out.e'
    scale_refine = 1
    valgrind = 'HEAVY'

    detail = 'bounding boxes,'
  []

  [RndBoundingBoxIC]
    type = Exodiff
    input = 'RndBoundingBoxIC.i'
    exodiff = 'RndBoundingBoxIC_out.e'
    scale_refine = 1
    valgrind = 'HEAVY'
    max_parallel = 1
    max_threads = 1
    recover = false # See #5207

    detail = 'bounding boxes with random noise,'
  []

  [MultiBoundingBoxIC1D]
    type = Exodiff
    input = MultiBoundingBoxIC1D.i
    exodiff = MultiBoundingBoxIC1D_out.e

    detail = 'multiple bounding boxes in 1D,'
  []

  [MultiBoundingBoxIC2D]
    type = Exodiff
    input = MultiBoundingBoxIC2D.i
    exodiff = MultiBoundingBoxIC2D_out.e

    detail = 'multiple bounding boxes in 2D, and'
  []

  [MultiBoundingBoxIC3D]
    type = Exodiff
    input = MultiBoundingBoxIC3D.i
    exodiff = MultiBoundingBoxIC3D_out.e

    detail = 'multiple bounding boxes in 3D.'
  []
  [IsolatedBoundingBoxIC_2D]
    type = Exodiff
    input = 'IsolatedBoundingBoxIC_2D.i'
    exodiff = 'IsolatedBoundingBoxIC_2D_out.e'

    detail = 'Diffused interface can be assigned for isolated bounding boxes in 2D,'
  []

  [IsolatedBoundingBoxIC_3D]
    type = Exodiff
    input = 'IsolatedBoundingBoxIC_3D.i'
    exodiff = 'IsolatedBoundingBoxIC_3D_out.e'

    detail = '3D,'
  []

  [NestedBoundingBoxIC_2D]
    type = Exodiff
    input = 'NestedBoundingBoxIC_2D.i'
    exodiff = 'NestedBoundingBoxIC_2D_out.e'

    detail = 'nested bounding boxes in 2D, and'
  []

  [NestedBoundingBoxIC_3D]
    type = Exodiff
    input = 'NestedBoundingBoxIC_3D.i'
    exodiff = 'NestedBoundingBoxIC_3D_out.e'

    detail = '3D.'
  []
  [IsolatedBoundingBoxIC_2D_Overlapping]
    type = RunException
    input = 'IsolatedBoundingBoxIC_2D_Overlapping.i'
    expect_err = 'Partially overlapping boxes are not allowed. Note that this includes the overlapping diffused interfaces. For nested boxes, use NestedBoundingBoxIC.C'

    detail = 'Using IsolatedBoundingBoxIC to create overlapping boxes will throw an error.'
  []
[]

[./timestepmaterial]
  type = 'Exodiff'
  input = 'timestepmaterial.i'
  exodiff = 'timestepmaterial_out.e'
  issues = '#7621'
  design = 'TimeStepMaterial.md'
  requirement = 'A material shall be implemented that provides dt, time, and time step number as material properties'
[../]

[./variablegradientmaterial]
  type = 'Exodiff'
  input = 'variablegradientmaterial.i'
  exodiff = 'variablegradientmaterial_out.e'
  issues = '#7621'
  requirement = 'A material shall be implemented that computes the magnitude of the gradient of a given variable'
  design = 'VariableGradientMaterial.md'
[../]

[./interface_grad]
  type = 'Exodiff'
  input = 'interface_grad.i'
  exodiff = 'interface_grad_out.e'
  issues = '#8211'
  requirement = 'An interface kernel shall be implemented to match gradients between two subdomains'
  design = 'InterfaceDiffusionFluxMatch.md'
[../]

[./interface_flux]
  type = 'Exodiff'
  input = 'interface_flux.i'
  exodiff = 'interface_flux_out.e'
  issues = '#8211'
  requirement = 'Demonstrate an InterfaceKernel (InterfaceDiffusionFlux) that can replace a pair of integrated DiffusionFluxBC boundary conditions.'
  design = 'InterfaceDiffusionBoundaryTerm.md'
[../]

[./equal_gradient_lagrange]
  type = 'Exodiff'
  input = 'equal_gradient_lagrange.i'
  exodiff = 'equal_gradient_lagrange_out.e'
  issues = '#8211'
  requirement = 'An InterfaceKernel set shall be implemnted that can enforce the componentwise continuity of the gradient of a variable using the Lagrange multiplier method'
  design = 'EqualGradientLagrangeInterface.md'
[../]

[./SmoothCircleIC_tanh]
  type = Exodiff
  input = 'SmoothCircleIC_tanh.i'
  exodiff = 'SmoothCircleIC_tanh_out.e'
  scale_refine = 1
  requirement = 'A smooth circle initial condition with a hyperbolic tangent profile shall be provided'
  design = 'ics/SmoothCircleIC.md'
  issues = '#12143'
[../]

[./prepare_mesh]
  type = RunApp
  input = 'prepare_mesh.i'
  requirement = 'A capability to initialize polycrystal phase field variables from a file mesh shall be provided'
  design = 'action/PolycrystalVariablesAction.md'
  issues = '#12294'
[../]

[./PolycrystalVariables_initial_from_file]
  type = Exodiff
  input = 'PolycrystalVariables_initial_from_file.i'
  exodiff = 'PolycrystalVariables_initial_from_file_out.e'
  prereq = prepare_mesh
  requirement = 'A capability to initialize polycrystal phase field variables from a file mesh shall be provided through the PolycrystalVariables action'
  design = 'action/PolycrystalVariablesAction.md'
  issues = '#12294'
[../]

[./tolerance_test]
  type = 'Exodiff'
  input = 'PFCRFF_tolerance_test.i'
  exodiff = 'PFCRFF_tolerance_test_out.e'

  requirement = "The system shall support a tolerance approach to handing the natural log when using the Cahn-Hilliard RFF kernel"
  issues = "#5338"
  design = "CHPFCRFF.md"
[../]

[./cancelation_test]
  type = 'Exodiff'
  input = 'PFCRFF_cancelation_test.i'
  exodiff = 'PFCRFF_cancelation_test_out.e'

  requirement = "The system shall support a cancelation approach to handing the natural log when using the Cahn-Hilliard RFF kernel"
  issues = "#5338"
  design = "CHPFCRFF.md"
[../]

[./expansion_test]
  type = 'Exodiff'
  input = 'PFCRFF_expansion_test.i'
  exodiff = 'PFCRFF_expansion_test_out.e'

  requirement = "The system shall support an expansion approach to handing the natural log when using the Cahn-Hilliard RFF kernel"
  issues = "#5338"
  design = "CHPFCRFF.md"
[../]

[./CahnHilliard]
  type = 'Exodiff'
  input = 'CahnHilliard.i'
  exodiff = 'CahnHilliard_out.e'
  issues = '#3356'
  design = '/CahnHilliard.md'
  requirement = 'MOOSE shall provide a non-split Cahn-Hilliard formalism'
[../]

[./SplitCahnHilliard]
  type = 'Exodiff'
  input = 'SplitCahnHilliard.i'
  exodiff = 'SplitCahnHilliard_out.e'
  issues = '#3356'
  design = '/SplitCHParsed.md'
  requirement = 'MOOSE shall provide a split Cahn-Hilliard formalism'
[../]

[./ADSplitCahnHilliard]
  type = 'Exodiff'
  input = 'ADSplitCahnHilliard.i'
  exodiff = 'SplitCahnHilliard_out.e'
  prereq = SplitCahnHilliard
  issues = '#13138'
  design = '/ADSplitCHParsed.md'
  requirement = 'MOOSE shall provide an AD version of the split Cahn-Hilliard formalism'
[../]

[./ADSplitCahnHilliard-jac]
  type = 'PetscJacobianTester'
  input = 'ADSplitCahnHilliard.i'
  run_sim = 'True'
  cli_args = 'Outputs/exodus=false Executioner/num_steps=2'
  ratio_tol = 1e-8
  difference_tol = 1e-4
  petsc_version = '<3.9.0 || >=3.9.4'
  issues = '#13138'
  design = '/ADSplitCHParsed.md'
  requirement = 'The Jacobian for the AD split Cahn-Hilliard problem shall be perfect'
[../]

[./SplitCHWRes]
  type = 'Exodiff'
  input = 'SplitCHWRes.i'
  exodiff = 'SplitCHWRes_out.e'
  issues = '#14140'
  design = '/SplitCHWRes.md'
  requirement = 'MOOSE shall provide a kernel option to implement transport terms for the off-diagonal Onsager matrix components'
[../]

[./AllenCahn]
  type = 'Exodiff'
  input = 'AllenCahn.i'
  exodiff = 'AllenCahn_out.e'
  issues = '#3816'
  design = '/AllenCahn.md'
  requirement = 'A Allen-Cahn phase field formulation shall be provided'
[../]

[./analyzejacobian_AllenCahn]
  type = 'AnalyzeJacobian'
  input = 'AllenCahn.i'
  prereq = 'CoupledAllenCahn'
  expect_out = '\nNo errors detected. :-\)\n'
  resize_mesh = true
  recover = false
  petsc_version = '<3.9.0 || >=3.9.4'
  issues = '#3816'
  design = '/AllenCahn.md'
  requirement = 'The Allen-Cahn model shall have perfect Jacobians'
[../]

[./AllenCahnVariableL]
  type = 'Exodiff'
  input = 'AllenCahnVariableL.i'
  exodiff = 'AllenCahnVariableL_out.e'
  issues = '#3816'
  design = '/AllenCahn.md'
  requirement = 'A Allen-Cahn phase field formulation with a variable dependent mobility shall be provided'
[../]

[./ADAllenCahn]
  type = 'Exodiff'
  input = 'ADAllenCahn.i'
  allow_test_objects = true
  exodiff = 'ADAllenCahn_out.e'
  issues = '#13197'
  design = '/ADAllenCahn.md'
  requirement = 'An AD version of the Allen-Cahn phase field formulation shall be provided'
[../]

[./ADAllenCahn-jac]
  type = 'PetscJacobianTester'
  input = 'ADAllenCahn.i'
  allow_test_objects = true
  run_sim = 'True'
  cli_args = 'Outputs/exodus=false Executioner/num_steps=1'
  ratio_tol = 1e-7
  difference_tol = 1e-5
  issues = '#13197'
  design = '/ADAllenCahn.md'
  requirement = 'The Jacobian for the AD Allen-Cahn problem shall be perfect'
[../]

[./ADAllenCahnVariableL]
  type = 'Exodiff'
  input = 'ADAllenCahnVariableL.i'
  allow_test_objects = true
  exodiff = 'ADAllenCahnVariableL_out.e'
  issues = '#13197'
  design = '/ADAllenCahn.md'
  requirement = 'An AD version of the Allen-Cahn phase field formulation with a variable dependent mobility shall be provided'
[../]

[./ADAllenCahnVariableL-jac]
  type = 'PetscJacobianTester'
  input = 'ADAllenCahnVariableL.i'
  allow_test_objects = true
  run_sim = 'True'
  cli_args = 'Outputs/exodus=false Executioner/num_steps=1'
  ratio_tol = 1e-7
  difference_tol = 1e-5
  issues = '#13197'
  design = '/ADAllenCahn.md'
  requirement = 'The Jacobian for the AD Allen-Cahn problem with a variable dependent mobility shall be perfect'
[../]

[./CoupledAllenCahn]
  type = 'Exodiff'
  prereq = 'AllenCahn'
  input = 'CoupledAllenCahn.i'
  exodiff = 'AllenCahn_out.e'
  issues = '#6194'
  design = '/CoupledAllenCahn.md'
  requirement = 'A coupled Allen-Cahn formulation shall be provided'
[../]

[./CoupledCoefAllenCahn]
  type = 'Exodiff'
  input = 'CoupledCoefAllenCahn.i'
  exodiff = 'CoupledCoefAllenCahn_out.e'
  issues = '#6265'
  design = '/CoupledAllenCahn.md'
  requirement = 'A coupled Allen-Cahn formulation with a user defined prefactor shall be provided'
[../]

[./MatGradSquareCoupled]
  type = 'Exodiff'
  input = 'MatGradSquareCoupled.i'
  exodiff = 'MatGradSquareCoupled_out.e'
  issues = '#10721'
  design = '/MatGradSquareCoupled.md'
  requirement = 'A coupled gradient square kernel shall be provided'
[../]

[./SimpleSplitCHWRes]
  type = 'Exodiff'
  input = 'SimpleSplitCHWRes.i'
  exodiff = 'SimpleSplitCHWRes_out.e'
  issues = '#6910'
  design = '/SimpleSplitCHWRes.md'
  requirement = 'A suite of simple to understand phase field kernels shall be provided for novice users'
[../]

[./SimpleCHInterface]
  type = 'Exodiff'
  input = 'SimpleCHInterface.i'
  exodiff = 'SimpleCHInterface_out.e'
  issues = '#6910'
  design = '/SimpleCHInterface.md'
  requirement = 'A suite of simple to understand phase field kernels shall be provided for novice users'
[../]

[./ACInterfaceStress]
  type = 'Exodiff'
  input = 'ACInterfaceStress.i'
  exodiff = 'ACInterfaceStress_out.e'
  cli_args = 'Executioner/dt=0.001'
  issues = '#9658'
  design = '/ACInterfaceStress.md'
  requirement = 'A free energy contribution from elastic stresses in interfaces shall be provided'
[../]

[./analyzejacobian_ACInterfaceStress]
  type = 'AnalyzeJacobian'
  input = 'ACInterfaceStress_jacobian.i'
  expect_out = '\nNo errors detected. :-\)\n'
  recover = false
  heavy = true
  issues = '#9658'
  design = '/ACInterfaceStress.md'
  requirement = 'The free energy contribution from elastic stresses in interfaces shall shall have a perfect Jacobian'
[../]

[./nonuniform_barrier_coefficient]
  type = 'Exodiff'
  input = 'nonuniform_barrier_coefficient.i'
  exodiff = 'nonuniform_barrier_coefficient_out.e'
  issues = '#11829'
  design = '/ACBarrierFunction.md'
  requirement = 'The barrier height and gradient energy parameter must be permitted to depend on non-linear variables'
[../]

[./EulerAngleVariables2RGBAux]
  type = 'Exodiff'
  input = 'EulerAngleVariables2RGBAux.i'
  exodiff = 'EulerAngleVariables2RGBAux_out.e'

  issues = "#7332"
  design = "EulerAngleVariables2RGBAux.md"
  requirement = "The system shall output an RGB field that can be interpreted as either a component
                   or a combined Euler angle given a grain structure."
[../]

[./1phase_reconstruction]
  type = 'Exodiff'
  input = '1phase_reconstruction.i'
  exodiff = '1phase_reconstruction_out.e'

  issues = "#9110"
  design = "EBSD.md"
  requirement = "The system shall support reading EBSD data and initializing a Polycrystal grain structure with that data."
[../]

[./1phase_reconstruction_40x40]
  type = 'Exodiff'
  input = '1phase_reconstruction.i'

  # Read in a 2-phase file but ignore phase
  cli_args = 'Mesh/filename=ebsd_40x40_2_phase.txt GlobalParams/op_num=6 Outputs/file_base=1phase_reconstruction_40x40_out'
  exodiff = '1phase_reconstruction_40x40_out.e'

  issues = "#9110"
  design = "EBSD.md"
  requirement = "The system shall support reading EBSD data to initalized Polycrystal grain structures while supporting
                    reduced order parameter IC assignment."
[../]

[./1phase_evolution]
  type = 'Exodiff'
  input = '1phase_evolution.i'
  exodiff = '1phase_evolution_out.e'
  max_time = 1000

  issues = "#9110"
  design = "EBSD.md"
  requirement = "The system shall support grain evolution when beginning from EBSD ICs."
[../]

[./2phase_reconstruction]
  type = 'Exodiff'
  input = '2phase_reconstruction.i'
  exodiff = '2phase_reconstruction_out.e'
  recover = false # issue #5188

  issues = "#9110 #5920"
  design = "EBSD.md"
  requirement = "The system shall support reading a single phase of EBSD data at a time to initialize PolycrystalICs."
[../]

[./2phase_reconstruction2]
  type = 'Exodiff'
  input = '2phase_reconstruction2.i'
  exodiff = '2phase_reconstruction2_out.e'
  recover = false # issue #5188

  issues = "#9110 #5920"
  design = "EBSD.md"
  requirement = "The system shall support reading a single phase of EBSD data at a time to initialize PolycrystalICs
                   while supporting reduced order parameter IC assignment."
[../]

[./2phase_reconstruction3]
  type = 'Exodiff'
  input = '2phase_reconstruction3.i'
  exodiff = '2phase_reconstruction3_out.e'
  recover = false # issue #5188

  issues = "#9110 #5920"
  design = "EBSD.md"
  requirement = "The system shall support reading EBSD data to initialize PolycrystalICs with discontinuous numbering."
[../]

[./2phase_reconstruction4]
  type = 'Exodiff'
  input = '2phase_reconstruction4.i'
  exodiff = '2phase_reconstruction4_out.e'
  recover = false # issue #5188

  issues = "#9110 #5920"
  design = "EBSD.md"
  requirement = "The system shall support reading a single phase of EBSD data at a time to initialize PolycrystalICs
                   while supporting reduced order parameter IC assignment and display the coloring."
[../]

[./regions_without_grains]
  type = 'CSVDiff'
  input = 'euler2rgb_no_grain_region.i'
  csvdiff = 'euler2rgb_no_grain_region_out.csv'
  max_time = 1000

  issues = "#9110 #5920"
  design = "EBSD.md"
  requirement = "The system shall support reading a single phase of EBSD data at a time to initialize PolycrystalICs
                   and support regions within the domain that contain no grains at all."
[../]

[./average_orientation]
  type = 'Exodiff'
  input = 'euler2rgb_non_uniform_orientation.i'
  exodiff = 'euler2rgb_non_uniform_orientation_out.e'

  issues = "#13869"
  design = "EBSDReader.md"
  method = "!dbg"
  requirement = "The system shall support grain evolution when beginning from EBSD ICs and compute average orientation
                   of non-uniformly oriented grains."
[../]