BoundaryInfo: fix internal boundary lookup without AMR

Restore previous behavior in `side_with_boundary_id()`. When AMR is disabled,
internal boundaries incorrectly returned invalid_uint. Add fallback return
for non-external sides.

Add `testInternalBoundary()` to verify correct side detection on a QUAD4
mesh. Update `disconnected_neighbor_test` to use default API.

Author: ChengHauYang

include/mesh/boundary_info.h

@@ -616,22 +616,12 @@ class BoundaryInfo : public ParallelObject
   /**
    * \returns A side of element \p elem whose associated boundary id is
    * \p boundary_id if such a side exists, and \p invalid_uint otherwise.
-   * \p include_internal_boundary
-   * If true, sides on internal logical boundaries are also considered.
-   * If false (default), only sides on the geometric boundary
-   * (i.e. sides without a valid neighbor element) are inspected.
-   *
-   * Setting this to true is useful for intentionally disconnected
-   * interfaces (e.g. cohesive zone interfaces) where
-   * a neighboring element exists but the side should still be treated
-   * as a boundary for enforcement of interface conditions.
    *
    * \note If multiple sides of \p elem have the same id, only the lowest numbered
    * such side is returned.
    */
   unsigned int side_with_boundary_id(const Elem * const elem,
-                                     const boundary_id_type boundary_id,
-                                     bool include_internal_boundary = false) const;
+                                     const boundary_id_type boundary_id) const;
 
   /**
    * \returns All sides of element \p elem whose associated boundary id is

src/mesh/boundary_info.C

@@ -2298,8 +2298,7 @@ void BoundaryInfo::renumber_node_id (boundary_id_type old_id,
 
 
 unsigned int BoundaryInfo::side_with_boundary_id(const Elem * const elem,
-                                                 const boundary_id_type boundary_id_in,
-                                                 bool include_internal_boundary) const
+                                                 const boundary_id_type boundary_id_in) const
 {
   const Elem * searched_elem = elem;
 
@@ -2326,24 +2325,25 @@ unsigned int BoundaryInfo::side_with_boundary_id(const Elem * const elem,
           if (elem->neighbor_ptr(side) == nullptr)
             return side;
 
+          // Internal boundary case
+          const Elem * p = elem;
+
+#ifdef LIBMESH_ENABLE_AMR
           // If we're on an internal boundary then we need to be sure
           // it's the same internal boundary as our top_parent
-          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);
+#else
+          // do not forget to return the internal boundary when AMR is disabled
+          return side;
 #endif
-          // 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)
+          // We're on that side of our top_parent; return it
+          if (!p)
             return side;
         }
         // Otherwise we need to check if the child's ancestors have something on

tests/mesh/boundary_info.C

@@ -29,6 +29,7 @@ public:
 #if LIBMESH_DIM > 1
   CPPUNIT_TEST( testMesh );
   CPPUNIT_TEST( testRenumber );
+  CPPUNIT_TEST( testInternalBoundary );
 # if LIBMESH_DIM > 2
   CPPUNIT_TEST( testSelectiveRenumber );
 # endif
@@ -1110,6 +1111,49 @@ public:
       }
   }
 
+
+  void testInternalBoundary()
+  {
+    LOG_UNIT_TEST;
+
+    Mesh mesh(*TestCommWorld);
+
+    // Build a 2x2 QUAD4 structured mesh on [0,1]x[0,1].
+    MeshTools::Generation::build_square(mesh,
+                                        2, 2,
+                                        0., 1.,
+                                        0., 1.,
+                                        QUAD4);
+
+    BoundaryInfo & bi = mesh.get_boundary_info();
+
+    // Select an element on the left side of the interior boundary
+    // (average x-coordinate < 0.5).
+    Elem * left_elem = nullptr;
+    for (auto & elem : mesh.active_element_ptr_range())
+    {
+      if (elem->vertex_average()(0) < 0.5)
+      {
+        left_elem = elem;
+        break;
+      }
+    }
+
+    CPPUNIT_ASSERT(left_elem);
+    unsigned int internal_side = 1;
+    CPPUNIT_ASSERT(left_elem->neighbor_ptr(internal_side) != nullptr);
+
+    // Assign a custom boundary ID on this internal side.
+    boundary_id_type BID = 7;
+    bi.add_side(left_elem, internal_side, BID);
+
+    mesh.prepare_for_use();
+
+    unsigned int found_side = bi.side_with_boundary_id(left_elem, BID);
+    CPPUNIT_ASSERT_EQUAL(internal_side, found_side);
+  }
+
+
 };
 
 CPPUNIT_TEST_SUITE_REGISTRATION( BoundaryInfoTest );

tests/systems/disconnected_neighbor_test.C

@@ -78,6 +78,12 @@ void assemble_temperature_jump(EquationSystems &es,
     fe_face_L->attach_quadrature_rule(&qface);
     fe_face_R->attach_quadrature_rule(&qface);
 
+    const auto &JxW_vol = fe->get_JxW();
+    const auto &dphi_vol = fe->get_dphi();
+    const auto &phi_L = fe_face_L->get_phi();
+    const auto &phi_R = fe_face_R->get_phi();
+    const auto &JxW_face = fe_face_L->get_JxW();
+
     DenseMatrix<Number> Ke;
     DenseVector<Number> Fe;
     std::vector<dof_id_type> dof_indices;
@@ -96,34 +102,21 @@ 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();
-
       for (unsigned int qp = 0; qp < qrule.n_points(); qp++)
         for (unsigned int i = 0; i < n_dofs; i++)
           for (unsigned int j = 0; j < n_dofs; j++)
             Ke(i, j) += conductance * JxW_vol[qp] * (dphi_vol[i][qp] * dphi_vol[j][qp]);
 
       // --- Left-side interface ---
-      unsigned int side = boundary.side_with_boundary_id(elem, interface_left_id, true /*include_internal_boundary*/);
+      unsigned int side = boundary.side_with_boundary_id(elem, interface_left_id);
       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();
 
           std::vector<dof_id_type> dofs_L, dofs_R;
           dof_map.dof_indices(elem, dofs_L);
@@ -148,22 +141,14 @@ void assemble_temperature_jump(EquationSystems &es,
         }
 
       // --- Right-side interface ---
-      side = boundary.side_with_boundary_id(elem, interface_right_id, true /*include_internal_boundary*/);
+      side = boundary.side_with_boundary_id(elem, interface_right_id);
       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();
 
           std::vector<dof_id_type> dofs_R, dofs_L;
           dof_map.dof_indices(elem, dofs_R);