GribFile.h

#ifndef _WINC_GRIBFILE
#define _WINC_GRIBFILE
 
#include <WXP/Date.h>
#include <WXP/DomainVal.h>
#include <WXP/File.h>
#include <WXP/Filename.h>
#include <WXP/GribPDB.h>
#include <WXP/GribParam.h>
#include <WXP/Grid.h>
#include <WXP/GridSpec.h>
#include <WXP/Grids.h>
#include <WXP/ModelName.h>
#include <WXP/VarName.h>
 
namespace WXP {
   class GribFile {
      File file;
      int access;
      bool opened;
      File hfile;
      Date date;
      GribPDB pdb;
      DomainVal dv;
      GribParam gparam[200];
      VarName vname;
      int nparam;
      bool use_hfile;
      int wrap;
   
      /* Grid definition parameters */
      int version;
      int type;
      int discipline;
      int sect_flag;
   
      int ploc;         /* Location of beginning of product */
      int gloc;         /* Location of beginning of GRIB product */
      int dloc;         /* Location of beginning of data */
      int gind;         /* Grid index within GRIB product */
      char wmo_hdr[30];/* WMO header */
      int size;        /* GRIB product size */
      int num;          /* Current product count */
      int gnum;         /* Current grid count in product */
      bool peeked;
   
      static const int NUM_VALID = 20;
 
      /* Data block */
      static const int DATA_SIZE = 25000;
      int data_size;
      int data_off;
      unsigned char data[DATA_SIZE];
      float miss;  /* Missing value */
   
      /* GRIB2 section parameters */
      int sect;
      int slen;
      bool cont;
      bool pcont;
 
      /* GRIB2 data template and grid size */
      int data_pnts;
      int drs_temp;
 
      /* Grid definition parameters */
      float lat;                 /* The latitude of the first gridpoint */
      int  xdir;                 /* The scanning on x direction */
      int  ydir;                 /* The scanning on y direction */
      int  xalt;                 /* Rows scan in different directions */
      int  pole;                 /* Specifies single pole point */
 
      /* Thinned grid parameters */
      int  thin;                 /* Specifies whether grid is thinning */
      int *thin_val;             /* Thinning array */
 
      /* Base values for grid value scaling */
      float ref;                 /* Reference value */
      float sfac;                /* Scale factor */
      float dscale;              /* Scale factor */
      int max_val;
      int data_type;             /* Whether data is integer or float */
   
      /* Bit Map section parameters */
      unsigned char *bmb;        /* The bit map block */
      int bmoff;                 /* Offset in the BMB */
      int bmlen;                 /* Length in the BMB */
   
      /* Bitwise storage parameters */
      int  bpval;                /* Specifies the number of bits per
                                  * gridpoint value used in encoding GRIB */
      int  bpoff;                /* Offset in data stream in bytes */
      int  data_bits;    
      int  data_bytes;    
      long bit_mask;    
      int  temp_data;
 
      /* GRIB2 complex decoding */
      int split_method;
      int miss_type;
      float miss1, miss2;
      int num_bits;
      int num_group;
      int num_bits_gref;
      int ref_gwidth;
      int num_bits_gwidth;
      int ref_glen;
      int inc_glen;
      int last_glen;
      int num_bits_glen;
      int order;
      int spat_bytes;
  
      /* JMA codec data */
      float *map;
      int num_map;
 
      /* Checks for corrupt data */ 
      int  valid_data[NUM_VALID];
      int  bad;                  /* Specifies whether gridpoint data bad */
      int  bad_limit;            /* Limit value for determining bad grid */
      int  bad_max;              /* Max number of bad values before all bad */
      int  bad_test;             /* Limit value for determining bad grid */
      int  prev_val;
 
      /* Miscellaneous parameters */
      int lev_type;              /* Type of vertical level */
      int grid_type;             /* Type of grid */
      ModelName mname;
   
      int initClass();
      public:
      GribFile();
      GribFile( const char *filename );
      GribFile( Filename &filename );
      ~GribFile();
      int init();
      bool isOpen();
      int setParam( const char *str );
      int useHdrFile( bool val );
      int setMaxBad( int val );
      inline int setMissValue( float rmiss ){ miss = rmiss; return 1; };
      inline int setValueBits( int val ){ bpval = val; return 1; };
      inline int setWrap( int val ){ wrap = val; return 1; };
      int open( const char *filename, int raccess );
      int open( const char *filename );
      int open( Filename &filename );
      int close();
      int rewind();
      inline int getVersion(){ return version; };
      inline const char* getWmoHdr(){ return wmo_hdr; };
      int getHeader( Grid &grid );
      int read( Grid &grid );
      int read( const char *spec, Grid &grid );
      int read( GridSpec &spec, Grid &grid );
      int read( Grids &grids );
      int makeInfo( GribPDB &pdb, Grid &grid );
      int makeDatim( Grid &grid );
      int peek( Grid &grid );
      int next( );
      int readHeader();
      int searchGRIB();
      int readData( int bytes );
      int readBits();
      unsigned char getByte( int loc );
      int seekData( int val );
      int tellData();
   
      GribParam getVer1Param( int ver, int src, int table, int param );
      int readPDB( GribPDB &pdb );
      int setPDB( GribPDB &pdb, Grid &grid );
      int readGDB( DomainVal &dv );
      int readBMB();
      bool checkBMB();
      int readBDB( Grid &grid );
 
      int readSection();
      int skipSection();
      GribParam getVer2Param( int src, int disc, int cat, int param );
      int readIDS( GribPDB &pdb );
      int readGDS( DomainVal &dv );
      int readPDS( GribPDB &pdb );
      int readDRS();
      int readBMS();
      int readDS( Grid &grid );
 
      int writeBits( int val );
      int write( Grid &grid );
   
      static int checkType( const char *filename );
      static float convIBMFloat( const unsigned char *pc );
      static int convIBMFloat( float val, unsigned char *pc );
      static float convIEEEFloat( const unsigned char *pc );
      static float convScale( const unsigned char *pc );
      static int convScale( float scale );
      static int setDomain( int type, DomainVal &dv );
   
      static const int LIMIT = 300000;
   
      enum Type {
         NONE,
         WXP,
         WMO,
         WXP_OLD,
         NCEP,
         RAW,
         RAW_NS };
   };
}   
#endif