Refactor {get,has}MFEMObject() to avoid dealing w/ system names (idaholab#32781)

Author: nmnobre

framework/include/base/TheWarehouse.h

@@ -490,18 +490,13 @@ class TheWarehouse
     results.clear();
     results.reserve(objs.size());
     for (auto & obj : objs)
-    {
-      mooseAssert(obj, "Null object");
-      auto cast_obj = dynamic_cast<T *>(obj);
-      if (obj)
-        mooseAssert(cast_obj,
-                    "Queried object " + obj->typeAndName() + " has incompatible c++ type with " +
-                        MooseUtils::prettyCppType<T>());
-      mooseAssert(std::find(results.begin(), results.end(), cast_obj) == results.end(),
-                  "Duplicate object");
-      if (show_all || obj->enabled())
-        results.push_back(cast_obj);
-    }
+      if (auto cast_obj = dynamic_cast<T *>(obj))
+      {
+        mooseAssert(std::find(results.begin(), results.end(), cast_obj) == results.end(),
+                    "Duplicate object");
+        if (show_all || obj->enabled())
+          results.push_back(cast_obj);
+      }
     return results;
   }
 

framework/include/mfem/problem/MFEMProblem.h

@@ -343,17 +343,16 @@ class MFEMProblem : public ExternalProblem
   }
 
   /**
-   * Retrieve an MFEM object from the warehouse by system and name.
+   * Retrieve an MFEM object from the warehouse by type and name.
    */
   template <typename T>
-  T & getMFEMObject(const std::string & system,
-                    const std::string & name,
-                    const THREAD_ID tid = 0) const;
+  T & getMFEMObject(const std::string & name, const THREAD_ID tid = 0) const;
 
   /**
-   * Determine whether an MFEM object with the supplied system and name exists.
+   * Determine whether an MFEM object with the supplied type and name exists.
    */
