Merge pull request idaholab#29580 from hugary1995/neml2_v2

NEML2 submodule update. This update brings out-of-place evaluation, JIT, along with various other improvements and bug fixes to MOOSE. Most notably, the NEML2 Action in MOOSE has been significantly improved to simplify model setup and allow block restriction.

framework/doc/content/source/materials/GenericConstantRealVectorValue.md

@@ -0,0 +1,24 @@
+# GenericConstantRealVectorValue
+
+!syntax description /Materials/GenericConstantRealVectorValue
+
+## Overview
+
+`GenericConstantRealVectorValue` creates a `RealVectorValue` material property that use
+constant values to fill the value.
+
+This can be used to quickly create simple constant 3-vector properties, for testing,
+for initial survey of a problem or simply because the material properties do not vary much over the
+domain explored by the simulation.
+
+The AD counterpart `ADGenericConstantRealVectorValue` creates a `ADRealVectorValue` material property.
+
+## Example Input File Syntax
+
+!listing test/tests/materials/generic_materials/generic_constant_real_vector_value.i block=Materials/vector
+
+!syntax parameters /Materials/GenericConstantRealVectorValue
+
+!syntax inputs /Materials/GenericConstantRealVectorValue
+
+!syntax children /Materials/GenericConstantRealVectorValue

framework/include/materials/GenericConstantRealVectorValue.h

@@ -0,0 +1,34 @@
+//* 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 "Material.h"
+
+/**
+ * Declares a constant material property of type RealVectorValue.
+ */
+template <bool is_ad>
+class GenericConstantRealVectorValueTempl : public Material
+{
+public:
+  static InputParameters validParams();
+
+  GenericConstantRealVectorValueTempl(const InputParameters & parameters);
+
+protected:
+  virtual void initQpStatefulProperties() override;
+  virtual void computeQpProperties() override;
+
+  const RealVectorValue _vector;
+  GenericMaterialProperty<RealVectorValue, is_ad> & _prop;
+};
+
+typedef GenericConstantRealVectorValueTempl<false> GenericConstantRealVectorValue;
+typedef GenericConstantRealVectorValueTempl<true> ADGenericConstantRealVectorValue;

framework/include/utils/MooseArray.h

@@ -173,10 +173,13 @@ class MooseArray
    */
   std::vector<T> stdVector() const;
 
+  ///@{
   /**
    * Reference to first element of array
    */
   const T * data() const { return _data; }
+  T * data() { return _data; }
+  ///@}
 
 private:
   /// Smart pointer storage

framework/include/utils/RankFourTensor.h

@@ -201,7 +201,7 @@ class RankFourTensorTempl
   void printReal(std::ostream & stm = Moose::out) const;
 
   /// copies values from a into this tensor
-  RankFourTensorTempl<T> & operator=(const RankFourTensorTempl<T> & a);
+  RankFourTensorTempl<T> & operator=(const RankFourTensorTempl<T> & a) = default;
 
   /**
    * Assignment-from-scalar operator.  Used only to zero out the tensor.

framework/include/utils/RankFourTensorImplementation.h

@@ -120,15 +120,6 @@ RankFourTensorTempl<T>::zero()
     _vals[i] = 0.0;
 }
 
-template <typename T>
-RankFourTensorTempl<T> &
-RankFourTensorTempl<T>::operator=(const RankFourTensorTempl<T> & a)
-{
-  for (auto i : make_range(N4))
-    _vals[i] = a._vals[i];
-  return *this;
-}
-
 template <typename T>
 template <template <typename> class Tensor, typename T2>
 auto

framework/include/utils/RankTwoTensor.h

@@ -497,7 +497,7 @@ class RankTwoTensorTempl : public libMesh::TensorValue<T>
    * //       7 4 1 ]
    * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    */
