Use MeshBase data to inform us when we should prepare

We also can signal to the `MeshBase` object if we've done some
operation that renders the mesh unprepared. If we do this meticulously
then we can trust checks of the `is_prepared` flag to tell us when we
need to `prepare_for_use` or not

Closes idaholab#15944 idaholab#15936 idaholab#15823

framework/include/actions/SetupMeshCompleteAction.h

@@ -23,10 +23,7 @@ class SetupMeshCompleteAction : public Action
 
   SetupMeshCompleteAction(InputParameters params);
 
-  bool completeSetup(MooseMesh * mesh);
-
   virtual void act() override;
 
   PerfID _uniform_refine_timer;
 };
-

framework/include/mesh/MooseMesh.h

@@ -327,7 +327,7 @@ class MooseMesh : public MooseObject, public Restartable, public PerfGraphInterf
   virtual const Elem * queryElemPtr(const dof_id_type i) const;
 
   /**
-   * Setter/getter for the _is_prepared flag.
+   * Setter/getter for whether the mesh is prepared
    */
   bool prepared() const;
   virtual void prepared(bool state);
@@ -460,10 +460,11 @@ class MooseMesh : public MooseObject, public Restartable, public PerfGraphInterf
   const RealVectorValue & getNormalByBoundaryID(BoundaryID id) const;
 
   /**
-   * Calls prepare_for_use() if force=true on the underlying Mesh object, then communicates various
-   * boundary information on parallel meshes. Also calls update() internally.
+   * Calls prepare_for_use() if the underlying MeshBase object isn't prepared, then communicates
+   * various boundary information on parallel meshes. Also calls update() internally. We maintain
+   * the boolean parameter in order to maintain backwards compatability but it doesn't do anything
    */
