/**
   * \returns The next unique id to be used.
   */
  unique_id_type next_unique_id() const { return _next_unique_id; }

  /**
   * Sets the next available unique id to be used.  On a

#endif
  _allow_empty_variables(false),
  _write_complex_abs(true),
  _set_unique_ids_from_maps(false),
  _disc_bex(false)
{
  // if !LIBMESH_HAVE_EXODUS_API, we didn't use this

#endif
  _allow_empty_variables(false),
  _write_complex_abs(true),
  _set_unique_ids_from_maps(false),
  _disc_bex(false)
{
  // if !LIBMESH_HAVE_EXODUS_API, we didn't use this

  std::unordered_map<const Node *, Elem *> spline_nodeelem_ptrs;

  // Loop over the nodes, create Nodes with local processor_id 0.
  for (auto i : make_range(exio_helper->num_nodes))
    {
      // Determine the libmesh node id implied by "i". The
      // get_libmesh_node_id() helper function expects a 1-based
      // Exodus node id, so we construct the "implied" Exodus node id
      // from "i" by adding 1.
      auto libmesh_node_id = exio_helper->get_libmesh_node_id(/*exodus_node_id=*/i+1);

      // Catch the node that was added to the mesh
      Node * added_node = mesh.add_point (Point(exio_helper->x[i], exio_helper->y[i], exio_helper->z[i]), libmesh_node_id);

      // Sanity check: throw an error if the Mesh assigned an ID to
      // the Node which does not match the libmesh_id we just determined.
      libmesh_error_msg_if(added_node->id() != static_cast<unsigned>(libmesh_node_id),
                           "Error!  Mesh assigned node ID "
                           << added_node->id()
                           << " which is different from the (zero-based) Exodus ID "

      // If the _set_unique_ids_from_maps flag is true, set the
      // unique_id for "node", otherwise do nothing.
      exio_helper->conditionally_set_node_unique_id(mesh, added_node, i);

      // If we have a set of spline weights, these nodes are going to
      // be used as control points for Bezier elements, and we need

      if (weights_exist)
        {
          const auto w = exio_helper->w[i];
          Point & p = *added_node;
          p /= w;  // Exodus Bezier Extraction stores spline nodes in projective space

          added_node->set_extra_datum<Real>(weight_index, exio_helper->w[i]);

          // ExodusII_IO_Helper::get_libmesh_elem_id() helper function
          // expects a 1-based Exodus elem id, so we construct the
          // "implied" Exodus elem id from "j" by adding 1.
          auto libmesh_elem_id = exio_helper->get_libmesh_elem_id(/*exodus_elem_id=*/j+1);

          uelem->set_id(libmesh_elem_id);

          // Record that we have seen an element of dimension uelem->dim()
          elems_of_dimension[uelem->dim()] = true;

          // If the _set_unique_ids_from_maps flag is true, set the
          // unique_id for "elem", otherwise do nothing.
          exio_helper->conditionally_set_elem_unique_id(mesh, elem, j);

          // If the Mesh assigned an ID different from the one we
          // tried to give it, we should probably error.
          libmesh_error_msg_if(elem->id() != static_cast<unsigned>(libmesh_elem_id),
                               "Error!  Mesh assigned ID "
                               << elem->id()
                               << " which is different from the (zero-based) Exodus ID "

              for (int k=0; k<exio_helper->num_nodes_per_elem; k++)
                {
                  // Get index into this block's connectivity array
                  int gi = elem_num * exio_helper->num_nodes_per_elem + conv.get_node_map(k);

                  // Get the 1-based Exodus node id from the "connect" array
                  auto exodus_node_id = exio_helper->connect[gi];

                  // Convert this index to a libMesh Node id
                  auto libmesh_node_id = exio_helper->get_libmesh_node_id(exodus_node_id);

                  // Set the node pointer in the Elem
                  elem->set_node(k, mesh.node_ptr(libmesh_node_id));

                        libmesh_vector_at(coef_vec, elem_node_index);

                      // Get the libMesh node corresponding to that row
                      const int gi = elem_num * exio_helper->bex_num_elem_cvs + spline_node_index;

                      // Get the 1-based Exodus node id from the "connect" array
                      auto exodus_node_id = exio_helper->connect[gi];

                      // Convert this index to a libMesh Node id
                      auto libmesh_node_id = exio_helper->get_libmesh_node_id(exodus_node_id);

                      if (coef != 0) // Ignore irrelevant spline nodes
                        key.emplace_back(libmesh_node_id, coef);

        // Call helper function to get the libmesh Elem id for the
        // e'th entry in the current elem_list.
        dof_id_type libmesh_elem_id =
          exio_helper->get_libmesh_elem_id(exio_helper->elem_list[e]);

        // Set any relevant node/edge maps for this element
        Elem & elem = mesh.elem_ref(libmesh_elem_id);

           // Call helper function to get the libmesh Elem id for the
           // e'th entry in the current elemset_list.
           dof_id_type libmesh_elem_id =
             exio_helper->get_libmesh_elem_id(exio_helper->elemset_list[e]);

            // Get a pointer to this Elem
            Elem * elem = mesh.elem_ptr(libmesh_elem_id);

        for (int i=0; i<exio_helper->num_nodes_per_set[nodeset]; ++i)
          {
            int exodus_node_id = exio_helper->node_sets_node_list[i + offset];
            auto libmesh_node_id = exio_helper->get_libmesh_node_id(exodus_node_id);
            mesh.get_boundary_info().add_node(libmesh_node_id, nodeset_id);
          }
      }
  }

  _write_complex_abs = val;
}

void ExodusII_IO::set_unique_ids_from_maps (bool val)
{
  _set_unique_ids_from_maps = val;

  // Set this flag on the helper object as well. The helper needs to know about this
  // flag, since it sometimes needs to construct libmesh Node ids from nodal connectivity
  // arrays (see e.g. ExodusII_IO_Helper::read_edge_blocks()).
  exio_helper->set_unique_ids_from_maps = val;
}

void ExodusII_IO::use_mesh_dimension_instead_of_spatial_dimension(bool val)
{

  num_nodal_vars(0),
  num_elem_vars(0),
  verbose(v),
  set_unique_ids_from_maps(false),
  opened_for_writing(false),
  opened_for_reading(false),
  _run_only_on_proc0(run_only_on_proc0),

          // Loop over indices in connectivity array, build edge elements,
          // look them up in the edge_map.
          for (auto [i, sz] = std::make_tuple(0u, connect.size()); i<sz; i+=num_nodes_per_edge)
            {
              auto edge = Elem::build(conv.libmesh_elem_type());
              for (int n=0; n<num_nodes_per_edge; ++n)
                {
                  auto exodus_node_id = this->connect[i+n];
                  dof_id_type libmesh_node_id = this->get_libmesh_node_id(exodus_node_id);
                  edge->set_node(n, mesh.node_ptr(libmesh_node_id));
                }

    }

  // Clear out any previously read nodal variable values
  this->nodal_var_values.clear();

  std::vector<Real> unmapped_nodal_var_values(num_nodes);

     MappedInputVector(unmapped_nodal_var_values, _single_precision).data());
  EX_CHECK_ERR(ex_err, "Error reading nodal variable values!");

  for (auto i : make_range(num_nodes))
    {
      // Determine the libmesh node id implied by "i". The
      // get_libmesh_node_id() helper function expects a 1-based

      // true, then calling get_libmesh_node_id(i+1) will just return
      // i, otherwise it will determine the value (with error
      // checking) using this->node_num_map.
      auto libmesh_node_id = this->get_libmesh_node_id(/*exodus_node_id=*/i+1);

      // Store the nodal value in the map.
      this->nodal_var_values[libmesh_node_id] = unmapped_nodal_var_values[i];
    }
}

          // index "ex_el_num".  This function expects a one-based
          // index, so we add 1 to ex_el_num when we pass it in.
          auto libmesh_elem_id =
            this->get_libmesh_elem_id(ex_el_num + 1);

          // Store the elemental value in the map.
          elem_var_value_map[libmesh_elem_id] = block_elem_var_values[j];

          // Go to the next sequential element ID.
          ex_el_num++;
        }
    }
}