-  RankTwoTensorTempl<T> & operator=(const RankTwoTensorTempl<T> & a);
+  RankTwoTensorTempl<T> & operator=(const RankTwoTensorTempl<T> & a) = default;
 
   /**
    * @brief Assignment operator (from a ColumnMajorMatrixTempl<T>)

framework/include/utils/RankTwoTensorImplementation.h

@@ -369,14 +369,6 @@ RankTwoTensorTempl<T>::transpose() const
   return libMesh::TensorValue<T>::transpose();
 }
 
-template <typename T>
-RankTwoTensorTempl<T> &
-RankTwoTensorTempl<T>::operator=(const RankTwoTensorTempl<T> & a)
-{
-  libMesh::TensorValue<T>::operator=(a);
-  return *this;
-}
-
 template <typename T>
 RankTwoTensorTempl<T> &
 RankTwoTensorTempl<T>::operator+=(const RankTwoTensorTempl<T> & a)

framework/include/utils/SymmetricRankFourTensor.h

@@ -189,7 +189,7 @@ class SymmetricRankFourTensorTempl
   void printReal(std::ostream & stm = Moose::out) const;
 
   /// copies values from a into this tensor
-  SymmetricRankFourTensorTempl<T> & operator=(const SymmetricRankFourTensorTempl<T> & a);
+  SymmetricRankFourTensorTempl<T> & operator=(const SymmetricRankFourTensorTempl<T> & a) = default;
 
   /**
    * Assignment-from-scalar operator.  Used only to zero out the tensor.

framework/include/utils/SymmetricRankFourTensorImplementation.h

@@ -159,14 +159,6 @@ SymmetricRankFourTensorTempl<T>::rotate(const TypeTensor<T> & R)
   (*this) = M * (*this) * M.transposeMajor();
 }
 
-template <typename T>
-SymmetricRankFourTensorTempl<T> &
-SymmetricRankFourTensorTempl<T>::operator=(const SymmetricRankFourTensorTempl<T> & a)
-{
-  std::copy(a._vals.begin(), a._vals.end(), _vals.begin());
-  return *this;
-}
-
 template <typename T>
 SymmetricRankFourTensorTempl<T> &
 SymmetricRankFourTensorTempl<T>::operator*=(const T & a)

framework/src/materials/GenericConstantRealVectorValue.C

@@ -0,0 +1,53 @@
+//* 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
+
+#include "GenericConstantRealVectorValue.h"
+
+registerMooseObject("MooseApp", GenericConstantRealVectorValue);
+registerMooseObject("MooseApp", ADGenericConstantRealVectorValue);
+
+template <bool is_ad>
+InputParameters
+GenericConstantRealVectorValueTempl<is_ad>::validParams()
+{
+  InputParameters params = Material::validParams();
+  params.addClassDescription("Object for declaring a constant 3-vector as a material property.");
+  params.addRequiredParam<RealVectorValue>("vector_values", "Values defining the constant vector");
+  params.addRequiredParam<MaterialPropertyName>(
+      "vector_name", "Name of the vector material property to be created");
+  params.set<MooseEnum>("constant_on") = "SUBDOMAIN";
+  return params;
+}
+
+template <bool is_ad>
+GenericConstantRealVectorValueTempl<is_ad>::GenericConstantRealVectorValueTempl(
+    const InputParameters & parameters)
+  : Material(parameters),
+    _vector(getParam<RealVectorValue>("vector_values")),
+    _prop(declareGenericProperty<RealVectorValue, is_ad>(
+        getParam<MaterialPropertyName>("vector_name")))
+{
+}
+
+template <bool is_ad>
+void
+GenericConstantRealVectorValueTempl<is_ad>::initQpStatefulProperties()
+{
+  GenericConstantRealVectorValueTempl<is_ad>::computeQpProperties();
+}
+
+template <bool is_ad>
+void
+GenericConstantRealVectorValueTempl<is_ad>::computeQpProperties()
+{
+  _prop[_qp] = _vector;
+}
+
+template class GenericConstantRealVectorValueTempl<false>;
+template class GenericConstantRealVectorValueTempl<true>;

modules/combined/test/tests/optimization/invOpt_elasticity_modular/elasticity.i

@@ -1,14 +1,14 @@
 [Models]
   [adjoint_elasticity_model]
     type = LinearIsotropicElasticity
-    youngs_modulus = 5.0
-    poisson_ratio = 0.3
+    coefficients = '5.0 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     strain = 'forces/E'
   []
   [forward_elasticity_model]
     type = LinearIsotropicElasticity
-    youngs_modulus = 5.0
-    poisson_ratio = 0.3
+    coefficients = '5.0 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     strain = 'forces/E'
   []
 []

modules/combined/test/tests/optimization/invOpt_elasticity_modular/grad.i

@@ -69,7 +69,6 @@
   verbose = true
   device = 'cpu'
   [forward]
-    enable_AD = true
     model = 'forward_elasticity_model'
 
     moose_input_types = 'MATERIAL'

modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianCauchyCustomStress.md

@@ -0,0 +1,9 @@
+# ComputeLagrangianCauchyCustomStress
+
+Wrapper for constitutive model with a user-defined Cauchy stress and Cauchy stress Jacobian, useful for coupling with 3rd party libraries which define custom stress-strain relations.
+
+!syntax description /Materials/ComputeLagrangianCauchyCustomStress
+
+!syntax parameters /Materials/ComputeLagrangianCauchyCustomStress
+
+!syntax inputs /Materials/ComputeLagrangianCauchyCustomStress

modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianObjectiveCustomStress.md

@@ -1,23 +1,9 @@
 # ComputeLagrangianObjectiveCustomSymmetricStress
 
-!alert construction title=Undocumented Class
-The ComputeLagrangianObjectiveCustomSymmetricStress has not been documented. The content listed below should be used as a starting point for
-documenting the class, which includes the typical automatic documentation associated with a
-MooseObject; however, what is contained is ultimately determined by what is necessary to make the
-documentation clear for users.
+Objectively integrated constitutive model with a user-defined small stress and small stress Jacobian, useful for coupling with 3rd party libraries which define custom stress-strain relations.
 
 !syntax description /Materials/ComputeLagrangianObjectiveCustomSymmetricStress
 
-## Overview
-
-!! Replace these lines with information regarding the ComputeLagrangianObjectiveCustomSymmetricStress object.
-
-## Example Input File Syntax
-
-!! Describe and include an example of how to use the ComputeLagrangianObjectiveCustomSymmetricStress object.
-
 !syntax parameters /Materials/ComputeLagrangianObjectiveCustomSymmetricStress
 
 !syntax inputs /Materials/ComputeLagrangianObjectiveCustomSymmetricStress
-
-!syntax children /Materials/ComputeLagrangianObjectiveCustomSymmetricStress

modules/solid_mechanics/include/materials/lagrangian/ComputeLagrangianCauchyCustomStress.h

@@ -0,0 +1,30 @@
+//* 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 "ComputeLagrangianStressCauchy.h"
+#include "DerivativeMaterialPropertyNameInterface.h"
+
+/// Provide the Cauchy stress and jacobian directly
+///
+class ComputeLagrangianCauchyCustomStress : public ComputeLagrangianStressCauchy,
+                                            public DerivativeMaterialPropertyNameInterface
+{
+public:
+  static InputParameters validParams();
+  ComputeLagrangianCauchyCustomStress(const InputParameters & parameters);
+
+protected:
+  /// Implement the copy
+  virtual void computeQpCauchyStress() override;
+
+  const MaterialProperty<RankTwoTensor> & _custom_stress;
+  const MaterialProperty<RankFourTensor> & _custom_jacobian;
+};

modules/solid_mechanics/include/materials/lagrangian/ComputeLagrangianStrainBase.h

@@ -88,6 +88,9 @@ class ComputeLagrangianStrainBase : public Material, public G
   /// Strain increment
   MaterialProperty<RankTwoTensor> & _strain_increment;
 
+  /// Spatial velocity gradient increment
+  MaterialProperty<RankTwoTensor> & _spatial_velocity_increment;
+
   /// Vorticity increment
   MaterialProperty<RankTwoTensor> & _vorticity_increment;
 

modules/solid_mechanics/include/neml2/actions/NEML2Action.h

@@ -15,6 +15,8 @@
 
 #include "Action.h"
 
+class NEML2ActionCommon;
+
 /**
  * Action to set up NEML2 objects.
  */
