Map-based disconnected neighbor ghosting base on ptr + fixing internal interface support

This change introduces correct handling of intentionally disconnected interfaces (e.g., CZM or jump conditions) on distributed meshes:
- Replace ID-based lookup in `MapBasedDisconnectedGhosting` with direct `Elem*` neighbor mapping to avoid invalid lookups post-renumbering.
- Register the disconnected ghosting functor in `find_neighbors()` so ghosting stays consistent with the neighbor graph established by `prepare_for_use()`.
- Extend `BoundaryInfo::side_with_boundary_id()` to optionally allow internal/logical boundaries when explicitly requested by the caller.
- Fix face FE assembly under `--disable-deprecated` by explicitly requesting shape and map computations before reinit() calls.
- Remove older per-test ghosting setup now handled by the mesh.

Author: ChengHauYang

include/ghosting/map_based_disconnected_ghosting.h

@@ -23,9 +23,9 @@ class MapBasedDisconnectedGhosting : public GhostingFunctor
 {
 public:
 
-  // Map from (local element ID, local side number) to neighbor element ID.
+  // Map from (local element ptr) to neighbor element ptr.
   using DisconnectedMap =
-      std::map<dof_id_type, dof_id_type>;
+      std::unordered_map<const Elem *, const Elem *>;
 
   /**
    * @brief Constructor.

src/ghosting/map_based_disconnected_ghosting.C

@@ -40,14 +40,12 @@ MapBasedDisconnectedGhosting::operator() (
         coupled_elements.emplace(elem, nullcm);
 
       // Look up this element's neighbor in the map
-      auto it = _map.find(elem->id());
+      auto it = _map.find(elem);
       if (it == _map.end())
         continue;
 
       // Get the neighbor's ID
-      const dof_id_type neighbor_id = it->second;
-
-      const Elem * neighbor_ptr = _mesh->query_elem_ptr(neighbor_id);
+      const Elem * neighbor_ptr = it->second;
 
       // If the neighbor pointer is valid (meaning it's local or ghosted)
       // AND it's not on processor 'p', add it to the couplings.

src/mesh/boundary_info.C

@@ -2323,25 +2323,27 @@ unsigned int BoundaryInfo::side_with_boundary_id(const Elem * const elem,
         {
           // If we're on this external boundary then we share this
           // external boundary id
-          if (elem->neighbor_ptr(side) == nullptr || include_internal_boundary)
+          if (elem->neighbor_ptr(side) == nullptr)
             return side;
 
           // If we're on an internal boundary then we need to be sure
           // it's the same internal boundary as our top_parent
-          const Elem * p = elem;
-
+          bool aligned_with_parent = false;
 #ifdef LIBMESH_ENABLE_AMR
-
+          const Elem * p = elem;
           while (p != nullptr)
           {
             const Elem * parent = p->parent();
             if (parent && !parent->is_child_on_side(parent->which_child_am_i(p), side))
               break;
             p = parent;
           }
+          aligned_with_parent = (p == nullptr);
 #endif
-          // We're on that side of our top_parent; return it
-          if (!p)
+          // Two valid cases:
+          // 1. The internal face is geometrically aligned with the parent's boundary side (original behavior)
+          // 2. The caller explicitly allows logical/internal boundaries (e.g. CZM interfaces)
+          if (aligned_with_parent || include_internal_boundary)
             return side;
         }
         // Otherwise we need to check if the child's ancestors have something on

src/mesh/unstructured_mesh.C

@@ -50,6 +50,7 @@
 // for disconnected neighbors
 #include "libmesh/periodic_boundaries.h"
 #include "libmesh/periodic_boundary.h"
+#include <libmesh/map_based_disconnected_ghosting.h>
 
 namespace {
 
@@ -1003,6 +1004,7 @@ void UnstructuredMesh::find_neighbors (const bool reset_remote_elements,
 
   if (db)
     {
+      MapBasedDisconnectedGhosting::DisconnectedMap disconnected_map;
       // Obtain a point locator
       std::unique_ptr<PointLocatorBase> point_locator = this->sub_point_locator();
 
@@ -1026,12 +1028,19 @@ void UnstructuredMesh::find_neighbors (const bool reset_remote_elements,
 
                   if (neigh && neigh != remote_elem && neigh != element)
                     {
-                      element->set_neighbor(ms, this->elem_ptr(neigh->id()));
-                      this->elem_ptr(neigh->id())->set_neighbor(neigh_side, element);
+                      auto neigh_changeable = this->elem_ptr(neigh->id());
+                      element->set_neighbor(ms, neigh_changeable);
+                      neigh_changeable->set_neighbor(neigh_side, element);
+                      disconnected_map.emplace(element, neigh_changeable);
+                      disconnected_map.emplace(neigh_changeable, element);
                     }
                 }
             }
         }
+      // Now add the ghosting functor to keep these neighbors in sync
+      auto map_ghosting =
+        std::make_shared<MapBasedDisconnectedGhosting>(*this, disconnected_map);
+      this->add_ghosting_functor(map_ghosting);
     }
 #endif // LIBMESH_ENABLE_PERIODIC
 

tests/systems/disconnected_neighbor_test.C

@@ -96,6 +96,8 @@ void assemble_temperature_jump(EquationSystems &es,
       Fe.zero();
 
       // --- Volume contribution ---
+      fe->get_dphi();   // sets calculate_dphi = true
+      fe->get_JxW();    // sets calculate_map  = true
       fe->reinit(elem);
       const auto &JxW_vol = fe->get_JxW();
       const auto &dphi_vol = fe->get_dphi();
@@ -109,13 +111,17 @@ void assemble_temperature_jump(EquationSystems &es,
       unsigned int side = boundary.side_with_boundary_id(elem, interface_left_id, true /*include_internal_boundary*/);
       if (side != libMesh::invalid_uint)
         {
+          fe_face_L->get_phi();    // sets calculate_phi = true
+          fe_face_L->get_JxW();    // sets calculate_map = true
           fe_face_L->reinit(elem, side);
           const auto &phi_L = fe_face_L->get_phi();
           const auto &JxW_face = fe_face_L->get_JxW();
 
           const Elem *neighbor = elem->neighbor_ptr(side);
           libmesh_assert(neighbor);
           unsigned int n_side = neighbor->which_neighbor_am_i(elem);
+          fe_face_R->get_phi();
+          fe_face_R->get_JxW();
           fe_face_R->reinit(neighbor, n_side);
           const auto &phi_R = fe_face_R->get_phi();
 
@@ -145,13 +151,17 @@ void assemble_temperature_jump(EquationSystems &es,
       side = boundary.side_with_boundary_id(elem, interface_right_id, true /*include_internal_boundary*/);
       if (side != libMesh::invalid_uint)
         {
+          fe_face_R->get_phi();    // sets calculate_phi = true
+          fe_face_R->get_JxW();    // sets calculate_map = true
           fe_face_R->reinit(elem, side);
           const auto &phi_R = fe_face_R->get_phi();
           const auto &JxW_face = fe_face_R->get_JxW();
 
           const Elem *neighbor = elem->neighbor_ptr(side);
           libmesh_assert(neighbor);
           unsigned int n_side = neighbor->which_neighbor_am_i(elem);
+          fe_face_L->get_phi();
+          fe_face_L->get_JxW();
           fe_face_L->reinit(neighbor, n_side);
           const auto &phi_L = fe_face_L->get_phi();
 
@@ -267,17 +277,6 @@ private:
     // And, in `prepare_for_use()`, libMesh will set up the disconnected neighbor relationships.
     mesh.add_disconnected_boundaries(interface_left_id, interface_right_id, RealVectorValue(0.0, 0.0, 0.0));
 
-
-    // new, map-based ghosting functor
-    MapBasedDisconnectedGhosting::DisconnectedMap disconnected_map;
-    // Elem 0 connects to Elem 1
-    disconnected_map[0] = 1;
-    // Elem 1 connects to Elem 0
-    disconnected_map[1] = 0;
-    auto map_ghosting =
-      std::make_shared<MapBasedDisconnectedGhosting>(mesh, disconnected_map);
-    mesh.add_ghosting_functor(map_ghosting);
-
     // libMesh shouldn't renumber, or our based-on-initial-id
     // assertions later may fail.
     mesh.allow_renumbering(false);