dump_geom_sets.cxx

Go to the documentation of this file.

// This utility reads a MOAB HDF5 mesh file, and prints out
// the list of all geometry entitysets and the parent and
// child geometry entitysets of each such entityset.

#include <stdio.h>
#include <stdlib.h>
#include <hdf5.h>
#include <vector>
#include <map>
#include <string>

// Open HDF5 file
hid_t open_file( const char* name )
{
  hid_t handle = H5Fopen( name, H5F_ACC_RDONLY, H5P_DEFAULT );
  if (handle < 0) {
    fprintf(stderr, "Cannot open file: \"%s\"\n", name );
    exit (1);
  }
  return handle;
}

// Read a scalar attribute value from an HDF5 file
long read_scalar_attrib( hid_t file, const char* table, const char* attrib )
{
  hid_t table_id = H5Dopen( file, table );
  if (table_id < 0) {
    fprintf(stderr, "Invalid file.  Data not found: \"%s\"\n", table );
    exit (1);
  }
  
  hid_t attr_id = H5Aopen_name( table_id, attrib );
  H5Dclose( table_id );
  if (attr_id < 0) {
    fprintf(stderr, "Invalid file.  No \"%s\" attrib on \"%s\"\n", attrib, table );
    exit (1);
  }
  
  long value;
  herr_t rval = H5Aread( attr_id, H5T_NATIVE_LONG, &value );
  H5Aclose( attr_id );
  if (rval < 0) {
    fprintf(stderr, "Failed to read \"%s\" attrib on \"%s\"\n", attrib, table );
    exit (2);
  }
  
  return value;
}


// Read a data table from an HDF5 file
void read_data( hid_t file, const char* name, int expected_cols, std::vector<long>& data )
{
  hid_t handle = H5Dopen( file, name );
  if (handle < 0) {
    fprintf(stderr, "Invalid file.  Data not found: \"%s\"\n", name );
    exit (1);
  }

  hid_t space = H5Dget_space( handle );
  if (space < 0) {
    fprintf(stderr, "Internal error accessing: \"%s\"\n", name );
    exit (2);
  }
  
  int ndims = H5Sget_simple_extent_ndims( space );
  if (ndims < 0) {
    fprintf(stderr, "Internal error accessing: \"%s\"\n", name );
    exit (2);
  }
  else if (ndims < 1 || ndims > 2) {
    fprintf(stderr, "\"%s\" is an %d-dimension table.  Corrupt file?", name, ndims );
    exit (2);
  }
  
  hsize_t dims[2] = { 0, 1 };
  H5Sget_simple_extent_dims( space, dims, 0 );
  H5Sclose( space );
  
  if (dims[1] != expected_cols) {
    fprintf(stderr, "Error reading \"%s\": expected %d cols, has %d\n", name, expected_cols, (int)dims[1] );
    exit (2);
  }
  
  data.resize( dims[0] * dims[1] );
  herr_t rval = H5Dread( handle, H5T_NATIVE_LONG, H5S_ALL, H5S_ALL, H5P_DEFAULT, &data[0] );
  if (rval < 0) {
    fprintf(stderr, "Error reading data from: \"%s\"\n", name );
    exit (1);
  }
  
  H5Dclose( handle );
}

// Given two vectors of the same length, create a map where the
// key is taken from the first vectgor and the value is taken 
// from the second vector.
void create_map( const std::vector<long>& ents, 
                 const std::vector<long>& vals,
                 std::map<long,long>& map,
                 const char* name )
{
  if (ents.size() != vals.size()) {
    fprintf(stderr, "Invalid data for tag \"%s\": mismatched table lengths.\n", name );
    exit (1);
  }
  
  std::vector<long>::const_iterator e_iter = ents.begin(), v_iter = vals.begin();
  for (; e_iter != ents.end(); ++e_iter, ++v_iter)
    map[*e_iter] = *v_iter;
} 

