Merge pull request #4229 from roystgnr/exodus_names

Expand Exodus name limits

Author: roystgnr

include/mesh/exodusII_io.h

@@ -578,6 +578,16 @@ class ExodusII_IO : public MeshInput<MeshBase>,
    */
   void append(bool val);
 
+  /**
+   * For backwards compatibility, libMesh currently truncates names in
+   * ExodusII output to the old default of 32 characters, but user
+   * code can expand that to up to 80 characters by setting a larger
+   * \p max_length manually.
+   *
+   * This must be set before a file is opened for writing.
+   */
+  void set_max_name_length(unsigned int max_length);
+
   /**
    * Return list of the elemental variable names
    */

include/mesh/exodusII_io_helper.h

@@ -604,6 +604,12 @@ class ExodusII_IO_Helper : public ParallelObject
    */
   void set_coordinate_offset(Point p);
 
+  /**
+   * Set how many characters to use in names when opening a file for
+   * writing.
+   */
+  void set_max_name_length(unsigned int max_length);
+
   /**
    * \returns A vector with three copies of each element in the provided name vector,
    * starting with r_, i_ and a_ respectively. If the "write_complex_abs" parameter
@@ -1003,6 +1009,9 @@ class ExodusII_IO_Helper : public ParallelObject
   // old format.
   bool _write_hdf5;
 
+  // The maximum name length to use when writing
+  unsigned int _max_name_length;
+
   // Set once the elem num map has been read
   int _end_elem_id;
 

include/mesh/mesh_base.h

@@ -1797,6 +1797,15 @@ class MeshBase : public ParallelObject
    */
   void cache_elem_data();
 
