Merge pull request #28857 from GiudGiud/PR_lumped

Finish support for AD time derivatives of dofs

framework/include/interfaces/Coupleable.h

@@ -241,6 +241,28 @@ class Coupleable
   const GenericVariableValue<is_ad> & coupledGenericDofValue(const std::string & var_name,
                                                              unsigned int comp = 0) const;
 
+  /**
+   * Returns time derivative of a coupled variable for use in templated automatic differentiation
+   * classes
+   * @param var_name Name of coupled variable
+   * @param comp Component number for vector of coupled variables
+   * @return Reference to a GenericVariableValue for the coupled variable time derivative
+   */
+  template <bool is_ad>
+  const GenericVariableValue<is_ad> & coupledGenericDot(const std::string & var_name,
+                                                        unsigned int comp = 0) const;
+
+  /**
+   * Returns the second time derivative of a coupled variable for use in templated automatic
+   * differentiation classes
+   * @param var_name Name of coupled variable
+   * @param comp Component number for vector of coupled variables
+   * @return Reference to a GenericVariableValue for the coupled variable second time derivative
+   */
+  template <bool is_ad>
+  const GenericVariableValue<is_ad> & coupledGenericDotDot(const std::string & var_name,
+                                                           unsigned int comp = 0) const;
+
   /**
    * Returns value of a coupled lower-dimensional variable
    * @param var_name Name of coupled variable

framework/include/variables/MooseLinearVariableFV.h

@@ -404,6 +404,7 @@ class MooseLinearVariableFV : public MooseVariableField<OutputType>
 
   [[noreturn]] virtual const MooseArray<ADReal> & adDofValues() const override;
   [[noreturn]] virtual const MooseArray<ADReal> & adDofValuesNeighbor() const override;
+  [[noreturn]] virtual const MooseArray<ADReal> & adDofValuesDot() const override;
   [[noreturn]] virtual const dof_id_type & nodalDofIndex() const override final;
   [[noreturn]] virtual const dof_id_type & nodalDofIndexNeighbor() const override final;
 

framework/include/variables/MooseVariableData.h

@@ -428,6 +428,11 @@ class MooseVariableData : public MooseVariableDataBase<OutputType>
    */
   const MooseArray<ADReal> & adDofValues() const;
 
+  /**
+   * Return the AD time derivative values of degrees of freedom
+   */
+  const MooseArray<ADReal> & adDofValuesDot() const;
+
   /////////////////////////////// Increment stuff ///////////////////////////////////////
 
   /**
@@ -453,7 +458,7 @@ class MooseVariableData : public MooseVariableDataBase<OutputType>
    * for nodal basis families
    */
   void assignADNodalValue(const ADReal & value, const unsigned int & component);
-  void fetchADDoFValues();
+  void fetchADNodalValues();
 
   const FEType & _fe_type;
 
@@ -726,6 +731,17 @@ MooseVariableData<OutputType>::adDofValues() const
   return _ad_dof_values;
 }
 
+template <typename OutputType>
+const MooseArray<ADReal> &
+MooseVariableData<OutputType>::adDofValuesDot() const
+{
+  _need_ad = _need_ad_u_dot = true;
+  if (!_time_integrator)
+    // See explanation in adUDot() body
+    _need_u_dot = true;
+  return _ad_dofs_dot;
+}
+
 template <typename OutputType>
 const typename Moose::ADType<OutputType>::type &
 MooseVariableData<OutputType>::adNodalValue() const

framework/include/variables/MooseVariableDataFV.h

@@ -259,6 +259,11 @@ class MooseVariableDataFV : public MooseVariableDataBase<OutputType>, public Mes
    */
   const MooseArray<ADReal> & adDofValues() const;
 
