From 731326336aee75cab6b536db6592f0bac7720380 Mon Sep 17 00:00:00 2001
From: Daniel Schwen <daniel.schwen@inl.gov>
Date: Wed, 8 May 2024 09:33:10 -0600
Subject: [PATCH] Backwards compatible approach (#27513)

---
 .../include/actions/MaterialOutputAction.h    |  79 ++--
 .../include/auxkernels/MaterialAuxBase.h      | 129 ++++---
 .../include/auxkernels/MaterialRateAuxBase.h  |   2 -
 .../include/auxkernels/MaterialRealAux.h      |  14 +-
 .../auxkernels/MaterialRealVectorValueAux.h   |  16 +-
 .../VectorMaterialRealVectorValueAux.h        |   2 +-
 framework/include/base/Assembly.h             |   2 +-
 framework/include/functions/Function.h        |   9 +-
 .../functions/PiecewiseMultiInterpolation.h   |   5 +-
 .../include/functions/PiecewiseMultilinear.h  |   3 +-
 framework/include/kernels/BodyForce.h         |   2 +-
 .../materials/MaterialFunctorConverter.h      |   2 +-
 .../include/materials/MaterialProperty.h      |  15 +-
 .../SideDiffusiveFluxIntegral.h               |   2 +-
 framework/include/utils/MooseADWrapper.h      |  42 ---
 framework/include/utils/MooseTypes.h          |  67 ++--
 framework/include/utils/MooseUtils.h          |   2 +-
 framework/include/utils/NestedSolve.h         |   7 +-
 framework/src/actions/MaterialOutputAction.C  | 338 ++++++++++--------
 framework/src/auxkernels/MaterialRealAux.C    |  24 +-
 .../auxkernels/MaterialRealVectorValueAux.C   |  28 +-
 .../VectorMaterialRealVectorValueAux.C        |   4 +-
 framework/src/base/Assembly.C                 |   4 +-
 .../functions/PiecewiseMultiInterpolation.C   |   8 +-
 .../src/functions/PiecewiseMultilinear.C      |   8 +-
 .../PenaltyInterfaceDiffusion.C               |   2 +-
 .../materials/CoupledValueFunctionMaterial.C  |   2 +-
 .../src/materials/MaterialFunctorConverter.C  |   2 +-
 .../SideDiffusiveFluxIntegral.C               |   2 +-
 .../include/materials/ADComputeFiniteStrain.h |   2 +-
 .../ADComputeFiniteStrainElasticStress.h      |   4 +-
 .../ADComputeIncrementalSmallStrain.h         |   2 +-
 .../ADComputeIncrementalStrainBase.h          |   2 +-
 .../include/materials/StressUpdateBase.h      |   4 +-
 .../IsotropicPlasticityStressUpdate.C         |   2 +-
 test/include/materials/OutputTestMaterial.h   |   5 +-
 36 files changed, 423 insertions(+), 420 deletions(-)
 delete mode 100644 framework/include/utils/MooseADWrapper.h

diff --git a/framework/include/actions/MaterialOutputAction.h b/framework/include/actions/MaterialOutputAction.h
index af3e58120f6b..bccce6f0dab7 100644
--- a/framework/include/actions/MaterialOutputAction.h
+++ b/framework/include/actions/MaterialOutputAction.h
@@ -9,72 +9,48 @@
 
 #pragma once
 
-// MOOSE includes
 #include "Action.h"
 #include "MaterialData.h"
 #include "FEProblemBase.h"
-#include "SerialAccess.h"
 
 class MooseObjectAction;
 class MaterialBase;
 
-struct MaterialOutputActionDescriptor
-{
-};
-
 /**
  * Creates AuxVariables and AuxKernels for automatic output of material properties
  */
 class MaterialOutputAction : public Action
 {
 public:
-  /**
-   * Class constructor
-   * @param params Input parameters for this action object
-   */
   static InputParameters validParams();
 
   MaterialOutputAction(const InputParameters & params);
-  virtual void act() override;
 
-  /// output function called from SetupOutput::apply (through Moose::typeLoop)
-  template <typename T, int I>
-  void setupOutput(const MaterialPropertyName & prop_name, const MaterialBase & material);
+  virtual void act() override;
 
-protected:
-  template <typename T, int I, bool is_ad, bool is_functor>
-  void setupOutputHelper(const MaterialPropertyName & prop_name, const MaterialBase & material);
-
-  /// List of supported raw types (equivalent AD types are also supported)
-  typedef Moose::TypeList<Real,
-                          RealVectorValue,
-                          RealTensorValue,
-                          RankTwoTensor,
-                          RankFourTensor,
-                          SymmetricRankTwoTensor,
-                          SymmetricRankFourTensor>
-      SupportedTypes;
-
-  /// List of AuxKernels used for the respective property type output ('AD' prefix is added automatically for is_ad)
-  static const std::vector<std::string> _aux_kernel_names;
-
-  /// List of index symbols
-  static const std::vector<std::string> _index_symbols;
-
-  /// List of coefficient parameter names
-  static const std::vector<std::vector<std::string>> _param_names;
-
-  template <typename T, int I>
-  struct SetupOutput
+  /// Meta data describing the setup of an output object
+  struct OutputMetaData
   {
-    static void apply(MaterialOutputAction * self,
-                      const MaterialPropertyName & prop_name,
-                      const MaterialBase & material)
-    {
-      self->setupOutput<T, I>(prop_name, material);
-    }
+    std::string _aux_kernel_name;
+    std::string _index_symbols;
+    std::vector<std::string> _param_names;
   };
 
+protected:
+  /**
+   * A function to be overriden by derived actions to handle a set of material property types
+   */
+  virtual std::vector<std::string> materialOutput(const std::string & property_name,
+                                                  const MaterialBase & material,
+                                                  bool get_names_only);
+
+  /// Universal output object setup function
+  std::vector<std::string> outputHelper(const OutputMetaData & metadata,
+                                        const MaterialPropertyName & property_name,
+                                        const std::string & var_name_base,
+                                        const MaterialBase & material,
+                                        bool get_names_only);
+
   /**
    * Helper method for testing if the material exists as a block or boundary material
    * @tparam T The property type (e.g., REAL)
@@ -108,7 +84,6 @@ class MaterialOutputAction : public Action
    *
    * @return An InputParameter object with common properties added.
    */
-  template <bool is_functor>
   InputParameters getParams(const std::string & type,
                             const std::string & property_name,
                             const std::string & variable_name,
@@ -127,12 +102,6 @@ class MaterialOutputAction : public Action
   /// variables for the current MaterialBase object
   std::set<std::string> _material_variable_names;
 
-  /// all variables added by this action
-  std::set<std::string> _all_variable_names;
-
-  /// property names we succeeded to set output up for
-  std::set<std::string> _supported_properties;
-
   /// Map of output names and list of variables associated with the output
   std::map<OutputName, std::set<std::string>> _material_variable_names_map;
 
@@ -169,9 +138,5 @@ template <typename T>
 bool
 MaterialOutputAction::hasFunctorProperty(const std::string & property_name)
 {
-  // functors support a limited set of types
-  if constexpr (std::is_same_v<T, Real> || std::is_same_v<T, RealVectorValue>)
-    return _problem->hasFunctorWithType<T>(property_name, 0);
-  else
-    return false;
+  return _problem->hasFunctorWithType<T>(property_name, 0);
 }
diff --git a/framework/include/auxkernels/MaterialAuxBase.h b/framework/include/auxkernels/MaterialAuxBase.h
index df876e3ce18c..34957701ee64 100644
--- a/framework/include/auxkernels/MaterialAuxBase.h
+++ b/framework/include/auxkernels/MaterialAuxBase.h
@@ -16,7 +16,7 @@
  * A base class for the various Material related AuxKernal objects.
  * \p RT is short for return type
  */
-template <typename T, bool is_ad, typename RT = Real>
+template <typename T, bool is_ad, bool is_functor = false, typename RT = Real>
 class MaterialAuxBaseTempl : public AuxKernelTempl<RT>
 {
 public:
@@ -29,10 +29,9 @@ class MaterialAuxBaseTempl : public AuxKernelTempl<RT>
   MaterialAuxBaseTempl(const InputParameters & parameters);
 
   /// Functors really only work for Real and RealVectorValue for now :(
-  using MaterialAuxFunctorType =
-      typename std::conditional<std::is_same_v<T, Real> || std::is_same_v<T, RealVectorValue>,
-                                Moose::Functor<GenericType<T, is_ad>>,
-                                void>::type;
+  using PropertyType = typename std::conditional<is_functor,
+                                                 Moose::Functor<Moose::GenericType<T, is_ad>>,
+                                                 GenericMaterialProperty<T, is_ad>>::type;
 
 protected:
   virtual RT computeValue() override;
@@ -43,17 +42,14 @@ class MaterialAuxBaseTempl : public AuxKernelTempl<RT>
   /// Returns material property values at quadrature points
   virtual RT getRealValue() = 0;
 
-  /// Material property for this AuxKernel
-  const GenericMaterialProperty<T, is_ad> * _property;
-
-  /// Functor for this AuxKernel
-  const MaterialAuxFunctorType * _functor;
+  /// (Functor)Material property for this AuxKernel
+  const PropertyType & _prop;
 
   /// Evaluate at this quadrature point only
   const unsigned int _selected_qp;
 
   /// T Value evaluated from either the property or the functor
-  GenericType<T, is_ad> _full_value;
+  Moose::GenericType<T, is_ad> _full_value;
 
 private:
   /// Multiplier for the material property
@@ -61,67 +57,76 @@ class MaterialAuxBaseTempl : public AuxKernelTempl<RT>
 
   /// Value to be added to the material property
   const RT _offset;
+
+  /// ID of the subdomain currently being iterated over
+  const SubdomainID & _current_subdomain_id;
 };
 
-template <typename T, bool is_ad, typename RT>
+template <typename T, bool is_ad, bool is_functor, typename RT>
 InputParameters
-MaterialAuxBaseTempl<T, is_ad, RT>::validParams()
+MaterialAuxBaseTempl<T, is_ad, is_functor, RT>::validParams()
 {
   InputParameters params = AuxKernelTempl<RT>::validParams();
-  params.addParam<MaterialPropertyName>(
-      "property", "The scalar material property name (set either this or `functor`).");
-  // functors do not support all types
-  if constexpr (!std::is_same_v<MaterialAuxFunctorType, void>)
-    params.addParam<MooseFunctorName>(
-        "functor", "The scalar material property name (set either this or `property`).");
+  params.addRequiredParam<MaterialPropertyName>("property",
+                                                "The scalar (functor)material property name.");
   params.addParam<Real>(
       "factor", 1, "The factor by which to multiply your material property for visualization");
   params.addParam<RT>("offset", 0, "The offset to add to your material property for visualization");
 
-  params.addParam<unsigned int>(
-      "selected_qp",
-      "Evaluate the material property at a specified quadrature point. This only needs "
-      "to be used if you are interested in a particular quadrature point in each element. "
-      "Otherwise do not include this parameter in your input file.");
-  params.addParamNamesToGroup("selected_qp", "Advanced");
+  if constexpr (!is_functor)
+  {
+    params.addParam<unsigned int>(
+        "selected_qp",
+        "Evaluate the material property at a specified quadrature point. This only needs "
+        "to be used if you are interested in a particular quadrature point in each element. "
+        "Otherwise do not include this parameter in your input file.");
+    params.addParamNamesToGroup("selected_qp", "Advanced");
+  }
 
   return params;
 }
 
-template <typename T, bool is_ad, typename RT>
-MaterialAuxBaseTempl<T, is_ad, RT>::MaterialAuxBaseTempl(const InputParameters & parameters)
+template <typename T, bool is_ad, bool is_functor, typename RT>
+MaterialAuxBaseTempl<T, is_ad, is_functor, RT>::MaterialAuxBaseTempl(
+    const InputParameters & parameters)
   : AuxKernelTempl<RT>(parameters),
-    _property(this->isParamValid("property")
-                  ? &this->template getGenericMaterialProperty<T, is_ad>("property")
-                  : nullptr),
-    _functor(this->isParamValid("functor")
-                 ? [this]() {
-                    if constexpr (!std::is_same_v<MaterialAuxFunctorType, void>)
-                      return &this->template getFunctor<GenericType<T, is_ad>>("functor");
-                    else
-                    {
-                      libmesh_ignore(this);
-                      return nullptr;
-                    }
-                 }()
-                 : nullptr),
-    _selected_qp(this->isParamValid("selected_qp") ? this->template getParam<unsigned int>("selected_qp") : libMesh::invalid_uint),
+    _prop([this]() -> const auto & {
+      if constexpr (is_functor)
+        return this->template getFunctor<Moose::GenericType<T, is_ad>>("property");
+      else
+        return this->template getGenericMaterialProperty<T, is_ad>("property");
+    }()),
+    _selected_qp(this->isParamValid("selected_qp")
+                     ? this->template getParam<unsigned int>("selected_qp")
+                     : libMesh::invalid_uint),
     _factor(this->template getParam<Real>("factor")),
-    _offset(this->template getParam<RT>("offset"))
+    _offset(this->template getParam<RT>("offset")),
+    _current_subdomain_id(this->_assembly.currentSubdomainID())
 {
-  if (!_property == !_functor)
-    mooseError("Specify either a `property` or a `functor` parameter.");
-  if (_functor && _selected_qp != libMesh::invalid_uint)
-    this->paramError("selected_qp",
-                     "Selective quadrature point evaluation is not implemented for functors.");
 }
 
-template <typename T, bool is_ad, typename RT>
+template <typename T, bool is_ad, bool is_functor, typename RT>
 RT
-MaterialAuxBaseTempl<T, is_ad, RT>::computeValue()
+MaterialAuxBaseTempl<T, is_ad, is_functor, RT>::computeValue()
 {
-  // Material Property Values
-  if (_property)
+  // Functor Values
+  if constexpr (is_functor)
+  {
+    if (this->isNodal())
+    {
+      const Moose::NodeArg node_arg{this->_current_node, _current_subdomain_id};
+      const auto state = this->determineState();
+      _full_value = _prop(node_arg, state);
+    }
+    else
+    {
+      const auto elem_arg = this->makeElemArg(this->_current_elem);
+      const auto state = this->determineState();
+      _full_value = _prop(elem_arg, state);
+    }
+  }
+  // Material Properties
+  else
   {
     if (_selected_qp != libMesh::invalid_uint)
     {
@@ -135,29 +140,15 @@ MaterialAuxBaseTempl<T, is_ad, RT>::computeValue()
                          this->_q_point.size(),
                          " quadrature points in the element");
       }
-      _full_value = (*_property)[_selected_qp];
-    }
-    else
-      _full_value = (*_property)[this->_qp];
-  }
-
-  // Functor Values
-  if (_functor)
-  {
-    if constexpr (!std::is_same_v<MaterialAuxFunctorType, void>)
-    {
-      const auto elem_arg = this->makeElemArg(this->_current_elem);
-      const auto state = this->determineState();
-      _full_value = (*_functor)(elem_arg, state);
+      _full_value = _prop[_selected_qp];
     }
     else
-      mooseError("Unsupported functor type");
+      _full_value = _prop[this->_qp];
   }
 
   checkFullValue();
-
   return _factor * getRealValue() + _offset;
 }
 
 template <typename T = Real>
-using MaterialAuxBase = MaterialAuxBaseTempl<T, false, Real>;
+using MaterialAuxBase = MaterialAuxBaseTempl<T, false, false, Real>;
diff --git a/framework/include/auxkernels/MaterialRateAuxBase.h b/framework/include/auxkernels/MaterialRateAuxBase.h
index e1b93408d4b1..277ff76270a2 100644
--- a/framework/include/auxkernels/MaterialRateAuxBase.h
+++ b/framework/include/auxkernels/MaterialRateAuxBase.h
@@ -44,8 +44,6 @@ MaterialRateAuxBaseTempl<T, is_ad, RT>::MaterialRateAuxBaseTempl(const InputPara
   : MaterialAuxBaseTempl<RT, is_ad>(parameters),
     _prop_old(this->template getMaterialPropertyOld<T>("property"))
 {
-  if (!this->_property)
-    this->paramError("functor", "This object does not support functors yet.");
 }
 
 template <typename T = Real>
diff --git a/framework/include/auxkernels/MaterialRealAux.h b/framework/include/auxkernels/MaterialRealAux.h
index f17baf4fd74c..242242be67a6 100644
--- a/framework/include/auxkernels/MaterialRealAux.h
+++ b/framework/include/auxkernels/MaterialRealAux.h
@@ -12,16 +12,11 @@
 // MOOSE includes
 #include "MaterialAuxBase.h"
 
-// Forward Declarations
-template <bool>
-class MaterialRealAuxTempl;
-typedef MaterialRealAuxTempl<false> MaterialRealAux;
-
 /**
  * Object for passing a scalar, REAL material property to an AuxVariable
  */
-template <bool is_ad>
-class MaterialRealAuxTempl : public MaterialAuxBaseTempl<Real, is_ad>
+template <bool is_ad, bool is_functor>
+class MaterialRealAuxTempl : public MaterialAuxBaseTempl<Real, is_ad, is_functor>
 {
 public:
   static InputParameters validParams();
@@ -37,4 +32,7 @@ class MaterialRealAuxTempl : public MaterialAuxBaseTempl<Real, is_ad>
   Real getRealValue() override;
 };
 
-typedef MaterialRealAuxTempl<true> ADMaterialRealAux;
+typedef MaterialRealAuxTempl<false, false> MaterialRealAux;
+typedef MaterialRealAuxTempl<true, false> ADMaterialRealAux;
+typedef MaterialRealAuxTempl<false, true> FunctorMaterialRealAux;
+typedef MaterialRealAuxTempl<true, true> ADFunctorMaterialRealAux;
diff --git a/framework/include/auxkernels/MaterialRealVectorValueAux.h b/framework/include/auxkernels/MaterialRealVectorValueAux.h
index 03e156a3be18..b2c6fcbf7a3e 100644
--- a/framework/include/auxkernels/MaterialRealVectorValueAux.h
+++ b/framework/include/auxkernels/MaterialRealVectorValueAux.h
@@ -16,8 +16,8 @@
 /**
  * AuxKernel for outputting a RealVectorValue material property component to an AuxVariable
  */
-template <typename T, bool is_ad>
-class MaterialRealVectorValueAuxTempl : public MaterialAuxBaseTempl<T, is_ad>
+template <typename T, bool is_ad, bool is_functor>
+class MaterialRealVectorValueAuxTempl : public MaterialAuxBaseTempl<T, is_ad, is_functor>
 {
 public:
   static InputParameters validParams();
@@ -35,9 +35,13 @@ class MaterialRealVectorValueAuxTempl : public MaterialAuxBaseTempl<T, is_ad>
   unsigned int _component;
 };
 
-typedef MaterialRealVectorValueAuxTempl<RealVectorValue, false> MaterialRealVectorValueAux;
-typedef MaterialRealVectorValueAuxTempl<RealVectorValue, true> ADMaterialRealVectorValueAux;
-typedef MaterialRealVectorValueAuxTempl<SymmetricRankTwoTensor, false>
+typedef MaterialRealVectorValueAuxTempl<RealVectorValue, false, false> MaterialRealVectorValueAux;
+typedef MaterialRealVectorValueAuxTempl<RealVectorValue, true, false> ADMaterialRealVectorValueAux;
+typedef MaterialRealVectorValueAuxTempl<RealVectorValue, false, true>
+    FunctorMaterialRealVectorValueAux;
+typedef MaterialRealVectorValueAuxTempl<RealVectorValue, true, true>
+    ADFunctorMaterialRealVectorValueAux;
+typedef MaterialRealVectorValueAuxTempl<SymmetricRankTwoTensor, false, false>
     MaterialSymmetricRankTwoTensorAux;
-typedef MaterialRealVectorValueAuxTempl<SymmetricRankTwoTensor, true>
+typedef MaterialRealVectorValueAuxTempl<SymmetricRankTwoTensor, true, false>
     ADMaterialSymmetricRankTwoTensorAux;
diff --git a/framework/include/auxkernels/VectorMaterialRealVectorValueAux.h b/framework/include/auxkernels/VectorMaterialRealVectorValueAux.h
index efbfbb54d19a..907c0107377a 100644
--- a/framework/include/auxkernels/VectorMaterialRealVectorValueAux.h
+++ b/framework/include/auxkernels/VectorMaterialRealVectorValueAux.h
@@ -17,7 +17,7 @@
  */
 template <bool is_ad>
 class VectorMaterialRealVectorValueAuxTempl
-  : public MaterialAuxBaseTempl<RealVectorValue, is_ad, RealVectorValue>
+  : public MaterialAuxBaseTempl<RealVectorValue, is_ad, false, RealVectorValue>
 {
 public:
   static InputParameters validParams();
diff --git a/framework/include/base/Assembly.h b/framework/include/base/Assembly.h
index 76f221963e3a..62a4fe32b77f 100644
--- a/framework/include/base/Assembly.h
+++ b/framework/include/base/Assembly.h
@@ -358,7 +358,7 @@ class Assembly
   }
 
   template <bool is_ad>
-  const MooseArray<GenericType<Point, is_ad>> & genericQPoints() const;
+  const MooseArray<Moose::GenericType<Point, is_ad>> & genericQPoints() const;
 
   /**
    * Return the current element
diff --git a/framework/include/functions/Function.h b/framework/include/functions/Function.h
index e336238074a8..3f5912ab6b12 100644
--- a/framework/include/functions/Function.h
+++ b/framework/include/functions/Function.h
@@ -18,7 +18,6 @@
 #include "MeshChangedInterface.h"
 #include "ScalarCoupleable.h"
 #include "MooseFunctor.h"
-#include "MooseADWrapper.h"
 #include "ChainedReal.h"
 
 // libMesh
@@ -209,7 +208,7 @@ template <typename U>
 auto
 Function::value(const U & t) const
 {
-  static const GenericType<Point, MooseIsADType<U>::value> p;
+  static const Moose::GenericType<Point, Moose::IsADType<U>::value> p;
   return value(t, p);
 }
 
@@ -217,7 +216,7 @@ template <typename U>
 auto
 Function::value(const U & t, const U & x, const U & y, const U & z) const
 {
-  GenericType<Point, MooseIsADType<U>::value> p(x, y, z);
+  Moose::GenericType<Point, Moose::IsADType<U>::value> p(x, y, z);
   return value(t, p);
 }
 
@@ -225,7 +224,7 @@ template <typename U>
 auto
 Function::timeDerivative(const U & t) const
 {
-  static const GenericType<Point, MooseIsADType<U>::value> p;
+  static const Moose::GenericType<Point, Moose::IsADType<U>::value> p;
   return timeDerivative(t, p);
 }
 
@@ -233,6 +232,6 @@ template <typename U>
 auto
 Function::timeDerivative(const U & t, const U & x, const U & y, const U & z) const
 {
-  GenericType<Point, MooseIsADType<U>::value> p(x, y, z);
+  Moose::GenericType<Point, Moose::IsADType<U>::value> p(x, y, z);
   return timeDerivative(t, p);
 }
diff --git a/framework/include/functions/PiecewiseMultiInterpolation.h b/framework/include/functions/PiecewiseMultiInterpolation.h
index e2d3eb89b404..55cd1398a069 100644
--- a/framework/include/functions/PiecewiseMultiInterpolation.h
+++ b/framework/include/functions/PiecewiseMultiInterpolation.h
@@ -47,8 +47,9 @@ class PiecewiseMultiInterpolation : public Function
 
   /// convert cartesian+time coordinates into grid coordinates
   template <bool is_ad>
-  GenericType<GridPoint, is_ad> pointInGrid(const GenericType<Real, is_ad> & t,
-                                            const GenericType<Point, is_ad> & p) const;
+  Moose::GenericType<GridPoint, is_ad>
+  pointInGrid(const Moose::GenericType<Real, is_ad> & t,
+              const Moose::GenericType<Point, is_ad> & p) const;
 
   /**
    * This does the core work.  Given a point, pt, defined
diff --git a/framework/include/functions/PiecewiseMultilinear.h b/framework/include/functions/PiecewiseMultilinear.h
index 57f8f3172f52..70b1e6591511 100644
--- a/framework/include/functions/PiecewiseMultilinear.h
+++ b/framework/include/functions/PiecewiseMultilinear.h
@@ -39,5 +39,6 @@ class PiecewiseMultilinear : public PiecewiseMultiInterpolation
 
 private:
   template <bool is_ad>
-  GenericType<Real, is_ad> sampleInternal(const GenericType<GridPoint, is_ad> pt) const;
+  Moose::GenericType<Real, is_ad>
+  sampleInternal(const Moose::GenericType<GridPoint, is_ad> pt) const;
 };
diff --git a/framework/include/kernels/BodyForce.h b/framework/include/kernels/BodyForce.h
index 66767e7cfbc1..153e343baa39 100644
--- a/framework/include/kernels/BodyForce.h
+++ b/framework/include/kernels/BodyForce.h
@@ -42,7 +42,7 @@ class BodyForceTempl : public GenericKernel<is_ad>
   const PostprocessorValue & _postprocessor;
 
   // AD/non-AD version of the quadrature point coordinates
-  const MooseArray<GenericType<Point, is_ad>> * _generic_q_point;
+  const MooseArray<Moose::GenericType<Point, is_ad>> * _generic_q_point;
 
   usingGenericKernelMembers;
 };
diff --git a/framework/include/materials/MaterialFunctorConverter.h b/framework/include/materials/MaterialFunctorConverter.h
index 75fddc943224..44631bd91f48 100644
--- a/framework/include/materials/MaterialFunctorConverter.h
+++ b/framework/include/materials/MaterialFunctorConverter.h
@@ -30,7 +30,7 @@ class MaterialFunctorConverterTempl : public Material
   const std::size_t _num_functors_to_convert;
 
   /// Incoming functors to convert. We up-convert non-AD functors to AD functors to ease implementation
-  std::vector<const Moose::Functor<GenericType<T, true>> *> _functors_in;
+  std::vector<const Moose::Functor<Moose::GenericType<T, true>> *> _functors_in;
   /// Regular material properties to create
   std::vector<MaterialProperty<T> *> _reg_props_out;
   /// AD material properties to create
diff --git a/framework/include/materials/MaterialProperty.h b/framework/include/materials/MaterialProperty.h
index 038ceed46290..4ca96ef53498 100644
--- a/framework/include/materials/MaterialProperty.h
+++ b/framework/include/materials/MaterialProperty.h
@@ -13,7 +13,6 @@
 #include <memory>
 #include <typeinfo>
 
-#include "MooseADWrapper.h"
 #include "MooseArray.h"
 #include "MooseTypes.h"
 #include "DataIO.h"
@@ -110,7 +109,7 @@ template <typename T, bool is_ad>
 class MaterialPropertyBase : public PropertyValue
 {
 public:
-  typedef GenericType<T, is_ad> value_type;
+  typedef Moose::GenericType<T, is_ad> value_type;
 
   MaterialPropertyBase(const PropertyValue::id_type id) : PropertyValue(id) {}
 
@@ -119,12 +118,12 @@ class MaterialPropertyBase : public PropertyValue
   /**
    * @returns a read-only reference to the parameter value.
    */
-  const MooseArray<GenericType<T, is_ad>> & get() const { return _value; }
+  const MooseArray<Moose::GenericType<T, is_ad>> & get() const { return _value; }
 
   /**
    * @returns a writable reference to the parameter value.
    */
-  MooseArray<GenericType<T, is_ad>> & set() { return _value; }
+  MooseArray<Moose::GenericType<T, is_ad>> & set() { return _value; }
 
   /**
    * String identifying the type of parameter stored.
@@ -141,12 +140,12 @@ class MaterialPropertyBase : public PropertyValue
   /**
    * Get element i out of the array as a writeable reference.
    */
-  GenericType<T, is_ad> & operator[](const unsigned int i) { return _value[i]; }
+  Moose::GenericType<T, is_ad> & operator[](const unsigned int i) { return _value[i]; }
 
   /**
    * Get element i out of the array as a ready-only reference.
    */
-  const GenericType<T, is_ad> & operator[](const unsigned int i) const { return _value[i]; }
+  const Moose::GenericType<T, is_ad> & operator[](const unsigned int i) const { return _value[i]; }
 
   /**
    * Copy the value of a Property from one specific to a specific qp in this Property.
@@ -197,7 +196,7 @@ class MaterialPropertyBase : public PropertyValue
 
 protected:
   /// Stored parameter value.
-  MooseArray<GenericType<T, is_ad>> _value;
+  MooseArray<Moose::GenericType<T, is_ad>> _value;
 };
 
 template <typename T>
@@ -471,7 +470,7 @@ class GenericOptionalMaterialProperty : public GenericOptionalMaterialPropertyBa
   operator=(const GenericOptionalMaterialProperty<T, is_ad> &) = delete;
 
   /// pass through operator[] to provide a similar API as MaterialProperty
-  const GenericType<T, is_ad> & operator[](const unsigned int i) const
+  const Moose::GenericType<T, is_ad> & operator[](const unsigned int i) const
   {
     // check if the optional property is valid in debug mode
     mooseAssert(
diff --git a/framework/include/postprocessors/SideDiffusiveFluxIntegral.h b/framework/include/postprocessors/SideDiffusiveFluxIntegral.h
index f0d4a102aac8..1b8d28cadefb 100644
--- a/framework/include/postprocessors/SideDiffusiveFluxIntegral.h
+++ b/framework/include/postprocessors/SideDiffusiveFluxIntegral.h
@@ -36,7 +36,7 @@ class SideDiffusiveFluxIntegralTempl : public SideIntegralVariablePostprocessor
   Real computeFaceInfoIntegral(const FaceInfo * fi) override;
 
   const GenericMaterialProperty<T, is_ad> * const _diffusion_coef;
-  const Moose::Functor<GenericType<T, is_ad>> * const _functor_diffusion_coef;
+  const Moose::Functor<Moose::GenericType<T, is_ad>> * const _functor_diffusion_coef;
 
 private:
   /// Routine to get the diffusive flux with a Real diffusivity
diff --git a/framework/include/utils/MooseADWrapper.h b/framework/include/utils/MooseADWrapper.h
deleted file mode 100644
index d3f0e68c5924..000000000000
--- a/framework/include/utils/MooseADWrapper.h
+++ /dev/null
@@ -1,42 +0,0 @@
-//* This file is part of the MOOSE framework
-//* https://www.mooseframework.org
-//*
-//* All rights reserved, see COPYRIGHT for full restrictions
-//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
-//*
-//* Licensed under LGPL 2.1, please see LICENSE for details
-//* https://www.gnu.org/licenses/lgpl-2.1.html
-
-#pragma once
-
-#include "MooseTypes.h"
-
-template <typename T>
-struct MooseIsADType
-{
-  static constexpr bool value = false;
-};
-
-template <>
-struct MooseIsADType<ADReal>
-{
-  static constexpr bool value = true;
-};
-
-template <>
-struct MooseIsADType<ADPoint>
-{
-  static constexpr bool value = true;
-};
-
-template <template <typename T, typename... Args> class W, typename T, typename... Args>
-struct MooseIsADType<W<T, Args...>>
-{
-  static constexpr bool value = MooseIsADType<T>::value;
-};
-
-template <typename T, typename... Args>
-struct MooseIsADType<MetaPhysicL::DualNumber<T, Args...>>
-{
-  static constexpr bool value = true;
-};
diff --git a/framework/include/utils/MooseTypes.h b/framework/include/utils/MooseTypes.h
index dd2ffe8f9f62..54f3b803f033 100644
--- a/framework/include/utils/MooseTypes.h
+++ b/framework/include/utils/MooseTypes.h
@@ -425,12 +425,6 @@ struct ADType<SymmetricRankFourTensor>
   typedef ADSymmetricRankFourTensor type;
 };
 
-// template <template <typename T, typename... Args> class W, typename T, typename... Args>
-// struct ADType<W<T, Args...>>
-// {
-//   typedef W<typename ADType<T>::type, Args...> type;
-// };
-
 template <template <typename T> class W, typename T>
 struct ADType<W<T>>
 {
@@ -544,6 +538,36 @@ struct ADType<ADVariableSecond>
   typedef ADVariableSecond type;
 };
 
+template <typename T>
+struct IsADType
+{
+  static constexpr bool value = false;
+};
+
+template <>
+struct IsADType<ADReal>
+{
+  static constexpr bool value = true;
+};
+
+template <>
+struct IsADType<ADPoint>
+{
+  static constexpr bool value = true;
+};
+
+template <template <typename T, typename... Args> class W, typename T, typename... Args>
+struct IsADType<W<T, Args...>>
+{
+  static constexpr bool value = IsADType<T>::value;
+};
+
+template <typename T, typename... Args>
+struct IsADType<MetaPhysicL::DualNumber<T, Args...>>
+{
+  static constexpr bool value = true;
+};
+
 /**
  * This is a helper variable template for cases when we want to use a default compile-time
  * error with constexpr-based if conditions. The templating delays the triggering
@@ -555,7 +579,7 @@ constexpr std::false_type always_false{};
 } // namespace Moose
 
 /**
- * some AD typedefs for backwards compatability
+ * some AD typedefs for backwards compatibility
  */
 typedef ADRealVectorValue DualRealVectorValue;
 typedef ADRealTensorValue DualRealTensorValue;
@@ -599,33 +623,36 @@ using ADTemplateVariablePhiGradient =
 using ADVariablePhiGradient = ADTemplateVariablePhiGradient<Real>;
 
 // Templated typed to support is_ad templated classes
+namespace Moose
+{
 template <typename T, bool is_ad>
-using GenericType = typename std::conditional<is_ad, typename Moose::ADType<T>::type, T>::type;
+using GenericType = typename std::conditional<is_ad, typename ADType<T>::type, T>::type;
+}
 
 template <bool is_ad>
-using GenericReal = GenericType<Real, is_ad>;
+using GenericReal = Moose::GenericType<Real, is_ad>;
 template <bool is_ad>
-using GenericChainedReal = GenericType<ChainedReal, is_ad>;
+using GenericChainedReal = Moose::GenericType<ChainedReal, is_ad>;
 template <bool is_ad>
-using GenericRealVectorValue = GenericType<RealVectorValue, is_ad>;
+using GenericRealVectorValue = Moose::GenericType<RealVectorValue, is_ad>;
 template <bool is_ad>
-using GenericRealTensorValue = GenericType<RealTensorValue, is_ad>;
+using GenericRealTensorValue = Moose::GenericType<RealTensorValue, is_ad>;
 template <bool is_ad>
-using GenericRankTwoTensor = GenericType<RankTwoTensor, is_ad>;
+using GenericRankTwoTensor = Moose::GenericType<RankTwoTensor, is_ad>;
 template <bool is_ad>
-using GenericRankThreeTensor = GenericType<RankThreeTensor, is_ad>;
+using GenericRankThreeTensor = Moose::GenericType<RankThreeTensor, is_ad>;
 template <bool is_ad>
-using GenericRankFourTensor = GenericType<RankFourTensor, is_ad>;
+using GenericRankFourTensor = Moose::GenericType<RankFourTensor, is_ad>;
 template <bool is_ad>
-using GenericVariableValue = GenericType<VariableValue, is_ad>;
+using GenericVariableValue = Moose::GenericType<VariableValue, is_ad>;
 template <bool is_ad>
-using GenericVariableGradient = GenericType<VariableGradient, is_ad>;
+using GenericVariableGradient = Moose::GenericType<VariableGradient, is_ad>;
 template <bool is_ad>
-using GenericVariableSecond = GenericType<VariableSecond, is_ad>;
+using GenericVariableSecond = Moose::GenericType<VariableSecond, is_ad>;
 template <bool is_ad>
-using GenericDenseVector = GenericType<DenseVector<Real>, is_ad>;
+using GenericDenseVector = Moose::GenericType<DenseVector<Real>, is_ad>;
 template <bool is_ad>
-using GenericDenseMatrix = GenericType<DenseMatrix<Real>, is_ad>;
+using GenericDenseMatrix = Moose::GenericType<DenseMatrix<Real>, is_ad>;
 
 namespace Moose
 {
diff --git a/framework/include/utils/MooseUtils.h b/framework/include/utils/MooseUtils.h
index 6f7a7db27816..6692f03e5960 100644
--- a/framework/include/utils/MooseUtils.h
+++ b/framework/include/utils/MooseUtils.h
@@ -14,7 +14,7 @@
 #include "InfixIterator.h"
 #include "MooseEnumItem.h"
 #include "MooseError.h"
-#include "MooseADWrapper.h"
+#include "MooseTypes.h"
 #include "Moose.h"
 #include "ADReal.h"
 #include "ExecutablePath.h"
diff --git a/framework/include/utils/NestedSolve.h b/framework/include/utils/NestedSolve.h
index 7d77dc1622fc..cbff43641b1c 100644
--- a/framework/include/utils/NestedSolve.h
+++ b/framework/include/utils/NestedSolve.h
@@ -11,7 +11,6 @@
 
 #include "MooseTypes.h"
 #include "RankTwoTensor.h"
-#include "MooseADWrapper.h"
 #include "InputParameters.h"
 
 #include "libmesh/utility.h"
@@ -49,9 +48,9 @@ class NestedSolveTempl
   NestedSolveTempl(const InputParameters & params);
 
   /// AD/non-AD switched type shortcuts
-  using NSReal = GenericType<Real, is_ad>;
-  using NSRealVectorValue = GenericType<RealVectorValue, is_ad>;
-  using NSRankTwoTensor = GenericType<RankTwoTensor, is_ad>;
+  using NSReal = Moose::GenericType<Real, is_ad>;
+  using NSRealVectorValue = Moose::GenericType<RealVectorValue, is_ad>;
+  using NSRankTwoTensor = Moose::GenericType<RankTwoTensor, is_ad>;
   /// Eigen type shortcuts
   using DynamicVector = Eigen::Matrix<NSReal, Eigen::Dynamic, 1>;
   using DynamicMatrix = Eigen::Matrix<NSReal, Eigen::Dynamic, Eigen::Dynamic>;
diff --git a/framework/src/actions/MaterialOutputAction.C b/framework/src/actions/MaterialOutputAction.C
index 6d86d9df54a9..bb28a360fe5e 100644
--- a/framework/src/actions/MaterialOutputAction.C
+++ b/framework/src/actions/MaterialOutputAction.C
@@ -24,29 +24,29 @@
 
 #include "libmesh/utility.h"
 
-/// List of AuxKernels used for the respective property type output (one entry for each type in SupportedTypes)
-const std::vector<std::string> MaterialOutputAction::_aux_kernel_names = {
-    "MaterialRealAux",
-    "MaterialRealVectorValueAux",
-    "MaterialRealTensorValueAux",
-    "MaterialRankTwoTensorAux",
-    "MaterialRankFourTensorAux",
-    "MaterialSymmetricRankTwoTensorAux",
-    "MaterialSymmetricRankFourTensorAux"};
-
-/// List of index symbols (one entry for each type in SupportedTypes)
-const std::vector<std::string> MaterialOutputAction::_index_symbols = {
-    "", "xyz", "012", "012", "012", "012345", "012345"};
-
-/// List of coefficient parameter names (one entry for each type in SupportedTypes)
-const std::vector<std::vector<std::string>> MaterialOutputAction::_param_names = {
-    {},
-    {"component"},
-    {"row", "column"},
-    {"i", "j"},
-    {"i", "j", "k", "l"},
-    {"component"},
-    {"i", "j"}};
+// /// List of AuxKernels used for the respective property type output (one entry for each type in SupportedTypes)
+// const std::vector<std::string> MaterialOutputAction::_aux_kernel_names = {
+//     "MaterialRealAux",
+//     "MaterialRealVectorValueAux",
+//     "MaterialRealTensorValueAux",
+//     "MaterialRankTwoTensorAux",
+//     "MaterialRankFourTensorAux",
+//     "MaterialSymmetricRankTwoTensorAux",
+//     "MaterialSymmetricRankFourTensorAux"};
+
+// /// List of index symbols (one entry for each type in SupportedTypes)
+// const std::vector<std::string> MaterialOutputAction::_index_symbols = {
+//     "", "xyz", "012", "012", "012", "012345", "012345"};
+
+// /// List of coefficient parameter names (one entry for each type in SupportedTypes)
+// const std::vector<std::vector<std::string>> MaterialOutputAction::_param_names = {
+//     {},
+//     {"component"},
+//     {"row", "column"},
+//     {"i", "j"},
+//     {"i", "j", "k", "l"},
+//     {"component"},
+//     {"i", "j"}};
 
 registerMooseAction("MooseApp", MaterialOutputAction, "add_output_aux_variables");
 registerMooseAction("MooseApp", MaterialOutputAction, "add_aux_kernel");
@@ -77,6 +77,8 @@ MaterialOutputAction::act()
   if (!_app.actionWarehouse().hasActions("add_output"))
     return;
 
+  bool get_names_only = _current_task == "add_output_aux_variables" ? true : false;
+
   // Set the pointers to the MaterialData objects (Note, these pointers are not available at
   // construction)
   _block_material_data = &_problem->getMaterialData(Moose::BLOCK_MATERIAL_DATA);
@@ -115,8 +117,8 @@ MaterialOutputAction::act()
   }
 
   // Loop through each material object
-  std::set<std::string> unsupported_properties;
-  std::set<std::string> material_property_names;
+  std::set<std::string> material_names;
+  std::set<std::string> unsupported_names;
   for (const auto & mat : material_ptrs)
   {
     // Extract the names of the output objects to which the material properties will be exported
@@ -133,8 +135,10 @@ MaterialOutputAction::act()
                                output_object_properties.end());
 
     // Clear the list of variable names for the current material object, this list will be populated
-    // with all the variables names for the current material object and is needed for purposes of
-    // controlling the which output objects show the material property data
+    // with all the
+    // variables names for the current material object and is needed for purposes of controlling the
+    // which output objects
+    // show the material property data
     _material_variable_names.clear();
 
     // Create necessary outputs for the properties if:
@@ -147,6 +151,7 @@ MaterialOutputAction::act()
       if (const auto fmat_ptr = dynamic_cast<const FunctorMaterial *>(mat.get()))
         names.insert(fmat_ptr->getSuppliedFunctors().begin(),
                      fmat_ptr->getSuppliedFunctors().end());
+
       for (const auto & name : names)
       {
         // Output the property only if the name is contained in the 'output_properties'
@@ -154,9 +159,12 @@ MaterialOutputAction::act()
         if (output_properties.empty() ||
             std::find(output_properties.begin(), output_properties.end(), name) !=
                 output_properties.end())
-        { // Add the material property for output
-          Moose::typeLoop<SetupOutput>(SupportedTypes{}, this, name, std::cref(*mat));
-          material_property_names.insert(name);
+        {
+          // Add the material property for output
+          auto curr_material_names = materialOutput(name, *mat, get_names_only);
+          if (curr_material_names.size() == 0)
+            unsupported_names.insert(name);
+          material_names.insert(curr_material_names.begin(), curr_material_names.end());
         }
       }
       // If the material object has limited outputs, store the variables associated with the
@@ -166,50 +174,55 @@ MaterialOutputAction::act()
           _material_variable_names_map[output_name].insert(_material_variable_names.begin(),
                                                            _material_variable_names.end());
     }
-
-    for (const auto & name : _material_variable_names)
-      _all_variable_names.insert(name);
-
-    for (const auto & name : material_property_names)
-      if (_supported_properties.count(name) == 0)
-        unsupported_properties.insert(name);
+  }
+  if (unsupported_names.size() > 0 && get_names_only)
+  {
+    std::ostringstream oss;
+    for (const auto & name : unsupported_names)
+      oss << "\n  " << name;
+    mooseWarning("The types for total ",
+                 unsupported_names.size(),
+                 " material properties:",
+                 oss.str(),
+                 "\nare not supported for automatic output by ",
+                 type(),
+                 ".");
   }
 
   if (_current_task == "add_output_aux_variables")
   {
-    // Check and warn for unsupported outputs
-    if (unsupported_properties.size() > 0)
+    auto params = _factory.getValidParams("MooseVariableConstMonomial");
+    // currently only elemental variables are supported for material property output
+    params.set<MooseEnum>("order") = "CONSTANT";
+    params.set<MooseEnum>("family") = "MONOMIAL";
+
+    // Create the AuxVariables
+    std::ostringstream oss;
+    for (const auto & var_name : material_names)
     {
-      std::string names;
-      for (const auto & name : unsupported_properties)
-        names += "\n  " + name;
-      mooseWarning("The types for total ",
-                   unsupported_properties.size(),
-                   " material properties:",
-                   names,
-                   "\nare not supported for automatic output by ",
-                   type(),
-                   ".");
+      oss << "\n  " << var_name;
+      if (_problem->hasVariable(var_name))
+        mooseError("The material property output " + var_name +
+                   " has the same name as an existing variable, either use the material"
+                   " declare_suffix parameter to disambiguate or the output_properties parameter"
+                   " to restrict the material properties to output");
+      _problem->addAuxVariable("MooseVariableConstMonomial", var_name, params);
     }
-
-    if (_all_variable_names.size() > 0)
-    {
-      std::string names;
-      for (const auto & name : _all_variable_names)
-        names += "\n  " + name;
-      _console << COLOR_CYAN << "The following total " << _all_variable_names.size()
-               << " aux variables:" << names << "\nare added for automatic output by " << type()
+    if (material_names.size() > 0)
+      _console << COLOR_CYAN << "The following total " << material_names.size()
+               << " aux variables:" << oss.str() << "\nare added for automatic output by " << type()
                << "." << COLOR_DEFAULT << std::endl;
-    }
-
+  }
+  else
+  {
     // When a MaterialBase object has 'output_properties' defined all other properties not listed
     // must be added to the hide list for the output objects so that properties that are not desired
     // do not appear.
     for (const auto & it : _material_variable_names_map)
     {
       std::set<std::string> hide;
-      std::set_difference(_all_variable_names.begin(),
-                          _all_variable_names.end(),
+      std::set_difference(material_names.begin(),
+                          material_names.end(),
                           it.second.begin(),
                           it.second.end(),
                           std::inserter(hide, hide.begin()));
@@ -219,95 +232,145 @@ MaterialOutputAction::act()
   }
 }
 
-template <typename T, int I>
-void
-MaterialOutputAction::setupOutput(const MaterialPropertyName & prop_name,
-                                  const MaterialBase & material)
+std::vector<std::string>
+MaterialOutputAction::materialOutput(const std::string & property_name,
+                                     const MaterialBase & material,
+                                     bool get_names_only)
 {
-  if (hasProperty<T>(prop_name))
-    setupOutputHelper<T, I, false, false>(prop_name, material);
-  else if (hasADProperty<T>(prop_name))
-    setupOutputHelper<T, I, true, false>(prop_name, material);
-  else if (hasFunctorProperty<T>(prop_name))
-    setupOutputHelper<T, I, false, true>(prop_name, material);
-  else if (hasFunctorProperty<typename Moose::ADType<T>::type>(prop_name))
-    setupOutputHelper<T, I, true, true>(prop_name, material);
+  std::vector<std::string> names;
+
+  // Material Properties
+  if (hasProperty<Real>(property_name))
+    names = outputHelper(
+        {"MaterialRealAux", "", {}}, property_name, property_name, material, get_names_only);
+
+  else if (hasADProperty<Real>(property_name))
+    names = outputHelper(
+        {"ADMaterialRealAux", "", {}}, property_name, property_name, material, get_names_only);
+
+  else if (hasProperty<RealVectorValue>(property_name))
+    names = outputHelper({"MaterialRealVectorValueAux", "xyz", {"component"}},
+                         property_name,
+                         property_name + "_",
+                         material,
+                         get_names_only);
+
+  else if (hasADProperty<RealVectorValue>(property_name))
+    names = outputHelper({"ADMaterialRealVectorValueAux", "xyz", {"component"}},
+                         property_name,
+                         property_name + "_",
+                         material,
+                         get_names_only);
+
+  else if (hasProperty<RealTensorValue>(property_name))
+    names = outputHelper({"MaterialRealTensorValueAux", "012", {"row", "column"}},
+                         property_name,
+                         property_name + "_",
+                         material,
+                         get_names_only);
+
+  else if (hasProperty<RankTwoTensor>(property_name))
+    names = outputHelper({"MaterialRankTwoTensorAux", "012", {"i", "j"}},
+                         property_name,
+                         property_name + "_",
+                         material,
+                         get_names_only);
+
+  else if (hasADProperty<RankTwoTensor>(property_name))
+    names = outputHelper({"ADMaterialRankTwoTensorAux", "012", {"i", "j"}},
+                         property_name,
+                         property_name + "_",
+                         material,
+                         get_names_only);
+
+  else if (hasProperty<RankFourTensor>(property_name))
+    names = outputHelper({"MaterialRankFourTensorAux", "012", {"i", "j", "k", "l"}},
+                         property_name,
+                         property_name + "_",
+                         material,
+                         get_names_only);
+
+  else if (hasProperty<SymmetricRankTwoTensor>(property_name))
+    names = outputHelper({"MaterialSymmetricRankTwoTensorAux", "012345", {"component"}},
+                         property_name,
+                         property_name + "_",
+                         material,
+                         get_names_only);
+
+  else if (hasProperty<SymmetricRankFourTensor>(property_name))
+    names = outputHelper({"MaterialSymmetricRankFourTensorAux", "012345", {"i", "j"}},
+                         property_name,
+                         property_name + "_",
+                         material,
+                         get_names_only);
+
+  // Functors
+  else if (hasFunctorProperty<Real>(property_name))
+    names = outputHelper({"FunctorMaterialRealAux", "", {}},
+                         property_name,
+                         property_name + "_out",
+                         material,
+                         get_names_only);
+
+  else if (hasFunctorProperty<ADReal>(property_name))
+    names = outputHelper({"ADFunctorMaterialRealAux", "", {}},
+                         property_name,
+                         property_name + "_out",
+                         material,
+                         get_names_only);
+
+  else if (hasFunctorProperty<RealVectorValue>(property_name))
+    names = outputHelper({"FunctorMaterialRealVectorValueAux", "xyz", {"component"}},
+                         property_name,
+                         property_name + "_out_",
+                         material,
+                         get_names_only);
+
+  else if (hasFunctorProperty<ADRealVectorValue>(property_name))
+    names = outputHelper({"ADFunctorMaterialRealVectorValueAux", "xyz", {"component"}},
+                         property_name,
+                         property_name + "_out_",
+                         material,
+                         get_names_only);
+
+  return names;
 }
 
-namespace
+std::vector<std::string>
+MaterialOutputAction::outputHelper(const MaterialOutputAction::OutputMetaData & metadata,
+                                   const MaterialPropertyName & property_name,
+                                   const std::string & var_name_base,
+                                   const MaterialBase & material,
+                                   bool get_names_only)
 {
-template <typename T>
-struct Size
-{
-  static constexpr std::size_t value = T::N;
-};
-
-template <>
-struct Size<Real>
-{
-  static constexpr std::size_t value = 1;
-};
-template <>
-struct Size<RealVectorValue>
-{
-  static constexpr std::size_t value = 3;
-};
-template <>
-struct Size<RealTensorValue>
-{
-  static constexpr std::size_t value = 3;
-};
-}
+  const auto & [kernel_name, index_symbols, param_names] = metadata;
+  const auto dim = param_names.size();
+  const auto size = index_symbols.size();
 
-template <typename T, int I, bool is_ad, bool is_functor>
-void
-MaterialOutputAction::setupOutputHelper(const MaterialPropertyName & prop_name,
-                                        const MaterialBase & material)
-{
-  const auto dim = _param_names[I].size();
+  std::vector<std::string> names;
+  // general 0 to 4 dimensional loop
   std::array<std::size_t, 4> i;
-  for (i[3] = 0; i[3] < (dim < 4 ? 1 : Size<T>::value); ++i[3])
-    for (i[2] = 0; i[2] < (dim < 3 ? 1 : Size<T>::value); ++i[2])
-      for (i[1] = 0; i[1] < (dim < 2 ? 1 : Size<T>::value); ++i[1])
-        for (i[0] = 0; i[0] < (dim < 1 ? 1 : Size<T>::value); ++i[0])
+  for (i[3] = 0; i[3] < (dim < 4 ? 1 : size); ++i[3])
+    for (i[2] = 0; i[2] < (dim < 3 ? 1 : size); ++i[2])
+      for (i[1] = 0; i[1] < (dim < 2 ? 1 : size); ++i[1])
+        for (i[0] = 0; i[0] < (dim < 1 ? 1 : size); ++i[0])
         {
-          std::string var_name = prop_name + (is_functor ? "_out" : "") + (dim ? "_" : "");
+          std::string var_name = var_name_base;
           for (const auto j : make_range(dim))
-            var_name += Moose::stringify(_index_symbols[I][i[j]]);
+            var_name += Moose::stringify(index_symbols[i[j]]);
+          names.push_back(var_name);
 
-          //  Add AuxVariables
-          if (_current_task == "add_output_aux_variables")
-          {
-            if (_problem->hasVariable(var_name) && _all_variable_names.count(var_name) == 0)
-              mooseError(
-                  "The material property output " + var_name +
-                  " has the same name as an existing variable, either use the material"
-                  " declare_suffix parameter to disambiguate or the output_properties parameter"
-                  " to restrict the material properties to output");
-
-            auto params = _factory.getValidParams("MooseVariableConstMonomial");
-            // currently only elemental variables are supported for material property output
-            params.set<MooseEnum>("order") = "CONSTANT";
-            params.set<MooseEnum>("family") = "MONOMIAL";
-            _problem->addAuxVariable("MooseVariableConstMonomial", var_name, params);
-          }
-
-          // Add AuxKernel
-          const auto kernel_name = (is_ad ? "AD" : "") + _aux_kernel_names[I];
-          auto params = getParams<is_functor>(kernel_name, prop_name, var_name, material);
-          if (_current_task == "add_aux_kernel")
+          if (!get_names_only)
           {
+            auto params = getParams(kernel_name, property_name, var_name, material);
             for (const auto j : make_range(dim))
-              params.template set<unsigned int>(_param_names[I][j]) = i[j];
-
+              params.template set<unsigned int>(param_names[j]) = i[j];
             _problem->addAuxKernel(kernel_name, material.name() + var_name, params);
           }
         }
-
-  _supported_properties.insert(prop_name);
+  return names;
 }
 
-template <bool is_functor>
 InputParameters
 MaterialOutputAction::getParams(const std::string & type,
                                 const std::string & property_name,
@@ -319,12 +382,7 @@ MaterialOutputAction::getParams(const std::string & type,
 
   // Set the action parameters
   InputParameters params = _factory.getValidParams(type);
-
-  // Adapt for regular or functor materials
-  if constexpr (is_functor)
-    params.set<MooseFunctorName>("functor") = property_name;
-  else
-    params.set<MaterialPropertyName>("property") = property_name;
+  params.set<MaterialPropertyName>("property") = property_name;
 
   params.set<AuxVariableName>("variable") = variable_name;
   if (_output_only_on_timestep_end)
diff --git a/framework/src/auxkernels/MaterialRealAux.C b/framework/src/auxkernels/MaterialRealAux.C
index dc726e69edc1..5efac41a70a1 100644
--- a/framework/src/auxkernels/MaterialRealAux.C
+++ b/framework/src/auxkernels/MaterialRealAux.C
@@ -11,28 +11,32 @@
 
 registerMooseObject("MooseApp", MaterialRealAux);
 registerMooseObject("MooseApp", ADMaterialRealAux);
+registerMooseObject("MooseApp", FunctorMaterialRealAux);
+registerMooseObject("MooseApp", ADFunctorMaterialRealAux);
 
-template <bool is_ad>
+template <bool is_ad, bool is_functor>
 InputParameters
-MaterialRealAuxTempl<is_ad>::validParams()
+MaterialRealAuxTempl<is_ad, is_functor>::validParams()
 {
-  InputParameters params = MaterialAuxBaseTempl<Real, is_ad>::validParams();
+  InputParameters params = MaterialAuxBaseTempl<Real, is_ad, is_functor>::validParams();
   params.addClassDescription("Outputs element volume-averaged material properties");
   return params;
 }
 
-template <bool is_ad>
-MaterialRealAuxTempl<is_ad>::MaterialRealAuxTempl(const InputParameters & parameters)
-  : MaterialAuxBaseTempl<Real, is_ad>(parameters)
+template <bool is_ad, bool is_functor>
+MaterialRealAuxTempl<is_ad, is_functor>::MaterialRealAuxTempl(const InputParameters & parameters)
+  : MaterialAuxBaseTempl<Real, is_ad, is_functor>(parameters)
 {
 }
 
-template <bool is_ad>
+template <bool is_ad, bool is_functor>
 Real
-MaterialRealAuxTempl<is_ad>::getRealValue()
+MaterialRealAuxTempl<is_ad, is_functor>::getRealValue()
 {
   return MetaPhysicL::raw_value(this->_full_value);
 }
 
-template class MaterialRealAuxTempl<false>;
-template class MaterialRealAuxTempl<true>;
+template class MaterialRealAuxTempl<false, false>;
+template class MaterialRealAuxTempl<true, false>;
+template class MaterialRealAuxTempl<false, true>;
+template class MaterialRealAuxTempl<true, true>;
diff --git a/framework/src/auxkernels/MaterialRealVectorValueAux.C b/framework/src/auxkernels/MaterialRealVectorValueAux.C
index db3307ba51ef..e1996edb97a3 100644
--- a/framework/src/auxkernels/MaterialRealVectorValueAux.C
+++ b/framework/src/auxkernels/MaterialRealVectorValueAux.C
@@ -13,14 +13,16 @@
 
 registerMooseObject("MooseApp", MaterialRealVectorValueAux);
 registerMooseObject("MooseApp", ADMaterialRealVectorValueAux);
+registerMooseObject("MooseApp", FunctorMaterialRealVectorValueAux);
+registerMooseObject("MooseApp", ADFunctorMaterialRealVectorValueAux);
 registerMooseObject("MooseApp", MaterialSymmetricRankTwoTensorAux);
 registerMooseObject("MooseApp", ADMaterialSymmetricRankTwoTensorAux);
 
-template <typename T, bool is_ad>
+template <typename T, bool is_ad, bool is_functor>
 InputParameters
-MaterialRealVectorValueAuxTempl<T, is_ad>::validParams()
+MaterialRealVectorValueAuxTempl<T, is_ad, is_functor>::validParams()
 {
-  InputParameters params = MaterialAuxBaseTempl<T, is_ad>::validParams();
+  InputParameters params = MaterialAuxBaseTempl<T, is_ad, is_functor>::validParams();
   params.addClassDescription(
       "Capture a component of a vector material property in an auxiliary variable.");
   params.addParam<unsigned int>("component", 0, "The vector component to consider for this kernel");
@@ -28,10 +30,10 @@ MaterialRealVectorValueAuxTempl<T, is_ad>::validParams()
   return params;
 }
 
-template <typename T, bool is_ad>
-MaterialRealVectorValueAuxTempl<T, is_ad>::MaterialRealVectorValueAuxTempl(
+template <typename T, bool is_ad, bool is_functor>
+MaterialRealVectorValueAuxTempl<T, is_ad, is_functor>::MaterialRealVectorValueAuxTempl(
     const InputParameters & parameters)
-  : MaterialAuxBaseTempl<T, is_ad>(parameters),
+  : MaterialAuxBaseTempl<T, is_ad, is_functor>(parameters),
     _component(this->template getParam<unsigned int>("component"))
 {
   if constexpr (std::is_same_v<T, RealVectorValue>)
@@ -50,14 +52,16 @@ MaterialRealVectorValueAuxTempl<T, is_ad>::MaterialRealVectorValueAuxTempl(
   }
 }
 
-template <typename T, bool is_ad>
+template <typename T, bool is_ad, bool is_functor>
 Real
-MaterialRealVectorValueAuxTempl<T, is_ad>::getRealValue()
+MaterialRealVectorValueAuxTempl<T, is_ad, is_functor>::getRealValue()
 {
   return MetaPhysicL::raw_value(this->_full_value(_component));
 }
 
-template class MaterialRealVectorValueAuxTempl<RealVectorValue, false>;
-template class MaterialRealVectorValueAuxTempl<RealVectorValue, true>;
-template class MaterialRealVectorValueAuxTempl<SymmetricRankTwoTensor, false>;
-template class MaterialRealVectorValueAuxTempl<SymmetricRankTwoTensor, true>;
+template class MaterialRealVectorValueAuxTempl<RealVectorValue, false, false>;
+template class MaterialRealVectorValueAuxTempl<RealVectorValue, true, false>;
+template class MaterialRealVectorValueAuxTempl<RealVectorValue, false, true>;
+template class MaterialRealVectorValueAuxTempl<RealVectorValue, true, true>;
+template class MaterialRealVectorValueAuxTempl<SymmetricRankTwoTensor, false, false>;
+template class MaterialRealVectorValueAuxTempl<SymmetricRankTwoTensor, true, false>;
diff --git a/framework/src/auxkernels/VectorMaterialRealVectorValueAux.C b/framework/src/auxkernels/VectorMaterialRealVectorValueAux.C
index 57e508059fc7..1df2a5edd325 100644
--- a/framework/src/auxkernels/VectorMaterialRealVectorValueAux.C
+++ b/framework/src/auxkernels/VectorMaterialRealVectorValueAux.C
@@ -18,7 +18,7 @@ template <bool is_ad>
 InputParameters
 VectorMaterialRealVectorValueAuxTempl<is_ad>::validParams()
 {
-  auto params = MaterialAuxBaseTempl<RealVectorValue, is_ad, RealVectorValue>::validParams();
+  auto params = MaterialAuxBaseTempl<RealVectorValue, is_ad, false, RealVectorValue>::validParams();
 
   params.addClassDescription(
       "Converts a vector-quantity material property into a vector auxiliary variable");
@@ -29,7 +29,7 @@ VectorMaterialRealVectorValueAuxTempl<is_ad>::validParams()
 template <bool is_ad>
 VectorMaterialRealVectorValueAuxTempl<is_ad>::VectorMaterialRealVectorValueAuxTempl(
     const InputParameters & parameters)
-  : MaterialAuxBaseTempl<RealVectorValue, is_ad, RealVectorValue>(parameters)
+  : MaterialAuxBaseTempl<RealVectorValue, is_ad, false, RealVectorValue>(parameters)
 {
 }
 
diff --git a/framework/src/base/Assembly.C b/framework/src/base/Assembly.C
index 78e21a556561..a86631bae54c 100644
--- a/framework/src/base/Assembly.C
+++ b/framework/src/base/Assembly.C
@@ -4946,14 +4946,14 @@ template void coordTransformFactor<ADPoint, ADReal>(const MooseMesh & mesh,
                                                     SubdomainID neighbor_sub_id);
 
 template <>
-const MooseArray<GenericType<Point, false>> &
+const MooseArray<Moose::GenericType<Point, false>> &
 Assembly::genericQPoints<false>() const
 {
   return qPoints();
 }
 
 template <>
-const MooseArray<GenericType<Point, true>> &
+const MooseArray<Moose::GenericType<Point, true>> &
 Assembly::genericQPoints<true>() const
 {
   return adQPoints();
diff --git a/framework/src/functions/PiecewiseMultiInterpolation.C b/framework/src/functions/PiecewiseMultiInterpolation.C
index f72e573316e1..395caff45a04 100644
--- a/framework/src/functions/PiecewiseMultiInterpolation.C
+++ b/framework/src/functions/PiecewiseMultiInterpolation.C
@@ -61,12 +61,12 @@ PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(const InputParameters &
 PiecewiseMultiInterpolation::~PiecewiseMultiInterpolation() {}
 
 template <bool is_ad>
-GenericType<PiecewiseMultiInterpolation::GridPoint, is_ad>
-PiecewiseMultiInterpolation::pointInGrid(const GenericType<Real, is_ad> & t,
-                                         const GenericType<Point, is_ad> & p) const
+Moose::GenericType<PiecewiseMultiInterpolation::GridPoint, is_ad>
+PiecewiseMultiInterpolation::pointInGrid(const Moose::GenericType<Real, is_ad> & t,
+                                         const Moose::GenericType<Point, is_ad> & p) const
 {
   // convert the inputs to an input to the sample function using _axes
-  GenericType<GridPoint, is_ad> point_in_grid(_dim);
+  Moose::GenericType<GridPoint, is_ad> point_in_grid(_dim);
   for (unsigned int i = 0; i < _dim; ++i)
   {
     if (_axes[i] < 3)
diff --git a/framework/src/functions/PiecewiseMultilinear.C b/framework/src/functions/PiecewiseMultilinear.C
index c18c984035bb..be120d020d5b 100644
--- a/framework/src/functions/PiecewiseMultilinear.C
+++ b/framework/src/functions/PiecewiseMultilinear.C
@@ -44,8 +44,8 @@ PiecewiseMultilinear::sample(const ADGridPoint & pt) const
 }
 
 template <bool is_ad>
-GenericType<Real, is_ad>
-PiecewiseMultilinear::sampleInternal(const GenericType<GridPoint, is_ad> pt) const
+Moose::GenericType<Real, is_ad>
+PiecewiseMultilinear::sampleInternal(const Moose::GenericType<GridPoint, is_ad> pt) const
 {
   /*
    * left contains the indices of the point to the 'left', 'down', etc, of pt
@@ -63,8 +63,8 @@ PiecewiseMultilinear::sampleInternal(const GenericType<GridPoint, is_ad> pt) con
    * those vertices, and weighting the contributions to the
    * final result depending on the distance of pt from the vertex
    */
-  GenericType<Real, is_ad> f = 0;
-  GenericType<Real, is_ad> weight;
+  Moose::GenericType<Real, is_ad> f = 0;
+  Moose::GenericType<Real, is_ad> weight;
   GridIndex arg(_dim);
   // number of points in hypercube = 2^_dim
   for (unsigned int i = 0; i < (1u << _dim); ++i)
diff --git a/framework/src/interfacekernels/PenaltyInterfaceDiffusion.C b/framework/src/interfacekernels/PenaltyInterfaceDiffusion.C
index 225263a9c8fe..fa6a5e2f3815 100644
--- a/framework/src/interfacekernels/PenaltyInterfaceDiffusion.C
+++ b/framework/src/interfacekernels/PenaltyInterfaceDiffusion.C
@@ -46,7 +46,7 @@ PenaltyInterfaceDiffusionTempl<T, is_ad>::computeQpResidual(Moose::DGResidualTyp
 {
   GenericReal<is_ad> r = 0;
 
-  GenericType<T, is_ad> jump_value = 0;
+  Moose::GenericType<T, is_ad> jump_value = 0;
 
   if (_jump != nullptr)
     jump_value = (*_jump)[_qp];
diff --git a/framework/src/materials/CoupledValueFunctionMaterial.C b/framework/src/materials/CoupledValueFunctionMaterial.C
index 6eccd2ca3129..4a25c1608ac6 100644
--- a/framework/src/materials/CoupledValueFunctionMaterial.C
+++ b/framework/src/materials/CoupledValueFunctionMaterial.C
@@ -71,7 +71,7 @@ template <bool is_ad>
 void
 CoupledValueFunctionMaterialTempl<is_ad>::computeQpProperties()
 {
-  GenericType<Point, is_ad> p;
+  Moose::GenericType<Point, is_ad> p;
   GenericReal<is_ad> t = 0.0;
 
   for (const auto i : make_range(_nvals))
diff --git a/framework/src/materials/MaterialFunctorConverter.C b/framework/src/materials/MaterialFunctorConverter.C
index 006758627a03..bc36c1387220 100644
--- a/framework/src/materials/MaterialFunctorConverter.C
+++ b/framework/src/materials/MaterialFunctorConverter.C
@@ -57,7 +57,7 @@ MaterialFunctorConverterTempl<T>::MaterialFunctorConverterTempl(const InputParam
   _reg_props_out.resize(reg_props_out.size());
 
   for (const auto i : make_range(_num_functors_to_convert))
-    _functors_in[i] = &getFunctor<GenericType<T, true>>(functors_in[i]);
+    _functors_in[i] = &getFunctor<Moose::GenericType<T, true>>(functors_in[i]);
 
   for (const auto i : index_range(ad_props_out))
     _ad_props_out[i] = &declareADProperty<T>(ad_props_out[i]);
diff --git a/framework/src/postprocessors/SideDiffusiveFluxIntegral.C b/framework/src/postprocessors/SideDiffusiveFluxIntegral.C
index 558a36d922d7..44f1366e0dec 100644
--- a/framework/src/postprocessors/SideDiffusiveFluxIntegral.C
+++ b/framework/src/postprocessors/SideDiffusiveFluxIntegral.C
@@ -51,7 +51,7 @@ SideDiffusiveFluxIntegralTempl<is_ad, T>::SideDiffusiveFluxIntegralTempl(
                         ? &getGenericMaterialProperty<T, is_ad>("diffusivity")
                         : nullptr),
     _functor_diffusion_coef(isParamValid("functor_diffusivity")
-                                ? &getFunctor<GenericType<T, is_ad>>("functor_diffusivity")
+                                ? &getFunctor<Moose::GenericType<T, is_ad>>("functor_diffusivity")
                                 : nullptr)
 {
   if (_fv && !isParamValid("functor_diffusivity"))
diff --git a/modules/solid_mechanics/include/materials/ADComputeFiniteStrain.h b/modules/solid_mechanics/include/materials/ADComputeFiniteStrain.h
index 90ba5ef2a762..acb3d09aeb5d 100644
--- a/modules/solid_mechanics/include/materials/ADComputeFiniteStrain.h
+++ b/modules/solid_mechanics/include/materials/ADComputeFiniteStrain.h
@@ -32,7 +32,7 @@ class ADComputeFiniteStrainTempl : public ADComputeIncrementalStrainBaseTempl<R2
   static MooseEnum decompositionType();
 
 protected:
-  using ADR2 = GenericType<R2, true>;
+  using ADR2 = Moose::GenericType<R2, true>;
   using FADR2 = FactorizedRankTwoTensorTempl<ADR2>;
 
   virtual void computeQpStrain();
diff --git a/modules/solid_mechanics/include/materials/ADComputeFiniteStrainElasticStress.h b/modules/solid_mechanics/include/materials/ADComputeFiniteStrainElasticStress.h
index 465362ff5364..235b0cca7045 100644
--- a/modules/solid_mechanics/include/materials/ADComputeFiniteStrainElasticStress.h
+++ b/modules/solid_mechanics/include/materials/ADComputeFiniteStrainElasticStress.h
@@ -29,8 +29,8 @@ class ADComputeFiniteStrainElasticStressTempl : public ADComputeStressBaseTempl<
   virtual void initQpStatefulProperties() override;
 
 protected:
-  using ADR2 = GenericType<R2, true>;
-  using ADR4 = GenericType<R4, true>;
+  using ADR2 = Moose::GenericType<R2, true>;
+  using ADR4 = Moose::GenericType<R4, true>;
 
   virtual void computeQpStress() override;
 
diff --git a/modules/solid_mechanics/include/materials/ADComputeIncrementalSmallStrain.h b/modules/solid_mechanics/include/materials/ADComputeIncrementalSmallStrain.h
index aff6c1853aac..298bccfa1440 100644
--- a/modules/solid_mechanics/include/materials/ADComputeIncrementalSmallStrain.h
+++ b/modules/solid_mechanics/include/materials/ADComputeIncrementalSmallStrain.h
@@ -28,7 +28,7 @@ class ADComputeIncrementalSmallStrainTempl : public ADComputeIncrementalStrainBa
   virtual void computeProperties() override;
 
 protected:
-  using ADR2 = GenericType<R2, true>;
+  using ADR2 = Moose::GenericType<R2, true>;
 
   /**
    * Computes the current and old deformation gradients and passes back the
diff --git a/modules/solid_mechanics/include/materials/ADComputeIncrementalStrainBase.h b/modules/solid_mechanics/include/materials/ADComputeIncrementalStrainBase.h
index 86c675a921a1..4a1f249bb061 100644
--- a/modules/solid_mechanics/include/materials/ADComputeIncrementalStrainBase.h
+++ b/modules/solid_mechanics/include/materials/ADComputeIncrementalStrainBase.h
@@ -36,7 +36,7 @@ class ADComputeIncrementalStrainBaseTempl : public ADComputeStrainBaseTempl<R2>
   void initialSetup() override;
 
 protected:
-  using ADR2 = GenericType<R2, true>;
+  using ADR2 = Moose::GenericType<R2, true>;
 
   virtual void initQpStatefulProperties() override;
 
diff --git a/modules/solid_mechanics/include/materials/StressUpdateBase.h b/modules/solid_mechanics/include/materials/StressUpdateBase.h
index 6c630e5fe8e7..402d0d52d944 100644
--- a/modules/solid_mechanics/include/materials/StressUpdateBase.h
+++ b/modules/solid_mechanics/include/materials/StressUpdateBase.h
@@ -55,9 +55,9 @@ class StressUpdateBaseTempl : public Material
   using Material::_qp;
 
   using GR2 = GenericRankTwoTensor<is_ad>;
-  using GSR2 = GenericType<R2, is_ad>;
+  using GSR2 = Moose::GenericType<R2, is_ad>;
   using GR4 = GenericRankFourTensor<is_ad>;
-  using GSR4 = GenericType<R4, is_ad>;
+  using GSR4 = Moose::GenericType<R4, is_ad>;
 
   /**
    * Given a strain increment that results in a trial stress, perform some
diff --git a/modules/solid_mechanics/src/materials/IsotropicPlasticityStressUpdate.C b/modules/solid_mechanics/src/materials/IsotropicPlasticityStressUpdate.C
index 2c1b0fbefc74..a0c57b1fa1bf 100644
--- a/modules/solid_mechanics/src/materials/IsotropicPlasticityStressUpdate.C
+++ b/modules/solid_mechanics/src/materials/IsotropicPlasticityStressUpdate.C
@@ -201,7 +201,7 @@ IsotropicPlasticityStressUpdateTempl<is_ad>::computeYieldStress(
 {
   if (_yield_stress_function)
   {
-    static const GenericType<Point, is_ad> p;
+    static const Moose::GenericType<Point, is_ad> p;
     _yield_stress = _yield_stress_function->value(_temperature[_qp], p);
 
     if (_yield_stress <= 0.0)
diff --git a/test/include/materials/OutputTestMaterial.h b/test/include/materials/OutputTestMaterial.h
index a36a8b10eb2d..c4b0fc169d52 100644
--- a/test/include/materials/OutputTestMaterial.h
+++ b/test/include/materials/OutputTestMaterial.h
@@ -15,13 +15,10 @@
 #include "RankFourTensorForward.h"
 #include "SymmetricRankTwoTensorForward.h"
 #include "SymmetricRankFourTensorForward.h"
+
 class OutputTestMaterial : public Material
 {
 public:
-  /**
-   * Class constructor
-   * @param prop_name
-   */
   static InputParameters validParams();
 
   OutputTestMaterial(const InputParameters & parameters);