+  /**
+   * libMesh often expects all processors to know about names of all
+   * subdomain ids, but distributed mesh generators may only know
+   * about part of a mesh when creating names.  This method can
+   * synchronize the subdomain id to name map across processors,
+   * assuming no conflicts exist.
+   */
+  void sync_subdomain_name_map();
+
   /**
    * Search the mesh for elements that have a neighboring element
    * of dim+1 and set that element as the interior parent

src/mesh/exodusII_io.C

@@ -2410,6 +2410,12 @@ void ExodusII_IO::set_hdf5_writing(bool write_hdf5)
 }
 
 
+void ExodusII_IO::set_max_name_length(unsigned int max_length)
+{
+  exio_helper->set_max_name_length(max_length);
+}
+
+
 void ExodusII_IO::set_discontinuous_bex(bool disc_bex)
 {
   _disc_bex = disc_bex;

src/mesh/exodusII_io_helper.C

@@ -59,6 +59,11 @@ extern "C" {
 namespace
 {
 
+// ExodusII defaults to 32 bytes names, but we've had user complaints
+// about truncation with those.
+// It looks like the maximum they'll support is 80 byte names.
+static constexpr int libmesh_max_str_length = MAX_LINE_LENGTH;
+
 using namespace libMesh;
 
 // File scope constant node/edge/face mapping arrays.
@@ -296,12 +301,13 @@ ExodusII_IO_Helper::ExodusII_IO_Helper(const ParallelObject & parent,
   _nodal_vars_initialized(false),
   _use_mesh_dimension_instead_of_spatial_dimension(false),
   _write_hdf5(true),
+  _max_name_length(32),
   _end_elem_id(0),
   _write_as_dimension(0),
   _single_precision(single_precision)
 {
   title.resize(MAX_LINE_LENGTH+1);
-  elem_type.resize(MAX_STR_LENGTH);
+  elem_type.resize(libmesh_max_str_length);
   init_element_equivalence_map();
   init_conversion_map();
 }
@@ -693,11 +699,34 @@ void ExodusII_IO_Helper::open(const char * filename, bool read_only)
   EX_CHECK_ERR(ex_id, err_msg);
   if (verbose) libMesh::out << "File opened successfully." << std::endl;
 
+  // If we're writing then we'll want to use the specified length;
+  // if we're reading then we'll override this by what's in the file.
+  int max_name_length_to_set = _max_name_length;
+
   if (read_only)
+  {
     opened_for_reading = true;
+
+    // ExodusII reads truncate to 32-char strings by default; we'd
+    // like to support whatever's in the file, so as early as possible
+    // let's find out what that is.
+    int max_name_length = exII::ex_inquire_int(ex_id, exII::EX_INQ_DB_MAX_USED_NAME_LENGTH);
+
+    libmesh_error_msg_if(max_name_length > MAX_LINE_LENGTH,
+                         "Unexpected maximum name length of " <<
+                         max_name_length << " in file " << filename <<
+                         " exceeds expected " << MAX_LINE_LENGTH);
+
+    // I don't think the 32 here should be necessary, but let's make
+    // sure we don't accidentally make things *worse* for anyone.
+    max_name_length_to_set = std::max(max_name_length, 32);
+  }
   else
     opened_for_writing = true;
 
+  ex_err = exII::ex_set_max_name_length(ex_id, max_name_length_to_set);
+  EX_CHECK_ERR(ex_err, "Error setting max ExodusII name length.");
+
   current_filename = std::string(filename);
 }
 
@@ -791,7 +820,7 @@ void ExodusII_IO_Helper::read_qa_records()
         {
           qa_storage[i].resize(4);
           for (auto j : make_range(4))
-            qa_storage[i][j].resize(MAX_STR_LENGTH+1);
+            qa_storage[i][j].resize(libmesh_max_str_length+1);
         }
 
       // inner_array_t is a fixed-size array of 4 strings
@@ -873,7 +902,7 @@ void ExodusII_IO_Helper::read_nodes()
   if (n_nodal_attr > 0)
     {
       std::vector<std::vector<char>> attr_name_data
-        (n_nodal_attr, std::vector<char>(MAX_STR_LENGTH + 1));
+        (n_nodal_attr, std::vector<char>(libmesh_max_str_length + 1));
       std::vector<char *> attr_names(n_nodal_attr);
       for (auto i : index_range(attr_names))
         attr_names[i] = attr_name_data[i].data();
@@ -934,7 +963,7 @@ void ExodusII_IO_Helper::read_bex_cv_blocks()
       std::vector<std::vector<char>> blob_names(n_blobs);
       for (auto i : make_range(n_blobs))
         {
-          blob_names[i].resize(MAX_STR_LENGTH+1);
+          blob_names[i].resize(libmesh_max_str_length+1);
           blobs[i].name = blob_names[i].data();
         }
 
@@ -991,7 +1020,7 @@ void ExodusII_IO_Helper::read_bex_cv_blocks()
 
       int n_blob_vars;
       exII::ex_get_variable_param(ex_id, exII::EX_BLOB, &n_blob_vars);
-      std::vector<char> var_name (MAX_STR_LENGTH + 1);
+      std::vector<char> var_name (libmesh_max_str_length + 1);
       for (auto v_id : make_range(1,n_blob_vars+1))
         {
           ex_err = exII::ex_get_variable_name(ex_id, exII::EX_BLOB, v_id, var_name.data());
@@ -1052,7 +1081,7 @@ void ExodusII_IO_Helper::read_block_info()
       EX_CHECK_ERR(ex_err, "Error getting block IDs.");
       message("All block IDs retrieved successfully.");
 
-      char name_buffer[MAX_STR_LENGTH+1];
+      char name_buffer[libmesh_max_str_length+1];
       for (int i=0; i<num_elem_blk; ++i)
         {
           ex_err = exII::ex_get_name(ex_id, exII::EX_ELEM_BLOCK,
@@ -1075,7 +1104,7 @@ void ExodusII_IO_Helper::read_block_info()
       message("All edge block IDs retrieved successfully.");
 
       // Read in edge block names
-      char name_buffer[MAX_STR_LENGTH+1];
+      char name_buffer[libmesh_max_str_length+1];
       for (int i=0; i<num_edge_blk; ++i)
         {
           ex_err = exII::ex_get_name(ex_id, exII::EX_EDGE_BLOCK,
@@ -1532,7 +1561,7 @@ void ExodusII_IO_Helper::read_sideset_info()
       id_list.resize   (num_elem_all_sidesets);
     }
 
-  char name_buffer[MAX_STR_LENGTH+1];
+  char name_buffer[libmesh_max_str_length+1];
   for (int i=0; i<num_side_sets; ++i)
     {
       ex_err = exII::ex_get_name(ex_id, exII::EX_SIDE_SET,
@@ -1560,7 +1589,7 @@ void ExodusII_IO_Helper::read_nodeset_info()
       num_node_df_per_set.resize(num_node_sets);
     }
 
-  char name_buffer[MAX_STR_LENGTH+1];
+  char name_buffer[libmesh_max_str_length+1];
   for (int i=0; i<num_node_sets; ++i)
     {
       ex_err = exII::ex_get_name(ex_id, exII::EX_NODE_SET,
@@ -1600,7 +1629,7 @@ void ExodusII_IO_Helper::read_elemset_info()
       // libMesh::out << "num_elem_all_elemsets = " << num_elem_all_elemsets << std::endl;
     }
 
-  char name_buffer[MAX_STR_LENGTH+1];
+  char name_buffer[libmesh_max_str_length+1];
   for (int i=0; i<num_elem_sets; ++i)
     {
       ex_err = exII::ex_get_name(ex_id, exII::EX_ELEM_SET,
@@ -1760,7 +1789,7 @@ void ExodusII_IO_Helper::read_all_nodesets()
   EX_CHECK_ERR(ex_err, "Error reading concatenated nodesets");
 
   // Read the nodeset names from file!
-  char name_buffer[MAX_STR_LENGTH+1];
+  char name_buffer[libmesh_max_str_length+1];
   for (int i=0; i<num_node_sets; ++i)
     {
       ex_err = exII::ex_get_name
@@ -1945,7 +1974,7 @@ void ExodusII_IO_Helper::read_var_names_impl(const char * var_type,
     return;
 
   // Second read the actual names and convert them into a format we can use
-  NamesData names_table(count, MAX_STR_LENGTH);
+  NamesData names_table(count, libmesh_max_str_length);
 
   ex_err = exII::ex_get_var_names(ex_id,
                                   var_type,
@@ -2031,16 +2060,17 @@ ExodusII_IO_Helper::write_var_names_impl(const char * var_type,
 
   if (count > 0)
     {
-      NamesData names_table(count, MAX_STR_LENGTH);
+      NamesData names_table(count, _max_name_length);
 
       // Store the input names in the format required by Exodus.
       for (int i=0; i != count; ++i)
         {
-          if(names[i].length() > MAX_STR_LENGTH)
+          if(names[i].length() > _max_name_length)
             libmesh_warning(
-              "*** Warning, Exodus variable name \""
-              << names[i] << "\" too long (max " << MAX_STR_LENGTH
-              << " characters). Name will be truncated. ");
+              "*** Warning, Exodus variable name \"" <<
+              names[i] << "\" too long (current max " <<
+              _max_name_length << "/" << libmesh_max_str_length <<
+              " characters). Name will be truncated. ");
           names_table.push_back_entry(names[i]);
         }
 
@@ -2296,6 +2326,13 @@ void ExodusII_IO_Helper::create(std::string filename)
 
       EX_CHECK_ERR(ex_id, "Error creating ExodusII/Nemesis mesh file.");
 
+      // We don't have access to the names we might be writing until we
+      // write them, so we can't set a guaranteed max name length here.
+      // But it looks like the most ExodusII can support is 80, so we'll
+      // just waste 48 bytes here and there.
+      ex_err = exII::ex_set_max_name_length(ex_id, _max_name_length);
+      EX_CHECK_ERR(ex_err, "Error setting max ExodusII name length.");
+
       if (verbose)
         libMesh::out << "File created successfully." << std::endl;
     }
@@ -2683,13 +2720,13 @@ void ExodusII_IO_Helper::write_elements(const MeshBase & mesh, bool use_disconti
   std::vector<int> num_edges_per_elem_vec;
   std::vector<int> num_faces_per_elem_vec;
   std::vector<int> num_attr_vec;
-  NamesData elem_type_table(num_elem_blk, MAX_STR_LENGTH);
+  NamesData elem_type_table(num_elem_blk, _max_name_length);
 
   // Note: It appears that there is a bug in exodusII::ex_put_name where
   // the index returned from the ex_id_lkup is erroneously used.  For now
   // the work around is to use the alternative function ex_put_names, but
   // this function requires a char ** data structure.
-  NamesData names_table(num_elem_blk, MAX_STR_LENGTH);
+  NamesData names_table(num_elem_blk, _max_name_length);
 
   num_elem = 0;
 
@@ -2870,14 +2907,14 @@ void ExodusII_IO_Helper::write_elements(const MeshBase & mesh, bool use_disconti
   // be passed to exII::ex_put_concat_all_blocks() at the same time as the
   // information about elem blocks.
   std::vector<int> edge_blk_id;
-  NamesData edge_type_table(num_edge_blk, MAX_STR_LENGTH);
+  NamesData edge_type_table(num_edge_blk, _max_name_length);
   std::vector<int> num_edge_this_blk_vec;
   std::vector<int> num_nodes_per_edge_vec;
   std::vector<int> num_attr_edge_vec;
 
   // We also build a data structure of edge block names which can
   // later be passed to exII::ex_put_names().
-  NamesData edge_block_names_table(num_edge_blk, MAX_STR_LENGTH);
+  NamesData edge_block_names_table(num_edge_blk, _max_name_length);
 
   // Note: We are going to use the edge **boundary** ids as **block** ids.
   for (const auto & pr : edge_id_to_conn)
@@ -3217,7 +3254,7 @@ void ExodusII_IO_Helper::write_sidesets(const MeshBase & mesh)
   // Write out the sideset names, but only if there is something to write
   if (side_boundary_ids.size() > 0)
     {
-      NamesData names_table(side_boundary_ids.size(), MAX_STR_LENGTH);
+      NamesData names_table(side_boundary_ids.size(), _max_name_length);
 
       std::vector<exII::ex_set> sets(side_boundary_ids.size());
 
@@ -3298,7 +3335,7 @@ void ExodusII_IO_Helper::write_nodesets(const MeshBase & mesh)
   // Write out the nodeset names, but only if there is something to write
   if (node_boundary_ids.size() > 0)
     {
-      NamesData names_table(node_boundary_ids.size(), MAX_STR_LENGTH);
+      NamesData names_table(node_boundary_ids.size(), _max_name_length);
 
       // Vectors to be filled and passed to exII::ex_put_concat_sets()
       // Use existing class members and avoid variable shadowing.
@@ -3500,10 +3537,10 @@ void ExodusII_IO_Helper::check_existing_vars(ExodusVarType type,
   bool match =
     std::equal(names.begin(), names.end(),
                names_from_file.begin(),
-               [](const std::string & a,
-                  const std::string & b) -> bool
+               [this](const std::string & a,
+                      const std::string & b) -> bool
                {
-                 return a.compare(/*pos=*/0, /*len=*/MAX_STR_LENGTH, b) == 0;
+                 return a.compare(/*pos=*/0, /*len=*/_max_name_length, b) == 0;
                });
 
   if (!match)
