Factor out read_extra_integers

Author: roystgnr

include/mesh/exodusII_io_helper.h

@@ -306,6 +306,18 @@ class ExodusII_IO_Helper : public ParallelObject
                                  int time_step,
                                  std::map<dof_id_type, Real> & elem_var_value_map);
 
+  /**
+   * Reads element "extra integer" values, using the variable names
+   * specified in \p extra_integer_var_names, and converting the
+   * stored values to integer format.  The returned value is a vector
+   * (indexed in the same way as extra_integer_vars) of maps from
+   * element id to extra integer value.
+   *
+   * Currently values from the last time step are used.
+   */
+  std::vector<std::map<dof_id_type, dof_id_type>> read_extra_integers(
+    const std::vector<std::string> & extra_integer_var_names);
+
   /**
    * Helper function that takes a (1-based) Exodus node/elem id and
    * determines the corresponding libMesh Node/Elem id. Takes into account

src/mesh/exodusII_io.C

@@ -406,13 +406,11 @@ void ExodusII_IO::read (const std::string & fname)
   // have already been attached to spline control nodes.
   mesh.reserve_elem(exio_helper->w.size() + exio_helper->num_elem);
 
-  // Read variables for extra integer IDs
-  std::vector<std::map<dof_id_type, Real>> elem_ids(extra_ids.size());
-  // We use the last time step to load the IDs
   exio_helper->read_num_time_steps();
-  unsigned int last_step = exio_helper->num_time_steps;
-  for (auto i : index_range(extra_ids))
-    exio_helper->read_elemental_var_values(_extra_integer_vars[i], last_step, elem_ids[i]);
+
+  // Read variables for extra integer IDs
+  auto extra_integer_values =
+    exio_helper->read_extra_integers(_extra_integer_vars);
 
   // Read in the element connectivity for each block.
   int nelem_last_block = 0;
@@ -504,44 +502,7 @@ void ExodusII_IO::read (const std::string & fname)
 
           // Assign extra integer IDs
           for (auto & id : extra_ids)
-          {
-            const Real v = elem_ids[id][elem->id()];
-
-            if (v == Real(-1))
-              {
-                elem->set_extra_integer(id, DofObject::invalid_id);
-                continue;
-              }
-
-            // Ignore FE_INVALID here even if we've enabled FPEs; a
-            // thrown exception is preferred over an FPE signal.
-            FPEDisabler disable_fpes;
-            const long long iv = std::llround(v);
-
-            // Check if the real number is outside of the range we can
-            // convert exactly
-
-            long long max_representation = 1;
-            max_representation = (max_representation << std::min(std::numeric_limits<Real>::digits,
-                                                                 std::numeric_limits<double>::digits));
-            libmesh_error_msg_if(iv > max_representation,
-                                 "Error! An element integer value higher than "
-                                 << max_representation
-                                 << " was found! Exodus uses real numbers for storing element "
-                                 " integers, which can only represent integers from 0 to "
-                                 << max_representation
-                                 << ".");
-
-            libmesh_error_msg_if(iv < 0,
-                                 "Error! An element integer value less than -1"
-                                 << " was found! Exodus uses real numbers for storing element "
-                                 " integers, which can only represent integers from 0 to "
-                                 << max_representation
-                                 << ".");
-
-
-            elem->set_extra_integer(id, cast_int<dof_id_type>(iv));
-          }
+             elem->set_extra_integer(id, extra_integer_values[id][elem->id()]);
 
           // Set all the nodes for this element
           //

src/mesh/exodusII_io_helper.C

@@ -2131,6 +2131,77 @@ void ExodusII_IO_Helper::read_elemental_var_values(std::string elemental_var_nam
 
 
 
+std::vector<std::map<dof_id_type, dof_id_type>>
+ExodusII_IO_Helper::read_extra_integers
+  (const std::vector<std::string> & extra_integer_var_names)
+{
+  std::vector<std::map<dof_id_type, dof_id_type>>
+    extra_integer_values(extra_integer_var_names.size());
+
+  if (extra_integer_var_names.empty())
+    return extra_integer_values;
+
+  // Make sure we have an up-to-date count of the number of time steps in the file.
+  this->read_num_time_steps();
+
+  // Prepare to check if each real number is outside of the
+  // range we can convert exactly
+
+  const int exodus_digits = _single_precision ?
+                            std::numeric_limits<float>::digits :
+                            std::numeric_limits<double>::digits;
+
+  const int shift = std::min(std::numeric_limits<Real>::digits,
+                             exodus_digits);
+
+  const long long max_representation = 1LL << shift;
+
+  for (auto i : index_range(extra_integer_var_names))
+    {
+      std::map<dof_id_type, Real> raw_vals;
+
+      // Read element extra "integers" as doubles from the last time step
+      this->read_elemental_var_values(extra_integer_var_names[i], this->num_time_steps, raw_vals);
+
+      // Convert doubles to actual integers, at least within the
+      // largest convex subset of doubles where this is a bijection.
+      auto & values = extra_integer_values[i];
+
+      for (auto [elem_id, extra_val] : raw_vals)
+        {
+          if (extra_val == Real(-1))
+            {
+              values[elem_id] = DofObject::invalid_id;
+              continue;
+            }
+
+          // Ignore FE_INVALID here even if we've enabled FPEs; a
+          // thrown exception is preferred over an FPE signal.
+          FPEDisabler disable_fpes;
+          const long long int_val = std::llround(extra_val);
+
+          libmesh_error_msg_if(int_val > max_representation,
+                               "Error! An element integer value higher than "
+                               << max_representation
+                               << " was found! Exodus uses real numbers for storing element "
+                               " integers, which can only represent integers from 0 to "
+                               << max_representation << ".");
+
+          libmesh_error_msg_if(int_val < 0,
+                               "Error! An element integer value less than -1"
+                               << " was found! Exodus uses real numbers for storing element "
+                               " integers, which can only represent integers from 0 to "
+                               << max_representation << ".");
+
+          values[elem_id] = cast_int<dof_id_type>(int_val);
+        }
+    }
+
+  return extra_integer_values;
+}
+
+
+
 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);