-  void prepare(bool force = false);
+  void prepare(bool = false);
 
   /**
    * Calls buildNodeListFromSideList(), buildNodeList(), and buildBndElemList().
@@ -1121,10 +1122,7 @@ class MooseMesh : public MooseObject, public Restartable, public PerfGraphInterf
   bool _is_nemesis;
 
   /// True if prepare has been called on the mesh
-  bool _is_prepared;
-
-  /// True if prepare_for_use should be called when Mesh is prepared
-  bool _needs_prepare_for_use;
+  bool _moose_mesh_prepared = false;
 
   /// The elements that were just refined.
   std::unique_ptr<ConstElemPointerRange> _refined_elements;

framework/src/actions/SetupMeshCompleteAction.C

@@ -39,17 +39,6 @@ SetupMeshCompleteAction::SetupMeshCompleteAction(InputParameters params)
 {
 }
 
-bool
-SetupMeshCompleteAction::completeSetup(MooseMesh * mesh)
-{
-  bool prepared = mesh->prepared();
-
-  if (!prepared)
-    mesh->prepare();
-
-  return prepared;
-}
-
 void
 SetupMeshCompleteAction::act()
 {
@@ -116,9 +105,9 @@ SetupMeshCompleteAction::act()
   else
   {
     // Prepare the mesh (may occur multiple times)
-    completeSetup(_mesh.get());
+    _mesh->prepare();
 
     if (_displaced_mesh)
-      completeSetup(_displaced_mesh.get());
+      _displaced_mesh->prepare();
   }
 }

framework/src/mesh/MooseMesh.C

@@ -169,8 +169,6 @@ MooseMesh::MooseMesh(const InputParameters & parameters)
     _custom_partitioner_requested(false),
     _uniform_refine_level(0),
     _is_nemesis(getParam<bool>("nemesis")),
-    _is_prepared(false),
-    _needs_prepare_for_use(false),
     _node_to_elem_map_built(false),
     _node_to_active_semilocal_elem_map_built(false),
     _patch_size(getParam<unsigned int>("patch_size")),
@@ -239,8 +237,6 @@ MooseMesh::MooseMesh(const MooseMesh & other_mesh)
     _custom_partitioner_requested(other_mesh._custom_partitioner_requested),
     _uniform_refine_level(other_mesh.uniformRefineLevel()),
     _is_nemesis(false),
-    _is_prepared(false),
-    _needs_prepare_for_use(other_mesh._needs_prepare_for_use),
     _node_to_elem_map_built(false),
     _node_to_active_semilocal_elem_map_built(false),
     _patch_size(other_mesh._patch_size),
@@ -358,33 +354,28 @@ MooseMesh::freeBndElems()
 }
 
 void
-MooseMesh::prepare(bool force)
+MooseMesh::prepare(bool)
 {
   TIME_SECTION(_prepare_timer);
 
   mooseAssert(_mesh, "The MeshBase has not been constructed");
 
-  if (dynamic_cast<DistributedMesh *>(&getMesh()) && !_is_nemesis)
-  {
-    // Call prepare_for_use() and don't mess with the renumbering
-    // setting
-    if (force || _needs_prepare_for_use)
-    {
-      CONSOLE_TIMED_PRINT("Preparing for use");
+  if (!dynamic_cast<DistributedMesh *>(&getMesh()) || _is_nemesis)
+    // For whatever reason we do not want to allow renumbering here nor ever in the future?
+    getMesh().allow_renumbering(false);
 
-      getMesh().prepare_for_use();
-    }
-  }
-  else
+  if (!_mesh->is_prepared())
   {
     CONSOLE_TIMED_PRINT("Preparing for use");
 
-    // Call prepare_for_use() and DO NOT allow renumbering
-    getMesh().allow_renumbering(false);
-    if (force || _needs_prepare_for_use)
-      getMesh().prepare_for_use();
+    _mesh->prepare_for_use();
+
+    _moose_mesh_prepared = false;
   }
 
+  if (_moose_mesh_prepared)
+    return;
+
   // Collect (local) subdomain IDs
   _mesh_subdomains.clear();
   for (const auto & elem : getMesh().element_ptr_range())
@@ -418,9 +409,7 @@ MooseMesh::prepare(bool force)
 
   update();
 
-  // Prepared has been called
-  _is_prepared = true;
-  _needs_prepare_for_use = false;
+  _moose_mesh_prepared = true;
 }
 
 void
@@ -2511,26 +2500,32 @@ MooseMesh::queryElemPtr(const dof_id_type i) const
 bool
 MooseMesh::prepared() const
 {
-  return _is_prepared;
+  return _mesh->is_prepared() && _moose_mesh_prepared;
 }
 
 void
 MooseMesh::prepared(bool state)
 {
-  _is_prepared = state;
+  if (state)
+    mooseError("We don't have any right to tell the libmesh mesh that it *is* prepared. Only a "
+               "call to prepare_for_use should tell us that");
+
+  _mesh->set_isnt_prepared();
+
+  // If the libMesh mesh isn't preparead, then our MooseMesh wrapper is also no longer prepared
+  _moose_mesh_prepared = false;
 
   /**
    * If we are explicitly setting the mesh to not prepared, then we've likely modified the mesh
    * and can no longer make assumptions about orthogonality. We really should recheck.
    */
-  if (!state)
-    _regular_orthogonal_mesh = false;
+  _regular_orthogonal_mesh = false;
 }
 
 void
 MooseMesh::needsPrepareForUse()
 {
-  _needs_prepare_for_use = true;
+  prepared(false);
 }
 
 const std::set<SubdomainID> &

framework/src/meshgenerators/FancyExtruderGenerator.C

@@ -562,5 +562,7 @@ FancyExtruderGenerator::generate()
     }
   }
 
+  mesh->set_isnt_prepared();
+
   return mesh;
 }

framework/src/meshgenerators/SideSetsGeneratorBase.C

@@ -64,6 +64,16 @@ SideSetsGeneratorBase::setup(MeshBase & mesh)
   _fe_face = FEBase::build(dim, fe_type);
   _qface = libmesh_make_unique<QGauss>(dim - 1, FIRST);
   _fe_face->attach_quadrature_rule(_qface.get());
+
+  // Change this when we have more fine-grained control over advertising what we need need and how
+  // we satisfy those needs. For now we know we need to have neighbors...and we do have an explicit
+  // `find_neighbors` call...but we don't have a `neighbors_found` API and it seems off to do:
+  //
+  // if (!mesh.is_prepared())
+  //   mesh.find_neighbors()
+
+  if (!mesh.is_prepared())
+    mesh.prepare_for_use();
 }
 
 void