* user-defined disconnected interfaces,
 * such as cohesive zone boundaries.
 */
class DisconnectedNeighborCoupling : public GhostingFunctor
{
public:
  using DisconnectedMap = std::unordered_map<const Elem *, const Elem *>;

  DisconnectedNeighborCoupling(const MeshBase & mesh) :
    GhostingFunctor(mesh),
    _dof_coupling(nullptr)
  {}

  virtual std::unique_ptr<GhostingFunctor> clone () const override
  { return std::make_unique<DisconnectedNeighborCoupling>(*this); }

  virtual void operator() (const MeshBase::const_element_iterator & range_begin,
                           const MeshBase::const_element_iterator & range_end,

  this->prepare_send_list();
}

void DofMap::set_implicit_neighbor_dofs(bool implicit_neighbor_dofs)
{
  _implicit_neighbor_dofs_initialized = true;
  _implicit_neighbor_dofs = implicit_neighbor_dofs;
}

void DofMap::set_verify_dirichlet_bc_consistency(bool val)
{

  // has been called.
  if (_implicit_neighbor_dofs_initialized)
    {
      implicit_neighbor_dofs = _implicit_neighbor_dofs;

      // Again, if the user explicitly says implicit_neighbor_dofs = false,
      // then we return here.
      if (!implicit_neighbor_dofs)
        return false;
    }

namespace libMesh
{

void DisconnectedNeighborCoupling::operator()(
    const MeshBase::const_element_iterator & range_begin,
    const MeshBase::const_element_iterator & range_end,
    processor_id_type p,
    map_type & coupled_elements)
{
  libmesh_assert(_mesh);
  auto * db = _mesh->get_disconnected_boundaries();
  if (!db)
    return;

  std::unique_ptr<PointLocatorBase> point_locator = _mesh->sub_point_locator();

  // Primary ghosting: elements in range_begin...range_end
  for (const auto & elem : as_range(range_begin, range_end))
    if (elem->processor_id() != p)
      coupled_elements.emplace(elem, _dof_coupling);

  // Also ghost their disconnected neighbors
  for (const auto & elem : as_range(range_begin, range_end))
    for (auto s : elem->side_index_range())
    {
      for (const auto & [id, boundary_ptr] : *db)
      {
        if (!_mesh->get_boundary_info().has_boundary_id(elem, s, id))
          continue;

        unsigned int neigh_side = invalid_uint;
        const Elem * neigh =
            db->neighbor(id, *point_locator, elem, s, &neigh_side);

        if (!neigh || neigh == remote_elem)
          continue;

        if (neigh->processor_id() != p)
          coupled_elements.emplace(neigh, _dof_coupling);
      }
    }
}


} // namespace libMesh

        {
          // If we're on this external boundary then we share this
          // external boundary id
          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
          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;
          }
#else
          // do not forget to return the internal boundary when AMR is disabled
          return side;
#endif
          // 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
        // the side of the child

  // if we get here, we found elem in the data structure but not
  // the requested boundary id, so return the default value
  return libMesh::invalid_uint;
}

#ifdef LIBMESH_ENABLE_AMR

          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;
          }
#endif
          // We're on that side of our top_parent; return it
          if (!p)
            returnval.push_back(side);
        }
        // Otherwise we trust what we got and return the side
        else

                      sender_could_become_owner)
                    {
                      if (it != repartitioned_node_pids.end() &&
                          pid < it->second)
                        it->second = pid;
                      else
                        repartitioned_node_pids[n] = pid;
                    }
                  else
                    if (it == repartitioned_node_pids.end())
                      repartitioned_node_pids[n] =
                        DofObject::invalid_processor_id;

                  repartitioned_node_sets_to_push[pid].insert(n);

  /**
   * Register a pair of boundaries as disconnected boundaries.
   */
  void MeshBase::add_disconnected_boundaries(const boundary_id_type b1,
                                             const boundary_id_type b2,
                                             const RealVectorValue & translation)
    {
      // Lazily allocate the container the first time it’s needed
      if (!_disconnected_boundary_pairs)
        _disconnected_boundary_pairs = std::make_unique<PeriodicBoundaries>();

      // Create forward and inverse boundary mappings
      PeriodicBoundary forward(translation);
      PeriodicBoundary inverse(translation * -1.0);

      forward.myboundary       = b1;
      forward.pairedboundary   = b2;
      inverse.myboundary       = b2;
      inverse.pairedboundary   = b1;

      // Add both directions into the container
      _disconnected_boundary_pairs->emplace(b1, forward.clone());
      _disconnected_boundary_pairs->emplace(b2, inverse.clone());
    }

  PeriodicBoundaries * MeshBase::get_disconnected_boundaries()
    {
      return _disconnected_boundary_pairs.get();
    }

  const PeriodicBoundaries * MeshBase::get_disconnected_boundaries() const
    {
      return _disconnected_boundary_pairs.get();
    }
#endif

  //
  // For safety, refinement is disabled while disconnected boundaries are
  // present.
  if (_mesh.get_disconnected_boundaries())
    {
      libmesh_error_msg(
        "Mesh contains disconnected boundary interfaces; refinement is disabled.\n"
        "MeshRefinement::refine_elements() cannot proceed because disconnected\n"
        "boundaries may produce invalid neighbor relations. Please remove or\n"

                              if (neighbor->p_level() < my_p_level &&
                                  neighbor->p_refinement_flag() != Elem::REFINE)
                                {
                                  neighbor->set_p_refinement_flag(Elem::REFINE);
                                  level_one_satisfied = false;
                                  compatible_with_coarsening = false;
                                }
                              if (neighbor->p_level() == my_p_level &&

#ifdef LIBMESH_ENABLE_PERIODIC
  // Get the disconnected boundaries object (from periodic BCs)
  auto * db = this->get_disconnected_boundaries();

  if (db)
    {
      // Obtain a point locator
      std::unique_ptr<PointLocatorBase> point_locator = this->sub_point_locator();

      for (const auto & element : this->element_ptr_range())
        {
          for (auto ms : element->side_index_range())
            {
              // Skip if this side already has a valid neighbor (including remote neighbors)
              if (element->neighbor_ptr(ms) != nullptr &&
                  element->neighbor_ptr(ms) != remote_elem)
                continue;

              for (const auto & [id, boundary_ptr] : *db)
                {
                  if (!this->get_boundary_info().has_boundary_id(element, ms, id))
                    continue;

                  unsigned int neigh_side;
                  const Elem * neigh =
                    db->neighbor(id, *point_locator, element, ms, &neigh_side);

                  if (neigh && neigh != remote_elem && neigh != element)
                    {
                      auto neigh_changeable = this->elem_ptr(neigh->id());
                      element->set_neighbor(ms, neigh_changeable);
                      neigh_changeable->set_neighbor(neigh_side, element);
                    }
                }
            }
        }

      // Ghost the disconnected elements
      this->add_ghosting_functor(std::make_unique<DisconnectedNeighborCoupling>(*this));
    }
#endif // LIBMESH_ENABLE_PERIODIC

#ifdef LIBMESH_ENABLE_AMR