From 1585b08fc19021649ba7cf66c493201d2ac9a284 Mon Sep 17 00:00:00 2001
From: Gary Hu <thu@anl.gov>
Date: Wed, 18 Dec 2024 08:35:18 -0600
Subject: [PATCH 01/11] NEML2 submodule update

- Update neml2 submodule
- Remove dependency on LabeledTensor
- Update all neml2 models
- Update all moose-neml2 input files
- Attempted to speedup data transfer between moose and neml2
- Make moose data types trivially copyable
- Add a neml2 crystal plasticity example
- Add ability to initialize neml2 variables in neml2 action

ref #29579
---
 .../GenericConstantRealVectorValue.h          |  34 +++
 framework/include/utils/MooseArray.h          |   3 +
 framework/include/utils/RankFourTensor.h      |   2 +-
 .../utils/RankFourTensorImplementation.h      |   9 -
 framework/include/utils/RankTwoTensor.h       |   2 +-
 .../utils/RankTwoTensorImplementation.h       |   8 -
 .../include/utils/SymmetricRankFourTensor.h   |   2 +-
 .../SymmetricRankFourTensorImplementation.h   |   8 -
 .../GenericConstantRealVectorValue.C          |  53 ++++
 .../invOpt_elasticity_modular/elasticity.i    |   8 +-
 .../invOpt_elasticity_modular/grad.i          |   1 -
 modules/solid_mechanics/contrib/neml2         |   2 +-
 .../ComputeLagrangianCauchyCustomStress.h     |  30 ++
 .../lagrangian/ComputeLagrangianStrainBase.h  |   3 +
 .../include/neml2/actions/NEML2Action.h       |  33 +++
 .../include/neml2/actions/NEML2ActionCommon.h |   6 +
 .../include/neml2/interfaces/MOOSEToNEML2.h   |   3 +-
 .../neml2/interfaces/NEML2ModelInterface.h    |  41 +--
 .../materials/NEML2ToMOOSEMaterialProperty.h  |  10 +-
 .../MOOSEMaterialPropertyToNEML2.h            |   6 +-
 .../neml2/userobjects/MOOSEToNEML2Batched.h   |  82 +++++-
 .../neml2/userobjects/MOOSEVariableToNEML2.h  |   4 +-
 .../neml2/userobjects/NEML2ModelExecutor.h    |  38 ++-
 .../include/neml2/utils/NEML2Utils.h          | 222 ++++++--------
 .../ComputeLagrangianCauchyCustomStress.C     |  42 +++
 .../lagrangian/ComputeLagrangianStrainBase.C  |   5 +
 .../src/neml2/actions/NEML2Action.C           | 271 +++++++++++-------
 .../src/neml2/actions/NEML2ActionCommon.C     |  39 ++-
 .../src/neml2/interfaces/MOOSEToNEML2.C       |   9 +-
 .../materials/NEML2ToMOOSEMaterialProperty.C  |  47 +--
 .../MOOSEMaterialPropertyToNEML2.C            |  21 +-
 .../userobjects/MOOSEPostprocessorToNEML2.C   |   2 +-
 .../neml2/userobjects/MOOSEToNEML2Batched.C   |  60 ----
 .../neml2/userobjects/MOOSEVariableToNEML2.C  |   9 -
 .../neml2/userobjects/NEML2ModelExecutor.C    | 146 +++++-----
 .../src/neml2/utils/NEML2Utils.C              | 124 +-------
 .../test/neml2/include/NEML2TestModel.h       |   2 +
 .../test/neml2/src/NEML2TestModel.cxx         |  13 +-
 .../test/tests/neml2/crystal_plasticity.i     | 118 ++++++++
 .../test/tests/neml2/custom_model.i           |   1 -
 .../tests/neml2/gold/crystal_plasticity.e     | Bin 0 -> 77488 bytes
 .../tests/neml2/models/crystal_plasticity.i   | 128 +++++++++
 .../test/tests/neml2/models/elasticity.i      |   4 +-
 .../test/tests/neml2/models/elasticity_2.i    |   8 +-
 .../test/tests/neml2/models/error.i           |   4 +-
 .../rate_independent_plasticity_isoharden.i   |   4 +-
 ...rate_independent_plasticity_isokinharden.i |   4 +-
 .../rate_independent_plasticity_kinharden.i   |   4 +-
 .../rate_independent_plasticity_perfect.i     |   4 +-
 .../neml2/models/viscoplasticity_chaboche.i   |   4 +-
 .../neml2/models/viscoplasticity_isoharden.i  |   4 +-
 .../models/viscoplasticity_isokinharden.i     |   4 +-
 .../neml2/models/viscoplasticity_kinharden.i  |   4 +-
 .../neml2/models/viscoplasticity_perfect.i    |   4 +-
 .../models/viscoplasticity_radial_return.i    |   8 +-
 .../solid_mechanics/test/tests/neml2/tests    |  10 +
 .../solid_mechanics/unit/src/NEML2UtilsTest.C | 174 +++++++++++
 57 files changed, 1209 insertions(+), 682 deletions(-)
 create mode 100644 framework/include/materials/GenericConstantRealVectorValue.h
 create mode 100644 framework/src/materials/GenericConstantRealVectorValue.C
 create mode 100644 modules/solid_mechanics/include/materials/lagrangian/ComputeLagrangianCauchyCustomStress.h
 create mode 100644 modules/solid_mechanics/src/materials/lagrangian/ComputeLagrangianCauchyCustomStress.C
 delete mode 100644 modules/solid_mechanics/src/neml2/userobjects/MOOSEToNEML2Batched.C
 create mode 100644 modules/solid_mechanics/test/tests/neml2/crystal_plasticity.i
 create mode 100644 modules/solid_mechanics/test/tests/neml2/gold/crystal_plasticity.e
 create mode 100644 modules/solid_mechanics/test/tests/neml2/models/crystal_plasticity.i
 create mode 100644 modules/solid_mechanics/unit/src/NEML2UtilsTest.C

diff --git a/framework/include/materials/GenericConstantRealVectorValue.h b/framework/include/materials/GenericConstantRealVectorValue.h
new file mode 100644
index 000000000000..97accfb9d4ac
--- /dev/null
+++ b/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;
diff --git a/framework/include/utils/MooseArray.h b/framework/include/utils/MooseArray.h
index 1d4941628bfa..ebde89e93773 100644
--- a/framework/include/utils/MooseArray.h
+++ b/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
diff --git a/framework/include/utils/RankFourTensor.h b/framework/include/utils/RankFourTensor.h
index b930eae69105..350b730bf031 100644
--- a/framework/include/utils/RankFourTensor.h
+++ b/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.
diff --git a/framework/include/utils/RankFourTensorImplementation.h b/framework/include/utils/RankFourTensorImplementation.h
index a5cd05461db0..06bb326ba52e 100644
--- a/framework/include/utils/RankFourTensorImplementation.h
+++ b/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
diff --git a/framework/include/utils/RankTwoTensor.h b/framework/include/utils/RankTwoTensor.h
index 3c0caf5afbb6..66e5e6f961eb 100644
--- a/framework/include/utils/RankTwoTensor.h
+++ b/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>)
diff --git a/framework/include/utils/RankTwoTensorImplementation.h b/framework/include/utils/RankTwoTensorImplementation.h
index 27563a0e9106..b69ac378a50e 100644
--- a/framework/include/utils/RankTwoTensorImplementation.h
+++ b/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)
diff --git a/framework/include/utils/SymmetricRankFourTensor.h b/framework/include/utils/SymmetricRankFourTensor.h
index 7878acd7014e..c17ddd0c96c2 100644
--- a/framework/include/utils/SymmetricRankFourTensor.h
+++ b/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.
diff --git a/framework/include/utils/SymmetricRankFourTensorImplementation.h b/framework/include/utils/SymmetricRankFourTensorImplementation.h
index 7a47d67790d4..e0004be3b9f3 100644
--- a/framework/include/utils/SymmetricRankFourTensorImplementation.h
+++ b/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)
diff --git a/framework/src/materials/GenericConstantRealVectorValue.C b/framework/src/materials/GenericConstantRealVectorValue.C
new file mode 100644
index 000000000000..41cc7667dccf
--- /dev/null
+++ b/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>;
diff --git a/modules/combined/test/tests/optimization/invOpt_elasticity_modular/elasticity.i b/modules/combined/test/tests/optimization/invOpt_elasticity_modular/elasticity.i
index bfc34feabece..c40702f52d9a 100644
--- a/modules/combined/test/tests/optimization/invOpt_elasticity_modular/elasticity.i
+++ b/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'
   []
 []
diff --git a/modules/combined/test/tests/optimization/invOpt_elasticity_modular/grad.i b/modules/combined/test/tests/optimization/invOpt_elasticity_modular/grad.i
index b02824f7b7e8..2f9b40927c5d 100644
--- a/modules/combined/test/tests/optimization/invOpt_elasticity_modular/grad.i
+++ b/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'
diff --git a/modules/solid_mechanics/contrib/neml2 b/modules/solid_mechanics/contrib/neml2
index 91c735e9d92e..f0891dce8016 160000
--- a/modules/solid_mechanics/contrib/neml2
+++ b/modules/solid_mechanics/contrib/neml2
@@ -1 +1 @@
-Subproject commit 91c735e9d92e1c101bb4af2ec89fed5666402eb7
+Subproject commit f0891dce80164f55cbb38a640bd85527599430c9
diff --git a/modules/solid_mechanics/include/materials/lagrangian/ComputeLagrangianCauchyCustomStress.h b/modules/solid_mechanics/include/materials/lagrangian/ComputeLagrangianCauchyCustomStress.h
new file mode 100644
index 000000000000..37a8b935595f
--- /dev/null
+++ b/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;
+};
diff --git a/modules/solid_mechanics/include/materials/lagrangian/ComputeLagrangianStrainBase.h b/modules/solid_mechanics/include/materials/lagrangian/ComputeLagrangianStrainBase.h
index 11e4df4bd258..a3fd4a6514f0 100644
--- a/modules/solid_mechanics/include/materials/lagrangian/ComputeLagrangianStrainBase.h
+++ b/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;
 
diff --git a/modules/solid_mechanics/include/neml2/actions/NEML2Action.h b/modules/solid_mechanics/include/neml2/actions/NEML2Action.h
index db156e989ab8..edaf5a25969f 100644
--- a/modules/solid_mechanics/include/neml2/actions/NEML2Action.h
+++ b/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,35 @@ 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:
+  /// 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;
+
+  /// Get the maximum length of all MOOSE names (for printing purposes)
+  std::size_t getLongestMOOSEName() const;
 };
diff --git a/modules/solid_mechanics/include/neml2/actions/NEML2ActionCommon.h b/modules/solid_mechanics/include/neml2/actions/NEML2ActionCommon.h
index acc6840c91e7..67d198a59913 100644
--- a/modules/solid_mechanics/include/neml2/actions/NEML2ActionCommon.h
+++ b/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;
 };
diff --git a/modules/solid_mechanics/include/neml2/interfaces/MOOSEToNEML2.h b/modules/solid_mechanics/include/neml2/interfaces/MOOSEToNEML2.h
index 1ce75f9a2e56..6ca535548a0c 100644
--- a/modules/solid_mechanics/include/neml2/interfaces/MOOSEToNEML2.h
+++ b/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
diff --git a/modules/solid_mechanics/include/neml2/interfaces/NEML2ModelInterface.h b/modules/solid_mechanics/include/neml2/interfaces/NEML2ModelInterface.h
index ff7ed5c37204..7116ce7fe559 100644
--- a/modules/solid_mechanics/include/neml2/interfaces/NEML2ModelInterface.h
+++ b/modules/solid_mechanics/include/neml2/interfaces/NEML2ModelInterface.h
@@ -9,6 +9,8 @@
 
 #pragma once
 
+#include "NEML2Utils.h"
+
 #ifdef NEML2_ENABLED
 #include "neml2/models/Model.h"
 #include "neml2/misc/parser_utils.h"
@@ -16,8 +18,6 @@
 #include "UserObject.h"
 #endif
 
-#include "NEML2Utils.h"
-
 /**
  * Interface class to provide common input parameters, members, and methods for MOOSEObjects that
  * use NEML2 models.
@@ -35,29 +35,17 @@ class NEML2ModelInterface : public T
 
 protected:
   /**
-   * Validate the NEML2 material model. This method should throw a moose error with the first
-   * encountered problem. Note that the developer is responsible for calling this method at the
-   * appropriate times, for example, at initialSetup().
+   * Validate the NEML2 material model. Note that the developer is responsible for calling this
+   * method at the appropriate times, for example, at initialSetup().
    */
   virtual void validateModel() const;
 
-  /// Initialize the model with a batch shape
-  void initModel(neml2::TensorShapeRef batch_shape);
-
   /// Get the NEML2 model
   neml2::Model & model() const { return _model; }
 
   /// Get the target compute device
   const torch::Device & device() const { return _device; }
 
-  /**
-   * @brief Convert a raw string to a neml2::VariableName
-   *
-   * @param raw_str
-   * @return neml2::VariableName
-   */
-  neml2::VariableName getNEML2VariableName(const std::string & raw_str) const;
-
 private:
   /// The NEML2 material model
   neml2::Model & _model;
@@ -86,11 +74,6 @@ NEML2ModelInterface<T>::validParams()
       ":<device-index> optionally specifies a device index. For example, device='cpu' sets the "
       "target compute device to be CPU, and device='cuda:1' sets the target compute device to be "
       "CUDA with device ID 1.");
-  params.addParam<bool>("enable_AD",
-                        false,
-                        "Set to true to enable PyTorch AD. When set to false (default), no "
-                        "function graph or gradient is computed, which speeds up model "
-                        "evaluation.");
   return params;
 }
 
@@ -109,7 +92,7 @@ template <class T>
 template <typename... P>
 NEML2ModelInterface<T>::NEML2ModelInterface(const InputParameters & params, P &&... args)
   : T(params, args...),
-    _model(neml2::get_model(params.get<std::string>("model"), params.get<bool>("enable_AD"))),
+    _model(neml2::get_model(params.get<std::string>("model"))),
     _device(params.get<std::string>("device"))
 {
 }
@@ -121,18 +104,4 @@ NEML2ModelInterface<T>::validateModel() const
   neml2::diagnose(_model);
 }
 
-template <class T>
-void
-NEML2ModelInterface<T>::initModel(neml2::TensorShapeRef batch_shape)
-{
-  _model.reinit(batch_shape, /*deriv_order=*/1, _device, /*dtype=*/torch::kFloat64);
-}
-
-template <class T>
-neml2::VariableName
-NEML2ModelInterface<T>::getNEML2VariableName(const std::string & raw_str) const
-{
-  return neml2::utils::parse<neml2::VariableName>(raw_str);
-}
-
 #endif // NEML2_ENABLED
diff --git a/modules/solid_mechanics/include/neml2/materials/NEML2ToMOOSEMaterialProperty.h b/modules/solid_mechanics/include/neml2/materials/NEML2ToMOOSEMaterialProperty.h
index 98421b5ae770..d3c92d528d99 100644
--- a/modules/solid_mechanics/include/neml2/materials/NEML2ToMOOSEMaterialProperty.h
+++ b/modules/solid_mechanics/include/neml2/materials/NEML2ToMOOSEMaterialProperty.h
@@ -32,7 +32,7 @@ class NEML2ToMOOSEMaterialProperty : public Material
   void computeProperties() override;
 
 protected:
-  void initQpStatefulProperties() override;
+  void initQpStatefulProperties() override {}
 
   /// User object managing the execution of the NEML2 model
   const NEML2ModelExecutor & _execute_neml2_model;
@@ -43,8 +43,8 @@ class NEML2ToMOOSEMaterialProperty : public Material
   /// Initial condition
   const MaterialProperty<T> * _prop0;
 
-  /// labled view to the requested output (or its derivative)
-  const neml2::Tensor & _output_view;
+  /// Reference to the requested output (or its derivative) value
+  const neml2::Tensor & _value;
 #endif
 };
 
@@ -54,4 +54,6 @@ class NEML2ToMOOSEMaterialProperty : public Material
 DefineNEML2ToMOOSEMaterialPropertyAlias(Real, Real);
 DefineNEML2ToMOOSEMaterialPropertyAlias(SymmetricRankTwoTensor, SymmetricRankTwoTensor);
 DefineNEML2ToMOOSEMaterialPropertyAlias(SymmetricRankFourTensor, SymmetricRankFourTensor);
-DefineNEML2ToMOOSEMaterialPropertyAlias(std::vector<Real>, StdVector);
+DefineNEML2ToMOOSEMaterialPropertyAlias(RealVectorValue, RealVectorValue);
+DefineNEML2ToMOOSEMaterialPropertyAlias(RankTwoTensor, RankTwoTensor);
+DefineNEML2ToMOOSEMaterialPropertyAlias(RankFourTensor, RankFourTensor);
diff --git a/modules/solid_mechanics/include/neml2/userobjects/MOOSEMaterialPropertyToNEML2.h b/modules/solid_mechanics/include/neml2/userobjects/MOOSEMaterialPropertyToNEML2.h
index ad515c1e07d6..ede0196eb02d 100644
--- a/modules/solid_mechanics/include/neml2/userobjects/MOOSEMaterialPropertyToNEML2.h
+++ b/modules/solid_mechanics/include/neml2/userobjects/MOOSEMaterialPropertyToNEML2.h
@@ -18,7 +18,7 @@
  * Gather a MOOSE material property for insertion into the NEML2 model.
  */
 template <typename T, unsigned int state>