@@ -3553,7 +3590,7 @@ ExodusII_IO_Helper::write_elemsets(const MeshBase & mesh)
     return;
 
   // TODO: Add support for named elemsets
-  // NamesData names_table(elemsets.size(), MAX_STR_LENGTH);
+  // NamesData names_table(elemsets.size(), _max_name_length);
 
   // We only need to write elemsets if the Mesh has an extra elem
   // integer called "elemset_code" defined on it.
@@ -4811,6 +4848,18 @@ void ExodusII_IO_Helper::set_hdf5_writing(bool write_hdf5)
 }
 
 
+void ExodusII_IO_Helper::set_max_name_length(unsigned int max_length)
+{
+  // Opt mode error, because this may be exposed to users
+  libmesh_error_msg_if (max_length > libmesh_max_str_length,
+                        "Exodus maximum name length is limited to " <<
+                        libmesh_max_str_length << " characters");
+
+  // Devel+dbg mode assertion, because developers should do better
+  libmesh_assert(!opened_for_writing);
+
+  _max_name_length = max_length;
+}
 
 
 void ExodusII_IO_Helper::write_as_dimension(unsigned dim)

src/mesh/mesh_base.C

@@ -1882,6 +1882,16 @@ void MeshBase::cache_elem_data()
     }
 }
 
+
+void MeshBase::sync_subdomain_name_map()
+{
+  // This requires every processor
+  parallel_object_only();
+
+  this->comm().set_union(_block_id_to_name);
+}
+
+
 void MeshBase::detect_interior_parents()
 {
   // This requires an inspection on every processor