+  /**
+   * Return the AD dof time derivatives
+   */
+  const MooseArray<ADReal> & adDofValuesDot() const;
+
   /////////////////////////////// Increment stuff ///////////////////////////////////////
 
   /**
@@ -473,6 +478,14 @@ MooseVariableDataFV<OutputType>::adDofValues() const
   return _ad_dof_values;
 }
 
+template <typename OutputType>
+const MooseArray<ADReal> &
+MooseVariableDataFV<OutputType>::adDofValuesDot() const
+{
+  _need_ad = _need_ad_u_dot = true;
+  return _ad_dofs_dot;
+}
+
 template <typename OutputType>
 inline bool
 MooseVariableDataFV<OutputType>::safeToComputeADUDot() const

framework/include/variables/MooseVariableFE.h

@@ -594,15 +594,9 @@ class MooseVariableFE : public MooseVariableField<OutputType>
   const MooseArray<Number> & dofValuesDuDotDotDu() const override;
   const MooseArray<Number> & dofValuesDuDotDotDuNeighbor() const override;
 
-  /**
-   * Return the AD dof values
-   */
   const MooseArray<ADReal> & adDofValues() const override;
-
-  /**
-   * Return the AD neignbor dof values
-   */
   const MooseArray<ADReal> & adDofValuesNeighbor() const override;
+  const MooseArray<ADReal> & adDofValuesDot() const override;
 
   /**
    * Compute and store incremental change in solution at QPs based on increment_vec
@@ -844,6 +838,13 @@ MooseVariableFE<OutputType>::adDofValuesNeighbor() const
   return _neighbor_data->adDofValues();
 }
 
+template <typename OutputType>
+inline const MooseArray<ADReal> &
+MooseVariableFE<OutputType>::adDofValuesDot() const
+{
+  return _element_data->adDofValuesDot();
+}
+
 template <typename OutputType>
 inline const typename Moose::ADType<OutputType>::type &
 MooseVariableFE<OutputType>::adNodalValue() const

framework/include/variables/MooseVariableFV.h

@@ -423,11 +423,9 @@ class MooseVariableFV : public MooseVariableField<OutputType>
   const MooseArray<Number> & dofValuesDuDotDotDu() const override;
   const MooseArray<Number> & dofValuesDuDotDotDuNeighbor() const override;
 
-  /// Returns the AD dof values.
   const MooseArray<ADReal> & adDofValues() const override;
-
-  /// Returns the AD neighbor dof values
   const MooseArray<ADReal> & adDofValuesNeighbor() const override;
+  const MooseArray<ADReal> & adDofValuesDot() const override;
 
   /// Note: const monomial is always the case - higher order solns are
   /// reconstructed - so this is simpler func than FE equivalent.
@@ -732,6 +730,13 @@ MooseVariableFV<OutputType>::adDofValuesNeighbor() const
   return _neighbor_data->adDofValues();
 }
 
+template <typename OutputType>
+inline const MooseArray<ADReal> &
+MooseVariableFV<OutputType>::adDofValuesDot() const
+{
+  return _element_data->adDofValuesDot();
+}
+
 template <typename OutputType>
 typename MooseVariableFV<OutputType>::ValueType
 MooseVariableFV<OutputType>::evaluate(const ElemArg & elem_arg, const StateArg & state) const

framework/include/variables/MooseVariableField.h

@@ -168,6 +168,11 @@ class MooseVariableField : public MooseVariableFieldBase,
    */
   virtual const MooseArray<ADReal> & adDofValuesNeighbor() const = 0;
 