-class MOOSEMaterialPropertyToNEML2 : public MOOSEToNEML2Batched
+class MOOSEMaterialPropertyToNEML2 : public MOOSEToNEML2Batched<T>
 {
 public:
   static InputParameters validParams();
@@ -27,7 +27,7 @@ class MOOSEMaterialPropertyToNEML2 : public MOOSEToNEML2Batched
 
 #ifdef NEML2_ENABLED
 protected:
-  torch::Tensor convertQpMOOSEData() const override;
+  const MooseArray<T> & elemMOOSEData() const override { return _mat_prop.get(); }
 
   /// MOOSE material property to read data from
   const MaterialProperty<T> & _mat_prop;
@@ -41,4 +41,4 @@ class MOOSEMaterialPropertyToNEML2 : public MOOSEToNEML2Batched
 DefineMOOSEMaterialPropertyToNEML2Alias(Real, Real);
 DefineMOOSEMaterialPropertyToNEML2Alias(RankTwoTensor, RankTwoTensor);
 DefineMOOSEMaterialPropertyToNEML2Alias(SymmetricRankTwoTensor, SymmetricRankTwoTensor);
-DefineMOOSEMaterialPropertyToNEML2Alias(std::vector<Real>, StdVector);
+DefineMOOSEMaterialPropertyToNEML2Alias(RealVectorValue, RealVectorValue);
diff --git a/modules/solid_mechanics/include/neml2/userobjects/MOOSEToNEML2Batched.h b/modules/solid_mechanics/include/neml2/userobjects/MOOSEToNEML2Batched.h
index 496b788cd6cd..4485f274297c 100644
--- a/modules/solid_mechanics/include/neml2/userobjects/MOOSEToNEML2Batched.h
+++ b/modules/solid_mechanics/include/neml2/userobjects/MOOSEToNEML2Batched.h
@@ -12,6 +12,20 @@
 #include "MOOSEToNEML2.h"
 #include "ElementUserObject.h"
 
+/**
+ * @brief Generic gatherer for collecting "batched" MOOSE data for NEML2
+ *
+ * It is generic in the sense that it can be used for most MOOSE data types that take the form of
+ * MooseArray<T>.
+ *
+ * It is not so generic in the sense that the collected data is always a std::vector of
+ * MooseArray<T>, where the vector size is generally the number of elements this ElementUserObject
+ * operates on, and the MooseArray<T> size is generally the number of quadrature points in each
+ * element.
+ *
+ * @tparam T Type of the underlying MOOSE data, e.g., Real, SymmetricRankTwoTensor, etc.
+ */
+template <typename T>
 class MOOSEToNEML2Batched : public MOOSEToNEML2, public ElementUserObject
 {
 public:
@@ -32,17 +46,71 @@ class MOOSEToNEML2Batched : public MOOSEToNEML2, public ElementUserObject
 
   neml2::Tensor gatheredData() const override;
 
-  // The number of gathered data items (for setting the model batch size)
+  // The number of batches
   std::size_t size() const { return _buffer.size(); }
 
 protected:
-  /// Convert the underlying MOOSE data to a torch::Tensor
-  virtual torch::Tensor convertQpMOOSEData() const = 0;
+  /// MOOSE data for the current element
+  virtual const MooseArray<T> & elemMOOSEData() const = 0;
 
   /// Intermediate data buffer, filled during the element loop
-  std::vector<torch::Tensor> _buffer;
-
-  /// Current element's quadrature point indexing
-  unsigned int _qp;
+  std::vector<T> _buffer;
 #endif
 };
+
+template <typename T>
+InputParameters
+MOOSEToNEML2Batched<T>::validParams()
+{
+  auto params = MOOSEToNEML2::validParams();
+  params += ElementUserObject::validParams();
+
+  // Since we use the NEML2 model to evaluate the residual AND the Jacobian at the same time, we
+  // want to execute this user object only at execute_on = LINEAR (i.e. during residual evaluation).
+  // The NONLINEAR exec flag below is for computing Jacobian during automatic scaling.
+  ExecFlagEnum execute_options = MooseUtils::getDefaultExecFlagEnum();
+  execute_options = {EXEC_INITIAL, EXEC_LINEAR, EXEC_NONLINEAR};
+  params.set<ExecFlagEnum>("execute_on") = execute_options;
+
+  return params;
+}
+
+template <typename T>
+MOOSEToNEML2Batched<T>::MOOSEToNEML2Batched(const InputParameters & params)
+  : MOOSEToNEML2(params), ElementUserObject(params)
+{
+}
+
+#ifdef NEML2_ENABLED
+template <typename T>
+void
+MOOSEToNEML2Batched<T>::initialize()
+{
+  _buffer.clear();
+}
+
+template <typename T>
+void
+MOOSEToNEML2Batched<T>::execute()
+{
+  const auto & elem_data = this->elemMOOSEData();
+  for (auto i : index_range(elem_data))
+    _buffer.push_back(elem_data[i]);
+}
+
+template <typename T>
+void
+MOOSEToNEML2Batched<T>::threadJoin(const UserObject & uo)
+{
+  // append vectors
+  const auto & m2n = static_cast<const MOOSEToNEML2Batched<T> &>(uo);
+  _buffer.insert(_buffer.end(), m2n._buffer.begin(), m2n._buffer.end());
+}
+
+template <typename T>
+neml2::Tensor
+MOOSEToNEML2Batched<T>::gatheredData() const
+{
+  return NEML2Utils::fromBlob(_buffer);
+}
+#endif
diff --git a/modules/solid_mechanics/include/neml2/userobjects/MOOSEVariableToNEML2.h b/modules/solid_mechanics/include/neml2/userobjects/MOOSEVariableToNEML2.h
index 1a9f3ff614bf..c46bde8b4a64 100644
--- a/modules/solid_mechanics/include/neml2/userobjects/MOOSEVariableToNEML2.h
+++ b/modules/solid_mechanics/include/neml2/userobjects/MOOSEVariableToNEML2.h
@@ -15,7 +15,7 @@
  * Gather a MOOSE variable for insertion into the NEML2 model.
  */
 template <unsigned int state>
-class MOOSEVariableToNEML2Templ : public MOOSEToNEML2Batched
+class MOOSEVariableToNEML2Templ : public MOOSEToNEML2Batched<Real>
 {
 public:
   static InputParameters validParams();
@@ -24,7 +24,7 @@ class MOOSEVariableToNEML2Templ : public MOOSEToNEML2Batched
 
 #ifdef NEML2_ENABLED
 protected:
-  torch::Tensor convertQpMOOSEData() const override;
+  const MooseArray<Real> & elemMOOSEData() const override { return _moose_variable; }
 
   /// Coupled MOOSE variable to read data from
   const VariableValue & _moose_variable;
diff --git a/modules/solid_mechanics/include/neml2/userobjects/NEML2ModelExecutor.h b/modules/solid_mechanics/include/neml2/userobjects/NEML2ModelExecutor.h
index 2d7a6408ca44..4780682e1028 100644
--- a/modules/solid_mechanics/include/neml2/userobjects/NEML2ModelExecutor.h
+++ b/modules/solid_mechanics/include/neml2/userobjects/NEML2ModelExecutor.h
@@ -13,12 +13,6 @@
 #include "GeneralUserObject.h"
 #include "NEML2BatchIndexGenerator.h"
 
-#ifdef NEML2_ENABLED
-#include "neml2/tensors/LabeledVector.h"
-#include "neml2/tensors/LabeledMatrix.h"
-#include "neml2/models/Model.h"
-#endif
-
 class MOOSEToNEML2;
 
 /**
@@ -51,15 +45,15 @@ class NEML2ModelExecutor : public NEML2ModelInterface<GeneralUserObject>
   std::size_t getBatchIndex(dof_id_type elem_id) const;
 
   /// Get a reference(!) to the requested output view
-  const neml2::Tensor & getOutputView(const neml2::VariableName & output_name) const;
+  const neml2::Tensor & getOutput(const neml2::VariableName & output_name) const;
 
   /// Get a reference(!) to the requested output derivative view
-  const neml2::Tensor & getOutputDerivativeView(const neml2::VariableName & output_name,
-                                                const neml2::VariableName & input_name) const;
+  const neml2::Tensor & getOutputDerivative(const neml2::VariableName & output_name,
+                                            const neml2::VariableName & input_name) const;
 
   /// Get a reference(!) to the requested output parameter derivative view
-  const neml2::Tensor & getOutputParameterDerivativeView(const neml2::VariableName & output_name,
-                                                         const std::string & parameter_name) const;
+  const neml2::Tensor & getOutputParameterDerivative(const neml2::VariableName & output_name,
+                                                     const std::string & parameter_name) const;
 
   /// check if the output is fully computed and ready to be fetched
   bool outputReady() const { return _output_ready; }
@@ -92,14 +86,17 @@ class NEML2ModelExecutor : public NEML2ModelInterface<GeneralUserObject>
   /// flag that indicates if output data has been fully computed
   bool _output_ready;
 
-  /// The input vector of the material model
-  const neml2::LabeledVector & _in;
+  /// The model parameters to update (gathered from MOOSE)
+  std::map<std::string, neml2::Tensor> _model_params;
+
+  /// The input variables of the material model
+  neml2::ValueMap _in;
 
-  /// The output vector of the material model
-  const neml2::LabeledVector & _out;
+  /// The output variables of the material model
+  neml2::ValueMap _out;
 
-  /// The derivative of the output vector w.r.t. the input vector
-  const neml2::LabeledMatrix & _dout_din;
+  /// The derivative of the output variables w.r.t. the input variables
+  neml2::DerivMap _dout_din;
 
   // set of variables to skip
   std::set<neml2::VariableName> _skip_vars;
@@ -114,14 +111,13 @@ class NEML2ModelExecutor : public NEML2ModelInterface<GeneralUserObject>
   std::vector<const MOOSEToNEML2 *> _gatherers;
 
   /// set of output variables that were retrieved (by other objects)
-  mutable std::map<neml2::VariableName, neml2::Tensor> _retrieved_outputs;
+  mutable neml2::ValueMap _retrieved_outputs;
 
   /// set of derivatives that were retrieved (by other objects)
-  mutable std::map<std::pair<neml2::VariableName, neml2::VariableName>, neml2::Tensor>
-      _retrieved_derivatives;
+  mutable neml2::DerivMap _retrieved_derivatives;
 
   /// set of parameter derivatives that were retrieved (by other objects)
-  mutable std::map<std::pair<neml2::VariableName, std::string>, neml2::Tensor>
+  mutable std::map<neml2::VariableName, std::map<std::string, neml2::Tensor>>
       _retrieved_parameter_derivatives;
 #endif
 };
diff --git a/modules/solid_mechanics/include/neml2/utils/NEML2Utils.h b/modules/solid_mechanics/include/neml2/utils/NEML2Utils.h
index 19df14c1d6c5..c712929d474e 100644
--- a/modules/solid_mechanics/include/neml2/utils/NEML2Utils.h
+++ b/modules/solid_mechanics/include/neml2/utils/NEML2Utils.h
@@ -11,8 +11,9 @@
 
 #ifdef NEML2_ENABLED
 
-#include "neml2/models/Model.h"
 #include "neml2/misc/parser_utils.h"
+#include "neml2/tensors/tensors.h"
+#include "neml2/models/LabeledAxisAccessor.h"
 #include "RankTwoTensor.h"
 #include "RankFourTensor.h"
 #include "SymmetricRankTwoTensor.h"
@@ -22,19 +23,13 @@
 #endif
 
 #include "InputParameters.h"
+#include "MooseArray.h"
+#include <type_traits>
 
 class MooseObject;
 class Action;
 class SubProblem;
 
-#ifdef NEML2_ENABLED
-namespace neml2
-{
-/// Pretty print the summary of a NEML2 model
-std::ostream & operator<<(std::ostream &, const Model &);
-}
-#endif
-
 namespace NEML2Utils
 {
 
@@ -45,76 +40,101 @@ void assertVariable(const neml2::VariableName &);
 /// Assert that the NEML2 variable name sits on either the old_forces or the old_state subaxis
 void assertOldVariable(const neml2::VariableName &);
 
-/// Convert a MOOSE data structure to its NEML2 counterpart
-template <typename T>
-neml2::Tensor toNEML2(const T &);
+/// Parse a raw string into NEML2 variable name
+neml2::VariableName parseVariableName(const std::string &);
 
-/**
- * Convert a wrapped (batched) MOOSE data structure to its NEML2 counterpart
- * The wrapper should implement size()
- */
 template <typename T>
-neml2::Tensor toNEML2Batched(const T & data);
-
-// @{ Template specializations
-template <>
-neml2::Tensor toNEML2(const Real & v);
+struct Layout
+{
+};
 template <>
-neml2::Tensor toNEML2(const RankTwoTensor & r2t);
+struct Layout<Real>
+{
+  static constexpr std::array<neml2::Size, 0> shape{};
+  static constexpr std::array<neml2::Size, 1> strides{1};
+};
 template <>
-neml2::Tensor toNEML2(const std::vector<Real> & v);
-// @}
-
-/**
- * Decompose a `std::vector<std::tuple<Args...>>` into a `std::tuple<std::vector<Args>...>`
- * The original data structure (the batched tuple) is what BatchMaterial gathered for us, but it
- * allows for inhomogeneous batches, i.e., the batch data structure could change from batch to
- * batch. The batched tuple is efficient in terms of data gathering, but it is disadvantageous when
- * we want to convert and set all batches at once. This method essentially "homogenizes" the batched
- * tuple to a tuple of batched data structures.
- */
-template <typename... Args>
-std::tuple<std::vector<Args>...>
-homogenizeBatchedTuple(const std::vector<std::tuple<Args...>> & from);
-
-template <size_t I = 0, typename... Args>
-void homogenizeBatchedTupleInner(const std::vector<std::tuple<Args...>> & from,
-                                 std::tuple<std::vector<Args>...> & to);
-
-/// Convert a NEML2 data structure to its MOOSE counterpart
-template <typename T>
-T toMOOSE(const neml2::Tensor &);
-
-// @{ Template specializations
+struct Layout<RealVectorValue>
+{
+  static constexpr std::array<neml2::Size, 1> shape{3};
+  static constexpr std::array<neml2::Size, 2> strides{3, 1};
+};
 template <>
-Real toMOOSE(const neml2::Tensor & t);
+struct Layout<RankTwoTensor>
+{
+  static constexpr std::array<neml2::Size, 2> shape{3, 3};
+  static constexpr std::array<neml2::Size, 3> strides{9, 3, 1};
+};
 template <>
-SymmetricRankTwoTensor toMOOSE(const neml2::Tensor & t);
+struct Layout<SymmetricRankTwoTensor>
+{
+  static constexpr std::array<neml2::Size, 1> shape{6};
+  static constexpr std::array<neml2::Size, 2> strides{6, 1};
+};
 template <>
-std::vector<Real> toMOOSE(const neml2::Tensor & t);
+struct Layout<RankFourTensor>
+{
+  static constexpr std::array<neml2::Size, 4> shape{3, 3, 3, 3};
+  static constexpr std::array<neml2::Size, 5> strides{81, 27, 9, 3, 1};
+};
 template <>
-SymmetricRankFourTensor toMOOSE(const neml2::Tensor & t);
-// @}
+struct Layout<SymmetricRankFourTensor>
+{
+  static constexpr std::array<neml2::Size, 2> shape{6, 6};
+  static constexpr std::array<neml2::Size, 3> strides{36, 6, 1};
+};
 
 /**
- * Convert a MOOSE data structure to its NEML2 counterpart and copy the values into a NEML2
- * LabeledVector
+ * @brief Map from MooseArray to neml2::Tensor without copying the data
+ *
+ * This method is used in gatherers which gather data from MOOSE as input variables to the NEML2
+ * material model. So in theory, we only need to overload MOOSE types that can potentially be used
+ * as input variables.
  */
-template <size_t I = 0, typename T, typename... Ts>
-void set(neml2::LabeledVector & v,
-         const std::vector<neml2::VariableName> & indices,
-         const T * t0,
-         const Ts *... t);
+template <typename T>
+neml2::Tensor
+fromBlob(const std::vector<T> & data)
+{
+  // The const_cast is fine because torch works with non-const ptr so that it can optionally handle
+  // deallocation. But we are not going to let torch do that.
+  const auto torch_tensor =
+      torch::from_blob(const_cast<T *>(data.data()),
+                       neml2::utils::add_shapes(data.size(), Layout<T>::shape),
+                       torch::TensorOptions().dtype(torch::kFloat64));
+  return neml2::Tensor(torch_tensor, 1);
+}
 
 /**
- * Convert a wrapped (batched) MOOSE data structure to its NEML2 counterpart and copy the values
- * into a NEML2 LabeledVector
+ * @brief Directly copy a contiguous chunk of memory of a torch::Tensor to a MOOSE data of type T
+ *
+ * This assumes the torch::Tensor and T have the same layout, for example both row-major
+ * with T = RankTwoTensor. If the layouts are different, we may need to reshape/reorder/transpose
+ * the torch::Tensor before copying.
+ *
+ * For this method to work,
+ * 1. the address of \p dest must align with the first element of the data,
+ * 2. the number of elements in \p dest must match the number of elements in \p src,
+ * 3. the \p src tensor must be of type torch::kFloat64, and
+ * 4. data in \p dest must be reinterpretable as Real.
  */
-template <size_t I = 0, typename T, typename... Ts>
-void setBatched(neml2::LabeledVector & v,
-                const std::vector<neml2::VariableName> & indices,
-                const T * t0,
-                const Ts *... t);
+template <typename T>
+void
+copyTensorToMOOSEData(const torch::Tensor & src, T & dest)
+{
+  if (src.dtype() != torch::kFloat64)
+    mooseError(
+        "Cannot copy torch::Tensor with dtype ", src.dtype(), " into ", demangle(typeid(T).name()));
+  if (src.numel() != Layout<T>::strides[0])
+    mooseError("Cannot copy torch::Tensor with shape ",
+               src.sizes(),
+               " into ",
+               demangle(typeid(T).name()),
+               " with different number of elements.");
+  auto dest_tensor = torch::from_blob(reinterpret_cast<Real *>(&dest),
+                                      Layout<T>::shape,
+                                      torch::TensorOptions().dtype(torch::kFloat64));
+  dest_tensor.copy_(src.reshape(Layout<T>::shape));
+}
 
 static std::string NEML2_help_message = R""""(
 ==============================================================================
@@ -130,78 +150,6 @@ To debug NEML2 related issues:
 ==============================================================================
 )"""";
 
-////////////////////////////////////////////////////////////////////////////////
-// Implementations
-////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-neml2::Tensor
-toNEML2Batched(const T & data)
-{
-  std::vector<torch::Tensor> res(data.size());
-  for (const auto i : index_range(data))
-    res[i] = toNEML2<typename T::value_type>(data[i]);
-  return neml2::Tensor(torch::stack(res, 0), 1);
-}
-
-template <typename... Args>
-std::tuple<std::vector<Args>...>
-homogenizeBatchedTuple(const std::vector<std::tuple<Args...>> & from)
-{
-  std::tuple<std::vector<Args>...> to;
-  homogenizeBatchedTupleInner(from, to);
-  return to;
-}
-
-template <size_t I, typename... Args>
-void
-homogenizeBatchedTupleInner(const std::vector<std::tuple<Args...>> & from,
-                            std::tuple<std::vector<Args>...> & to)
-{
-  typedef typename std::tuple_element<I, std::tuple<Args...>>::type Arg;
-  std::vector<Arg> toi;
-  std::transform(from.cbegin(),
-                 from.cend(),
-                 std::back_inserter(toi),
-                 [](const auto & b) { return std::get<I>(b); });
-  std::get<I>(to) = toi;
-
-  // recursively act on the rest of the args
-  if constexpr ((I + 1) < sizeof...(Args))
-    homogenizeBatchedTupleInner<I + 1>(from, to);
-}
-
-template <size_t I, typename T, typename... Ts>
-void
-set(neml2::LabeledVector & v,
-    const std::vector<neml2::VariableName> & indices,
-    const T * t0,
-    const Ts *... t)
-{
-  if (t0)
-    v.base_index_put_(indices[I], toNEML2(*t0));
-
-  // Recursively act on the rest of the data
-  // The compiler should be able to easily deduce the rest of the template parameters...
-  if constexpr (sizeof...(Ts) > 0)
-    set<I + 1>(v, indices, t...);
-}
-
-template <size_t I, typename T, typename... Ts>
-void
-setBatched(neml2::LabeledVector & v,
-           const std::vector<neml2::VariableName> & indices,
-           const T * t0,
-           const Ts *... t)
-{
-  if (t0)
-    v.base_index_put_(indices[I], toNEML2Batched(*t0));
-
-  // recursively act on the rest of the data
-  // The compiler should be able to easily deduce the rest of the template parameters...
-  if constexpr (sizeof...(Ts) > 0)
-    setBatched<I + 1>(v, indices, t...);
-}
-
 #endif // NEML2_ENABLED
 
 /// Determine whether the NEML2 material model should be evaluated
diff --git a/modules/solid_mechanics/src/materials/lagrangian/ComputeLagrangianCauchyCustomStress.C b/modules/solid_mechanics/src/materials/lagrangian/ComputeLagrangianCauchyCustomStress.C
new file mode 100644
index 000000000000..6bae30765224
--- /dev/null
+++ b/modules/solid_mechanics/src/materials/lagrangian/ComputeLagrangianCauchyCustomStress.C
@@ -0,0 +1,42 @@
+//* 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 "ComputeLagrangianCauchyCustomStress.h"
+
+registerMooseObject("SolidMechanicsApp", ComputeLagrangianCauchyCustomStress);
+
+InputParameters
+ComputeLagrangianCauchyCustomStress::validParams()
+{
+  InputParameters params = ComputeLagrangianStressCauchy::validParams();
+
+  params.addClassDescription("Custom stress update providing the Cauchy stress");
+
+  params.addRequiredParam<MaterialPropertyName>("custom_cauchy_stress",
+                                                "The name of the Cauchy stress.");
+  params.addRequiredParam<MaterialPropertyName>("custom_cauchy_jacobian",
+                                                "The name of the Cauchy stress Jacobian.");
+
+  return params;
+}
+
+ComputeLagrangianCauchyCustomStress::ComputeLagrangianCauchyCustomStress(
+    const InputParameters & parameters)
+  : ComputeLagrangianStressCauchy(parameters),
+    _custom_stress(getMaterialProperty<RankTwoTensor>("custom_cauchy_stress")),
+    _custom_jacobian(getMaterialProperty<RankFourTensor>("custom_cauchy_jacobian"))
+{
+}
+
+void
+ComputeLagrangianCauchyCustomStress::computeQpCauchyStress()
+{
+  _cauchy_stress[_qp] = _custom_stress[_qp];
+  _cauchy_jacobian[_qp] = _custom_jacobian[_qp];
+}
diff --git a/modules/solid_mechanics/src/materials/lagrangian/ComputeLagrangianStrainBase.C b/modules/solid_mechanics/src/materials/lagrangian/ComputeLagrangianStrainBase.C
index 57204926a86c..9445be440d19 100644
--- a/modules/solid_mechanics/src/materials/lagrangian/ComputeLagrangianStrainBase.C
+++ b/modules/solid_mechanics/src/materials/lagrangian/ComputeLagrangianStrainBase.C
@@ -51,6 +51,8 @@ ComputeLagrangianStrainBase<G>::ComputeLagrangianStrainBase(const InputParameter
     _mechanical_strain(declareProperty<RankTwoTensor>(_base_name + "mechanical_strain")),
     _mechanical_strain_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "mechanical_strain")),
     _strain_increment(declareProperty<RankTwoTensor>(_base_name + "strain_increment")),
+    _spatial_velocity_increment(
+        declareProperty<RankTwoTensor>(_base_name + "spatial_velocity_increment")),
     _vorticity_increment(declareProperty<RankTwoTensor>(_base_name + "vorticity_increment")),
     _F_ust(declareProperty<RankTwoTensor>(_base_name + "unstabilized_deformation_gradient")),
     _F_avg(declareProperty<RankTwoTensor>(_base_name + "average_deformation_gradient")),
@@ -148,6 +150,9 @@ ComputeLagrangianStrainBase<G>::computeQpIncrementalStrains(const RankTwoTensor
   // Increment the mechanical strain
   _mechanical_strain[_qp] = _mechanical_strain_old[_qp] + _strain_increment[_qp];
 
+  // Yes, this does make sense to do it here
+  _spatial_velocity_increment[_qp] = _vorticity_increment[_qp] + _strain_increment[_qp];
+
   // Faked rotation increment for ComputeStressBase materials
   _rotation_increment[_qp] = RankTwoTensor::Identity();
 }
diff --git a/modules/solid_mechanics/src/neml2/actions/NEML2Action.C b/modules/solid_mechanics/src/neml2/actions/NEML2Action.C
index 1c83a1dfba68..48eb0cfa8573 100644
--- a/modules/solid_mechanics/src/neml2/actions/NEML2Action.C
+++ b/modules/solid_mechanics/src/neml2/actions/NEML2Action.C
@@ -29,7 +29,7 @@ const std::map<neml2::TensorType, std::string> tensor_type_map = {
     {neml2::TensorType::kR2, "RankTwoTensor"},
     {neml2::TensorType::kSSR4, "SymmetricRankFourTensor"},
     {neml2::TensorType::kR4, "RankFourTensor"},
-};
+    {neml2::TensorType::kRot, "RealVectorValue"}};
 // NEML2 (output, input) type --> NEML2 derivative type
 const std::map<std::pair<neml2::TensorType, neml2::TensorType>, neml2::TensorType> deriv_type_map =
     {
@@ -81,13 +81,21 @@ NEML2Action::NEML2Action(const InputParameters & params)
   // Apply parameters under the common area, i.e., under [NEML2]
   const auto & all_params = _app.getInputParameterWarehouse().getInputParameters();
   auto & sub_block_params = *(all_params.find(uniqueActionName())->second.get());
-  auto common_block = _awh.getActions<NEML2ActionCommon>();
-  mooseAssert(common_block.size() == 1, "There must exist one and only one common NEML2 action.");
-  sub_block_params.applyParameters(common_block[0]->parameters());
+  const auto & common_action = getCommonAction();
+  sub_block_params.applyParameters(common_action.parameters());
 
   // verbosity
   _verbose = getParam<bool>("verbose");
 
+  // Set up optional output variable initialization
+  auto init_vars = getParam<std::vector<MaterialPropertyName>>("initialize_outputs");
+  auto init_vals = getParam<std::vector<MaterialPropertyName>>("initialize_output_values");
+  if (init_vars.size() != init_vals.size())
+    paramError("initialize_outputs",
+               "initialize_outputs should have the same length as initialize_output_values");
+  for (auto i : index_range(init_vars))
+    _initialize_output_values[init_vars[i]] = init_vals[i];
+
   // Set up additional outputs for each requested material property
   auto outputs = getParam<std::vector<MaterialPropertyName>>("export_outputs");
   auto output_targets = getParam<std::vector<std::vector<OutputName>>>("export_output_targets");
@@ -98,6 +106,14 @@ NEML2Action::NEML2Action(const InputParameters & params)
     _export_output_targets[outputs[i]] = output_targets[i];
 }
 
