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 &&

                                        compatible_with_coarsening = false;
                                      }
                                    if (subneighbor.p_level() == my_p_level &&
                                        subneighbor.p_refinement_flag() == Elem::COARSEN)
                                      {
                                        subneighbor.set_p_refinement_flag(Elem::DO_NOTHING);
                                        level_one_satisfied = false;

                }
            }

          const auto elem_order = Elem::type_to_default_order_map[elem->type()];

          // Index of the current edge
          unsigned current_edge = 0;

                  // Find another node in this element on this edge
                  for (unsigned other_node_this_edge = 0; other_node_this_edge != n_nodes; other_node_this_edge++)
                    {
                      const bool both_vertices = elem->is_vertex(local_node_number) &&
                                                 elem->is_vertex(other_node_this_edge);
                      if ( elem->is_node_on_edge(other_node_this_edge, current_edge) && // On the current edge
                           elem->node_id(other_node_this_edge) != global_id          && // But not the original node
                            // vertex nodes on the same edge of higher order elements are not nodal neighbors
                          (elem_order == 1 || !both_vertices))
                        {
                          // We've found a nodal neighbor!  Save a pointer to it..
                          node_to_save = elem->node_ptr(other_node_this_edge);

                          // Make sure we found something
                          libmesh_assert(node_to_save != nullptr);

                          neighbor_set.insert(node_to_save);
                        }
                    }
                }

void build_nodes_to_elem_map (const MeshBase & mesh,
                              std::vector<std::vector<const Elem *>> & nodes_to_elem_map)
{
  // A vector indexed over all nodes is too inefficient to use for a
  // distributed mesh.  Use the unordered_map API instead.
  if (!mesh.is_serial())
    libmesh_deprecated();

  nodes_to_elem_map.resize (mesh.max_node_id());

  for (const auto & elem : mesh.element_ptr_range())
    for (auto & node : elem->node_ref_range())
      {
        libmesh_assert_less (node.id(), nodes_to_elem_map.size());

        nodes_to_elem_map[node.id()].push_back(elem);
      }
}

void find_nodal_neighbors(const MeshBase &,
                          const Node & node,
                          const std::vector<std::vector<const Elem *>> & nodes_to_elem_map,
                          std::vector<const Node *> & neighbors)
{
  find_nodal_neighbors_helper(node.id(), nodes_to_elem_map[node.id()],
                              neighbors);
}