Additional refinement

Refs idaholab#14823

framework/include/kernels/MaterialPropertyValue.h

@@ -10,18 +10,32 @@
 #pragma once
 
 #include "KernelValue.h"
+#include "ADKernelValue.h"
 
-class MaterialPropertyValue : public KernelValue
+// switch parent class depending on is_ad value
+template <bool is_ad>
+using KernelValueParent = typename std::conditional<is_ad, ADKernelValue, KernelValue>::type;
+
+template <bool is_ad>
+class MaterialPropertyValueTempl : public KernelValueParent<is_ad>
 {
 public:
   static InputParameters validParams();
 
-  MaterialPropertyValue(const InputParameters & parameters);
+  MaterialPropertyValueTempl(const InputParameters & parameters);
 
 protected:
-  virtual Real precomputeQpResidual() override;
-  virtual Real precomputeQpJacobian() override;
+  virtual GenericReal<is_ad> precomputeQpResidual();
+  virtual Real precomputeQpJacobian();
 
   const Real _kernel_sign;
-  const MaterialProperty<Real> & _prop;
+  const GenericMaterialProperty<Real, is_ad> & _prop;
+
+  using KernelValueParent<is_ad>::_qp;
+  using KernelValueParent<is_ad>::_u;
+  using KernelValueParent<is_ad>::_phi;
+  using KernelValueParent<is_ad>::_j;
 };
+
+using MaterialPropertyValue = MaterialPropertyValueTempl<false>;
+using ADMaterialPropertyValue = MaterialPropertyValueTempl<true>;

framework/src/kernels/MaterialPropertyValue.C

@@ -10,11 +10,13 @@
 #include "MaterialPropertyValue.h"
 
 registerMooseObject("MooseApp", MaterialPropertyValue);
+registerMooseObject("MooseApp", ADMaterialPropertyValue);
 
+template <bool is_ad>
 InputParameters
-MaterialPropertyValue::validParams()
+MaterialPropertyValueTempl<is_ad>::validParams()
 {
-  InputParameters params = KernelValue::validParams();
+  InputParameters params = KernelValueParent<is_ad>::validParams();
   params.addClassDescription(
       "Residual term (u - prop) to set variable u equal to a given material property prop");
   params.addRequiredParam<MaterialPropertyName>(
@@ -24,21 +26,41 @@ MaterialPropertyValue::validParams()
   return params;
 }
 
-MaterialPropertyValue::MaterialPropertyValue(const InputParameters & parameters)
-  : KernelValue(parameters),
-    _kernel_sign(getParam<bool>("positive") ? 1.0 : -1.0),
-    _prop(getMaterialProperty<Real>("prop_name"))
+template <bool is_ad>
+MaterialPropertyValueTempl<is_ad>::MaterialPropertyValueTempl(const InputParameters & parameters)
+  : KernelValueParent<is_ad>(parameters),
+    _kernel_sign(this->template getParam<bool>("positive") ? 1.0 : -1.0),
+    _prop(this->template getGenericMaterialProperty<Real, is_ad>("prop_name"))
 {
 }
 
+template <>
 Real
-MaterialPropertyValue::precomputeQpResidual()
+MaterialPropertyValueTempl<false>::precomputeQpResidual()
 {
   return _kernel_sign * (_prop[_qp] - _u[_qp]);
 }
 
+template <>
+ADReal
+MaterialPropertyValueTempl<true>::precomputeQpResidual()
+{
+  return _kernel_sign * (_prop[_qp] - _u[_qp]);
+}
+
+template <>
 Real
-MaterialPropertyValue::precomputeQpJacobian()
+MaterialPropertyValueTempl<false>::precomputeQpJacobian()
 {
   return -_kernel_sign * _phi[_j][_qp];
 }
+
+template <>
+Real
+MaterialPropertyValueTempl<true>::precomputeQpJacobian()
+{
+  mooseError("This should never get called");
+}
+
+template class MaterialPropertyValueTempl<false>;
+template class MaterialPropertyValueTempl<true>;

modules/tensor_mechanics/include/actions/TensorMechanicsAction.h

@@ -107,6 +107,7 @@ class TensorMechanicsAction : public TensorMechanicsActionBase
   bool _cylindrical_axis_point1_valid;
   bool _cylindrical_axis_point2_valid;
   bool _direction_valid;
+  bool _verbose;
 
   /// points used to determine axis of rotation for cyclindrical stress/strain quantities
   Point _cylindrical_axis_point1;

modules/tensor_mechanics/src/actions/TensorMechanicsAction.C

@@ -108,6 +108,7 @@ TensorMechanicsAction::TensorMechanicsAction(const InputParameters & params)
     _cylindrical_axis_point1_valid(params.isParamSetByUser("cylindrical_axis_point1")),
     _cylindrical_axis_point2_valid(params.isParamSetByUser("cylindrical_axis_point2")),
     _direction_valid(params.isParamSetByUser("direction")),
+    _verbose(getParam<bool>("verbose")),
     _auto_eigenstrain(getParam<bool>("automatic_eigenstrain_names"))
 {
   // determine if incremental strains are to be used
@@ -517,7 +518,17 @@ TensorMechanicsAction::actOutputGeneration()
         _problem->addAuxKernel(
             ad_prepend + "MaterialRealAux", _base_name + out + '_' + name(), params);
       }
-      else
+      index++;
+    }
+  }
+  else if (_current_task == "add_kernel")
+  {
+    std::string ad_prepend = _use_ad ? "AD" : "";
+    // Loop through output aux variables
+    unsigned int index = 0;
+    for (auto out : _generate_output)
+    {
+      if (_material_output_family[index] != "MONOMIAL")
       {
         InputParameters params = emptyInputParameters();
 
@@ -681,10 +692,11 @@ TensorMechanicsAction::verifyOrderAndFamilyOutputs()
     // For only one order, make all orders the same magnitude
     if (order_check.size() == 1)
       _material_output_order.assign(_generate_output.size(), _material_output_order[0]);
-    Moose::out << COLOR_CYAN << "*** Automatic applied material output orders ***"
-               << "\n"
-               << _name << ": " << Moose::stringify(_material_output_order) << "\n"
-               << COLOR_DEFAULT;
+    if (_verbose)
+      Moose::out << COLOR_CYAN << "*** Automatic applied material output orders ***"
+                 << "\n"
+                 << _name << ": " << Moose::stringify(_material_output_order) << "\n"
+                 << COLOR_DEFAULT;
   }
 
   if (family_check.size() == _generate_output.size())
@@ -698,10 +710,11 @@ TensorMechanicsAction::verifyOrderAndFamilyOutputs()
       _material_output_family.assign(_generate_output.size(), "MONOMIAL");
     if (family_check.size() == 1)
       _material_output_family.assign(_generate_output.size(), _material_output_family[0]);
-    Moose::out << COLOR_CYAN << "*** Automatic applied material output families ***"
-               << "\n"
-               << _name << ": " << Moose::stringify(_material_output_family) << "\n"
-               << COLOR_DEFAULT;
+    if (_verbose)
+      Moose::out << COLOR_CYAN << "*** Automatic applied material output families ***"
+                 << "\n"
+                 << _name << ": " << Moose::stringify(_material_output_family) << "\n"
+                 << COLOR_DEFAULT;
   }
 }
 