+const NEML2ActionCommon &
+NEML2Action::getCommonAction() const
+{
+  auto common_block = _awh.getActions<NEML2ActionCommon>();
+  mooseAssert(common_block.size() == 1, "There must exist one and only one common NEML2 action.");
+  return *common_block[0];
+}
+
 #ifndef NEML2_ENABLED
 
 void
@@ -113,24 +129,7 @@ NEML2Action::act()
   if (_current_task == "add_user_object")
   {
     // Get the NEML2 model so that we can introspect variable tensor types
-    auto & model = neml2::get_model(getParam<std::string>("model"));
-
-    // List inputs, outputs, and parameters of the model
-    if (_verbose)
-    {
-      _console << COLOR_YELLOW << "*** NEML2 MATERIAL MODEL SUMMARY BEGIN ***" << COLOR_DEFAULT
-               << std::endl;
-      _console << "Input file location:       " << parameters().blockLocation() << std::endl;
-      _console << "Input file path:           " << parameters().blockFullpath() << std::endl;
-      _console << "Material model Name:       " << getParam<std::string>("model") << std::endl;
-      _console << "Evaluation device:         " << getParam<std::string>("device") << std::endl;
-      _console << "Automatic differentiation: "
-               << (getParam<bool>("enable_AD") ? "Enabled" : "Disabled") << std::endl;
-      _console << "Material model structure:  " << std::endl;
-      _console << model;
-      _console << COLOR_YELLOW << "*** NEML2 MATERIAL MODEL SUMMARY END ***\n"
-               << COLOR_DEFAULT << std::endl;
-    }
+    const auto & model = neml2::get_model(getParam<std::string>("model"));
 
     setupInputMappings(model);
     setupParameterMappings(model);
@@ -138,6 +137,9 @@ NEML2Action::act()
     setupDerivativeMappings(model);
     setupParameterDerivativeMappings(model);
 
+    if (_verbose)
+      printSummary(model);
+
     // MOOSEToNEML2 input gatherers
     std::vector<UserObjectName> gatherers;
     for (const auto & input : _inputs)
@@ -146,8 +148,10 @@ NEML2Action::act()
       {
         auto obj_name = "__moose(" + input.moose.name + ")->neml2(" +
                         neml2::utils::stringify(input.neml2.name) + ")_" + name() + "__";
+        if (!tensor_type_map.count(input.neml2.type))
+          mooseError("NEML2 type ", input.neml2.type, " not yet mapped to MOOSE");
         auto obj_moose_type = tensor_type_map.at(input.neml2.type) + "MaterialProperty";
-        if (input.neml2.name.start_with("old_forces") || input.neml2.name.start_with("old_state"))
+        if (input.neml2.name.is_old_force() || input.neml2.name.is_old_state())
           obj_moose_type = "Old" + obj_moose_type;
         auto obj_type = "MOOSE" + obj_moose_type + "ToNEML2";
         auto obj_params = _factory.getValidParams(obj_type);
@@ -162,7 +166,7 @@ NEML2Action::act()
         auto obj_name = "__moose(" + input.moose.name + ")->neml2(" +
                         neml2::utils::stringify(input.neml2.name) + ")_" + name() + "__";
         std::string obj_moose_type = "Variable";
-        if (input.neml2.name.start_with("old_forces") || input.neml2.name.start_with("old_state"))
+        if (input.neml2.name.is_old_force() || input.neml2.name.is_old_state())
           obj_moose_type = "Old" + obj_moose_type;
         auto obj_type = "MOOSE" + obj_moose_type + "ToNEML2";
         auto obj_params = _factory.getValidParams(obj_type);
@@ -177,7 +181,7 @@ NEML2Action::act()
         auto obj_name = "__moose(" + input.moose.name + ")->neml2(" +
                         neml2::utils::stringify(input.neml2.name) + ")" + name() + "__";
         auto obj_moose_type = std::string("Postprocessor");
-        if (input.neml2.name.start_with("old_forces") || input.neml2.name.start_with("old_state"))
+        if (input.neml2.name.is_old_force() || input.neml2.name.is_old_state())
           obj_moose_type = "Old" + obj_moose_type;
         auto obj_type = "MOOSE" + obj_moose_type + "ToNEML2";
         auto obj_params = _factory.getValidParams(obj_type);
@@ -200,6 +204,8 @@ NEML2Action::act()
       {
         auto obj_name =
             "__moose(" + param.moose.name + ")->neml2(" + param.neml2.name + ")_" + name() + "__";
+        if (!tensor_type_map.count(param.neml2.type))
+          mooseError("NEML2 type ", param.neml2.type, " not yet mapped to MOOSE");
         auto obj_moose_type = tensor_type_map.at(param.neml2.type);
         auto obj_type = "MOOSE" + obj_moose_type + "MaterialPropertyToNEML2";
         auto obj_params = _factory.getValidParams(obj_type);
@@ -268,12 +274,17 @@ NEML2Action::act()
       {
         auto obj_name = "__neml2(" + neml2::utils::stringify(output.neml2.name) + ")->moose(" +
                         output.moose.name + ")_" + name() + "__";
+        if (!tensor_type_map.count(output.neml2.type))
+          mooseError("NEML2 type ", output.neml2.type, " not yet mapped to MOOSE");
         auto obj_type = "NEML2ToMOOSE" + tensor_type_map.at(output.neml2.type) + "MaterialProperty";
         auto obj_params = _factory.getValidParams(obj_type);
         obj_params.set<UserObjectName>("neml2_executor") = _executor_name;
         obj_params.set<MaterialPropertyName>("to_moose") = output.moose.name;
         obj_params.set<std::string>("from_neml2") = neml2::utils::stringify(output.neml2.name);
         obj_params.set<std::vector<SubdomainName>>("block") = _block;
+        if (_initialize_output_values.count(output.moose.name))
+          obj_params.set<MaterialPropertyName>("moose_material_property_init") =
+              _initialize_output_values[output.moose.name];
         if (_export_output_targets.count(output.moose.name))
           obj_params.set<std::vector<OutputName>>("outputs") =
               _export_output_targets[output.moose.name];
@@ -293,10 +304,16 @@ NEML2Action::act()
         auto obj_name = "__neml2(d(" + neml2::utils::stringify(deriv.neml2.y.name) + ")/d(" +
                         neml2::utils::stringify(deriv.neml2.x.name) + "))->moose(" +
                         deriv.moose.name + ")_" + name() + "__";
-        auto obj_type =
-            "NEML2ToMOOSE" +
-            tensor_type_map.at(deriv_type_map.at({deriv.neml2.y.type, deriv.neml2.x.type})) +
-            "MaterialProperty";
+        if (!deriv_type_map.count({deriv.neml2.y.type, deriv.neml2.x.type}))
+          mooseError("NEML2 derivative type for d(",
+                     deriv.neml2.y.type,
+                     ")/d(",
+                     deriv.neml2.x.type,
+                     ") not yet mapped to MOOSE");
+        auto deriv_type = deriv_type_map.at({deriv.neml2.y.type, deriv.neml2.x.type});
+        if (!tensor_type_map.count(deriv_type))
+          mooseError("NEML2 type ", deriv_type, " not yet mapped to MOOSE");
+        auto obj_type = "NEML2ToMOOSE" + tensor_type_map.at(deriv_type) + "MaterialProperty";
         auto obj_params = _factory.getValidParams(obj_type);
         obj_params.set<UserObjectName>("neml2_executor") = _executor_name;
         obj_params.set<MaterialPropertyName>("to_moose") = deriv.moose.name;
@@ -323,10 +340,16 @@ NEML2Action::act()
         auto obj_name = "__neml2(d(" + neml2::utils::stringify(param_deriv.neml2.y.name) + ")/d(" +
                         param_deriv.neml2.x.name + "))->moose(" + param_deriv.moose.name + ")_" +
                         name() + "__";
-        auto obj_type = "NEML2ToMOOSE" +
-                        tensor_type_map.at(deriv_type_map.at(
-                            {param_deriv.neml2.y.type, param_deriv.neml2.x.type})) +
-                        "MaterialProperty";
+        if (!deriv_type_map.count({param_deriv.neml2.y.type, param_deriv.neml2.x.type}))
+          mooseError("NEML2 derivative type for d(",
+                     param_deriv.neml2.y.type,
+                     ")/d(",
+                     param_deriv.neml2.x.type,
+                     ") not yet mapped to MOOSE");
+        auto deriv_type = deriv_type_map.at({param_deriv.neml2.y.type, param_deriv.neml2.x.type});
+        if (!tensor_type_map.count(deriv_type))
+          mooseError("NEML2 type ", deriv_type, " not yet mapped to MOOSE");
+        auto obj_type = "NEML2ToMOOSE" + tensor_type_map.at(deriv_type) + "MaterialProperty";
         auto obj_params = _factory.getValidParams(obj_type);
         obj_params.set<UserObjectName>("neml2_executor") = _executor_name;
         obj_params.set<MaterialPropertyName>("to_moose") = param_deriv.moose.name;
@@ -350,22 +373,16 @@ NEML2Action::act()
 void
 NEML2Action::setupInputMappings(const neml2::Model & model)
 {
-  const auto moose_input_types =
-      getParam<MultiMooseEnum>("moose_input_types").getSetValueIDs<MOOSEIOType>();
-  const auto moose_inputs = getParam<std::vector<std::string>>("moose_inputs");
-  const auto neml2_inputs = getParam<std::vector<std::string>>("neml2_inputs");
-
-  if (moose_inputs.size() != moose_input_types.size())
-    paramError("moose_inputs", "moose_inputs must have the same length as moose_input_types");
-  if (moose_inputs.size() != neml2_inputs.size())
-    paramError("moose_inputs", "moose_inputs must have the same length as neml2_inputs");
+  const auto [moose_input_types, moose_inputs, neml2_inputs] =
+      getInputParameterMapping<MOOSEIOType, std::string, std::string>(
+          "moose_input_types", "moose_inputs", "neml2_inputs");
 
   for (auto i : index_range(moose_inputs))
   {
-    auto neml2_input = neml2::utils::parse<neml2::VariableName>(neml2_inputs[i]);
+    auto neml2_input = NEML2Utils::parseVariableName(neml2_inputs[i]);
     _inputs.push_back({
         {moose_inputs[i], moose_input_types[i]},
-        {neml2_input, model.input_type(neml2_input)},
+        {neml2_input, model.input_variable(neml2_input).type()},
     });
   }
 }
@@ -373,17 +390,9 @@ NEML2Action::setupInputMappings(const neml2::Model & model)
 void
 NEML2Action::setupParameterMappings(const neml2::Model & model)
 {
-  const auto moose_param_types =
-      getParam<MultiMooseEnum>("moose_parameter_types").getSetValueIDs<MOOSEIOType>();
-  const auto moose_params = getParam<std::vector<std::string>>("moose_parameters");
-  const auto neml2_params = getParam<std::vector<std::string>>("neml2_parameters");
-
-  if (moose_params.size() != moose_param_types.size())
-    paramError("moose_parameters",
-               "moose_params must have the same length as moose_parameter_types");
-  if (moose_params.size() != neml2_params.size())
-    paramError("moose_parameters",
-               "moose_parameters must have the same length as neml2_parameters");
+  const auto [moose_param_types, moose_params, neml2_params] =
+      getInputParameterMapping<MOOSEIOType, std::string, std::string>(
+          "moose_parameter_types", "moose_parameters", "neml2_parameters");
 
   for (auto i : index_range(moose_params))
     _params.push_back({{moose_params[i], moose_param_types[i]},
@@ -393,22 +402,16 @@ NEML2Action::setupParameterMappings(const neml2::Model & model)
 void
 NEML2Action::setupOutputMappings(const neml2::Model & model)
 {
-  const auto moose_output_types =
-      getParam<MultiMooseEnum>("moose_output_types").getSetValueIDs<MOOSEIOType>();
-  const auto moose_outputs = getParam<std::vector<std::string>>("moose_outputs");
-  const auto neml2_outputs = getParam<std::vector<std::string>>("neml2_outputs");
-
-  if (moose_outputs.size() != moose_output_types.size())
-    paramError("moose_outputs", "moose_outputs must have the same length as moose_output_types");
-  if (moose_outputs.size() != neml2_outputs.size())
-    paramError("moose_outputs", "moose_outputs must have the same length as neml2_outputs");
+  const auto [moose_output_types, moose_outputs, neml2_outputs] =
+      getInputParameterMapping<MOOSEIOType, std::string, std::string>(
+          "moose_output_types", "moose_outputs", "neml2_outputs");
 
   for (auto i : index_range(moose_outputs))
   {
-    auto neml2_output = neml2::utils::parse<neml2::VariableName>(neml2_outputs[i]);
+    auto neml2_output = NEML2Utils::parseVariableName(neml2_outputs[i]);
     _outputs.push_back({
         {moose_outputs[i], moose_output_types[i]},
-        {neml2_output, model.output_type(neml2_output)},
+        {neml2_output, model.output_variable(neml2_output).type()},
     });
   }
 }
@@ -416,28 +419,21 @@ NEML2Action::setupOutputMappings(const neml2::Model & model)
 void
 NEML2Action::setupDerivativeMappings(const neml2::Model & model)
 {
-  const auto moose_deriv_types =
-      getParam<MultiMooseEnum>("moose_derivative_types").getSetValueIDs<MOOSEIOType>();
-  const auto moose_derivs = getParam<std::vector<std::string>>("moose_derivatives");
-  const auto neml2_derivs = getParam<std::vector<std::vector<std::string>>>("neml2_derivatives");
-
-  if (moose_derivs.size() != moose_deriv_types.size())
-    paramError("moose_derivatives",
-               "moose_derivatives must have the same length as moose_derivative_types");
-  if (moose_derivs.size() != neml2_derivs.size())
-    paramError("moose_derivatives",
-               "moose_derivatives must have the same length as neml2_derivatives");
+  const auto [moose_deriv_types, moose_derivs, neml2_derivs] =
+      getInputParameterMapping<MOOSEIOType, std::string, std::vector<std::string>>(
+          "moose_derivative_types", "moose_derivatives", "neml2_derivatives");
 
   for (auto i : index_range(moose_derivs))
   {
     if (neml2_derivs[i].size() != 2)
       paramError("neml2_derivatives", "The length of each pair in neml2_derivatives must be 2.");
 
-    auto neml2_y = neml2::utils::parse<neml2::VariableName>(neml2_derivs[i][0]);
-    auto neml2_x = neml2::utils::parse<neml2::VariableName>(neml2_derivs[i][1]);
+    auto neml2_y = NEML2Utils::parseVariableName(neml2_derivs[i][0]);
+    auto neml2_x = NEML2Utils::parseVariableName(neml2_derivs[i][1]);
     _derivs.push_back({
         {moose_derivs[i], moose_deriv_types[i]},
-        {{neml2_y, model.output_type(neml2_y)}, {neml2_x, model.input_type(neml2_x)}},
+        {{neml2_y, model.output_variable(neml2_y).type()},
+         {neml2_x, model.input_variable(neml2_x).type()}},
     });
   }
 }
@@ -445,20 +441,11 @@ NEML2Action::setupDerivativeMappings(const neml2::Model & model)
 void
 NEML2Action::setupParameterDerivativeMappings(const neml2::Model & model)
 {
-  const auto moose_param_deriv_types =
-      getParam<MultiMooseEnum>("moose_parameter_derivative_types").getSetValueIDs<MOOSEIOType>();
-  const auto moose_param_derivs = getParam<std::vector<std::string>>("moose_parameter_derivatives");
-  const auto neml2_param_derivs =
-      getParam<std::vector<std::vector<std::string>>>("neml2_parameter_derivatives");
-
-  if (moose_param_derivs.size() != moose_param_deriv_types.size())
-    paramError("moose_parameter_derivatives",
-               "moose_parameter_derivatives must have the same length as "
-               "moose_parameter_derivative_types");
-  if (moose_param_derivs.size() != neml2_param_derivs.size())
-    paramError(
-        "moose_parameter_derivatives",
-        "moose_parameter_derivatives must have the same length as neml2_parameter_derivatives");
+  const auto [moose_param_deriv_types, moose_param_derivs, neml2_param_derivs] =
+      getInputParameterMapping<MOOSEIOType, std::string, std::vector<std::string>>(
+          "moose_parameter_derivative_types",
+          "moose_parameter_derivatives",
+          "neml2_parameter_derivatives");
 
   for (auto i : index_range(moose_param_derivs))
   {
@@ -466,12 +453,104 @@ NEML2Action::setupParameterDerivativeMappings(const neml2::Model & model)
       paramError("neml2_parameter_derivatives",
                  "The length of each pair in neml2_parameter_derivatives must be 2.");
 
-    auto neml2_y = neml2::utils::parse<neml2::VariableName>(neml2_param_derivs[i][0]);
+    auto neml2_y = NEML2Utils::parseVariableName(neml2_param_derivs[i][0]);
     auto neml2_x = neml2_param_derivs[i][1];
     _param_derivs.push_back({
         {moose_param_derivs[i], moose_param_deriv_types[i]},
-        {{neml2_y, model.output_type(neml2_y)}, {neml2_x, model.get_parameter(neml2_x).type()}},
+        {{neml2_y, model.output_variable(neml2_y).type()},
+         {neml2_x, model.get_parameter(neml2_x).type()}},
     });
   }
 }
+
+void
+NEML2Action::printSummary(const neml2::Model & model) const
+{
+  // Save formatting of the output stream so that we can restore it later
+  const auto flags = _console.flags();
+
+  // Default width for the summary
+  const int width = 79;
+
+  _console << std::endl;
+  _console << COLOR_CYAN << std::setw(width) << std::setfill('*') << std::left
+           << "NEML2 MATERIAL MODEL SUMMARY BEGIN " << std::setfill(' ') << COLOR_DEFAULT
+           << std::endl;
+
+  // Metadata
+  _console << "NEML2 input file location: " << getCommonAction().fname() << std::endl;
+  _console << "NEML2 action path:         " << parameters().blockFullpath() << std::endl;
+
+  // List inputs, outputs, and parameters of the model
+  _console << COLOR_CYAN << std::setw(width) << std::setfill('-') << std::left
+           << "Material model structure " << std::setfill(' ') << COLOR_DEFAULT << std::endl;
+  _console << model;
+
+  // List transfer between MOOSE and NEML2
+  _console << COLOR_CYAN << std::setw(width) << std::setfill('-') << std::left
+           << "Transfer between MOOSE and NEML2 " << std::setfill(' ') << COLOR_DEFAULT
+           << std::endl;
+
+  // Figure out the longest name length so that we could align the arrows
+  const auto max_moose_name_length = getLongestMOOSEName();
+
+  // List input transfer, MOOSE -> NEML2
+  for (const auto & input : _inputs)
+  {
+    _console << std::setw(max_moose_name_length) << std::right
+             << (input.neml2.name.is_old_force() || input.neml2.name.is_old_state()
+                     ? ("(old) " + input.moose.name)
+                     : input.moose.name)
+             << " --> " << input.neml2.name << std::endl;
+  }
+
+  // List parameter transfer, MOOSE -> NEML2
+  for (const auto & param : _params)
+    _console << std::setw(max_moose_name_length) << std::right << param.moose.name << " --> "
+             << param.neml2.name << std::endl;
+
+  // List output transfer, NEML2 -> MOOSE
+  for (const auto & output : _outputs)
+    _console << std::setw(max_moose_name_length) << std::right << output.moose.name << " <-- "
+             << output.neml2.name << std::endl;
+
+  // List derivative transfer, NEML2 -> MOOSE
+  for (const auto & deriv : _derivs)
+    _console << std::setw(max_moose_name_length) << std::right << deriv.moose.name << " <-- d("
+             << deriv.neml2.y.name << ")/d(" << deriv.neml2.x.name << ")" << std::endl;
+
+  // List parameter derivative transfer, NEML2 -> MOOSE
+  for (const auto & param_deriv : _param_derivs)
+    _console << std::setw(max_moose_name_length) << std::right << param_deriv.moose.name
+             << " <-- d(" << param_deriv.neml2.y.name << ")/d(" << param_deriv.neml2.x.name << ")"
+             << std::endl;
+
+  _console << COLOR_CYAN << std::setw(width) << std::setfill('*') << std::left
+           << "NEML2 MATERIAL MODEL SUMMARY END " << std::setfill(' ') << COLOR_DEFAULT << std::endl
+           << std::endl;
+
+  // Restore the formatting of the output stream
+  _console.flags(flags);
+}
+
+std::size_t
+NEML2Action::getLongestMOOSEName() const
+{
+  std::size_t max_moose_name_length = 0;
+  for (const auto & input : _inputs)
+    max_moose_name_length =
+        std::max(max_moose_name_length,
+                 input.neml2.name.is_old_force() || input.neml2.name.is_old_state()
+                     ? input.moose.name.size() + 6
+                     : input.moose.name.size()); // 6 is the length of "(old) "
+  for (const auto & param : _params)
+    max_moose_name_length = std::max(max_moose_name_length, param.moose.name.size());
+  for (const auto & output : _outputs)
+    max_moose_name_length = std::max(max_moose_name_length, output.moose.name.size());
+  for (const auto & deriv : _derivs)
+    max_moose_name_length = std::max(max_moose_name_length, deriv.moose.name.size());
+  for (const auto & param_deriv : _param_derivs)
+    max_moose_name_length = std::max(max_moose_name_length, param_deriv.moose.name.size());
+  return max_moose_name_length;
+}
 #endif // NEML2_ENABLED
diff --git a/modules/solid_mechanics/src/neml2/actions/NEML2ActionCommon.C b/modules/solid_mechanics/src/neml2/actions/NEML2ActionCommon.C
index b919a130abc3..37e60985b7d9 100644
--- a/modules/solid_mechanics/src/neml2/actions/NEML2ActionCommon.C
+++ b/modules/solid_mechanics/src/neml2/actions/NEML2ActionCommon.C
@@ -14,6 +14,7 @@
 
 #ifdef NEML2_ENABLED
 #include "neml2/base/Factory.h"
+#include "neml2/misc/parser_utils.h"
 #endif
 
 registerMooseAction("SolidMechanicsApp", NEML2ActionCommon, "parse_neml2");
@@ -111,6 +112,21 @@ NEML2ActionCommon::commonParams()
                         true,
                         NEML2Utils::docstring("Whether to print additional information about the "
                                               "NEML2 model at the beginning of the simulation"));
+
+  params.addParam<std::vector<MaterialPropertyName>>(
+      "initialize_outputs",
+      {},
+      "List of MOOSE material properties to be initialized. Each these properties must correspond "
+      "to a stateful NEML2 variable (which appears on both the input old state sub-axis and the "
+      "output state sub-axis). These MOOSE material properties will be initialized with the values "
+      "of properties specified in the initialize_output_values list.");
+  params.addParam<std::vector<MaterialPropertyName>>(
+      "initialize_output_values",
+      {},
+      "List of MOOSE material properties whose initial values (evaluated at the 0th time step) "
+      "will be used to initialize stateful properties. See the description of initialize_outputs "
+      "for more details.");
+
   params.addParam<std::vector<MaterialPropertyName>>(
       "export_outputs",
       {},
@@ -122,6 +138,7 @@ NEML2ActionCommon::commonParams()
       {},
       "The export targets corresponding to each MOOSE material property specified in "
       "export_outputs.");
+
   return params;
 }
 
@@ -133,28 +150,26 @@ NEML2ActionCommon::validParams()
   params.addRequiredParam<DataFileName>(
       "input",
       NEML2Utils::docstring("Path to the NEML2 input file containing the NEML2 model(s)."));
+  params.addParam<std::vector<std::string>>(
+      "cli_args",
+      {},
+      "Additional command line arguments to use when parsing the NEML2 input file.");
   return params;
 }
 
 NEML2ActionCommon::NEML2ActionCommon(const InputParameters & params)
-  : Action(params), _fname(getDataFileName("input"))
+  : Action(params),
+    _fname(getParam<DataFileName>("input")),
+    _cli_args(getParam<std::vector<std::string>>("cli_args"))
 {
   NEML2Utils::assertNEML2Enabled();
 }
 
-#ifndef NEML2_ENABLED
-
-void
-NEML2ActionCommon::act()
-{
-}
-
-#else
-
 void
 NEML2ActionCommon::act()
 {
+#ifdef NEML2_ENABLED
   if (_current_task == "parse_neml2")
-    neml2::load_input(std::string(_fname));
-}
+    neml2::load_input(std::string(_fname), neml2::utils::join(_cli_args, " "));
 #endif
+}
diff --git a/modules/solid_mechanics/src/neml2/interfaces/MOOSEToNEML2.C b/modules/solid_mechanics/src/neml2/interfaces/MOOSEToNEML2.C
index 05050c9561ce..ec002cc33a3f 100644
--- a/modules/solid_mechanics/src/neml2/interfaces/MOOSEToNEML2.C
+++ b/modules/solid_mechanics/src/neml2/interfaces/MOOSEToNEML2.C
@@ -36,7 +36,7 @@ MOOSEToNEML2::setMode(MOOSEToNEML2::Mode m) const
   _mode = m;
 
   if (_mode == Mode::VARIABLE || _mode == Mode::OLD_VARIABLE)
-    _neml2_variable = neml2::utils::parse<neml2::VariableName>(_raw_name);
+    _neml2_variable = NEML2Utils::parseVariableName(_raw_name);
   else if (_mode == Mode::PARAMETER)
     _neml2_parameter = _raw_name;
   else
@@ -70,12 +70,13 @@ MOOSEToNEML2::NEML2ParameterName() const
 }
 
 void
-MOOSEToNEML2::insertInto(neml2::Model & model) const
+MOOSEToNEML2::insertInto(neml2::ValueMap & input,
+                         std::map<std::string, neml2::Tensor> & params) const
 {
   if (_mode == Mode::VARIABLE || _mode == Mode::OLD_VARIABLE)
-    model.input_storage().base_index_put_(_neml2_variable, gatheredData());
+    input[_neml2_variable] = gatheredData();
   else if (_mode == Mode::PARAMETER)
-    model.set_parameter(_neml2_parameter, gatheredData());
+    params[_neml2_parameter] = gatheredData();
   else
     mooseError("Encountered invalid Mode in MOOSEToNEML2::insertInto");
 }
diff --git a/modules/solid_mechanics/src/neml2/materials/NEML2ToMOOSEMaterialProperty.C b/modules/solid_mechanics/src/neml2/materials/NEML2ToMOOSEMaterialProperty.C
index a3725490eea2..ce169955e562 100644
--- a/modules/solid_mechanics/src/neml2/materials/NEML2ToMOOSEMaterialProperty.C
+++ b/modules/solid_mechanics/src/neml2/materials/NEML2ToMOOSEMaterialProperty.C
@@ -16,7 +16,9 @@
 RegisterNEML2ToMOOSEMaterialProperty(Real);
 RegisterNEML2ToMOOSEMaterialProperty(SymmetricRankTwoTensor);
 RegisterNEML2ToMOOSEMaterialProperty(SymmetricRankFourTensor);
-RegisterNEML2ToMOOSEMaterialProperty(StdVector);
+RegisterNEML2ToMOOSEMaterialProperty(RealVectorValue);
+RegisterNEML2ToMOOSEMaterialProperty(RankTwoTensor);
+RegisterNEML2ToMOOSEMaterialProperty(RankFourTensor);
 
 template <typename T>
 InputParameters
@@ -65,45 +67,42 @@ NEML2ToMOOSEMaterialProperty<T>::NEML2ToMOOSEMaterialProperty(const InputParamet
     _prop0(isParamValid("moose_material_property_init")
                ? &getMaterialProperty<T>("moose_material_property_init")
                : nullptr),
-    _output_view(
+    _value(
         !isParamValid("neml2_input_derivative")
             ? (!isParamValid("neml2_parameter_derivative")
-                   ? _execute_neml2_model.getOutputView(neml2::utils::parse<neml2::VariableName>(
-                         getParam<std::string>("from_neml2")))
-                   : _execute_neml2_model.getOutputParameterDerivativeView(
-                         neml2::utils::parse<neml2::VariableName>(
-                             getParam<std::string>("from_neml2")),
+                   ? _execute_neml2_model.getOutput(
+                         NEML2Utils::parseVariableName(getParam<std::string>("from_neml2")))
+                   : _execute_neml2_model.getOutputParameterDerivative(
+                         NEML2Utils::parseVariableName(getParam<std::string>("from_neml2")),
                          getParam<std::string>("neml2_parameter_derivative")))
-            : _execute_neml2_model.getOutputDerivativeView(
-                  neml2::utils::parse<neml2::VariableName>(getParam<std::string>("from_neml2")),
-                  neml2::utils::parse<neml2::VariableName>(
-                      getParam<std::string>("neml2_input_derivative"))))
+            : _execute_neml2_model.getOutputDerivative(
+                  NEML2Utils::parseVariableName(getParam<std::string>("from_neml2")),
+                  NEML2Utils::parseVariableName(getParam<std::string>("neml2_input_derivative"))))
 #endif
 {
   NEML2Utils::assertNEML2Enabled();
 }
 
 #ifdef NEML2_ENABLED
-template <typename T>
-void
-NEML2ToMOOSEMaterialProperty<T>::initQpStatefulProperties()
-{
-  if (_prop0)
-    _prop[_qp] = (*_prop0)[_qp];
-}
-
 template <typename T>
 void
 NEML2ToMOOSEMaterialProperty<T>::computeProperties()
 {
+  // See issue #28971: Using _prop0 to set initial condition for this possibly stateful property may
+  // not work. As a workaround, we set the initial condition here when _t_step == 0.
+  if (_t_step == 0 && _prop0)
+  {
+    _prop.set() = _prop0->get();
+    return;
+  }
+
   if (!_execute_neml2_model.outputReady())
     return;
 
   // look up start index for current element
   const auto i = _execute_neml2_model.getBatchIndex(_current_elem->id());
-
-  for (std::size_t qp = 0; qp < _qrule->n_points(); qp++)
-    _prop[qp] = NEML2Utils::toMOOSE<T>(_output_view.batch_index({neml2::Size(i + qp)}));
+  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
+    NEML2Utils::copyTensorToMOOSEData(_value.batch_index({neml2::Size(i + _qp)}), _prop[_qp]);
 }
 #endif
 
@@ -112,4 +111,6 @@ NEML2ToMOOSEMaterialProperty<T>::computeProperties()
 InstantiateNEML2ToMOOSEMaterialProperty(Real);
 InstantiateNEML2ToMOOSEMaterialProperty(SymmetricRankTwoTensor);
 InstantiateNEML2ToMOOSEMaterialProperty(SymmetricRankFourTensor);
-InstantiateNEML2ToMOOSEMaterialProperty(std::vector<Real>);
+InstantiateNEML2ToMOOSEMaterialProperty(RealVectorValue);
+InstantiateNEML2ToMOOSEMaterialProperty(RankTwoTensor);
+InstantiateNEML2ToMOOSEMaterialProperty(RankFourTensor);
diff --git a/modules/solid_mechanics/src/neml2/userobjects/MOOSEMaterialPropertyToNEML2.C b/modules/solid_mechanics/src/neml2/userobjects/MOOSEMaterialPropertyToNEML2.C
index 722fa8d29eab..37b92da7788a 100644
--- a/modules/solid_mechanics/src/neml2/userobjects/MOOSEMaterialPropertyToNEML2.C
+++ b/modules/solid_mechanics/src/neml2/userobjects/MOOSEMaterialPropertyToNEML2.C
@@ -16,40 +16,31 @@
 RegisterMOOSEMaterialPropertyToNEML2(Real);
 RegisterMOOSEMaterialPropertyToNEML2(RankTwoTensor);
 RegisterMOOSEMaterialPropertyToNEML2(SymmetricRankTwoTensor);
-RegisterMOOSEMaterialPropertyToNEML2(StdVector);
+RegisterMOOSEMaterialPropertyToNEML2(RealVectorValue);
 
 template <typename T, unsigned int state>
 InputParameters
 MOOSEMaterialPropertyToNEML2<T, state>::validParams()
 {
-  auto params = MOOSEToNEML2Batched::validParams();
+  auto params = MOOSEToNEML2Batched<T>::validParams();
   params.addClassDescription(NEML2Utils::docstring(
       "Gather a MOOSE material property of type " + demangle(typeid(T).name()) +
       " for insertion into the specified input or model parameter of a NEML2 model."));
-  params.addRequiredParam<MaterialPropertyName>(
+  params.template addRequiredParam<MaterialPropertyName>(
       "from_moose", NEML2Utils::docstring("MOOSE material property to read from"));
   return params;
 }
 
 template <typename T, unsigned int state>
 MOOSEMaterialPropertyToNEML2<T, state>::MOOSEMaterialPropertyToNEML2(const InputParameters & params)
-  : MOOSEToNEML2Batched(params)
+  : MOOSEToNEML2Batched<T>(params)
 #ifdef NEML2_ENABLED
     ,
-    _mat_prop(getGenericMaterialProperty<T, false>("from_moose", state))
+    _mat_prop(this->template getGenericMaterialProperty<T, false>("from_moose", state))
 #endif
 {
 }
 
-#ifdef NEML2_ENABLED
-template <typename T, unsigned int state>
-torch::Tensor
-MOOSEMaterialPropertyToNEML2<T, state>::convertQpMOOSEData() const
-{
-  return NEML2Utils::toNEML2<T>(_mat_prop[_qp]);
-}
-#endif
-
 #define InstantiateMOOSEMaterialPropertyToNEML2(T)                                                 \
   template class MOOSEMaterialPropertyToNEML2<T, 0>;                                               \
   template class MOOSEMaterialPropertyToNEML2<T, 1>
@@ -57,4 +48,4 @@ MOOSEMaterialPropertyToNEML2<T, state>::convertQpMOOSEData() const
 InstantiateMOOSEMaterialPropertyToNEML2(Real);
 InstantiateMOOSEMaterialPropertyToNEML2(RankTwoTensor);
 InstantiateMOOSEMaterialPropertyToNEML2(SymmetricRankTwoTensor);
-InstantiateMOOSEMaterialPropertyToNEML2(std::vector<Real>);
+InstantiateMOOSEMaterialPropertyToNEML2(RealVectorValue);
diff --git a/modules/solid_mechanics/src/neml2/userobjects/MOOSEPostprocessorToNEML2.C b/modules/solid_mechanics/src/neml2/userobjects/MOOSEPostprocessorToNEML2.C
index 0bd60de3f34c..7407de9cc62b 100644
--- a/modules/solid_mechanics/src/neml2/userobjects/MOOSEPostprocessorToNEML2.C
+++ b/modules/solid_mechanics/src/neml2/userobjects/MOOSEPostprocessorToNEML2.C
@@ -50,7 +50,7 @@ template <unsigned int state>
 neml2::Tensor
 MOOSEPostprocessorToNEML2Templ<state>::gatheredData() const
 {
-  return NEML2Utils::toNEML2<Real>(_moose_pp);
+  return neml2::Scalar::full(_moose_pp);
 }
 #endif
 
diff --git a/modules/solid_mechanics/src/neml2/userobjects/MOOSEToNEML2Batched.C b/modules/solid_mechanics/src/neml2/userobjects/MOOSEToNEML2Batched.C
deleted file mode 100644
index 48261a6ad13a..000000000000
--- a/modules/solid_mechanics/src/neml2/userobjects/MOOSEToNEML2Batched.C
+++ /dev/null
@@ -1,60 +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
-
-#include "MOOSEToNEML2Batched.h"
-
-InputParameters
-MOOSEToNEML2Batched::validParams()
-{
-  auto params = MOOSEToNEML2::validParams();
-  params += ElementUserObject::validParams();
-
-  // Since we use the NEML2 model to evaluate the residual AND the Jacobian at the same time, we
-  // want to execute this user object only at execute_on = LINEAR (i.e. during residual evaluation).
-  // The NONLINEAR exec flag below is for computing Jacobian during automatic scaling.
-  ExecFlagEnum execute_options = MooseUtils::getDefaultExecFlagEnum();
-  execute_options = {EXEC_INITIAL, EXEC_LINEAR, EXEC_NONLINEAR};
-  params.set<ExecFlagEnum>("execute_on") = execute_options;
-
-  return params;
-}
-
-MOOSEToNEML2Batched::MOOSEToNEML2Batched(const InputParameters & params)
-  : MOOSEToNEML2(params), ElementUserObject(params)
-{
-}
-
-#ifdef NEML2_ENABLED
-void
-MOOSEToNEML2Batched::initialize()
-{
-  _buffer.clear();
-}
-
-void
-MOOSEToNEML2Batched::execute()
-{
-  for (_qp = 0; _qp < _qrule->n_points(); _qp++)
-    _buffer.push_back(convertQpMOOSEData());
-}
-
-void
-MOOSEToNEML2Batched::threadJoin(const UserObject & uo)
-{
-  // append vectors
-  const auto & m2n = static_cast<const MOOSEToNEML2Batched &>(uo);
-  _buffer.insert(_buffer.end(), m2n._buffer.begin(), m2n._buffer.end());
-}
-
-neml2::Tensor
-MOOSEToNEML2Batched::gatheredData() const
-{
-  return neml2::Tensor(torch::stack(_buffer, 0), 1);
-}
-#endif
diff --git a/modules/solid_mechanics/src/neml2/userobjects/MOOSEVariableToNEML2.C b/modules/solid_mechanics/src/neml2/userobjects/MOOSEVariableToNEML2.C
index f88b7c92719c..bcb8f1621425 100644
--- a/modules/solid_mechanics/src/neml2/userobjects/MOOSEVariableToNEML2.C
+++ b/modules/solid_mechanics/src/neml2/userobjects/MOOSEVariableToNEML2.C
@@ -44,14 +44,5 @@ MOOSEVariableToNEML2Templ<1>::MOOSEVariableToNEML2Templ(const InputParameters &
 {
 }
 
-#ifdef NEML2_ENABLED
-template <unsigned int state>
-torch::Tensor
-MOOSEVariableToNEML2Templ<state>::convertQpMOOSEData() const
-{
-  return NEML2Utils::toNEML2<Real>(_moose_variable[_qp]);
-}
-#endif
-
 template class MOOSEVariableToNEML2Templ<0>;
 template class MOOSEVariableToNEML2Templ<1>;
diff --git a/modules/solid_mechanics/src/neml2/userobjects/NEML2ModelExecutor.C b/modules/solid_mechanics/src/neml2/userobjects/NEML2ModelExecutor.C
index b432fa0149fa..3e66ebcc05e4 100644
--- a/modules/solid_mechanics/src/neml2/userobjects/NEML2ModelExecutor.C
+++ b/modules/solid_mechanics/src/neml2/userobjects/NEML2ModelExecutor.C
@@ -25,9 +25,10 @@ NEML2ModelExecutor::actionParams()
   params.addParam<std::vector<std::string>>(
       "skip_inputs",
       {},
-      NEML2Utils::docstring("List of NEML2 variables to skip when setting up the model input. If "
-                            "an input variable is skipped, its value will stay zero. If a required "
-                            "input variable is not skipped, an error will be raised."));
+      NEML2Utils::docstring(
+          "List of NEML2 variables to skip error checking when setting up the model input. If an "
+          "input variable is skipped, its value will stay zero. If a required input variable is "
+          "not skipped, an error will be raised."));
   return params;
 }
 
@@ -66,23 +67,21 @@ NEML2ModelExecutor::NEML2ModelExecutor(const InputParameters & params)
 #ifdef NEML2_ENABLED
     ,
     _batch_index_generator(getUserObject<NEML2BatchIndexGenerator>("batch_index_generator")),
-    _output_ready(false),
-    _in(model().input_storage()),
-    _out(model().output_storage()),
-    _dout_din(model().derivative_storage())
+    _output_ready(false)
 #endif
 {
 #ifdef NEML2_ENABLED
+  validateModel();
+
   // add user object dependencies by name (the UOs do not need to exist yet for this)
   for (const auto & gatherer_name : getParam<std::vector<UserObjectName>>("gatherers"))
     _depend_uo.insert(gatherer_name);
   for (const auto & gatherer_name : getParam<std::vector<UserObjectName>>("param_gatherers"))
     _depend_uo.insert(gatherer_name);
 
+  // variables to skip error checking (converting vector to set to prevent duplicate checks)
   for (const auto & var_name : getParam<std::vector<std::string>>("skip_inputs"))
-    _skip_vars.insert(neml2::utils::parse<neml2::VariableName>(var_name));
-
-  validateModel();
+    _skip_vars.insert(NEML2Utils::parseVariableName(var_name));
 #endif
 }
 
@@ -95,26 +94,24 @@ NEML2ModelExecutor::initialSetup()
   {
     // gather coupled user objects late to ensure they are constructed. Do not add them as
     // dependencies (that's already done in the constructor).
-    const auto & uo = getUserObjectByName<MOOSEToNEML2>(gatherer_name, /*is_dependency = */ false);
+    const auto & uo = getUserObjectByName<MOOSEToNEML2>(gatherer_name, /*is_dependency=*/false);
 
-    // introspect the NEML2 model to figure out if the gatherer UO is gathering for a NEML2 input
-    // variable or for a NEML2 model parameter
-    if (model().input_axis().has_variable(getNEML2VariableName(uo.NEML2Name())))
-    {
-      auto varname = getNEML2VariableName(uo.NEML2Name());
-      if (varname.start_with("old_forces") || varname.start_with("old_state"))
-        uo.setMode(MOOSEToNEML2::Mode::OLD_VARIABLE);
-      else
-        uo.setMode(MOOSEToNEML2::Mode::VARIABLE);
-      addGatheredVariable(gatherer_name, uo.NEML2VariableName());
-    }
-    else
+    // the target neml2 variable must exist on the input axis
+    if (!model().input_axis().has_variable(NEML2Utils::parseVariableName(uo.NEML2Name())))
       mooseError("The MOOSEToNEML2 gatherer named '",
                  gatherer_name,
                  "' is gathering MOOSE data for a non-existent NEML2 input variable named '",
                  uo.NEML2Name(),
                  "'.");
 
+    // tell the gatherer to gather for a model input variable
+    const auto varname = NEML2Utils::parseVariableName(uo.NEML2Name());
+    if (varname.is_old_force() || varname.is_old_state())
+      uo.setMode(MOOSEToNEML2::Mode::OLD_VARIABLE);
+    else
+      uo.setMode(MOOSEToNEML2::Mode::VARIABLE);
+
+    addGatheredVariable(gatherer_name, uo.NEML2VariableName());
     _gatherers.push_back(&uo);
   }
 
@@ -123,32 +120,32 @@ NEML2ModelExecutor::initialSetup()
   {
     // gather coupled user objects late to ensure they are constructed. Do not add them as
     // dependencies (that's already done in the constructor).
-    const auto & uo = getUserObjectByName<MOOSEToNEML2>(gatherer_name, /*is_dependency = */ false);
+    const auto & uo = getUserObjectByName<MOOSEToNEML2>(gatherer_name, /*is_dependency=*/false);
 
     // introspect the NEML2 model to figure out if the gatherer UO is gathering for a NEML2 input
     // variable or for a NEML2 model parameter
-    if (model().named_parameters().has_key(uo.NEML2Name()))
-    {
-      uo.setMode(MOOSEToNEML2::Mode::PARAMETER);
-      addGatheredParameter(gatherer_name, uo.NEML2ParameterName());
-    }
-    else
+    if (!model().named_parameters().has_key(uo.NEML2Name()))
       mooseError("The MOOSEToNEML2 gatherer named '",
                  gatherer_name,
                  "' is gathering MOOSE data for a non-existent NEML2 model parameter named '",
                  uo.NEML2Name(),
                  "'.");
 
+    // tell the gatherer to gather for a model parameter
+    uo.setMode(MOOSEToNEML2::Mode::PARAMETER);
+
+    addGatheredParameter(gatherer_name, uo.NEML2ParameterName());
     _gatherers.push_back(&uo);
   }
 
   // iterate over set of required inputs and error out if we find one that is not provided
-  std::set<neml2::VariableName> required_inputs = model().input_axis().variable_names();
+  std::vector<neml2::VariableName> required_inputs = model().input_axis().variable_names();
   for (const auto & input : required_inputs)
   {
     if (_skip_vars.count(input))
       continue;
-    if (input.start_with("state"))
+    // skip input state variables because they are "initial guesses" to the nonlinear system
+    if (input.is_state())
       continue;
     if (!_gathered_variable_names.count(input))
       paramError("gatherers", "The required model input `", input, "` is not gathered");
@@ -158,7 +155,7 @@ NEML2ModelExecutor::initialSetup()
   // sufficient for stateful data management, but that's the best we can do here without being
   // overly restrictive.
   for (const auto & input : required_inputs)
-    if (input.start_with("old_state") && !_retrieved_outputs.count(input.remount("state")))
+    if (input.is_old_state() && !_retrieved_outputs.count(input.current()))
       mooseError(
           "The NEML2 model requires a stateful input variable `",
           input,
@@ -219,12 +216,6 @@ NEML2ModelExecutor::execute()
 
   try
   {
-    auto batch_shape = neml2::TensorShape{neml2::Size(_batch_index_generator.getBatchIndex())};
-
-    // Reallocate the variable storage only when the batch shape has changed
-    if (neml2::TensorShapeRef(batch_shape) != model().batch_sizes())
-      initModel(batch_shape);
-
     fillInputs();
 
     if (_t_step > 0)
@@ -255,50 +246,75 @@ void
 NEML2ModelExecutor::fillInputs()
 {
   for (const auto & uo : _gatherers)
-    uo->insertInto(model());
+    uo->insertInto(_in, _model_params);
+
+  // Update model parameters
+  model().set_parameters(_model_params);
+  _model_params.clear();
 
   // Request gradient for the model parameters that we request AD for
-  for (auto & [deriv, tensor] : _retrieved_parameter_derivatives)
-    model().get_parameter(deriv.second).requires_grad_(true);
+  for (const auto & [y, dy] : _retrieved_parameter_derivatives)
+    for (const auto & [p, tensor] : dy)
+      model().get_parameter(p).requires_grad_(true);
 }
 
 void
 NEML2ModelExecutor::applyPredictor()
 {
+  if (!model().input_axis().has_state())
+    return;
+
   // Set trial state variables (i.e., initial guesses).
   // Right now we hard-code to use the old state as the trial state.
   // TODO: implement other predictors
-  if (model().input_axis().has_subaxis("state") && model().input_axis().has_subaxis("old_state"))
-    _in.slice("state").fill(_in.slice("old_state"));
+  const auto input_state = model().input_axis().subaxis(neml2::STATE);
+  const auto input_old_state = model().input_axis().subaxis(neml2::OLD_STATE);
+  for (const auto & var : input_state.variable_names())
+    if (input_old_state.has_variable(var))
+      _in[var.prepend(neml2::STATE)] = _in[var.prepend(neml2::OLD_STATE)];
 }
 
 void
 NEML2ModelExecutor::solve()
 {
   // Evaluate the NEML2 material model
-  model().value_and_dvalue(_in);
+  std::tie(_out, _dout_din) = model().value_and_dvalue(_in);
+  _in.clear();
 }
 
 void
 NEML2ModelExecutor::extractOutputs()
 {
+  const auto N = _batch_index_generator.getBatchIndex();
+
   // retrieve outputs
-  for (auto & [y, tensor] : _retrieved_outputs)
-    tensor = _out.base_index(y).to(torch::kCPU);
+  for (auto & [y, target] : _retrieved_outputs)
+    target = _out[y].to(torch::kCPU);
+
+  // retrieve parameter derivatives
+  for (auto & [y, dy] : _retrieved_parameter_derivatives)
+    for (auto & [p, target] : dy)
+      target = neml2::math::jacrev(_out[y],
+                                   model().get_parameter(p),
+                                   /*retain_graph=*/true,
+                                   /*create_graph=*/false,
+                                   /*allow_unused=*/false)
+                   .to(torch::kCPU);
+
+  // clear output
+  _out.clear();
 
   // retrieve derivatives
-  for (auto & [deriv, tensor] : _retrieved_derivatives)
-  {
-    auto & [y, x] = deriv;
-    tensor = _dout_din.base_index({y, x}).to(torch::kCPU);
-  }
+  for (auto & [y, dy] : _retrieved_derivatives)
+    for (auto & [x, target] : dy)
+    {
+      const auto & source = _dout_din[y][x];
+      if (source.defined())
+        target = source.to(torch::kCPU).batch_expand({neml2::Size(N)});
+    }
 
-  // retrieve parameter derivatives
-  for (auto & [deriv, tensor] : _retrieved_parameter_derivatives)
-  {
-    auto & [y, p] = deriv;
-    tensor = neml2::math::jacrev(_out.base_index(y), model().get_parameter(p)).to(torch::kCPU);
-  }
+  // clear derivatives
+  _dout_din.clear();
 }
 
 void
@@ -310,7 +326,7 @@ NEML2ModelExecutor::checkExecutionStage() const
 }
 
 const neml2::Tensor &
-NEML2ModelExecutor::getOutputView(const neml2::VariableName & output_name) const
+NEML2ModelExecutor::getOutput(const neml2::VariableName & output_name) const
 {
   checkExecutionStage();
 
@@ -321,8 +337,8 @@ NEML2ModelExecutor::getOutputView(const neml2::VariableName & output_name) const
 }
 
 const neml2::Tensor &
-NEML2ModelExecutor::getOutputDerivativeView(const neml2::VariableName & output_name,
-                                            const neml2::VariableName & input_name) const
+NEML2ModelExecutor::getOutputDerivative(const neml2::VariableName & output_name,
+                                        const neml2::VariableName & input_name) const
 {
   checkExecutionStage();
 
@@ -340,12 +356,12 @@ NEML2ModelExecutor::getOutputDerivativeView(const neml2::VariableName & output_n
                input_name,
                "', but the NEML2 input variable does not exist.");
 
-  return _retrieved_derivatives[{output_name, input_name}];
+  return _retrieved_derivatives[output_name][input_name];
 }
 
 const neml2::Tensor &
-NEML2ModelExecutor::getOutputParameterDerivativeView(const neml2::VariableName & output_name,
-                                                     const std::string & parameter_name) const
+NEML2ModelExecutor::getOutputParameterDerivative(const neml2::VariableName & output_name,
+                                                 const std::string & parameter_name) const
 {
   checkExecutionStage();
 
@@ -363,7 +379,7 @@ NEML2ModelExecutor::getOutputParameterDerivativeView(const neml2::VariableName &
                parameter_name,
                "', but the NEML2 model parameter does not exist.");
 
-  return _retrieved_parameter_derivatives[{output_name, parameter_name}];
+  return _retrieved_parameter_derivatives[output_name][parameter_name];
 }
 
 #endif
diff --git a/modules/solid_mechanics/src/neml2/utils/NEML2Utils.C b/modules/solid_mechanics/src/neml2/utils/NEML2Utils.C
index bbccc4a6b60a..63fd01fa75ed 100644
--- a/modules/solid_mechanics/src/neml2/utils/NEML2Utils.C
+++ b/modules/solid_mechanics/src/neml2/utils/NEML2Utils.C
@@ -10,43 +10,8 @@
 #include "NEML2Utils.h"
 #include "SubProblem.h"
 
-#ifdef NEML2_ENABLED
-
-#include "VariadicTable.h"
-
-namespace neml2
-{
-
-std::ostream &
-operator<<(std::ostream & os, const Model & model)
-{
-  VariadicTable<std::string, std::string, std::string, Size> table(
-      {"Type", "Name", "Tensor type", "Storage size"});
-
-  for (const auto && [name, var] : model.input_variables())
-    table.addRow("input", utils::stringify(name), utils::stringify(var.type()), var.base_storage());
-
-  for (const auto && [name, var] : model.output_variables())
-    table.addRow(
-        "output", utils::stringify(name), utils::stringify(var.type()), var.base_storage());
-
-  for (auto && [name, param] : model.named_parameters())
-    table.addRow("parameter", name, utils::stringify(param.type()), Tensor(param).base_storage());
-
-  for (auto && [name, buffer] : model.named_buffers())
-    table.addRow("buffer", name, utils::stringify(buffer.type()), Tensor(buffer).base_storage());
-
-  table.print(os);
-
-  return os;
-}
-} // namespace neml2
-
-#endif // NEML2_ENABLED
-
 namespace NEML2Utils
 {
-
 #ifdef NEML2_ENABLED
 void
 assertVariable(const neml2::VariableName & v)
@@ -54,12 +19,8 @@ assertVariable(const neml2::VariableName & v)
   if (v.empty())
     mooseError("Empty NEML2 variable");
 
-  if (!v.start_with("forces") && !v.start_with("state"))
-    mooseError("The NEML2 variable '",
-               v,
-               "' should be defined on the forces or the state sub-axis, got ",
-               v.slice(0, 1),
-               " instead");
+  if (!v.is_force() && !v.is_state())
+    mooseError("The NEML2 variable '", v, "' is on the wrong subaxis.");
 }
 
 void
@@ -68,86 +29,15 @@ assertOldVariable(const neml2::VariableName & v)
   if (v.empty())
     mooseError("Empty NEML2 variable");
 
-  if (!v.start_with("old_forces") && !v.start_with("old_state"))
-    mooseError("The NEML2 variable '",
-               v,
-               "' should be defined on the old_forces or the old_state sub-axis, got ",
-               v.slice(0, 1),
-               " instead");
-}
-
-template <>
-neml2::Tensor
-toNEML2(const Real & v)
-{
-  return neml2::Scalar::full(v);
-}
-
-// FIXME: This is an unfortunately specialization because the models I included for testing use
-// symmetric tensors everywhere. Once I tested all the models with full tensors (i.e. not in Mandel
-// notation), I should be able to "fix" this specialization.
-template <>
-neml2::Tensor
-toNEML2(const RankTwoTensor & r2t)
-{
-  return neml2::SR2::fill(r2t(0, 0), r2t(1, 1), r2t(2, 2), r2t(1, 2), r2t(0, 2), r2t(0, 1));
-}
-
-template <>
-neml2::Tensor
-toNEML2(const SymmetricRankTwoTensor & r2t)
-{
-  return neml2::SR2::fill(r2t(0, 0), r2t(1, 1), r2t(2, 2), r2t(1, 2), r2t(0, 2), r2t(0, 1));
-}
-
-template <>
-neml2::Tensor
-toNEML2(const std::vector<Real> & v)
-{
-  return neml2::Tensor(torch::tensor(v, neml2::default_tensor_options()), 0);
-}
-
-template <>
-Real
-toMOOSE(const neml2::Tensor & t)
-{
-  return t.item<Real>();
-}
-
-template <>
-SymmetricRankTwoTensor
-toMOOSE(const neml2::Tensor & t)
-{
-  using symr2t = SymmetricRankTwoTensor;
-  return symr2t(t.base_index({0}).item<neml2::Real>() / symr2t::mandelFactor(0),
-                t.base_index({1}).item<neml2::Real>() / symr2t::mandelFactor(1),
-                t.base_index({2}).item<neml2::Real>() / symr2t::mandelFactor(2),
-                t.base_index({3}).item<neml2::Real>() / symr2t::mandelFactor(3),
-                t.base_index({4}).item<neml2::Real>() / symr2t::mandelFactor(4),
-                t.base_index({5}).item<neml2::Real>() / symr2t::mandelFactor(5));
-}
-
-template <>
-std::vector<Real>
-toMOOSE(const neml2::Tensor & t)
-{
-  auto tc = t.contiguous();
-  return std::vector<Real>(tc.data_ptr<neml2::Real>(), tc.data_ptr<neml2::Real>() + tc.numel());
+  if (!v.is_old_force() && !v.is_old_state())
+    mooseError("The NEML2 variable '", v, "' is on the wrong subaxis.");
 }
 
-template <>
-SymmetricRankFourTensor
-toMOOSE(const neml2::Tensor & t)
+neml2::VariableName
+parseVariableName(const std::string & s)
 {
-  // Well I don't see a good constructor for this, so let me fill out all the components.
-  SymmetricRankFourTensor symsymr4t;
-  for (const auto a : make_range(6))
-    for (const auto b : make_range(6))
-      symsymr4t(a, b) = t.base_index({a, b}).item<neml2::Real>();
-
-  return symsymr4t;
+  return neml2::utils::parse<neml2::VariableName>(s);
 }
-
 #endif // NEML2_ENABLED
 
 static const std::string missing_neml2 = "The `NEML2` library is required but not enabled. Refer "
diff --git a/modules/solid_mechanics/test/neml2/include/NEML2TestModel.h b/modules/solid_mechanics/test/neml2/include/NEML2TestModel.h
index 7de9326b8ed3..561f1a6d6a43 100644
--- a/modules/solid_mechanics/test/neml2/include/NEML2TestModel.h
+++ b/modules/solid_mechanics/test/neml2/include/NEML2TestModel.h
@@ -21,6 +21,8 @@ class NEML2TestModel : public Model
 
   NEML2TestModel(const OptionSet & options);
 
+  void request_AD() override;
+
 protected:
   // input variables
   const Variable<Scalar> & _input_a;
diff --git a/modules/solid_mechanics/test/neml2/src/NEML2TestModel.cxx b/modules/solid_mechanics/test/neml2/src/NEML2TestModel.cxx
index 85e32088c883..54892ec53275 100644
--- a/modules/solid_mechanics/test/neml2/src/NEML2TestModel.cxx
+++ b/modules/solid_mechanics/test/neml2/src/NEML2TestModel.cxx
@@ -22,9 +22,6 @@ NEML2TestModel::expected_options()
   options.set<VariableName>("B") = VariableName("forces", "B");
   options.set<VariableName>("sum") = VariableName("state", "internal", "sum");
   options.set<VariableName>("product") = VariableName("state", "internal", "product");
-  // Use AD
-  options.set<bool>("_use_AD_first_derivative") = true;
-  options.set<bool>("_use_AD_second_derivative") = true;
   return options;
 }
 
@@ -39,6 +36,16 @@ NEML2TestModel::NEML2TestModel(const OptionSet & options)
 {
 }
 
+void
+NEML2TestModel::request_AD()
+{
+  std::vector<const VariableBase *> inputs = {&_input_a, &_input_b};
+
+  // First derivatives
+  _sum.request_AD(inputs);
+  _product.request_AD(inputs);
+}
+
 void
 NEML2TestModel::set_value(bool out, bool dout_din, bool d2out_din2)
 {
diff --git a/modules/solid_mechanics/test/tests/neml2/crystal_plasticity.i b/modules/solid_mechanics/test/tests/neml2/crystal_plasticity.i
new file mode 100644
index 000000000000..0bd3f7da5ef3
--- /dev/null
+++ b/modules/solid_mechanics/test/tests/neml2/crystal_plasticity.i
@@ -0,0 +1,118 @@
+N = 2
+
+[GlobalParams]
+  displacements = 'disp_x disp_y disp_z'
+[]
+
+[Mesh]
+  [gmg]
+    type = GeneratedMeshGenerator
+    dim = 3
+    nx = ${N}
+    ny = ${N}
+    nz = ${N}
+  []
+[]
+
+[Physics]
+  [SolidMechanics]
+    [QuasiStatic]
+      [all]
+        strain = FINITE
+        new_system = true
+        add_variables = true
+        formulation = TOTAL
+        volumetric_locking_correction = true
+      []
+    []
+  []
+[]
+
+[NEML2]
+  input = 'models/crystal_plasticity.i'
+  [all]
+    model = 'model'
+    verbose = true
+    device = 'cpu'
+
+    moose_input_types = 'MATERIAL                           POSTPROCESSOR POSTPROCESSOR MATERIAL                  MATERIAL                  MATERIAL'
+    moose_inputs = '     spatial_velocity_increment         time          time          elastic_strain            orientation               slip_hardening'
+    neml2_inputs = '     forces/spatial_velocity_increment  forces/t      old_forces/t  old_state/elastic_strain  old_state/orientation     old_state/internal/slip_hardening'
+
+    moose_output_types = 'MATERIAL                            MATERIAL                  MATERIAL                  MATERIAL'
+    moose_outputs = '     neml2_cauchy_stress                 elastic_strain            orientation               slip_hardening'
+    neml2_outputs = '     state/internal/full_cauchy_stress   state/elastic_strain      state/orientation         state/internal/slip_hardening'
+
+    moose_derivative_types = 'MATERIAL'
+    moose_derivatives = '     neml2_cauchy_jacobian'
+    neml2_derivatives = '     state/internal/full_cauchy_stress forces/spatial_velocity_increment'
+
+    initialize_outputs = '      orientation'
+    initialize_output_values = 'initial_orientation'
+  []
+[]
+
+[Postprocessors]
+  [time]
+    type = TimePostprocessor
+    execute_on = 'INITIAL TIMESTEP_BEGIN'
+  []
+[]
+
+[Materials]
+  [copy]
+    type = ComputeLagrangianCauchyCustomStress
+    custom_cauchy_stress = 'neml2_cauchy_stress'
+    custom_cauchy_jacobian = 'neml2_cauchy_jacobian'
+  []
+  [initial_orientation]
+    type = GenericConstantRealVectorValue
+    vector_name = 'initial_orientation'
+    vector_values = '-0.54412095 -0.34931944 0.12600655'
+  []
+[]
+
+[BCs]
+  [xfix]
+    type = DirichletBC
+    variable = disp_x
+    boundary = left
+    value = 0
+  []
+  [yfix]
+    type = DirichletBC
+    variable = disp_y
+    boundary = bottom
+    value = 0
+  []
+  [zfix]
+    type = DirichletBC
+    variable = disp_z
+    boundary = back
+    value = 0
+  []
+  [xdisp]
+    type = FunctionDirichletBC
+    variable = disp_x
+    boundary = right
+    function = t
+    preset = false
+  []
+[]
+
+[Executioner]
+  type = Transient
+  solve_type = NEWTON
+  petsc_options_iname = '-pc_type'
+  petsc_options_value = 'lu'
+  automatic_scaling = true
+  dt = 5e-3
+  dtmin = 1e-3
+  num_steps = 5
+  residual_and_jacobian_together = true
+[]
+
+[Outputs]
+  file_base = 'crystal_plasticity'
+  exodus = true
+[]
diff --git a/modules/solid_mechanics/test/tests/neml2/custom_model.i b/modules/solid_mechanics/test/tests/neml2/custom_model.i
index 312311f23bb9..a7a85e4b2496 100644
--- a/modules/solid_mechanics/test/tests/neml2/custom_model.i
+++ b/modules/solid_mechanics/test/tests/neml2/custom_model.i
@@ -13,7 +13,6 @@
     model = 'model'
     verbose = true
     device = 'cpu'
-    enable_AD = true
 
     moose_input_types = 'VARIABLE MATERIAL'
     moose_inputs = '     a        b'
diff --git a/modules/solid_mechanics/test/tests/neml2/gold/crystal_plasticity.e b/modules/solid_mechanics/test/tests/neml2/gold/crystal_plasticity.e
new file mode 100644
index 0000000000000000000000000000000000000000..88f76a60081b859fb0b330a6c9bc384b5903f4a8
GIT binary patch
literal 77488
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

literal 0
HcmV?d00001

diff --git a/modules/solid_mechanics/test/tests/neml2/models/crystal_plasticity.i b/modules/solid_mechanics/test/tests/neml2/models/crystal_plasticity.i
new file mode 100644
index 000000000000..2459ca64e6b6
--- /dev/null
+++ b/modules/solid_mechanics/test/tests/neml2/models/crystal_plasticity.i
@@ -0,0 +1,128 @@
+[Tensors]
+  [a]
+    type = Scalar
+    values = '1.0'
+  []
+  [sdirs]
+    type = FillMillerIndex
+    values = '1 1 0'
+  []
+  [splanes]
+    type = FillMillerIndex
+    values = '1 1 1'
+  []
+[]
+
+[Solvers]
+  [newton]
+    type = NewtonWithLineSearch
+    max_linesearch_iterations = 5
+  []
+[]
+
+[Data]
+  [crystal_geometry]
+    type = CubicCrystal
+    lattice_parameter = "a"
+    slip_directions = "sdirs"
+    slip_planes = "splanes"
+  []
+[]
+
+[Models]
+  [spatial_velocity_gradient]
+    type = R2IncrementalRate
+    variable = 'forces/spatial_velocity_increment'
+    time = 'forces/t'
+    rate = 'forces/spatial_velocity_gradient'
+  []
+  [split_to_deformation_rate]
+    type = R2toSR2
+    input = 'forces/spatial_velocity_gradient'
+    output = 'forces/deformation_rate'
+  []
+  [split_to_vorticity]
+    type = R2toWR2
+    input = 'forces/spatial_velocity_gradient'
+    output = 'forces/vorticity'
+  []
+  [euler_rodrigues]
+    type = RotationMatrix
+    from = 'state/orientation'
+    to = 'state/orientation_matrix'
+  []
+  [elasticity]
+    type = LinearIsotropicElasticity
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
+    coefficients = '1e5 0.25'
+    strain = "state/elastic_strain"
+    stress = "state/internal/cauchy_stress"
+  []
+  [resolved_shear]
+    type = ResolvedShear
+  []
+  [elastic_stretch]
+    type = ElasticStrainRate
+  []
+  [plastic_spin]
+    type = PlasticVorticity
+  []
+  [plastic_deformation_rate]
+    type = PlasticDeformationRate
+  []
+  [orientation_rate]
+    type = OrientationRate
+  []
+  [sum_slip_rates]
+    type = SumSlipRates
+  []
+  [slip_rule]
+    type = PowerLawSlipRule
+    n = 8.0
+    gamma0 = 2.0e-1
+  []
+  [slip_strength]
+    type = SingleSlipStrengthMap
+    constant_strength = 50.0
+  []
+  [voce_hardening]
+    type = VoceSingleSlipHardeningRule
+    initial_slope = 500.0
+    saturated_hardening = 50.0
+  []
+  [integrate_slip_hardening]
+    type = ScalarBackwardEulerTimeIntegration
+    variable = 'state/internal/slip_hardening'
+  []
+  [integrate_elastic_strain]
+    type = SR2BackwardEulerTimeIntegration
+    variable = 'state/elastic_strain'
+  []
+  [integrate_orientation]
+    type = WR2ImplicitExponentialTimeIntegration
+    variable = 'state/orientation'
+  []
+
+  [implicit_rate]
+    type = ComposedModel
+    models = "spatial_velocity_gradient split_to_deformation_rate split_to_vorticity euler_rodrigues elasticity orientation_rate resolved_shear
+              elastic_stretch plastic_deformation_rate plastic_spin
+              sum_slip_rates slip_rule slip_strength voce_hardening
+              integrate_slip_hardening integrate_elastic_strain integrate_orientation"
+  []
+  [model_without_stress]
+    type = ImplicitUpdate
+    implicit_model = 'implicit_rate'
+    solver = 'newton'
+  []
+  [full_stress]
+    type = SR2toR2
+    input = 'state/internal/cauchy_stress'
+    output = 'state/internal/full_cauchy_stress'
+  []
+  [model]
+    type = ComposedModel
+    models = 'model_without_stress elasticity full_stress'
+    additional_outputs = 'state/elastic_strain'
+  []
+[]
diff --git a/modules/solid_mechanics/test/tests/neml2/models/elasticity.i b/modules/solid_mechanics/test/tests/neml2/models/elasticity.i
index c2a54c6ed04a..f5e9f15b7013 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/elasticity.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/elasticity.i
@@ -1,8 +1,8 @@
 [Models]
   [model]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1
-    poisson_ratio = 0.3
+    coefficients = '1 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     strain = 'forces/E'
   []
 []
diff --git a/modules/solid_mechanics/test/tests/neml2/models/elasticity_2.i b/modules/solid_mechanics/test/tests/neml2/models/elasticity_2.i
index fc11758a371b..a06662ac9108 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/elasticity_2.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/elasticity_2.i
@@ -1,14 +1,14 @@
 [Models]
   [model1]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1
-    poisson_ratio = 0.3
+    coefficients = '1 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     strain = 'forces/E'
   []
   [model2]
     type = LinearIsotropicElasticity
-    youngs_modulus = 2
-    poisson_ratio = 0.3
+    coefficients = '2 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     strain = 'forces/E'
   []
 []
diff --git a/modules/solid_mechanics/test/tests/neml2/models/error.i b/modules/solid_mechanics/test/tests/neml2/models/error.i
index d1a3b30f24b7..a35727029365 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/error.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/error.i
@@ -50,8 +50,8 @@
   []
   [elasticity]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     rate_form = true
   []
   [integrate_stress]
diff --git a/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_isoharden.i b/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_isoharden.i
index ab20052a632f..4893a9e0e42b 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_isoharden.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_isoharden.i
@@ -18,8 +18,8 @@
   []
   [elasticity]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
   []
   [mandel_stress]
     type = IsotropicMandelStress
diff --git a/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_isokinharden.i b/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_isokinharden.i
index 82fb3d591ac9..18a611ea53bd 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_isokinharden.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_isokinharden.i
@@ -22,8 +22,8 @@
   []
   [elasticity]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
   []
   [mandel_stress]
     type = IsotropicMandelStress
diff --git a/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_kinharden.i b/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_kinharden.i
index 7c6b149a198d..dc2adb553e5b 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_kinharden.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_kinharden.i
@@ -17,8 +17,8 @@
   []
   [elasticity]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
   []
   [mandel_stress]
     type = IsotropicMandelStress
diff --git a/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_perfect.i b/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_perfect.i
index 852c3b626605..0da308dd49c6 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_perfect.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/rate_independent_plasticity_perfect.i
@@ -13,8 +13,8 @@
   []
   [elasticity]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
   []
   [mandel_stress]
     type = IsotropicMandelStress
diff --git a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_chaboche.i b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_chaboche.i
index b7e55f8f12fe..16ebe0a9b506 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_chaboche.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_chaboche.i
@@ -85,8 +85,8 @@
   []
   [elasticity]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     rate_form = true
   []
   [integrate_ep]
diff --git a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_isoharden.i b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_isoharden.i
index f56c3fa1de1e..2652dd7d89e9 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_isoharden.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_isoharden.i
@@ -57,8 +57,8 @@
   []
   [elasticity]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     rate_form = true
   []
   [integrate_stress]
diff --git a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_isokinharden.i b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_isokinharden.i
index 54305d68ff0f..d8e40c076e60 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_isokinharden.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_isokinharden.i
@@ -70,8 +70,8 @@
   []
   [elasticity]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     rate_form = true
   []
   [integrate_ep]
diff --git a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_kinharden.i b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_kinharden.i
index 77a928dd3a36..aca3cc984184 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_kinharden.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_kinharden.i
@@ -62,8 +62,8 @@
   []
   [elasticity]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     rate_form = true
   []
   [integrate_Kp]
diff --git a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_perfect.i b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_perfect.i
index b276b92bddeb..f88733dc3995 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_perfect.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_perfect.i
@@ -49,8 +49,8 @@
   []
   [elasticity]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     rate_form = true
   []
   [integrate_stress]
diff --git a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_radial_return.i b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_radial_return.i
index 2aef40ce234c..37ff9d878164 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_radial_return.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/viscoplasticity_radial_return.i
@@ -17,8 +17,8 @@
   []
   [trial_cauchy_stress]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
     strain = 'forces/Ee_trial'
     stress = 'forces/S_trial'
   []
@@ -79,8 +79,8 @@
   []
   [cauchy_stress]
     type = LinearIsotropicElasticity
-    youngs_modulus = 1e5
-    poisson_ratio = 0.3
+    coefficients = '1e5 0.3'
+    coefficient_types = 'YOUNGS_MODULUS POISSONS_RATIO'
   []
   [mandel_stress]
     type = IsotropicMandelStress
diff --git a/modules/solid_mechanics/test/tests/neml2/tests b/modules/solid_mechanics/test/tests/neml2/tests
index 018fc91ee2fc..9046793f9bae 100644
--- a/modules/solid_mechanics/test/tests/neml2/tests
+++ b/modules/solid_mechanics/test/tests/neml2/tests
@@ -69,6 +69,16 @@
     issues = '#27493'
     collections = 'SYSTEM'
     requirement = 'The system shall be capable of modularly interfacing with the NEML2 library to perform constitutive update '
+    [crystal_plasticity]
+      detail = 'in a crystal plasticity problem.'
+      type = Exodiff
+      input = 'crystal_plasticity.i'
+      exodiff = 'crystal_plasticity.e'
+      required_submodule = 'contrib/neml2'
+      libtorch = true
+      recover = false
+      valgrind = heavy
+    []
     [elasticity]
       detail = 'to solve an elasticity problem;'
       type = Exodiff
diff --git a/modules/solid_mechanics/unit/src/NEML2UtilsTest.C b/modules/solid_mechanics/unit/src/NEML2UtilsTest.C
new file mode 100644
index 000000000000..49c4fef37dc6
--- /dev/null
+++ b/modules/solid_mechanics/unit/src/NEML2UtilsTest.C
@@ -0,0 +1,174 @@
+//* 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 "gtest/gtest.h"
+
+#include "NEML2Utils.h"
+
+#ifdef NEML2_ENABLED
+TEST(NEML2Utils, fromBlob_Real)
+{
+  std::vector<Real> data(3);
+  data[0] = 1.0;
+  data[1] = 2.0;
+  data[2] = 3.0;
+
+  auto tensor = NEML2Utils::fromBlob(data);
+  ASSERT_TRUE(tensor.defined());
+  ASSERT_TRUE(tensor.dim() == 1);
+  ASSERT_TRUE(tensor.batch_dim() == 1);
+  ASSERT_TRUE(tensor.base_dim() == 0);
+  ASSERT_TRUE(tensor.size(0) == 3);
+
+  for (neml2::Size n : index_range(data))
+    EXPECT_NEAR(tensor.index({n}).item<Real>(), data[n], 1e-12);
+}
+
+TEST(NEML2Utils, fromBlob_RealVectorValue)
+{
+  std::vector<RealVectorValue> data(3);
+  data[0] = RealVectorValue(1.0, 2.0, 3.0);
+  data[1] = RealVectorValue(4.0, 5.0, 6.0);
+  data[2] = RealVectorValue(7.0, 8.0, 9.0);
+
+  auto tensor = NEML2Utils::fromBlob(data);
+  ASSERT_TRUE(tensor.defined());
+  ASSERT_TRUE(tensor.dim() == 2);
+  ASSERT_TRUE(tensor.batch_dim() == 1);
+  ASSERT_TRUE(tensor.base_dim() == 1);
+  ASSERT_TRUE(tensor.size(0) == 3);
+  ASSERT_TRUE(tensor.size(1) == 3);
+
+  for (neml2::Size n : index_range(data))
+    for (neml2::Size i : make_range(3))
+      EXPECT_NEAR(tensor.index({n, i}).item<Real>(), data[n](i), 1e-12);
+}
+
+TEST(NEML2Utils, fromBlob_RankTwoTensor)
+{
+  std::vector<RankTwoTensor> data(2);
+  data[0] = RankTwoTensor(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+  data[1] = RankTwoTensor(-1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0);
+
+  auto tensor = NEML2Utils::fromBlob(data);
+  ASSERT_TRUE(tensor.defined());
+  ASSERT_TRUE(tensor.dim() == 3);
+  ASSERT_TRUE(tensor.batch_dim() == 1);
+  ASSERT_TRUE(tensor.base_dim() == 2);
+  ASSERT_TRUE(tensor.size(0) == 2);
+  ASSERT_TRUE(tensor.size(1) == 3);
+  ASSERT_TRUE(tensor.size(2) == 3);
+
+  for (neml2::Size n : index_range(data))
+    for (neml2::Size i : make_range(3))
+      for (neml2::Size j : make_range(3))
+        EXPECT_NEAR(tensor.index({n, i, j}).item<Real>(), data[n](i, j), 1e-12);
+}
+
+TEST(NEML2Utils, fromBlob_SymmetricRankTwoTensor)
+{
+  std::vector<SymmetricRankTwoTensor> data(2);
+  data[0] = SymmetricRankTwoTensor(1.0, 2.0, 3.0, 4.0, 5.0, 6.0);
+  data[1] = SymmetricRankTwoTensor(-1.0, -2.0, -3.0, -4.0, -5.0, -6.0);
+
+  auto tensor = NEML2Utils::fromBlob(data);
+  ASSERT_TRUE(tensor.defined());
+  ASSERT_TRUE(tensor.dim() == 2);
+  ASSERT_TRUE(tensor.batch_dim() == 1);
+  ASSERT_TRUE(tensor.base_dim() == 1);
+  ASSERT_TRUE(tensor.size(0) == 2);
+  ASSERT_TRUE(tensor.size(1) == 6);
+
+  for (neml2::Size n : index_range(data))
+    for (neml2::Size i : make_range(6))
+      EXPECT_NEAR(tensor.index({n, i}).item<Real>(), data[n](i), 1e-12);
+}
+
+TEST(NEML2Utils, copyTensorToMOOSEData_Real)
+{
+  Real data;
+  const auto tensor = torch::tensor(1.0, torch::TensorOptions().dtype(torch::kFloat64));
+  NEML2Utils::copyTensorToMOOSEData(tensor, data);
+
+  EXPECT_NEAR(tensor.item<Real>(), data, 1e-12);
+}
+
+TEST(NEML2Utils, copyTensorToMOOSEData_RealVectorValue)
+{
+  RealVectorValue data;
+  const auto tensor = torch::tensor({1.0, 2.0, 3.0}, torch::TensorOptions().dtype(torch::kFloat64));
+  NEML2Utils::copyTensorToMOOSEData(tensor, data);
+
+  for (neml2::Size i : make_range(3))
+    EXPECT_NEAR(tensor.index({i}).item<Real>(), data(i), 1e-12);
+}
+
+TEST(NEML2Utils, copyTensorToMOOSEData_RankTwoTensor)
+{
+  RankTwoTensor data;
+  const auto tensor = torch::tensor({{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0}},
+                                    torch::TensorOptions().dtype(torch::kFloat64));
+  NEML2Utils::copyTensorToMOOSEData(tensor, data);
+
+  for (neml2::Size i : make_range(3))
+    for (neml2::Size j : make_range(3))
+      EXPECT_NEAR(tensor.index({i, j}).item<Real>(), data(i, j), 1e-12);
+}
+
+TEST(NEML2Utils, copyTensorToMOOSEData_SymmetricRankTwoTensor)
+{
+  SymmetricRankTwoTensor data;
+  const auto tensor =
+      torch::tensor({1.0, 2.0, 3.0, 4.0, 5.0, 6.0}, torch::TensorOptions().dtype(torch::kFloat64));
+  NEML2Utils::copyTensorToMOOSEData(tensor, data);
+
+  for (neml2::Size i : make_range(6))
+    EXPECT_NEAR(tensor.index({i}).item<Real>(), data(i), 1e-12);
+}
+
+TEST(NEML2Utils, copyTensorToMOOSEData_RankFourTensor)
+{
+  RankFourTensor data;
+  const auto tensor =
+      torch::tensor({{{{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0}},
+                      {{10.0, 11.0, 12.0}, {13.0, 14.0, 15.0}, {16.0, 17.0, 18.0}},
+                      {{19.0, 20.0, 21.0}, {22.0, 23.0, 24.0}, {25.0, 26.0, 27.0}}},
+                     {{{28.0, 29.0, 30.0}, {31.0, 32.0, 33.0}, {34.0, 35.0, 36.0}},
+                      {{37.0, 38.0, 39.0}, {40.0, 41.0, 42.0}, {43.0, 44.0, 45.0}},
+                      {{46.0, 47.0, 48.0}, {49.0, 50.0, 51.0}, {52.0, 53.0, 54.0}}},
+                     {{{55.0, 56.0, 57.0}, {58.0, 59.0, 60.0}, {61.0, 62.0, 63.0}},
+                      {{64.0, 65.0, 66.0}, {67.0, 68.0, 69.0}, {70.0, 71.0, 72.0}},
+                      {{73.0, 74.0, 75.0}, {76.0, 77.0, 78.0}, {79.0, 80.0, 81.0}}}},
+                    torch::TensorOptions().dtype(torch::kFloat64));
+  NEML2Utils::copyTensorToMOOSEData(tensor, data);
+
+  for (neml2::Size i : make_range(3))
+    for (neml2::Size j : make_range(3))
+      for (neml2::Size k : make_range(3))
+        for (neml2::Size l : make_range(3))
+          EXPECT_NEAR(tensor.index({i, j, k, l}).item<Real>(), data(i, j, k, l), 1e-12);
+}
+
+TEST(NEML2Utils, copyTensorToMOOSEData_SymmetricRankFourTensor)
+{
+  SymmetricRankFourTensor data;
+  const auto tensor = torch::tensor({{1.0, 2.0, 3.0, 4.0, 5.0, 6.0},
+                                     {2.0, 3.0, 4.0, 5.0, 6.0, 7.0},
+                                     {3.0, 4.0, 5.0, 6.0, 7.0, 8.0},
+                                     {4.0, 5.0, 6.0, 7.0, 8.0, 9.0},
+                                     {5.0, 6.0, 7.0, 8.0, 9.0, 10.0},
+                                     {6.0, 7.0, 8.0, 9.0, 10.0, 11.0}},
+                                    torch::TensorOptions().dtype(torch::kFloat64));
+  NEML2Utils::copyTensorToMOOSEData(tensor, data);
+
+  for (neml2::Size i : make_range(6))
+    for (neml2::Size j : make_range(6))
+      EXPECT_NEAR(tensor.index({i, j}).item<Real>(), data(i, j), 1e-12);
+}
+#endif

From c2561217a164ef05b95daddb0bba2e2baf718c34 Mon Sep 17 00:00:00 2001
From: "Gary (Tianchen) Hu" <thu@anl.gov>
Date: Sat, 21 Dec 2024 20:44:39 -0500
Subject: [PATCH 02/11] Update NEML2Action.h

---
 modules/solid_mechanics/include/neml2/actions/NEML2Action.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/modules/solid_mechanics/include/neml2/actions/NEML2Action.h b/modules/solid_mechanics/include/neml2/actions/NEML2Action.h
index edaf5a25969f..4d78236de6f0 100644
--- a/modules/solid_mechanics/include/neml2/actions/NEML2Action.h
+++ b/modules/solid_mechanics/include/neml2/actions/NEML2Action.h
@@ -141,6 +141,7 @@ class NEML2Action : public Action
   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>>
@@ -162,6 +163,7 @@ class NEML2Action : public Action
 
   /// 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;

From 8487b92de2d2f374ce5b3267a7c12b34fa09702d Mon Sep 17 00:00:00 2001
From: Gary Hu <thu@anl.gov>
Date: Sun, 22 Dec 2024 08:01:25 -0500
Subject: [PATCH 03/11] Add missing tests and coumentation

---
 .../GenericConstantRealVectorValue.md         |  24 +++++++++++++++
 .../ComputeLagrangianCauchyCustomStress.md    |   9 ++++++
 .../ComputeLagrangianObjectiveCustomStress.md |  16 +---------
 .../ad_generic_constant_real_vector_value.i   |  27 ++++++++++++++++
 .../generic_constant_real_vector_value.i      |  27 ++++++++++++++++
 ...d_generic_constant_real_vector_value_out.e | Bin 0 -> 43588 bytes
 .../generic_constant_real_vector_value_out.e  | Bin 0 -> 43588 bytes
 test/tests/materials/generic_materials/tests  |  29 +++++++++++++-----
 8 files changed, 110 insertions(+), 22 deletions(-)
 create mode 100644 framework/doc/content/source/materials/GenericConstantRealVectorValue.md
 create mode 100644 modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianCauchyCustomStress.md
 create mode 100644 test/tests/materials/generic_materials/ad_generic_constant_real_vector_value.i
 create mode 100644 test/tests/materials/generic_materials/generic_constant_real_vector_value.i
 create mode 100644 test/tests/materials/generic_materials/gold/ad_generic_constant_real_vector_value_out.e
 create mode 100644 test/tests/materials/generic_materials/gold/generic_constant_real_vector_value_out.e

diff --git a/framework/doc/content/source/materials/GenericConstantRealVectorValue.md b/framework/doc/content/source/materials/GenericConstantRealVectorValue.md
new file mode 100644
index 000000000000..fac073006a23
--- /dev/null
+++ b/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
diff --git a/modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianCauchyCustomStress.md b/modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianCauchyCustomStress.md
new file mode 100644
index 000000000000..7d98cbbcf3cf
--- /dev/null
+++ b/modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianCauchyCustomStress.md
@@ -0,0 +1,9 @@
+# ComputeLagrangianCauchyCustomSymmetricStress
+
+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/ComputeLagrangianCauchyCustomSymmetricStress
+
+!syntax parameters /Materials/ComputeLagrangianCauchyCustomSymmetricStress
+
+!syntax inputs /Materials/ComputeLagrangianCauchyCustomSymmetricStress
diff --git a/modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianObjectiveCustomStress.md b/modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianObjectiveCustomStress.md
index 666230c2ec83..bcf1bba19909 100644
--- a/modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianObjectiveCustomStress.md
+++ b/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
diff --git a/test/tests/materials/generic_materials/ad_generic_constant_real_vector_value.i b/test/tests/materials/generic_materials/ad_generic_constant_real_vector_value.i
new file mode 100644
index 000000000000..e8841c81b4a6
--- /dev/null
+++ b/test/tests/materials/generic_materials/ad_generic_constant_real_vector_value.i
@@ -0,0 +1,27 @@
+[Mesh]
+  type = GeneratedMesh
+  dim = 1
+[]
+
+[Problem]
+  type = FEProblem
+  solve = false
+[]
+
+[Materials]
+  [vector]
+    type = ADGenericConstantRealVectorValue
+    vector_name = constant
+    vector_values = '1 2 3'
+    outputs = all
+  []
+[]
+
+[Executioner]
+  type = Transient
+  num_steps = 1
+[]
+
+[Outputs]
+  exodus = true
+[]
diff --git a/test/tests/materials/generic_materials/generic_constant_real_vector_value.i b/test/tests/materials/generic_materials/generic_constant_real_vector_value.i
new file mode 100644
index 000000000000..bb3d4ace0286
--- /dev/null
+++ b/test/tests/materials/generic_materials/generic_constant_real_vector_value.i
@@ -0,0 +1,27 @@
+[Mesh]
+  type = GeneratedMesh
+  dim = 1
+[]
+
+[Problem]
+  type = FEProblem
+  solve = false
+[]
+
+[Materials]
+  [vector]
+    type = GenericConstantRealVectorValue
+    vector_name = constant
+    vector_values = '1 2 3'
+    outputs = all
+  []
+[]
+
+[Executioner]
+  type = Transient
+  num_steps = 1
+[]
+
+[Outputs]
+  exodus = true
+[]
diff --git a/test/tests/materials/generic_materials/gold/ad_generic_constant_real_vector_value_out.e b/test/tests/materials/generic_materials/gold/ad_generic_constant_real_vector_value_out.e
new file mode 100644
index 0000000000000000000000000000000000000000..39fb0772ff87c3d4109da06d6c19abbaa1efe2aa
GIT binary patch
literal 43588
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

literal 0
HcmV?d00001

diff --git a/test/tests/materials/generic_materials/gold/generic_constant_real_vector_value_out.e b/test/tests/materials/generic_materials/gold/generic_constant_real_vector_value_out.e
new file mode 100644
index 0000000000000000000000000000000000000000..9f9b72d276548bcc6b1b6e5d3b13fe4512aba185
GIT binary patch
literal 43588
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
a^jyFCUdes$bG_U9d|w~f>vrG#{eJ<yg8w`K

literal 0
HcmV?d00001

diff --git a/test/tests/materials/generic_materials/tests b/test/tests/materials/generic_materials/tests
index de1f1ddf0c3d..91bfe6d02659 100644
--- a/test/tests/materials/generic_materials/tests
+++ b/test/tests/materials/generic_materials/tests
@@ -49,18 +49,33 @@
     [../]
   [../]
   [./symmetric_ranktwotensor]
-    requirement = 'The system shall shall be able to compute a SymmetricRankTwoTensor material object'
+    requirement = 'The system shall be able to compute a SymmetricRankTwoTensor material object'
     [./constant]
       type = 'CSVDiff'
       input = 'generic_constant_symmetric_rank_two_tensor.i'
       csvdiff = 'generic_constant_symmetric_rank_two_tensor_out.csv'
       detail = 'with constant values.'
     [../]
-      [./ad_constant]
-        type = 'CSVDiff'
-        input = 'ad_generic_constant_symmetric_rank_two_tensor.i'
-        csvdiff = 'ad_generic_constant_symmetric_rank_two_tensor_out.csv'
-        detail = 'with constant values using automatic differentiation.'
-      [../]
+    [./ad_constant]
+      type = 'CSVDiff'
+      input = 'ad_generic_constant_symmetric_rank_two_tensor.i'
+      csvdiff = 'ad_generic_constant_symmetric_rank_two_tensor_out.csv'
+      detail = 'with constant values using automatic differentiation.'
+    [../]
+  [../]
+  [./symmetric_realvectorvalue]
+    requirement = 'The system shall be able to compute a RealVectorValue material property'
+    [./constant]
+      type = 'Exodiff'
+      input = 'generic_constant_real_vector_value.i'
+      exodiff = 'generic_constant_real_vector_value_out.e'
+      detail = 'with constant values.'
+    [../]
+    [./ad_constant]
+      type = 'Exodiff'
+      input = 'ad_generic_constant_real_vector_value.i'
+      exodiff = 'ad_generic_constant_real_vector_value_out.e'
+      detail = 'with constant values using automatic differentiation.'
+    [../]
   [../]
 []

From 32c89696188cf70fccb60cedddcf4476785e4f0d Mon Sep 17 00:00:00 2001
From: "Gary (Tianchen) Hu" <thu@anl.gov>
Date: Sun, 22 Dec 2024 09:02:43 -0500
Subject: [PATCH 04/11] Update ComputeLagrangianCauchyCustomStress.md

---
 .../lagrangian/ComputeLagrangianCauchyCustomStress.md     | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianCauchyCustomStress.md b/modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianCauchyCustomStress.md
index 7d98cbbcf3cf..deedc2e794fc 100644
--- a/modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianCauchyCustomStress.md
+++ b/modules/solid_mechanics/doc/content/source/materials/lagrangian/ComputeLagrangianCauchyCustomStress.md
@@ -1,9 +1,9 @@
-# ComputeLagrangianCauchyCustomSymmetricStress
+# 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/ComputeLagrangianCauchyCustomSymmetricStress
+!syntax description /Materials/ComputeLagrangianCauchyCustomStress
 
-!syntax parameters /Materials/ComputeLagrangianCauchyCustomSymmetricStress
+!syntax parameters /Materials/ComputeLagrangianCauchyCustomStress
 
-!syntax inputs /Materials/ComputeLagrangianCauchyCustomSymmetricStress
+!syntax inputs /Materials/ComputeLagrangianCauchyCustomStress

From c645339570a8a9bd65d1fd1e02251041e2e26303 Mon Sep 17 00:00:00 2001
From: Gary Hu <thu@anl.gov>
Date: Mon, 23 Dec 2024 16:35:13 -0500
Subject: [PATCH 05/11] Address review comments

---
 .../solid_mechanics/include/neml2/utils/NEML2Utils.h | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/modules/solid_mechanics/include/neml2/utils/NEML2Utils.h b/modules/solid_mechanics/include/neml2/utils/NEML2Utils.h
index c712929d474e..a24dccbfdb26 100644
--- a/modules/solid_mechanics/include/neml2/utils/NEML2Utils.h
+++ b/modules/solid_mechanics/include/neml2/utils/NEML2Utils.h
@@ -23,8 +23,6 @@
 #endif
 
 #include "InputParameters.h"
-#include "MooseArray.h"
-#include <type_traits>
 
 class MooseObject;
 class Action;
@@ -85,11 +83,15 @@ struct Layout<SymmetricRankFourTensor>
 };
 
 /**
- * @brief Map from MooseArray to neml2::Tensor without copying the data
+ * @brief Map from std::vector<T> to neml2::Tensor without copying the data
  *
  * This method is used in gatherers which gather data from MOOSE as input variables to the NEML2
- * material model. So in theory, we only need to overload MOOSE types that can potentially be used
- * as input variables.
+ * material model. So in theory, we only need to provide Layout specializations for MOOSE types that
+ * can potentially be used as NEML2 input variables.
+ *
+ * For this method to work, the underlying data in \p data must be reinterpretable as Real
+ * (torch::kFloat64). The data class T must also be aligned and follow the striding implied by
+ * Layout<T>::shape. The data class T must also have no padding or overhead.
  */
 template <typename T>
 neml2::Tensor

From 4700310f3ea817f34767f196a5f8f59cdd7d20bb Mon Sep 17 00:00:00 2001
From: Gary Hu <thu@anl.gov>
Date: Thu, 2 Jan 2025 10:27:47 -0600
Subject: [PATCH 06/11] Fix CP example

---
 modules/solid_mechanics/contrib/neml2         |   2 +-
 .../test/tests/neml2/crystal_plasticity.i     |   1 +
 .../tests/neml2/gold/crystal_plasticity.e     | Bin 77488 -> 77408 bytes
 3 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/modules/solid_mechanics/contrib/neml2 b/modules/solid_mechanics/contrib/neml2
index f0891dce8016..c5080e057105 160000
--- a/modules/solid_mechanics/contrib/neml2
+++ b/modules/solid_mechanics/contrib/neml2
@@ -1 +1 @@
-Subproject commit f0891dce80164f55cbb38a640bd85527599430c9
+Subproject commit c5080e057105a2a053f0acd24c0ecd94703bdfda
diff --git a/modules/solid_mechanics/test/tests/neml2/crystal_plasticity.i b/modules/solid_mechanics/test/tests/neml2/crystal_plasticity.i
index 0bd3f7da5ef3..e661dfa18732 100644
--- a/modules/solid_mechanics/test/tests/neml2/crystal_plasticity.i
+++ b/modules/solid_mechanics/test/tests/neml2/crystal_plasticity.i
@@ -64,6 +64,7 @@ N = 2
     type = ComputeLagrangianCauchyCustomStress
     custom_cauchy_stress = 'neml2_cauchy_stress'
     custom_cauchy_jacobian = 'neml2_cauchy_jacobian'
+    large_kinematics = true
   []
   [initial_orientation]
     type = GenericConstantRealVectorValue
diff --git a/modules/solid_mechanics/test/tests/neml2/gold/crystal_plasticity.e b/modules/solid_mechanics/test/tests/neml2/gold/crystal_plasticity.e
index 88f76a60081b859fb0b330a6c9bc384b5903f4a8..d73c97886fb2748dd39e1c1d370f3f64b3c08dae 100644
GIT binary patch
delta 2914
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

delta 2968
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


From a335c30821f5664ae194d6ada3d33381ce1dd5c6 Mon Sep 17 00:00:00 2001
From: Gary Hu <thu@anl.gov>
Date: Thu, 2 Jan 2025 14:17:46 -0600
Subject: [PATCH 07/11] Point neml2 submodule to main; Update cp input file

---
 modules/solid_mechanics/contrib/neml2                           | 2 +-
 .../test/tests/neml2/models/crystal_plasticity.i                | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/solid_mechanics/contrib/neml2 b/modules/solid_mechanics/contrib/neml2
index c5080e057105..3c671ef903cf 160000
--- a/modules/solid_mechanics/contrib/neml2
+++ b/modules/solid_mechanics/contrib/neml2
@@ -1 +1 @@
-Subproject commit c5080e057105a2a053f0acd24c0ecd94703bdfda
+Subproject commit 3c671ef903cf2a866c38d618e7ba5b4670f3d14e
diff --git a/modules/solid_mechanics/test/tests/neml2/models/crystal_plasticity.i b/modules/solid_mechanics/test/tests/neml2/models/crystal_plasticity.i
index 2459ca64e6b6..25f4e3714d25 100644
--- a/modules/solid_mechanics/test/tests/neml2/models/crystal_plasticity.i
+++ b/modules/solid_mechanics/test/tests/neml2/models/crystal_plasticity.i
@@ -31,7 +31,7 @@
 
 [Models]
   [spatial_velocity_gradient]
-    type = R2IncrementalRate
+    type = R2IncrementToRate
     variable = 'forces/spatial_velocity_increment'
     time = 'forces/t'
     rate = 'forces/spatial_velocity_gradient'

From c6b3d8213badb9fc85adad3f32de60bde475dda4 Mon Sep 17 00:00:00 2001
From: Gary Hu <thu@anl.gov>
Date: Thu, 2 Jan 2025 15:06:37 -0600
Subject: [PATCH 08/11] Avoid hiding NonlinearSystem::set_guess

---
 modules/solid_mechanics/contrib/neml2 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/solid_mechanics/contrib/neml2 b/modules/solid_mechanics/contrib/neml2
index 3c671ef903cf..97c04238da58 160000
--- a/modules/solid_mechanics/contrib/neml2
+++ b/modules/solid_mechanics/contrib/neml2
@@ -1 +1 @@
-Subproject commit 3c671ef903cf2a866c38d618e7ba5b4670f3d14e
+Subproject commit 97c04238da581824afac2e9b416db7f14567b6f1

From f03858247761f17d5e797a01b801877eecf8fe18 Mon Sep 17 00:00:00 2001
From: Gary Hu <thu@anl.gov>
Date: Thu, 2 Jan 2025 19:34:48 -0600
Subject: [PATCH 09/11] Support cuda

---
 .../include/neml2/interfaces/NEML2ModelInterface.h          | 1 +
 modules/solid_mechanics/src/neml2/actions/NEML2Action.C     | 3 ++-
 .../src/neml2/userobjects/NEML2ModelExecutor.C              | 6 ++++++
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/modules/solid_mechanics/include/neml2/interfaces/NEML2ModelInterface.h b/modules/solid_mechanics/include/neml2/interfaces/NEML2ModelInterface.h
index 7116ce7fe559..3aa0c281e17f 100644
--- a/modules/solid_mechanics/include/neml2/interfaces/NEML2ModelInterface.h
+++ b/modules/solid_mechanics/include/neml2/interfaces/NEML2ModelInterface.h
@@ -95,6 +95,7 @@ NEML2ModelInterface<T>::NEML2ModelInterface(const InputParameters & params, P &&
     _model(neml2::get_model(params.get<std::string>("model"))),
     _device(params.get<std::string>("device"))
 {
+  _model.to(_device);
 }
 
 template <class T>
diff --git a/modules/solid_mechanics/src/neml2/actions/NEML2Action.C b/modules/solid_mechanics/src/neml2/actions/NEML2Action.C
index 48eb0cfa8573..306538103bc3 100644
--- a/modules/solid_mechanics/src/neml2/actions/NEML2Action.C
+++ b/modules/solid_mechanics/src/neml2/actions/NEML2Action.C
@@ -129,7 +129,8 @@ NEML2Action::act()
   if (_current_task == "add_user_object")
   {
     // Get the NEML2 model so that we can introspect variable tensor types
-    const auto & model = neml2::get_model(getParam<std::string>("model"));
+    auto & model = neml2::get_model(getParam<std::string>("model"));
+    model.to(getParam<std::string>("device"));
 
     setupInputMappings(model);
     setupParameterMappings(model);
diff --git a/modules/solid_mechanics/src/neml2/userobjects/NEML2ModelExecutor.C b/modules/solid_mechanics/src/neml2/userobjects/NEML2ModelExecutor.C
index 3e66ebcc05e4..7fa23e0ad1cd 100644
--- a/modules/solid_mechanics/src/neml2/userobjects/NEML2ModelExecutor.C
+++ b/modules/solid_mechanics/src/neml2/userobjects/NEML2ModelExecutor.C
@@ -248,6 +248,12 @@ NEML2ModelExecutor::fillInputs()
   for (const auto & uo : _gatherers)
     uo->insertInto(_in, _model_params);
 
+  // Send input variables and parameters to device
+  for (auto & [var, val] : _in)
+    val = val.to(device());
+  for (auto & [param, pval] : _model_params)
+    pval = pval.to(device());
+
   // Update model parameters
   model().set_parameters(_model_params);
   _model_params.clear();

From b9d41b34ae54aab2aef9599c142405decac80f30 Mon Sep 17 00:00:00 2001
From: Gary Hu <thu@anl.gov>
Date: Fri, 3 Jan 2025 12:48:10 -0600
Subject: [PATCH 10/11] Update neml2 submodule, again...

---
 modules/solid_mechanics/contrib/neml2 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/solid_mechanics/contrib/neml2 b/modules/solid_mechanics/contrib/neml2
index 97c04238da58..0e05ff17c9a8 160000
--- a/modules/solid_mechanics/contrib/neml2
+++ b/modules/solid_mechanics/contrib/neml2
@@ -1 +1 @@
-Subproject commit 97c04238da581824afac2e9b416db7f14567b6f1
+Subproject commit 0e05ff17c9a81b15e9c7d1c1c3ef5dbb66b1406e

From a68a209861d0961f2327010f6370ef3a0883f4c6 Mon Sep 17 00:00:00 2001
From: Gary Hu <thu@anl.gov>
Date: Mon, 6 Jan 2025 12:24:55 -0600
Subject: [PATCH 11/11] Update neml2 submodule to include AD speedup

---
 modules/solid_mechanics/contrib/neml2 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/solid_mechanics/contrib/neml2 b/modules/solid_mechanics/contrib/neml2
index 0e05ff17c9a8..486bd1916da1 160000
--- a/modules/solid_mechanics/contrib/neml2
+++ b/modules/solid_mechanics/contrib/neml2
@@ -1 +1 @@
-Subproject commit 0e05ff17c9a81b15e9c7d1c1c3ef5dbb66b1406e
+Subproject commit 486bd1916da159c6ab21ccf3c8aa5a9b541b453c