// Construct a string designator for a geometry entity given
// the handle of that geometry entity and maps from handle to
// dimension and handle to global id.
std::string ent_from_handle( const std::map<long,long>& dimmap,
                             const std::map<long,long>&  idmap,
                             long handle )
{
  std::string result;
  std::map<long,long>::const_iterator d_iter, i_iter;
  d_iter = dimmap.find( handle );
  i_iter =  idmap.find( handle );
  if (d_iter == dimmap.end() || i_iter == idmap.end()) 
    return result;

  switch (d_iter->second) {
    case 0: result += "v"; break;
    case 1: result += "c"; break;
    case 2: result += "s"; break;
    case 3: result += "V"; break;
    default:
      fprintf(stderr,"Invalid value in GEOM_DIMENSION tag data.\n");
      exit (1);
  }
  
  char buffer[128];
  sprintf(buffer, "%ld", i_iter->second );
  result += buffer;
  return result;
}
      
// Construct a string designator for list of geometry entities given
// a list of handles and maps from handle to
// dimension and handle to global id.
std::string ent_list_from_handles( const std::map<long,long>& dimmap,
                                   const std::map<long,long>&  idmap,
                                   const std::vector<long>& vect,
                                   long start, 
                                   long stop )
{
  std::string result;
  if (start >= (long)vect.size() || stop >= (long)vect.size() || stop < start) {
    fprintf(stderr, "Invalid set data.  Corrupt file?\n");
    exit(2);
  }
  std::vector<long>::const_iterator iter = vect.begin() + start+1,
                                     end = vect.begin() + stop+1;
  
  for (; iter != end; ++iter)
  {
    std::string tmp = ent_from_handle( dimmap, idmap, *iter );
    if (!tmp.empty()) {
      result += tmp;
      result += " ";
    }
    else
      result += "? ";
  }
  return result;
}

int main( int argc, char* argv[] )
{
    // Need a file name to read
  if (argc != 2) {
    printf("Usage: %s <file>\n", argv[0] );
    exit(1);
  }
  
    // Read everything we need from the file
  std::vector<long> set_meta, set_child, set_parent, dim_ents, dim_vals, id_ents, id_vals;
  hid_t file = open_file( argv[1] );
  read_data( file, "/tstt/sets/list", 4, set_meta );
  read_data( file, "/tstt/sets/parents", 1, set_parent );
  read_data( file, "/tstt/sets/children", 1, set_child );
  read_data( file, "/tstt/tags/GEOM_DIMENSION/id_list", 1, dim_ents );
  read_data( file, "/tstt/tags/GEOM_DIMENSION/values", 1, dim_vals );
  read_data( file, "/tstt/tags/GLOBAL_ID/id_list", 1, id_ents );
  read_data( file, "/tstt/tags/GLOBAL_ID/values", 1, id_vals );
  const long startid = read_scalar_attrib( file, "/tstt/sets/list", "start_id" );
  H5Fclose( file );
  
    // Construct handle->dimension and handle->global_id maps.
  std::map<long,long> dimmap, idmap;
  create_map( dim_ents, dim_vals, dimmap, "GEOM_DIMENSION" );
  create_map(  id_ents,  id_vals,  idmap, "GLOBAL_ID" ); 
  
    // For each entity set
  long parent_start = -1l, child_start = -1l;
  printf("handle  ID     Children             Parents\n");
  for (unsigned i = 0; i < set_meta.size(); i += 4)
  {
      // Get name
    long handle = startid + i/4;
    std::string name = ent_from_handle( dimmap, idmap, handle );
    if (name.empty()) // not a geometry set
      continue;
     
      // Get parents and children  
    long  child_end = set_meta[i+1];
    long parent_end = set_meta[i+2];
    std::string children = ent_list_from_handles( dimmap, idmap,  set_child,  child_start,  child_end );
    std::string  parents = ent_list_from_handles( dimmap, idmap, set_parent, parent_start, parent_end );
     child_start =  child_end;
    parent_start = parent_end;
    
      // Print
    printf( "%6ld  %-6s %-20s %-20s\n", handle, name.c_str(), children.c_str(), parents.c_str() );
  }
  
  return 0;
}