DistributedMesh::DistributedMesh (const MeshBase & other_mesh) :
  UnstructuredMesh (other_mesh), _is_serial(other_mesh.is_serial()),
  _is_serial_on_proc_0(other_mesh.is_serial_on_zero()),
  _deleted_coarse_elements(true), // better safe than sorry...
  _n_nodes(0), _n_elem(0), _max_node_id(0), _max_elem_id(0), // recomputed below
  _next_free_local_node_id(this->processor_id()),
  _next_free_local_elem_id(this->processor_id()),
  _next_free_unpartitioned_node_id(this->n_processors()),

  // copying only the objects visible to this processor, those counts
  // reflect an incomplete local view rather than other_mesh's totals,
  // and need to be copied afresh.
  _n_nodes = other_mesh.n_nodes();
  _n_elem = other_mesh.n_elem();
  _max_node_id = other_mesh.max_node_id();
  _max_elem_id = other_mesh.max_elem_id();

  // If other_mesh is actually a DistributedMesh, we can just copy its raw
  // counters directly, mirroring other_mesh's own bookkeeping exactly
  if (const DistributedMesh * other_dist_mesh = dynamic_cast<const DistributedMesh *>(&other_mesh))
    {
      _next_free_local_node_id = other_dist_mesh->_next_free_local_node_id;
      _next_free_local_elem_id = other_dist_mesh->_next_free_local_elem_id;
      _next_free_unpartitioned_node_id = other_dist_mesh->_next_free_unpartitioned_node_id;
      _next_free_unpartitioned_elem_id = other_dist_mesh->_next_free_unpartitioned_elem_id;
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      _next_unique_id = other_dist_mesh->_next_unique_id;
      _next_unpartitioned_unique_id = other_dist_mesh->_next_unpartitioned_unique_id;
#endif
    }
  else

      // the unique id counters we copy other_mesh's own local next_unique_id()
      // and derive the next available unique ids
      // (partitioned and unpartitioned) via set_next_unique_ids().
      this->set_next_ids();
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      libmesh_assert(other_mesh.comm().verify(other_mesh.next_unique_id()));
      this->set_next_unique_ids(other_mesh.next_unique_id());
#endif
    }

  // reports for has_synched_id_counts: the counts above are a faithful copy
  // of other_mesh's own (possibly not-yet-synced) counts, not a freshly
  // verified computation, so our synced-ness should match other_mesh's.
  this->_preparation = other_mesh.preparation();
}

void DistributedMesh::move_nodes_and_elements(MeshBase && other_meshbase)

  #endif
}

void DistributedMesh::set_next_ids()
{
  _next_free_unpartitioned_elem_id =
    ((_max_elem_id-1) / (this->n_processors() + 1) + 1) *

  _next_free_local_node_id =
    ((_max_node_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
    (this->n_processors() + 1) + this->processor_id();
}

#ifdef LIBMESH_ENABLE_UNIQUE_ID
void DistributedMesh::set_next_unique_ids(unique_id_type parallel_max_unique_id)
{
  // Unique ids are laid out in repeating groups of (n_processors()+1)
  // consecutive integers ("alignment" here means a value's position, i.e.

  // n_processors(), the unpartitioned pool's fixed offset within a group,
  // lands on that pool's reserved slot in that group.
  _next_unpartitioned_unique_id =
      ((parallel_max_unique_id - 1) / (this->n_processors() + 1) + 1) *
          (this->n_processors() + 1) +
      this->n_processors();

  // Same idiom, but shifted by (n_processors()-1) before dividing so that
  // the rounding accounts for processor_id() possibly being less than the

  // pool's above, or push it into the following group, depending on where
  // the max id and this processor's offset happen to fall.
  _next_unique_id =
      ((parallel_max_unique_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
          (this->n_processors() + 1) +
      this->processor_id();
}
#endif

// We use cached values for these so they can be called
// from one processor without bothering the rest, but
// we may need to update those caches before doing a full
// renumbering
void DistributedMesh::update_parallel_id_counts()
{
  // This function must be run on all processors at once
  parallel_object_only();

  _n_elem  = this->parallel_n_elem();
  _n_nodes = this->parallel_n_nodes();
  _max_node_id = this->parallel_max_node_id();
  _max_elem_id = this->parallel_max_elem_id();

  this->set_next_ids();

  // set_next_unique_ids() needs the true parallel max unique id (not just
  // this processor's possibly-stale cached _next_unique_id) since the whole
  // point of this function is to recompute counters that may have drifted
  // out of sync.
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  this->set_next_unique_ids(this->parallel_max_unique_id());
#endif

  this->_preparation.has_synched_id_counts = true;

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

    {
      ray_target = inside - Point(1);
      intersection_distances =
        this->find_ray_intersections(inside, ray_target);
    }

  // I'd make this an assert, but I'm not 100% confident we can't