WriteHDF5.hpp

Go to the documentation of this file.

#ifndef WRITE_HDF5_HPP
#define WRITE_HDF5_HPP

#include <list>
#ifdef USE_MPI // include this before HDF5 headers to avoid conflicts
#  include "moab_mpi.h"
#endif
#include "moab_mpe.h"
#include "mhdf.h"
#include "moab/Forward.hpp"
#include "moab/Range.hpp"
#include "moab/WriterIface.hpp"
#include "moab/RangeMap.hpp"
#include "moab/WriteUtilIface.hpp"
#include "DebugOutput.hpp"
#include "HDF5Common.hpp"

namespace moab {

class IODebugTrack;

/* If this define is not set, node->entity adjacencies will not be written */
#undef MB_H5M_WRITE_NODE_ADJACENCIES

class WriteHDF5 : public WriterIface
{

public:

  static WriterIface* factory( Interface* );

  WriteHDF5( Interface* iface );
  
  virtual ~WriteHDF5();
  
  ErrorCode write_file( const char* filename,
                          const bool overwrite,
                          const FileOptions& opts,
                          const EntityHandle* export_sets,
                          const int export_set_count,
                          const std::vector<std::string>& qa_records,
                          const Tag* tag_list = NULL,
                          int num_tags = 0,
                          int user_dimension = 3 );

  typedef EntityHandle id_t;
  
  static const hid_t id_type;

  struct ExportType
  {
    EntityType type;
    int num_nodes;

    virtual ~ExportType()
    { }
    
    bool operator==(ExportType t) const
      { return t.type == type && t.num_nodes == num_nodes; }
    bool operator!=(ExportType t) const
      { return t.type != type || t.num_nodes != num_nodes; }
    bool operator<(ExportType t) const
      { return type < t.type || (type == t.type && num_nodes < t.num_nodes); }
  }; 

  struct ExportSet : public ExportType
  {
    Range range;
    id_t first_id;
    long offset;
    long adj_offset;
    long max_num_ents, max_num_adjs;
    long total_num_ents;
    
    bool operator<( const ExportType& other ) const
      { return type < other.type || 
               (type == other.type && num_nodes < other.num_nodes); }
    
    bool operator<( std::pair<int,int> other ) const
      { return type < other.first || 
               (type == other.first && num_nodes < other.second); }
    
    bool operator==( const ExportType& other ) const
      { return (type == other.type && num_nodes == other.num_nodes); }
    
    bool operator==( std::pair<int,int> other ) const
      { return (type == other.first && num_nodes == other.second); }
                
    const char* name() const;
  };
  
  struct TagDesc
  {
    Tag tag_id;
    id_t sparse_offset;
    id_t var_data_offset;
    bool write_sparse;
    unsigned long max_num_ents;
    unsigned long max_num_vals;
    
    std::vector<ExportType> dense_list;
    
    bool have_dense( const ExportType& type ) const
      { return std::find(dense_list.begin(), dense_list.end(), type) != dense_list.end(); }
    
    bool operator<(const TagDesc&) const;
  };

  //static ErrorCode register_known_tag_types( Interface* );
  
  struct HDF5ErrorHandler {
    HDF5_Error_Func_Type func;
    void* data;
  };
  
  mhdf_FileHandle file_ptr() { return filePtr; }
  
  WriteUtilIface* write_util() { return writeUtil; }

protected:
  
  HDF5ErrorHandler errorHandler;

  virtual ErrorCode parallel_create_file( const char* filename,
                                            bool overwrite,
                                            const std::vector<std::string>& qa_records,
                                            const FileOptions& opts,
                                            const Tag* tag_list,
                                            int num_tags,
                                            int dimension = 3,
                                            double* times = 0 );
  virtual ErrorCode write_finished();
  virtual void debug_barrier_line(int lineno);
 
  ErrorCode gather_tags( const Tag* user_tag_list, int user_tag_list_length );

  bool check_dense_format_tag( const ExportSet& ents, 
                               const Range& all_tagged,
                               bool prefer_dense );

  ErrorCode count_adjacencies( const Range& elements, id_t& result );
  
public: // make these public so helper classes in WriteHDF5Parallel can use them

  ErrorCode create_elem_table( const ExportSet& block, long num_ents, long& first_id_out );
  
  ErrorCode create_set_meta( long num_sets, long& first_id_out );

protected:
  
