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);

      mesh_refinement.uniformly_refine(1);

      const bool move_only_boundary_nodes =
        mesh.mesh_dimension() != 2 || flat;
      MeshTools::Modification::interpolate_surface
        (mesh, sphere, /*ids=*/{}, move_only_boundary_nodes);
    }

  // A DistributedMesh needs a little prep before flattening

void MeshTools::Modification::interpolate_surface (MeshBase & mesh,
                                                   const Surface & surface,
                                                   std::set<std::size_t> ids,
                                                   bool use_boundary_nodes)
{
  const bool is_serial = mesh.is_serial();
  const processor_id_type mesh_pid = mesh.processor_id();

  // We might have to move ghost nodes on a distributed mesh if their
  // owners don't see a requisite element or boundary they're on.
  std::unordered_set<dof_id_type> moved_ghost_nodes;

  auto move_node = [& moved_ghost_nodes, & surface, is_serial, mesh_pid]
                   (Node & node) {
    node = surface.closest_point(node);

    if (!is_serial && node.processor_id() != mesh_pid)
      moved_ghost_nodes.insert(node.id());
  };

  const bool no_ids = ids.empty();
  const BoundaryInfo & boundary_info = mesh.get_boundary_info();

  for (const auto & elem : mesh.active_element_ptr_range())
    {
      if (elem->mapping_type() != LAGRANGE_MAP)
        libmesh_not_implemented();

      if (use_boundary_nodes)
        {
          for (auto s : elem->side_index_range())
            {
              if (no_ids)
                {
                  // If we're not using boundary ids, we're
                  // interpolating all external and no internal
                  // boundaries
                  if (elem->neighbor_ptr(s))
                    continue;
                }
              else
                {
                  if (std::none_of(ids.begin(), ids.end(),
                                   [&boundary_info,elem,s](std::size_t bcid)
                                   {return boundary_info.has_boundary_id(elem, s, bcid);}))
                    continue;
                }

              for (auto n : elem->nodes_on_side(s))
                move_node(elem->node_ref(n));
            }
        }
      else
        {
          if (no_ids || ids.count(elem->subdomain_id()))
            for (Node & node : elem->node_ref_range())
              move_node(node);
        }
    }

  if (!is_serial)
    {
      std::map<processor_id_type, std::vector<dof_id_type>> moved_nodes_map;
      for (auto id : moved_ghost_nodes)
        {
          const Node & node = mesh.node_ref(id);
          moved_nodes_map[node.processor_id()].push_back(node.id());
        }

      auto action_functor =
        [& mesh, & surface]
        (processor_id_type /* pid */,
         const std::vector<dof_id_type> & my_moved_nodes)
        {
          for (auto id : my_moved_nodes)
            {
              Node & node = mesh.node_ref(id);
              node = surface.closest_point(node);
            }
        };

      // First get new node positions to their owners
      Parallel::push_parallel_vector_data
        (mesh.comm(), moved_nodes_map, action_functor);

      // Then get node positions to anyone else with them ghosted
      SyncNodalPositions sync_object(mesh);
      Parallel::sync_dofobject_data_by_id
        (mesh.comm(), mesh.nodes_begin(), mesh.nodes_end(),
         sync_object);
    }

  // We haven't changed any topology, but just changing geometry could
  // have invalidated a point locator.
  mesh.clear_point_locator();
}