@@ -730,6 +743,7 @@ TensorMechanicsAction::actOutputMatProp()
               params.set<MaterialPropertyName>("rank_two_tensor") = _base_name + r2q.second;
               params.set<unsigned int>("index_i") = a;
               params.set<unsigned int>("index_j") = b;
+
               params.applyParameters(parameters());
               params.set<std::string>("property_name") = _base_name + out;
             }

modules/tensor_mechanics/src/actions/TensorMechanicsActionBase.C

@@ -153,6 +153,7 @@ TensorMechanicsActionBase::validParams()
       "Specifies the family of FE shape functions to use for this variable.");
   params.addParamNamesToGroup("generate_output material_output_order material_output_family",
                               "Output");
+  params.addParam<bool>("verbose", false, "Display extra information.");
 
   return params;
 }

modules/tensor_mechanics/test/tests/action/material_output_first_lagrange_manual.i

@@ -1,5 +1,4 @@
 # This input file is designed to test adding extra stress to ADComputeLinearElasticStress
-
 [Mesh]
   type = GeneratedMesh
   dim = 2

modules/tensor_mechanics/test/tests/action/tests

@@ -130,6 +130,7 @@
     type = RunApp
     input = 'material_output_order.i'
     expect_out = 'all: CONSTANT,CONSTANT,CONSTANT\n.*\nall: MONOMIAL,MONOMIAL,MONOMIAL\n'
+    cli_args ='Modules/TensorMechanics/Master/verbose=true'
     design = 'syntax/Modules/TensorMechanics/Master/index.md'
     requirement = 'The TensorMechanics MasterAction shall determine the necessary orders and families to apply to material outputs.'
   []
@@ -146,6 +147,8 @@
     type = Exodiff
     input = 'material_output_first_lagrange_manual.i'
     exodiff = 'material_output_first_lagrange_manual_out.e'
+    max_parallel = 1
+    max_threads = 1
     design = 'syntax/Modules/TensorMechanics/Master/index.md'
     requirement = 'The TensorMechanics MasterAction shall determine the necessary orders and families to apply to material outputs.'
   []