-  bool hasMFEMObject(const std::string & system, const std::string & name) const;
+  template <typename T>
+  bool hasMFEMObject(const std::string & name, const THREAD_ID tid = 0) const;
 
   /**
    * Enumerates the supported numeric representations for MFEM variables and operators.
@@ -378,21 +377,33 @@ class MFEMProblem : public ExternalProblem
 
 template <typename T>
 T &
-MFEMProblem::getMFEMObject(const std::string & system,
-                           const std::string & name,
-                           const THREAD_ID tid) const
+MFEMProblem::getMFEMObject(const std::string & name, const THREAD_ID tid) const
 {
   std::vector<T *> objs;
   theWarehouse()
       .query()
-      .condition<AttribSystem>(system)
+      .condition<AttribSystem>("MFEMObject")
       .condition<AttribThread>(tid)
       .condition<AttribName>(name)
       .queryInto(objs);
   if (objs.empty())
-    mooseError("Unable to find MFEM object with system '" + system + "' and name '" + name + "'");
+    mooseError("No MFEM object '" + name + "' of type '" + MooseUtils::prettyCppType<T>() + "'");
   mooseAssert(objs.size() == 1, "Shouldn't find more than one object with given system and name");
   return *(objs[0]);
 }
 
+template <typename T>
+bool
+MFEMProblem::hasMFEMObject(const std::string & name, const THREAD_ID tid) const
+{
+  std::vector<T *> objs;
+  theWarehouse()
+      .query()
+      .condition<AttribSystem>("MFEMObject")
+      .condition<AttribThread>(tid)
+      .condition<AttribName>(name)
+      .queryInto(objs);
+  return !objs.empty();
+}
+
 #endif

framework/src/mfem/base/MFEMObject.C

@@ -22,6 +22,7 @@ MFEMObject::validParams()
   params += VectorPostprocessorInterface::validParams();
   params += ReporterInterface::validParams();
   params.addClassDescription("Base class for MFEM objects backed directly by MooseObject.");
+  params.registerSystemAttributeName("MFEMObject");
   return params;
 }
 

framework/src/mfem/bcs/MFEMBoundaryCondition.C

@@ -23,7 +23,6 @@ MFEMBoundaryCondition::validParams()
 
   params.addClassDescription("Base class for applying boundary conditions to MFEM problems.");
   params.registerBase("BoundaryCondition");
-  params.registerSystemAttributeName("BoundaryCondition");
   params.addParam<VariableName>("variable", "Variable on which to apply the boundary condition");
   return params;
 }

framework/src/mfem/fespaces/MFEMFESpace.C

@@ -17,7 +17,6 @@ MFEMFESpace::validParams()
 {
   InputParameters params = MFEMObject::validParams();
   params.registerBase("MFEMFESpace");
-  params.registerSystemAttributeName("MFEMFESpace");
   MooseEnum ordering("NODES VDIM", "VDIM", false);
   params.addParam<MooseEnum>("ordering", ordering, "Ordering style to use for vector DoFs.");
   params.addParam<int>("vdim", 1, "The number of degrees of freedom per basis function.");

framework/src/mfem/functormaterials/MFEMFunctorMaterial.C

@@ -22,7 +22,6 @@ MFEMFunctorMaterial::validParams()
   params.addClassDescription(
       "Base class for declaration of material properties to add to MFEM problems.");
   params.registerBase("FunctorMaterial");
-  params.registerSystemAttributeName("FunctorMaterial");
   params.addPrivateParam<bool>("_neighbor", false);
   params.addPrivateParam<bool>("_interface", false);
   return params;

framework/src/mfem/indicators/MFEMIndicator.C

@@ -17,7 +17,6 @@ MFEMIndicator::validParams()
 {
   InputParameters params = MFEMObject::validParams();
   params.registerBase("Indicator");
-  params.registerSystemAttributeName("Indicator");
 
   params.addRequiredParam<VariableName>("variable", "Variable to perform amr with");
   params.addRequiredParam<std::string>("kernel", "Kernel to perform amr with");

framework/src/mfem/indicators/MFEML2ZienkiewiczZhuIndicator.C

@@ -31,21 +31,20 @@ MFEML2ZienkiewiczZhuIndicator::MFEML2ZienkiewiczZhuIndicator(const InputParamete
   if (isParamSetByUser("flux_fespace"))
   {
     // fetch the flux_fespace from the object system
-    auto object_ptr =
-        getMFEMProblem()
-            .getMFEMObject<MFEMFESpace>("MFEMFESpace", getParam<MFEMFESpaceName>("flux_fespace"))
-            .getSharedPtr();
+    auto object_ptr = getMFEMProblem()
+                          .getMFEMObject<MFEMFESpace>(getParam<MFEMFESpaceName>("flux_fespace"))
+                          .getSharedPtr();
     auto fespace_ptr = std::dynamic_pointer_cast<const MFEMFESpace>(object_ptr);
     _flux_fes = fespace_ptr->getFESpace();
   }
 
   if (isParamSetByUser("smooth_flux_fespace"))
   {
     // fetch the smooth_flux_fespace from the object system
-    auto object_ptr = getMFEMProblem()
-                          .getMFEMObject<MFEMFESpace>(
-                              "MFEMFESpace", getParam<MFEMFESpaceName>("smooth_flux_fespace"))
-                          .getSharedPtr();
+    auto object_ptr =
+        getMFEMProblem()
+            .getMFEMObject<MFEMFESpace>(getParam<MFEMFESpaceName>("smooth_flux_fespace"))
+            .getSharedPtr();
     auto fespace_ptr = std::dynamic_pointer_cast<const MFEMFESpace>(object_ptr);
     _smooth_flux_fes = fespace_ptr->getFESpace();
   }
@@ -55,7 +54,7 @@ void
 MFEML2ZienkiewiczZhuIndicator::createEstimator()
 {
   // fetch the kernel first so we can build an auxiliary blf integrator
-  MFEMKernel & kernel = getMFEMProblem().getMFEMObject<MFEMKernel>("Kernel", _kernel_name);
+  MFEMKernel & kernel = getMFEMProblem().getMFEMObject<MFEMKernel>(_kernel_name);
   _integ = std::unique_ptr<mfem::BilinearFormIntegrator>(kernel.createBFIntegrator());
 
   // Next, we need to check that this integrator is supported by mfem::L2ZienkiewiczZhuEstimator

framework/src/mfem/kernels/MFEMKernel.C

@@ -21,7 +21,6 @@ MFEMKernel::validParams()
   InputParameters params = MFEMObject::validParams();
   params += MFEMBlockRestrictable::validParams();
   params.registerBase("Kernel");
-  params.registerSystemAttributeName("Kernel");
   params.addParam<VariableName>("variable",
                                 "Variable labelling the weak form this kernel is added to");
   return params;

framework/src/mfem/markers/MFEMRefinementMarker.C

@@ -19,7 +19,6 @@ MFEMRefinementMarker::validParams()
 {
   InputParameters params = MFEMObject::validParams();
   params.registerBase("Marker");
-  params.registerSystemAttributeName("Marker");
 
   params.addRequiredParam<std::string>("indicator", "Estimator to use");
   params.addRangeCheckedParam<Real>("threshold",
@@ -49,7 +48,7 @@ void
 MFEMRefinementMarker::initialSetup()
 {
   // fetch const ref to the estimator
-  _estimator = &getMFEMProblem().getMFEMObject<MFEMIndicator>("Indicator", _estimator_name);
+  _estimator = &getMFEMProblem().getMFEMObject<MFEMIndicator>(_estimator_name);
 
   // Check if p-refinement is supported by the fespace supplied with the variable
   if (_max_p_level and !_estimator->getFESpace().PRefinementSupported())