Route shared Parameters per weak form

src/smith/differentiable_numerics/field_store.cpp

@@ -298,6 +298,22 @@ std::vector<FieldState> FieldStore::getStates(const std::string& weak_form_name)
   return fields_for_residual;
 }
 
+std::vector<FieldState> FieldStore::getParameters(const std::string& weak_form_name) const
+{
+  SLIC_ERROR_ROOT_IF(weak_form_name_to_field_names_.count(weak_form_name) == 0,
+                     axom::fmt::format("Weak form '{}' not found in FieldStore. Did you forget to call addReaction()?",
+                                       weak_form_name));
+
+  const auto& field_names = weak_form_name_to_field_names_.at(weak_form_name);
+  std::vector<FieldState> parameters_for_residual;
+  for (const auto& name : field_names) {
+    if (to_params_index_.count(name)) {
+      parameters_for_residual.push_back(getParameter(name));
+    }
+  }
+  return parameters_for_residual;
+}
+
 std::vector<FieldState> FieldStore::getStatesFromVectors(const std::string& weak_form_name,
                                                          const std::vector<FieldState>& state_fields,
                                                          const std::vector<FieldState>& param_fields) const

src/smith/differentiable_numerics/field_store.hpp

@@ -419,6 +419,13 @@ struct FieldStore {
    */
   std::vector<FieldState> getStates(const std::string& weak_form_name) const;
 
+  /**
+   * @brief Get the parameter fields associated with a weak form.
+   * @param weak_form_name Name of the weak form.
+   * @return std::vector<FieldState> Parameter fields in weak-form argument order.
+   */
+  std::vector<FieldState> getParameters(const std::string& weak_form_name) const;
+
   /**
    * @brief Extract state fields for a weak form from provided state and parameter vectors.
    * @param weak_form_name Name of the weak form.

src/smith/differentiable_numerics/system_base.cpp

@@ -57,8 +57,11 @@ std::vector<FieldState> SystemBase::solve(const TimeInfo& time_info) const
     }
   }
 
-  auto params = field_store->getParameterFields();
-  std::vector<std::vector<FieldState>> wk_params(weak_forms.size(), params);
+  std::vector<std::vector<FieldState>> wk_params;
+  wk_params.reserve(weak_forms.size());
+  for (const auto& weak_form : weak_forms) {
+    wk_params.push_back(field_store->getParameters(weak_form->name()));
+  }
 
   std::vector<WeakForm*> weak_form_ptrs;
   for (auto& p : weak_forms) {

src/smith/differentiable_numerics/tests/test_multiphysics_time_integrator.cpp

@@ -173,6 +173,36 @@ bool allNodesOnBoundary(const std::vector<vec2>& nodes, double x_target)
 
 }  // namespace
 
+TEST(FieldStore, WeakFormParametersExcludeUnrelatedSharedParametersAndPreserveOrder)
+{
+  axom::sidre::DataStore datastore;
+  StateManager::initialize(datastore, "weak_form_parameter_filtering");
+
+  auto mesh =
+    std::make_shared<Mesh>(mfem::Mesh::MakeCartesian2D(2, 2, mfem::Element::QUADRILATERAL), "parameter_filter_mesh");
+  auto field_store = std::make_shared<FieldStore>(mesh, 10);
+
+  FieldType<H1<1, 2>> shape_displacement("shape_displacement");
+  field_store->addShapeDisp(shape_displacement);
+  FieldType<H1<1>> unknown("unknown");
+  field_store->addIndependent(unknown, std::make_shared<QuasiStaticRule>());
+  FieldType<H1<1>> first_parameter("first_parameter");
+  FieldType<H1<1>> second_parameter("second_parameter");
+  FieldType<H1<1>> unrelated_parameter("unrelated_parameter");
+  field_store->addParameter(first_parameter);
+  field_store->addParameter(second_parameter);
+  field_store->addParameter(unrelated_parameter);
+
+  field_store->createSpaces("parameter_filtered_weak_form", unknown.name, unknown, second_parameter, first_parameter);
+  auto parameters = field_store->getParameters("parameter_filtered_weak_form");
+
+  ASSERT_EQ(parameters.size(), 2u);
+  EXPECT_EQ(parameters[0].get()->name(), second_parameter.name);
+  EXPECT_EQ(parameters[1].get()->name(), first_parameter.name);
+
+  StateManager::reset();
+}
+
 TEST(MultiphysicsTimeIntegrator, CycleZeroUsesBcsForReactionFieldNotUnknownZero)
 {
   axom::sidre::DataStore datastore;