dof_id_type ExodusII_IO_Helper::get_libmesh_node_id(int exodus_node_id)
{
  return this->get_libmesh_id(exodus_node_id, this->node_num_map);
}

dof_id_type ExodusII_IO_Helper::get_libmesh_elem_id(int exodus_elem_id)
{
  return this->get_libmesh_id(exodus_elem_id, this->elem_num_map);
}

dof_id_type
ExodusII_IO_Helper::get_libmesh_id(int exodus_id,
                                   const std::vector<int> & num_map)
{
  // The input exodus_id is assumed to be a (1-based) index into
  // the {node,elem}_num_map, so in order to use exodus_id as an index
  // in C++, we need to first make it zero-based.
  auto exodus_id_zero_based =
    cast_int<dof_id_type>(exodus_id - 1);

  // Throw an informative error message rather than accessing past the
  // end of the provided num_map. If we are setting Elem unique_ids
  // based on the num_map, we don't need to do this check.
  if (!this->set_unique_ids_from_maps)
    libmesh_error_msg_if(exodus_id_zero_based >= num_map.size(),
                         "Cannot get LibMesh id for Exodus id: " << exodus_id);

  // If the user set the flag which stores Exodus node/elem ids as

  // *and* then subtract 1 from that because the entries in the
  // num_map are also 1-based.
  dof_id_type libmesh_id =
    this->set_unique_ids_from_maps ?
    cast_int<dof_id_type>(exodus_id_zero_based) :
    cast_int<dof_id_type>(num_map[exodus_id_zero_based] - 1);

  return libmesh_id;
}



