ReadGCRM.hpp

Go to the documentation of this file.

#ifndef READGCRM_HPP
#define READGCRM_HPP

#ifndef IS_BUILDING_MB
//#error "ReadNC.hpp isn't supposed to be included into an application"
#endif

#include <vector>
#include <map>
#include <string>

#include "moab/Forward.hpp"
#include "moab/ReaderIface.hpp"
#include "moab/Range.hpp"
#include "moab/ScdInterface.hpp"
#include "DebugOutput.hpp"

#ifdef USE_MPI
#  include "moab_mpi.h"
#  include "moab/ParallelComm.hpp"
#endif 

#ifdef PNETCDF_FILE
#  include "pnetcdf.h"
#  define NCFUNC(func) ncmpi_ ## func
#  define NCFUNCA(func) ncmpi_ ## func ## _all
// keep it this way , introduce another macro, used so far only for ucd mesh
//#  define NCASYNCH
#  ifdef NCASYNCH
#    define NCREQ , &requests[j]
#    define NCFUNCAG(func) ncmpi_iget ## func 
#    define NCWAIT
#  else
#    define NCREQ2 , &requests[idxReq++]
#    define NCFUNCAG2(func) ncmpi_iget ## func
#    define NCREQ 
#    define NCFUNCAG(func) ncmpi_get ## func ## _all
#  endif
#  define NCDF_SIZE MPI_Offset
#  define NCDF_DIFF MPI_Offset
#else
#  include "netcdf.h"
#define NCREQ
#define NCGET get
#  define NCFUNC(func) nc_ ## func
#  define NCFUNCA(func) nc_ ## func
#  define NCFUNCAG(func) nc_get ## func
#  define NCDF_SIZE size_t
#  define NCDF_DIFF ptrdiff_t
#endif

namespace moab {

class ReadUtilIface;

class ReadGCRM : public ReaderIface
{
   
public:

  static ReaderIface* factory( Interface* );

  virtual ErrorCode load_file( const char* file_name,
                               const EntityHandle* file_set,
                               const FileOptions& opts,
                               const SubsetList* subset_list = 0,
                               const Tag* file_id_tag = 0 );

  virtual ErrorCode read_tag_values( const char* file_name,
                                     const char* tag_name,
                                     const FileOptions& opts,
                                     std::vector<int>& tag_values_out,
                                     const SubsetList* subset_list = 0 );
  
  ReadGCRM(Interface* impl = NULL);

  virtual ~ReadGCRM();

  // ENTLOCNSEDGE for north/south edge
  // ENTLOCWEEDGE for west/east edge
  enum EntityLocation {ENTLOCNODE=0, ENTLOCNSEDGE, ENTLOCEWEDGE, ENTLOCQUAD, ENTLOCSET};

private:

  ErrorCode read_vertices(int num_verts, EntityHandle &start_vertex, Range &read_ents);
  
  ErrorCode read_elements(int num_elems, EntityHandle start_vertex,
                          EntityHandle &start_elem, Range &read_ents);

  ErrorCode create_sets(int num_sets, EntityHandle start_vertex, int num_verts, 
                        EntityHandle start_elem, int num_elems, Range &read_ents);
  
  
  ErrorCode process_options(const FileOptions &opts);
  
  void reset();

  ErrorCode read_header();

  class AttData 
  {
    public:
    AttData() : attId(-1), attLen(0), attVarId(-2) {}
    int attId;
    NCDF_SIZE attLen;
    int attVarId;
    nc_type attDataType;
    std::string attName;
  };

  class VarData 
  {
    public:
    VarData() : varId(-1), numAtts(-1), read(false), entLoc(ENTLOCSET), numLev(1), sz(0), has_t(false) {}
    int varId;
    int numAtts;
    nc_type varDataType;
    std::vector<int> varDims; // the dimension indices making up this multi-dimensional variable
    std::map<std::string,AttData> varAtts;
    std::string varName;
    bool read;
    std::vector<Tag> varTags; // one tag for each timestep, varTags[t]
    std::vector<void*> varDatas;
    std::vector<std::vector<NCDF_SIZE> > readDims; // start value for this [t][dim]
    std::vector<std::vector<NCDF_SIZE> > readCounts; // number of data values for this [t][dim]
    int entLoc;
    int numLev;
    int sz;
    bool has_t;
  };

  ErrorCode get_attributes(int var_id, int num_atts, std::map<std::string,AttData> &atts,
                           const char *prefix="");
  
  ErrorCode get_dimensions(int file_id, std::vector<std::string> &dim_names, std::vector<int> &dim_vals);

  ErrorCode get_variables();
  
  unsigned int number_dimensions();

  ErrorCode get_tag(VarData &var_data, int tstep_num, Tag &tagh, int num_lev);
  
  ErrorCode create_attrib_string(const std::map<std::string, AttData>& attMap, 
                 std::string& attString,
                 std::vector<int>& attLen);

  ErrorCode create_tags(ScdInterface *scdi, EntityHandle file_set, const std::vector<int>& tstep_nums);
  
  ReadUtilIface* readMeshIface;

  int CPU_WORD_SIZE;
  int IO_WORD_SIZE;

  Interface* mbImpl;

  const char *fileName;
  
  int fileId, connectId;
  
  std::vector<std::string> dimNames;
  std::vector<int> dimVals;

  std::map<std::string,AttData> globalAtts;
  
  std::map<std::string,VarData> varInfo;

  int tMin, tMax;
  
  std::vector<double> tVals;

  int tDim;

  int numUnLim;

  EntityHandle mCurrentMeshHandle;

  EntityHandle startVertex, startElem;

  Tag mGlobalIdTag;

  int max_line_length, max_str_length;

  Range initRange;

  int vertexOffset;

  DebugOutput dbgOut;

  int partMethod;

  bool isParallel;

#ifdef USE_MPI
  ParallelComm *myPcomm;
#endif
  
};

inline unsigned int ReadGCRM::number_dimensions() 
{
  return dimVals.size();
}

} // namespace moab

#endif