@@ -28,6 +30,8 @@ class NEML2Action : public Action
   virtual void act() override;
 
 protected:
+  const NEML2ActionCommon & getCommonAction() const;
+
 #ifdef NEML2_ENABLED
 
   enum class MOOSEIOType
@@ -130,6 +134,37 @@ class NEML2Action : public Action
   /// Blocks this sub-block action applies to
   const std::vector<SubdomainName> _block;
 
+  /// Material property initial conditions
+  std::map<MaterialPropertyName, MaterialPropertyName> _initialize_output_values;
+
   /// Material property additional outputs
   std::map<MaterialPropertyName, std::vector<OutputName>> _export_output_targets;
+
+private:
+#ifdef NEML2_ENABLED
+  /// Get parameter lists for mapping between MOOSE and NEML2 quantities
+  template <typename EnumType, typename T1, typename T2>
+  std::tuple<std::vector<EnumType>, std::vector<T1>, std::vector<T2>>
+  getInputParameterMapping(const std::string & moose_type_opt,
+                           const std::string & moose_name_opt,
+                           const std::string & neml2_name_opt) const
+  {
+    const auto moose_types = getParam<MultiMooseEnum>(moose_type_opt).getSetValueIDs<EnumType>();
+    const auto moose_names = getParam<std::vector<T1>>(moose_name_opt);
+    const auto neml2_names = getParam<std::vector<T2>>(neml2_name_opt);
+
+    if (moose_types.size() != moose_names.size())
+      paramError(moose_name_opt, moose_name_opt, " must have the same length as ", moose_type_opt);
+    if (moose_names.size() != neml2_names.size())
+      paramError(moose_name_opt, moose_name_opt, " must have the same length as ", neml2_name_opt);
+
+    return {moose_types, moose_names, neml2_names};
+  }
+
+  /// Print a summary of the NEML2 model
+  void printSummary(const neml2::Model &) const;
+#endif
+
+  /// Get the maximum length of all MOOSE names (for printing purposes)
+  std::size_t getLongestMOOSEName() const;
 };