void
ExodusII_IO_Helper::
conditionally_set_node_unique_id(MeshBase & mesh, Node * node, int zero_based_node_num_map_index)
{
  this->set_dof_object_unique_id(mesh, node, libmesh_vector_at(this->node_num_map, zero_based_node_num_map_index));
}

void
ExodusII_IO_Helper::
conditionally_set_elem_unique_id(MeshBase & mesh, Elem * elem, int zero_based_elem_num_map_index)
{
  this->set_dof_object_unique_id(mesh, elem, libmesh_vector_at(this->elem_num_map, zero_based_elem_num_map_index));
}

void
ExodusII_IO_Helper::set_dof_object_unique_id(
  MeshBase & mesh,
  DofObject * dof_object,
  int exodus_mapped_id)
{
  if (this->set_unique_ids_from_maps)
  {
    // Exodus ids are always 1-based while libmesh ids are always
    // 0-based, so to make a libmesh unique_id here, we subtract 1
    // from the exodus_mapped_id to make it 0-based.
    auto exodus_mapped_id_zero_based =
      cast_int<dof_id_type>(exodus_mapped_id - 1);

    // Set added_node's unique_id to "exodus_mapped_id_zero_based".
    dof_object->set_unique_id(cast_int<unique_id_type>(exodus_mapped_id_zero_based));

    // Normally the Mesh is responsible for setting the unique_ids
    // of Nodes/Elems in a consistent manner, so when we set the unique_id

    // APIs for doing this are only defined when unique ids are
    // enabled.
#ifdef LIBMESH_ENABLE_UNIQUE_ID
    unique_id_type next_unique_id = mesh.next_unique_id();
    mesh.set_next_unique_id(std::max(next_unique_id, static_cast<unique_id_type>(exodus_mapped_id_zero_based + 1)));
#else
    // Avoid compiler warnings about the unused variable
    libmesh_ignore(mesh);

          // ids rather than node ids.
          if (!_add_sides)
            {
              if (this->set_unique_ids_from_maps)
                node_num_map.push_back(node.unique_id() + 1);
              else
                node_num_map.push_back(node.id() + 1);
            }

          // Also map the zero-based libmesh node id to the (1-based)

          // an Exodus Node id given a libMesh Node id, so it does
          // involve unique_ids.
          libmesh_node_num_to_exodus[ cast_int<int>(node.id()) ] = cast_int<int>(x.size());
        } // end for (node_ptr)
    }
  else // use_discontinuous
    {

  // Here we reserve() space so that we can push_back() onto the
  // elem_num_map in the loops below.
  this->elem_num_map.reserve(num_elem);

  // In the case of discontinuous plotting we initialize a map from
  // (element, node) pairs to the corresponding discontinuous node index.

  // already in the elem_num_map.
  auto next_fake_id = mesh.max_elem_id() + 1; // 1-based numbering in Exodus
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (this->set_unique_ids_from_maps)
    next_fake_id = mesh.next_unique_id();
#endif

  for (auto & [subdomain_id, element_id_vec] : subdomain_map)

      // element ids to add.
      if (subdomain_id < subdomain_id_end)
      {
        connect.resize(element_id_vec.size()*num_nodes_per_elem);

        for (auto i : index_range(element_id_vec))
        {
          unsigned int elem_id = element_id_vec[i];
          libmesh_elem_num_to_exodus[elem_id] = ++libmesh_elem_num_to_exodus_counter; // 1-based indexing for Exodus

          // push_back() either elem_id+1 or the current Elem's
          // unique_id+1 into the elem_num_map, depending on the value
          // of the set_unique_ids_from_maps flag.
          if (this->set_unique_ids_from_maps)
            this->elem_num_map.push_back(elem.unique_id() + 1);
          else
            this->elem_num_map.push_back(elem_id + 1);

        } // end for(i)
      }

        // Store num_elem_this_blk "fake" ids into the
        // elem_num_map. Use a traditional for-loop to avoid unused
        // variable warnings about the loop counter.
        for (int i=0; i<num_elem_this_blk; ++i)
          this->elem_num_map.push_back(next_fake_id++);
      }

      ++num_elem_this_blk_it;