+  /**
+   * Return the AD time derivatives at dofs
+   */
+  virtual const MooseArray<ADReal> & adDofValuesDot() const = 0;
+
   ///@{
   /**
    * Methods for retrieving values of variables at the nodes in a MooseArray for AuxKernelBase

framework/src/interfaces/Coupleable.C

@@ -1168,6 +1168,20 @@ Coupleable::coupledDotDot(const std::string & var_name, unsigned int comp) const
   }
 }
 
+template <>
+const GenericVariableValue<false> &
+Coupleable::coupledGenericDotDot<false>(const std::string & var_name, unsigned int comp) const
+{
+  return coupledDotDot(var_name, comp);
+}
+
+template <>
+const GenericVariableValue<true> &
+Coupleable::coupledGenericDotDot<true>(const std::string & var_name, unsigned int comp) const
+{
+  return adCoupledDotDot(var_name, comp);
+}
+
 const VariableValue &
 Coupleable::coupledDotOld(const std::string & var_name, unsigned int comp) const
 {
@@ -2207,12 +2221,18 @@ Coupleable::adCoupledDot(const std::string & var_name, unsigned int comp) const
     return *getADDefaultValue(var_name);
   checkFuncType(var_name, VarType::Dot, FuncAge::Curr);
 
-  if (_c_nodal)
-    mooseError("Not implemented");
-
   if (!_coupleable_neighbor)
+  {
+    if (_c_nodal)
+      return var->adDofValuesDot();
     return var->adUDot();
-  return var->adUDotNeighbor();
+  }
+  else
+  {
+    if (_c_nodal)
+      mooseError("AD neighbor nodal dof dot not implemented");
+    return var->adUDotNeighbor();
+  }
 }
 
 const ADVariableValue &
@@ -2687,6 +2707,20 @@ Coupleable::adCoupledDots(const std::string & var_name) const
   return coupledVectorHelper<const ADVariableValue *>(var_name, func);
 }
 
+template <>
+const GenericVariableValue<false> &
+Coupleable::coupledGenericDot<false>(const std::string & var_name, unsigned int comp) const
+{
+  return coupledDot(var_name, comp);
+}
+
+template <>
+const GenericVariableValue<true> &
+Coupleable::coupledGenericDot<true>(const std::string & var_name, unsigned int comp) const
+{
+  return adCoupledDot(var_name, comp);
+}
+
 // Explicit instantiations
 
 template const Real & Coupleable::getDefaultNodalValue<Real>(const std::string & var_name,

framework/src/timeintegrators/CentralDifference.C

@@ -46,6 +46,10 @@ CentralDifference::computeADTimeDerivatives(ADReal & ad_u_dot,
                                             const dof_id_type & dof,
                                             ADReal & ad_u_dotdot) const
 {
+  // Seeds ad_u_dotdot with _ad_dof_values and associated derivatives provided via ad_u_dot from
+  // MooseVariableData
+  ad_u_dotdot = ad_u_dot;
+
   computeTimeDerivativeHelper(ad_u_dot, ad_u_dotdot, _solution_old(dof), _solution_older(dof));
 }
 

framework/src/variables/MooseLinearVariableFV.C

@@ -851,6 +851,13 @@ MooseLinearVariableFV<OutputType>::adDofValuesNeighbor() const
   adError();
 }
 
+template <typename OutputType>
+const MooseArray<ADReal> &
+MooseLinearVariableFV<OutputType>::adDofValuesDot() const
+{
+  adError();
+}
+
 template <typename OutputType>
 const dof_id_type &
 MooseLinearVariableFV<OutputType>::nodalDofIndex() const

framework/src/variables/MooseVariableData.C

@@ -1149,7 +1149,7 @@ template <>
 void
 MooseVariableData<RealEigenVector>::computeMonomialValues()
 {
-  // Fixeme: will think of optimization later
+  // FIXME: will think of optimization later
   computeValues();
 }
 
@@ -1271,12 +1271,16 @@ MooseVariableData<OutputType>::computeAD(const unsigned int num_dofs, const unsi
   }
 
   if (_need_ad_u_dot && !_time_integrator)
+  {
     for (MooseIndex(nqp) qp = 0; qp < nqp; ++qp)
     {
       _ad_u_dot[qp] = _u_dot[qp];
       if (_need_ad_u_dotdot)
         _ad_u_dotdot[qp] = _u_dotdot[qp];
     }
+    for (unsigned int i = 0; i < num_dofs; i++)
+      _ad_dofs_dot[i] = _dof_values_dot[i];
+  }
 
   if (_need_ad_grad_u_dot && !_time_integrator)
     for (MooseIndex(nqp) qp = 0; qp < nqp; ++qp)
@@ -1771,20 +1775,25 @@ MooseVariableData<OutputType>::computeNodalValues()
     assignNodalValue();
 
     if (_need_ad)
-      fetchADDoFValues();
+      fetchADNodalValues();
   }
   else
     zeroSizeDofValues();
 }
 
 template <typename OutputType>
 void
-MooseVariableData<OutputType>::fetchADDoFValues()
+MooseVariableData<OutputType>::fetchADNodalValues()
 {
   auto n = _dof_indices.size();
   libmesh_assert(n);
   _ad_dof_values.resize(n);
 
+  if (_need_ad_u_dot)
+    _ad_dofs_dot.resize(n);
+  if (_need_ad_u_dotdot)
+    _ad_dofs_dotdot.resize(n);
+
   const bool do_derivatives =
       ADReal::do_derivatives && _sys.number() == _subproblem.currentNlSysNum();
 
@@ -1794,12 +1803,30 @@ MooseVariableData<OutputType>::fetchADDoFValues()
     if (do_derivatives)
       Moose::derivInsert(_ad_dof_values[i].derivatives(), _dof_indices[i], 1.);
     assignADNodalValue(_ad_dof_values[i], i);
+
+    if (_need_ad_u_dot)
+    {
+      if (_time_integrator && _time_integrator->dt())
+      {
+        _ad_dofs_dot[i] = _ad_dof_values[i];
+        _time_integrator->computeADTimeDerivatives(_ad_dofs_dot[i],
+                                                   _dof_indices[i],
+                                                   _need_ad_u_dotdot ? _ad_dofs_dotdot[i]
+                                                                     : _ad_real_dummy);
+      }
+      // Executing something with a time derivative at initial should not put a NaN
+      else if (_time_integrator && !_time_integrator->dt())
+        _ad_dofs_dot[i] = 0;
+      else
+        mooseError("AD nodal time derivatives not implemented for variables without a time "
+                   "integrator (auxiliary variables)");
+    }
   }
 }
 
 template <>
 void
-MooseVariableData<RealEigenVector>::fetchADDoFValues()
+MooseVariableData<RealEigenVector>::fetchADNodalValues()
 {
   mooseError("I do not know how to support AD with array variables");
 }

framework/src/variables/MooseVariableDataFV.C

@@ -50,9 +50,9 @@ MooseVariableDataFV<OutputType>::MooseVariableDataFV(const MooseVariableFV<Outpu
     _need_curl_old(false),
     _need_curl_older(false),
     // for FV variables, they use each other's ad_u values to compute ghost cell
-    // values - we don't have any way to propogate these inter-variable-data
+    // values - we don't have any way to propagate these inter-variable-data
     // dependencies. So if something needs an ad_u value, that need isn't
-    // propogated through to both the element and the neighbor
+    // propagated through to both the element and the neighbor
     // data structures. So instead just set _need_ad+_need_ad_u values to true always.
     _need_ad(true),
     _need_ad_u(true),

test/include/auxkernels/DotCouplingAux.h

@@ -14,16 +14,19 @@
 /**
  * Couples in the time derivatives of a NL variable
  */
-class DotCouplingAux : public AuxKernel
+template <bool is_ad>
+class DotCouplingAuxTempl : public AuxKernel
 {
 public:
   static InputParameters validParams();
 
-  DotCouplingAux(const InputParameters & parameters);
-  virtual ~DotCouplingAux();
+  DotCouplingAuxTempl(const InputParameters & parameters);
 
 protected:
   virtual Real computeValue();
 
-  const VariableValue & _v_dot;
+  const GenericVariableValue<is_ad> & _v_dot;
 };
+
+typedef DotCouplingAuxTempl<false> DotCouplingAux;
+typedef DotCouplingAuxTempl<true> ADDotCouplingAux;