modules/solid_mechanics/include/neml2/actions/NEML2ActionCommon.h

@@ -47,13 +47,19 @@ class NEML2ActionCommon : public Action
   /// Parameters that can be specified EITHER under the common area OR under sub-blocks
   static InputParameters commonParams();
 
+  /// Parameters that can ONLY be specified under the common area
   static InputParameters validParams();
 
   NEML2ActionCommon(const InputParameters &);
 
   virtual void act() override;
 
+  const FileName & fname() const { return _fname; }
+
 protected:
   /// Name of the NEML2 input file
   const FileName _fname;
+
+  /// List of cli-args
+  const std::vector<std::string> _cli_args;
 };

modules/solid_mechanics/include/neml2/interfaces/MOOSEToNEML2.h

@@ -13,7 +13,6 @@
 #include "InputParameters.h"
 
 #ifdef NEML2_ENABLED
-#include "neml2/tensors/LabeledVector.h"
 #include "neml2/models/Model.h"
 #endif
 
@@ -70,7 +69,7 @@ class MOOSEToNEML2
   virtual neml2::Tensor gatheredData() const = 0;
 
   /// Insert the gathered data into the NEML2 material model
-  void insertInto(neml2::Model &) const;
+  void insertInto(neml2::ValueMap &, std::map<std::string, neml2::Tensor> &) const;
 
 protected:
   /// Whether we should insert into NEML2 input variable or NEML2 model parameter