  ErrorCode count_set_size( const Range& sets,
                              long& contents_length_out,
                              long& children_length_out,
                              long& parents_length_out );

  ErrorCode get_set_info( EntityHandle set,
                            long& num_entities,
                            long& num_children,
                            long& num_parents,
                            unsigned long& flags );

  ErrorCode create_set_tables( long contents_length,
                               long children_length,
                               long parents_length );

  ErrorCode write_qa( const std::vector<std::string>& list );

  ErrorCode get_num_sparse_tagged_entities( const TagDesc& tag, size_t& count );
  ErrorCode get_sparse_tagged_entities( const TagDesc& tag, Range& range );
  void get_write_entities( Range& range );
  
  size_t bufferSize;
  char* dataBuffer;

  Interface* iFace;
  WriteUtilIface* writeUtil;
  
  mhdf_FileHandle filePtr;
  
  RangeMap<EntityHandle,id_t> idMap;
  
  std::list<ExportSet> exportList;
  ExportSet nodeSet;
  ExportSet setSet;
  
  const ExportSet* find( ExportType type ) const {
    if (type.type == MBVERTEX)
      return &nodeSet;
    else if (type.type == MBENTITYSET)
      return &setSet;
    else {
      std::list<ExportSet>::const_iterator it;
      it = std::find( exportList.begin(), exportList.end(), type );
      return it == exportList.end() ? 0 : &*it;
    }
  }
  
  unsigned long setContentsOffset;
  unsigned long setChildrenOffset, setParentsOffset;
  long maxNumSetContents, maxNumSetChildren, maxNumSetParents;
  bool writeSets, writeSetContents, writeSetChildren, writeSetParents;
  
  struct SpecialSetData {
    EntityHandle setHandle;
    unsigned setFlags;
    std::vector<id_t> contentIds;
    std::vector<id_t> childIds;
    std::vector<id_t> parentIds;
  };
  struct SpecSetLess {
    bool operator() (const SpecialSetData& a, EntityHandle b) const
      { return a.setHandle < b; }
  };

  
  std::vector<SpecialSetData> specialSets;
  const SpecialSetData* find_set_data( EntityHandle h ) const
    { return const_cast<WriteHDF5*>(this)->find_set_data(h); }
  SpecialSetData* find_set_data( EntityHandle h );
  
  std::list<TagDesc> tagList;

  bool parallelWrite;
  bool collectiveIO;
  bool writeTagDense;
  
  hid_t writeProp;
  
  DebugOutput dbgOut;
  
  static MPEState topState;
  static MPEState subState;
  
  bool debugTrack;

  void print_id_map() const;
  void print_id_map( std::ostream& str, const char* prefix = "" ) const;

  ErrorCode create_tag( const TagDesc& tag_data, 
                        unsigned long num_entities,
                        unsigned long var_len_total );
  
  ErrorCode assign_ids( const Range& entities, id_t first_id );
  
  ErrorCode range_to_blocked_list( const Range& input_range,
                                   std::vector<id_t>& output_id_list , 
                                   bool& ranged_list );
  
  ErrorCode range_to_blocked_list( const EntityHandle* input_ranges,
                                   size_t num_input_ranges,
                                   std::vector<id_t>& output_id_list , 
                                   bool& ranged_list );
  

  ErrorCode range_to_id_list( const Range& input_range,
                                id_t* array );
  ErrorCode vector_to_id_list( const std::vector<EntityHandle>& input,
                               std::vector<id_t>& output, 
                               bool remove_non_written = false );
  ErrorCode vector_to_id_list( const EntityHandle* input,
                               id_t* output,
                               size_t num_entities );
  ErrorCode vector_to_id_list( const EntityHandle* input,
                               size_t input_len,
                               id_t* output,
                               size_t& output_len,
                               bool remove_non_written );

  bool convert_handle_tag( EntityHandle* data, size_t count ) const;
  bool convert_handle_tag( const EntityHandle* source,
                           EntityHandle* dest, 
                           size_t count ) const;

  ErrorCode get_adjacencies( EntityHandle entity, std::vector<id_t>& adj );
                                
  ErrorCode get_tag_data_length( const TagDesc& tag_info,
                                 const Range& range,
                                 unsigned long& result );
  
private:

  ErrorCode write_file_impl( const char* filename,
                               const bool overwrite,
                               const FileOptions& opts,
                               const EntityHandle* export_sets,
                               const int export_set_count,
                               const std::vector<std::string>& qa_records,
                               const Tag* tag_list,
                               int num_tags,
                               int user_dimension = 3 );

  ErrorCode init();
  
  ErrorCode serial_create_file( const char* filename,
                                  bool overwrite,
                                  const std::vector<std::string>& qa_records,
                                  const Tag* tag_list,
                                  int num_tags,
                                  int dimension = 3 );
  
  ErrorCode gather_mesh_info( const std::vector<EntityHandle>& export_sets );
  
  ErrorCode gather_all_mesh( );
  
  ErrorCode initialize_mesh( const Range entities_by_dim[5] );
 
  ErrorCode write_nodes( );
  
  ErrorCode write_elems( ExportSet& elemset );
  
  ErrorCode write_sets( double* times );

  ErrorCode write_set_data( const WriteUtilIface::EntityListType which_data,
                            const hid_t handle,
                            IODebugTrack& track,
                            Range* ranged = 0,
                            Range* null_stripped = 0,
                            std::vector<long>* set_sizes = 0);
  
  ErrorCode write_adjacencies( const ExportSet& export_set );
  

  ErrorCode write_tag( const TagDesc& tag_data,
                       double* times );
                            
  ErrorCode get_connectivity( Range::const_iterator begin,
                              Range::const_iterator end,
                              int nodes_per_element,
                              id_t* id_data_out );
                                   
  ErrorCode get_tag_size( Tag tag,
                          DataType& moab_type,
                          int& num_bytes,
                          int& elem_size,
                          int& file_size,
                          mhdf_TagDataType& file_type,
                          hid_t& hdf_type );
                            
  ErrorCode write_sparse_ids( const TagDesc& tag_data, 
                              const Range& range,
                              hid_t table_handle, 
                              size_t table_size, 
                              const char* name = 0 );
  
  ErrorCode write_sparse_tag( const TagDesc& tag_data,
                              const std::string& tag_name,
                              DataType tag_data_type,
                              hid_t hdf5_data_type,
                              int hdf5_type_size );

  ErrorCode write_var_len_indices( const TagDesc& tag_data,
                                   const Range& range,
                                   hid_t idx_table,
                                   size_t table_size,
                                   int type_size,
                                   const char* name = 0 );
  
  ErrorCode write_var_len_data( const TagDesc& tag_data,
                                const Range& range,
                                hid_t table,
                                size_t table_size,
                                bool handle_tag,
                                hid_t hdf_type,
                                int type_size,
                                const char* name = 0 );
  
  ErrorCode write_var_len_tag( const TagDesc& tag_info,
                               const std::string& tag_name,
                               DataType tag_data_type,
                               hid_t hdf5_type,
                               int hdf5_type_size );

  ErrorCode write_dense_tag( const TagDesc& tag_data,
                             const ExportSet& elem_data,
                             const std::string& tag_name,
                             DataType tag_data_type,
                             hid_t hdf5_data_type,
                             int hdf5_type_size );

  ErrorCode write_tag_values( Tag tag_id,
                              hid_t data_table,
                              unsigned long data_offset,
                              const Range& range,
                              DataType tag_data_type,
                              hid_t hdf5_data_type,
                              int hdf5_type_size,
                              unsigned long max_num_ents,
                              IODebugTrack& debug_track );

protected:

  enum TimingValues { 
       TOTAL_TIME = 0,
         GATHER_TIME,
         CREATE_TIME,
           CREATE_NODE_TIME,
           NEGOTIATE_TYPES_TIME,
           CREATE_ELEM_TIME,
           FILEID_EXCHANGE_TIME,
           CREATE_ADJ_TIME,
           CREATE_SET_TIME,
             SHARED_SET_IDS,
             SHARED_SET_CONTENTS,
             SET_OFFSET_TIME,
           CREATE_TAG_TIME,
         COORD_TIME,
         CONN_TIME,
         SET_TIME,
           SET_META,
           SET_CONTENT,
           SET_PARENT,
           SET_CHILD,
         ADJ_TIME,
         TAG_TIME,
           DENSE_TAG_TIME,
           SPARSE_TAG_TIME,
           VARLEN_TAG_TIME,
         NUM_TIMES };

  
  virtual void print_times( const double times[NUM_TIMES] ) const;
};

} // namespace moab

#endif