WriteHDF5Parallel.hpp

Go to the documentation of this file.

#ifndef WRITE_HDF5_PARALLEL_HPP
#define WRITE_HDF5_PARALLEL_HPP

#include "WriteHDF5.hpp"
#include <H5Spublic.h>
#include <map>

namespace moab {

struct RemoteSetData;
class ParallelComm;
class IODebugTrack;

class WriteHDF5Parallel : public WriteHDF5
{
  public:

    static WriterIface* factory( Interface* );
    
    WriteHDF5Parallel( Interface* iface );

    virtual ~WriteHDF5Parallel();
    
  
  protected:
    
    virtual void debug_barrier_line(int lineno);

  
    virtual void print_times( const double* times ) const;
  
    virtual ErrorCode parallel_create_file( const char* filename,
                                     bool overwrite,
                                     const std::vector<std::string>& qa_records,
                                     const FileOptions& opts,
                                     const Tag* user_tag_list = 0,
                                     int user_tag_count = 0,
                                     int dimension = 3,
                                     double* times = 0);
    
    ErrorCode gather_interface_meshes( Range& non_local_ents );
    
    ErrorCode exchange_file_ids( const Range& non_local_ents );
    
    ErrorCode communicate_shared_set_ids( const Range& owned, const Range& remote );
    
    ErrorCode pack_set( Range::const_iterator set,
                        unsigned long* set_data,
                        size_t set_data_length );
  
    ErrorCode unpack_set( EntityHandle set, 
                          const unsigned long* set_data, 
                          size_t set_data_length );
                          
    ErrorCode communicate_shared_set_data( const Range& owned, const Range& remote );
    
    ErrorCode create_node_table( int dimension );
    
    ErrorCode negotiate_type_list();
    
    ErrorCode create_element_tables();
    
    ErrorCode create_adjacency_tables();
    
    ErrorCode create_meshset_tables(double* times);
    
    ErrorCode create_tag_tables();
   
    void remove_remote_entities( EntityHandle relative, Range& range );
    void remove_remote_entities( EntityHandle relative, std::vector<EntityHandle>& vect );
    void remove_remote_sets( EntityHandle relative, Range& range );
    void remove_remote_sets( EntityHandle relative, std::vector<EntityHandle>& vect );
  
    ErrorCode get_sharedset_tags();

    ErrorCode append_serial_tag_data( std::vector<unsigned char>& buffer,
                                      const WriteHDF5::TagDesc& tag );

    ErrorCode check_serial_tag_data( 
                               const std::vector<unsigned char>& buffer,
                               std::vector<TagDesc*>* missing = 0,
                               std::vector<TagDesc*>* newlist = 0 );
  
    struct DataSetCreator {
      virtual ErrorCode operator()( WriteHDF5* writer,
                                    long data_set_size,
                                    const ExportSet* group, 
                                    long& start_id_out ) const = 0;
    };
    struct NoopDescCreator : public DataSetCreator {
      ErrorCode operator()( WriteHDF5*, long, const ExportSet*, long& start_id ) const
      { start_id = -1; return MB_SUCCESS; }
    };
    
    ErrorCode create_dataset( int num_datasets,
                              const long* num_owned_entities,
                              long* offsets_out,
                              long* max_proc_ents_out,
                              long* total_ents_out,
                              const DataSetCreator& creator = NoopDescCreator(),
                              ExportSet* groups[] = 0,
                              id_t* first_ids_out = NULL );
  
    void print_shared_sets();
    void print_set_sharing_data( const Range& range, const char* label, Tag idt );
  
  private:

    ParallelComm *myPcomm;

    bool pcommAllocated;
    
    H5S_seloper_t hslabOp;
};

} // namespace moab

#endif