---

GRIB.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
//  File        : GRIB.h
//  Description : Grib file version1 interface
//  Project     : LAMMA 2004
//  Author      : Graziano Giuliani (LaMMA Regione Toscana)
//  References  : http://www.wmo.ch/web/www/WDM/Guides/Guide-binary-2.html
//  RCS ID      : $Id: GRIB.h,v 1.4 2004/09/03 15:00:47 ocean Exp $
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//-----------------------------------------------------------------------------

#include <string>
#include <cstdio>

typedef enum t_enum_GRIB_CENTER {
  GRIB_CENTER_UNKNOWN = -1,
  GRIB_CENTER_MELB    = 1,  
  GRIB_CENTER_MOSCOW  = 4,  
  GRIB_CENTER_NMC     = 7,  
  GRIB_CENTER_NWSTG   = 8,  
  GRIB_CENTER_JMA     = 34, 
  GRIB_CENTER_BEIJING = 38, 
  GRIB_CENTER_BSA     = 46, 
  GRIB_CENTER_NHC     = 52, 
  GRIB_CENTER_CMC     = 54, 
  GRIB_CENTER_GWC     = 57, 
  GRIB_CENTER_FNOC    = 58, 
  GRIB_CENTER_NOAA    = 59, 
  GRIB_CENTER_NCAR    = 60, 
  GRIB_CENTER_UKMO    = 74, 
  GRIB_CENTER_DWD     = 78, 
  GRIB_CENTER_ROME    = 80, 
  GRIB_CENTER_FWS     = 85, 
  GRIB_CENTER_ESA     = 97, 
  GRIB_CENTER_KNMI    = 94, 
  GRIB_CENTER_ECMWF   = 98, 
  GRIB_CENTER_LOCAL   = 128 
} t_enum_GRIB_CENTER;

typedef enum t_enum_GRIB_SUBCENTER {
  GRIB_SUBCENTER_UNKNOWN = -1,
  GRIB_SUBCENTER_LOCAL   = 128
} t_enum_GRIB_SUBCENTER;

typedef enum t_enum_GRIB_TABLE {
  GRIB_TABLE_UNKNOWN       = -1,
  GRIB_TABLE_INTERNATIONAL = 2,
  GRIB_TABLE_LOCAL         = 128
} t_enum_GRIB_TABLE;

typedef enum t_enum_GRIB_PROCESS {
  GRIB_PROCESS_UNKNOWN = -1,
  GRIB_PROCESS_LOCAL   = 128
} t_enum_GRIB_PROCESS;

typedef enum t_enum_GRIB_PARAMETER_TABLE_VERSION2 {
  GRIB_PARAMETER_UNKNOWN  = -1,
  GRIB_PARAMETER_RESERVED = 0,
  GRIB_PARAMETER_PRES_    = 1,   
  GRIB_PARAMETER_PRMSL    = 2,   
  GRIB_PARAMETER_PTEND    = 3,   
  GRIB_PARAMETER_PVORT    = 4,   
  GRIB_PARAMETER_ICAHT    = 5,   
  GRIB_PARAMETER_GP___    = 6,   
  GRIB_PARAMETER_HGT__    = 7,   
  GRIB_PARAMETER_DIST_    = 8,   
  GRIB_PARAMETER_HSTDV    = 9,   
  GRIB_PARAMETER_TOZNE    = 10,  
  GRIB_PARAMETER_TMP__    = 11,  
  GRIB_PARAMETER_VTMP_    = 12,  
  GRIB_PARAMETER_POT__    = 13,  
  GRIB_PARAMETER_EPOT_    = 14,  
  GRIB_PARAMETER_T_MAX    = 15,  
  GRIB_PARAMETER_T_MIN    = 16,  
  GRIB_PARAMETER_DPT__    = 17,  
  GRIB_PARAMETER_DEPR_    = 18,  
  GRIB_PARAMETER_LAPR_    = 19,  
  GRIB_PARAMETER_VIS__    = 20,  
  GRIB_PARAMETER_RDSP1    = 21,  
  GRIB_PARAMETER_RDSP2    = 22,  
  GRIB_PARAMETER_RDSP3    = 23,  
  GRIB_PARAMETER_PLI__    = 24,  
  GRIB_PARAMETER_TMP_A    = 25,  
  GRIB_PARAMETER_PRESA    = 26,  
  GRIB_PARAMETER_GP_A_    = 27,  
  GRIB_PARAMETER_WVSP1    = 28,  
  GRIB_PARAMETER_WVSP2    = 29,  
  GRIB_PARAMETER_WVSP3    = 30,  
  GRIB_PARAMETER_WDIR_    = 31,  
  GRIB_PARAMETER_WIND_    = 32,  
  GRIB_PARAMETER_U_GRD    = 33,  
  GRIB_PARAMETER_V_GRD    = 34,  
  GRIB_PARAMETER_STRM_    = 35,  
  GRIB_PARAMETER_V_POT    = 36,  
  GRIB_PARAMETER_MNTSF    = 37,  
  GRIB_PARAMETER_SGCVV    = 38,  
  GRIB_PARAMETER_V_VEL    = 39,  
  GRIB_PARAMETER_DZDT_    = 40,  
  GRIB_PARAMETER_ABS_V    = 41,  
  GRIB_PARAMETER_ABS_D    = 42,  
  GRIB_PARAMETER_REL_V    = 43,  
  GRIB_PARAMETER_REL_D    = 44,  
  GRIB_PARAMETER_VUCSH    = 45,  
  GRIB_PARAMETER_VVCSH    = 46,  
  GRIB_PARAMETER_DIR_C    = 47,  
  GRIB_PARAMETER_SP_C_    = 48,  
  GRIB_PARAMETER_UOGRD    = 49,  
  GRIB_PARAMETER_VOGRD    = 50,  
  GRIB_PARAMETER_SPF_H    = 51,  
  GRIB_PARAMETER_R_H__    = 52,  
  GRIB_PARAMETER_MIXR_    = 53,  
  GRIB_PARAMETER_P_WAT    = 54,  
  GRIB_PARAMETER_VAPP_    = 55,  
  GRIB_PARAMETER_SAT_D    = 56,  
  GRIB_PARAMETER_EVP__    = 57,  
  GRIB_PARAMETER_C_ICE    = 58,  
  GRIB_PARAMETER_PRATE    = 59,  
  GRIB_PARAMETER_TSTM_    = 60,  
  GRIB_PARAMETER_A_PCP    = 61,  
  GRIB_PARAMETER_NCPCP    = 62,  
  GRIB_PARAMETER_ACPCP    = 63,  
  GRIB_PARAMETER_SRWEQ    = 64,  
  GRIB_PARAMETER_WEASD    = 65,  
  GRIB_PARAMETER_SNO_D    = 66,  
  GRIB_PARAMETER_MIXHT    = 67,  
  GRIB_PARAMETER_TTHDP    = 68,  
  GRIB_PARAMETER_MTHD_    = 69,  
  GRIB_PARAMETER_MTH_A    = 70,  
  GRIB_PARAMETER_T_CDC    = 71,  
  GRIB_PARAMETER_CDCON    = 72,  
  GRIB_PARAMETER_L_CDC    = 73,  
  GRIB_PARAMETER_M_CDC    = 74,  
  GRIB_PARAMETER_H_CDC    = 75,  
  GRIB_PARAMETER_C_WAT    = 76,  
  GRIB_PARAMETER_BLI__    = 77,  
  GRIB_PARAMETER_SNO_C    = 78,  
  GRIB_PARAMETER_SNO_L    = 79,  
  GRIB_PARAMETER_WTMP_    = 80,  
  GRIB_PARAMETER_LAND_    = 81,  
  GRIB_PARAMETER_DSL_M    = 82,  
  GRIB_PARAMETER_SFC_R    = 83,  
  GRIB_PARAMETER_ALBDO    = 84,  
  GRIB_PARAMETER_TSOIL    = 85,  
  GRIB_PARAMETER_SOILM    = 86,  
  GRIB_PARAMETER_VEG__    = 87,  
  GRIB_PARAMETER_SALTY    = 88,  
  GRIB_PARAMETER_DEN__    = 89,  
  GRIB_PARAMETER_WATR_    = 90,  
  GRIB_PARAMETER_ICE_C    = 91,  
  GRIB_PARAMETER_ICETK    = 92,  
  GRIB_PARAMETER_DICED    = 93,  
  GRIB_PARAMETER_SICED    = 94,  
  GRIB_PARAMETER_U_ICE    = 95,  
  GRIB_PARAMETER_V_ICE    = 96,  
  GRIB_PARAMETER_ICE_G    = 97,  
  GRIB_PARAMETER_ICE_D    = 98,  
  GRIB_PARAMETER_SNO_M    = 99,  
  GRIB_PARAMETER_HTSGW    = 100, 
  GRIB_PARAMETER_WVDIR    = 101, 
  GRIB_PARAMETER_WVHGT    = 102, 
  GRIB_PARAMETER_WVPER    = 103, 
  GRIB_PARAMETER_SWDIR    = 104, 
  GRIB_PARAMETER_SWELL    = 105, 
  GRIB_PARAMETER_SWPER    = 106, 
  GRIB_PARAMETER_DIRPW    = 107, 
  GRIB_PARAMETER_PERPW    = 108, 
  GRIB_PARAMETER_DIRSW    = 109, 
  GRIB_PARAMETER_PERSW    = 110, 
  GRIB_PARAMETER_NSWRS    = 111, 
  GRIB_PARAMETER_NLWRS    = 112, 
  GRIB_PARAMETER_NSWRT    = 113, 
  GRIB_PARAMETER_NLWRT    = 114, 
  GRIB_PARAMETER_LWAVR    = 115, 
  GRIB_PARAMETER_SWAVR    = 116, 
  GRIB_PARAMETER_G_RAD    = 117, 
  GRIB_PARAMETER_BRTMP    = 118, 
  GRIB_PARAMETER_LWRAD    = 119, 
  GRIB_PARAMETER_SWRAD    = 120, 
  GRIB_PARAMETER_LHTFL    = 121, 
  GRIB_PARAMETER_SHTFL    = 122, 
  GRIB_PARAMETER_BLYDP    = 123, 
  GRIB_PARAMETER_U_FLX    = 124, 
  GRIB_PARAMETER_V_FLX    = 125, 
  GRIB_PARAMETER_WMIXE    = 126, 
  GRIB_PARAMETER_IMG_D    = 127, 
  GRIB_PARAMETER_LOCALUSE = 128, 
  GRIB_PARAMETER_MISSING  = 255  
} t_enum_GRIB_PARAMETER_TABLE_VERSION2;

typedef enum t_enum_GRIB_TIMEUNIT {
  GRIB_TIMEUNIT_UNKNOWN = -1,  
  GRIB_TIMEUNIT_MINUTE  = 0,   
  GRIB_TIMEUNIT_HOUR    = 1,   
  GRIB_TIMEUNIT_DAY     = 2,   
  GRIB_TIMEUNIT_MONTH   = 3,   
  GRIB_TIMEUNIT_YEAR    = 4,   
  GRIB_TIMEUNIT_DECADE  = 5,   
  GRIB_TIMEUNIT_NORMAL  = 6,   
  GRIB_TIMEUNIT_CENTURY = 7,   
  GRIB_TIMEUNIT_HOURS3  = 10,  
  GRIB_TIMEUNIT_HOURS6  = 11,  
  GRIB_TIMEUNIT_HOURS12 = 12,  
  GRIB_TIMEUNIT_SECOND  = 254  
} t_enum_GRIB_TIMEUNIT;

typedef enum t_enum_GRIB_TIMERANGE {
  GRIB_TIMERANGE_UNKNOWN                                                  = -1,
  GRIB_TIMERANGE_FORECAST_AT_REFTIME_PLUS_P1                              = 0,
  GRIB_TIMERANGE_ANALYSIS_AT_REFTIME                                      = 1,
  GRIB_TIMERANGE_VALID_IN_REFTIME_PLUS_P1_REFTIME_PLUS_P2                 = 2,
  GRIB_TIMERANGE_AVERAGE_IN_REFTIME_PLUS_P1_REFTIME_PLUS_P2               = 3,
  GRIB_TIMERANGE_ACCUMULATED_INTERVAL_REFTIME_PLUS_P1_REFTIME_PLUS_P2     = 4,
  GRIB_TIMERANGE_DIFFERENCE_REFTIME_PLUS_P2_REFTIME_PLUS_P1               = 5,
  GRIB_TIMERANGE_AVERAGE_IN_REFTIME_MINUS_P1_REFTIME_MINUS_P2             = 6,
  GRIB_TIMERANGE_AVERAGE_IN_REFTIME_MINUS_P1_REFTIME_PLUS_P2              = 7,
  GRIB_TIMERANGE_VALID_AT_REFTIME_PLUS_P1P2                               = 10,
  GRIB_TIMERANGE_CLIMATOLOGICAL_MEAN_OVER_MULTIPLE_YEARS_FOR_P2           = 51,
  GRIB_TIMERANGE_AVERAGE_OVER_FORECAST_OF_PERIOD_P1_REFTIME_PERIOD_P2     = 113,
  GRIB_TIMERANGE_ACCUMULATED_OVER_FORECAST_PERIOD_P1_REFTIME_PERIOD_P2    = 114,
  GRIB_TIMERANGE_AVERAGE_OVER_FORECAST_OF_PERIOD_P1_AT_INTERVALS_P2       = 115,
  GRIB_TIMERANGE_ACCUMULATION_OVER_FORECAST_PERIOD_P1_AT_INTERVALS_P2     = 116,
  GRIB_TIMERANGE_AVERAGE_OVER_FORECAST_FIRST_P1_OTHER_P2_REDUCED          = 117,
  GRIB_TIMERANGE_VARIANCE_OF_ANALYSES_WITH_REFERENCE_TIME_INTERVALS_P2    = 118,
  GRIB_TIMERANGE_STDDEV_OF_FORECASTS_FIRST_P1_OTHER_P2_REDUCED            = 119,
  GRIB_TIMERANGE_AVERAGE_OVER_ANALYSES_AT_INTERVALS_OF_P2                 = 123,
  GRIB_TIMERANGE_ACCUMULATION_OVER_ANALYSES_AT_INTERVALS_OF_P2            = 124,
  GRIB_TIMERANGE_STDDEV_OF_FORECASTS_RESPECT_TO_AVERAGE_OF_TENDENCY       = 125,
  GRIB_TIMERANGE_AVERAGE_OF_DAILY_FORECAST_ACCUMULATIONS                  = 128,
  GRIB_TIMERANGE_AVERAGE_OF_SUCCESSIVE_FORECAST_ACCUMULATIONS             = 129,
  GRIB_TIMERANGE_AVERAGE_OF_DAILY_FORECAST_AVERAGES                       = 130,
  GRIB_TIMERANGE_AVERAGE_OF_SUCCESSIVE_FORECAST_AVERAGES                  = 131
} t_enum_GRIB_TIMERANGE;

typedef enum t_enum_GRIB_GRIDS {
  GRIB_GRID_UNKNOWN                = -1,
  GRIB_GRID_REGULAR_LATLON         = 0,
  GRIB_GRID_MERCATOR               = 1,
  GRIB_GRID_GNOMONIC               = 2,
  GRIB_GRID_LAMBERT_CONFORMAL      = 3,
  GRIB_GRID_GAUSSIAN               = 4,
  GRIB_GRID_POLAR_STEREOGRAPHIC    = 5,
  GRIB_GRID_UTM                    = 6,
  GRIB_GRID_SIMPLE_POLYCONIC       = 7,
  GRIB_GRID_ALBERS_EQUAL_AREA      = 8,
  GRIB_GRID_MILLER_CYLINDRICAL     = 9,
  GRIB_GRID_ROTATED_LATLON         = 10,
  GRIB_GRID_OBLIQUE_LAMBERT        = 13,
  GRIB_GRID_ROTATED_GAUSSIAN       = 14,
  GRIB_GRID_STRETCHED_LATLON       = 20,
  GRIB_GRID_STRETCHED_GAUSSIAN     = 24,
  GRIB_GRID_STRETCHED_ROT_LATLON   = 30,
  GRIB_GRID_STRETCHED_ROT_GAUSSIAN = 34,
  GRIB_GRID_SPHERICAL_HARMONIC_COE = 50,
  GRIB_GRID_ROTATED_SPHER_HARM_COE = 60,
  GRIB_GRID_STRETCH_SPHER_HARM_COE = 70,
  GRIB_GRID_STRETCHED_ROT_SP_H_COE = 80,
  GRIB_GRID_SPACEVIEW              = 90
} t_enum_GRIB_GRIDS;

typedef enum t_enum_GRIB_LEVELS {
  GRIB_LEVEL_UNKNOWN = -1,
  GRIB_LEVEL_RESERVED = 0,
  GRIB_LEVEL_SURFACE,
  GRIB_LEVEL_CLOUD_BASE,
  GRIB_LEVEL_CLOUD_TOP,
  GRIB_LEVEL_ISOTHERM_0_DEG,
  GRIB_LEVEL_ADIABATIC_CONDENSATION_LIFTED_FROM_SURFACE,
  GRIB_LEVEL_MAXIMUM_WIND,
  GRIB_LEVEL_TROPOPAUSE,
  GRIB_LEVEL_NOMINAL_ATMOSPHERE_TOP,
  GRIB_LEVEL_SEA_BOTTOM,
  GRIB_LEVEL_ISOTHERMAL_K = 20,
  GRIB_LEVEL_ISOBARIC_mb = 100,
  GRIB_LEVEL_LAYER_ISOBARIC_mb,
  GRIB_LEVEL_MEAN_SEA_LEVEL,
  GRIB_LEVEL_ALTITUDE_ABOVE_MSL_m,
  GRIB_LEVEL_LAYER_ALTITUDE_ABOVE_MSL_m,
  GRIB_LEVEL_HEIGHT_ABOVE_GROUND_m,
  GRIB_LEVEL_LAYER_HEIGHT_ABOVE_GROUND_m,
  GRIB_LEVEL_SIGMA,
  GRIB_LEVEL_LAYER_SIGMA,
  GRIB_LEVEL_HYBRID,
  GRIB_LEVEL_LAYER_HYBRID,
  GRIB_LEVEL_DEPTH_BELOW_SURFACE_cm,
  GRIB_LEVEL_LAYER_DEPTH_BELOW_SURFACE_cm,
  GRIB_LEVEL_ISENTROPIC_K,
  GRIB_LEVEL_LAYER_ISENTROPIC_K,
  GRIB_LEVEL_PRESSURE_DIFFERENCE_FROM_GROUND_mb,
  GRIB_LEVEL_LAYER_PRESSURE_DIFFERENCE_FROM_GROUND_mb,
  GRIB_LEVEL_POTENTIAL_VORTICITY_SURFACE_PV_UNITS,
  GRIB_LEVEL_ETA,
  GRIB_LEVEL_LAYER_ETA,
  GRIB_LEVEL_LAYER_ISOBARIC_HIGH_PRECISION_mb,
  GRIB_LEVEL_HEIGHT_ABOVE_GROUND_HIGH_PRECISION_cm,
  GRIB_LEVEL_ISOBARIC_Pa,
  GRIB_LEVEL_LAYER_SIGMA_HIGH_PRECISION,
  GRIB_LEVEL_LAYER_ISOBARIC_MIXED_PRECISION_mb,
  GRIB_LEVEL_DEPTH_BELOW_SEA_m = 160,
  GRIB_LEVEL_ENTIRE_ATMOSPHERE = 200,
  GRIB_LEVEL_ENTIRE_OCEAN,
  GRIB_LEVEL_SPECIAL = 204
} t_enum_GRIB_LEVELS;

// ############################################################################
// Interface to time definition
// ############################################################################

class GRIB_TIME {
  public:
    GRIB_TIME( );

    void Decode(unsigned char *pds);

    unsigned char *Encode( );

    void set(int year, int month, int day, int hour, int minute,
             t_enum_GRIB_TIMEUNIT tu, t_enum_GRIB_TIMERANGE tr,
             int time1, int time2, int nave, int nmiss);

    void set_referencetime(int year, int month, int day, int hour, int minute);

    void set_analysis( );

    void set_forecast_hour(int hforecast);

    std::string Reftime( );

    std::string Reftime2000( );

    std::string TimeString( );

    std::string ValidTime( );

    time_t ForecastSeconds( );

    time_t ForecastSeconds2000( );

    t_enum_GRIB_TIMEUNIT timeunit;

    t_enum_GRIB_TIMERANGE timerange;

    friend std::ostream& operator<< ( std::ostream& os, GRIB_TIME &t );

    std::string reftime;

    std::string timestring;

    int year;
    int month;
    int day;
    int hour;
    int minute;
    int p1;
    int p2;
    int p1p2;
    int naveraged, nmissing;

  private:
    void set_time(t_enum_GRIB_TIMEUNIT tu, t_enum_GRIB_TIMERANGE tr, int time);
    void set_time(t_enum_GRIB_TIMEUNIT tu, t_enum_GRIB_TIMERANGE tr,
                  int time1, int time2);
    void set_time(t_enum_GRIB_TIMEUNIT tu, t_enum_GRIB_TIMERANGE tr,
                  int time1, int time2, int nave, int nmiss);
    char *timeunitstr( );
    void strref( );
    void strtime( );
};

// ############################################################################
// Interface to level definition
// ############################################################################

class GRIB_LEVEL {
  public:
    GRIB_LEVEL( );

    void Decode(unsigned char *pds);

    int Encode( );

    t_enum_GRIB_LEVELS type;

    float lv1;
    float lv2;

    bool is_LevelPressure( );
    bool is_LevelHeight( );
    bool is_Surface( );
    bool is_MeanSeaLevel( );

    void set_pressure(float plev);

    void set_height(float hgt);

    void set_seadepth(float dpt);

    void set_isentropic(float temp);

    void set_sigma(float sigma);

    void set_surface( );

    void set(t_enum_GRIB_LEVELS type, float lev1, float lev2);

    friend std::ostream& operator<< ( std::ostream& os, GRIB_LEVEL &l );

  private:
    void set(t_enum_GRIB_LEVELS type);
    void set(t_enum_GRIB_LEVELS type, float lev);
    std::string leveldesc( );
};

// ############################################################################
// Grid definitions
// ############################################################################

class GRIB_GRID_regular_latlon {
  public:
    void set(float lat1, float lon1,
             float lat2, float lon2,
             float dlon, float dlat);

    float lat1;  
    float lon1;  
    float lat2;  
    float lon2;  
    float dlat;  
    float dlon;  

    friend std::ostream& operator<< ( std::ostream& os,
                                      GRIB_GRID_regular_latlon &g );
};

class GRIB_GRID_gaussian_latlon {
  public:
    void set(float lat1, float lon1,
             float lat2, float lon2,
             float dlon, float N);

    float lat1;  
    float lon1;  
    float lat2;  
    float lon2;  
    float dlon;  
    float N;     

    friend std::ostream& operator<< ( std::ostream& os,
                                      GRIB_GRID_gaussian_latlon &g );
};

class GRIB_GRID_polar_stereographic {
  public:
    void set(float lat1, float lon1, float lov,
             float dx, float dy, bool pole);

    float lat1; 
    float lon1; 
    float lov;  
    float dx;   
    float dy;   
    bool pole;  

    friend std::ostream& operator<< ( std::ostream& os,
                                      GRIB_GRID_polar_stereographic &g );
};

class GRIB_GRID_lambert_conformal {
  public:
    void set(float lat1, float lon1, float lov,
             float latin1, float latin2,
             float latsp, float lonsp,
             float dx, float dy,
             bool pole, bool bipolar);

    float lat1;    
    float lon1;    
    float lov;     
    float latin1;  
    float latin2;  
    float latsp;   
    float lonsp;   
    float dx;      
    float dy;      
    bool pole;     
    bool bipolar;  

    friend std::ostream& operator<< ( std::ostream& os,
                                      GRIB_GRID_lambert_conformal &g );
};

class GRIB_GRID_mercator {
  public:
    void set(float lat1, float lon1,
             float lat2, float lon2,
             float dx, float dy, float latin);

    float lat1;   
    float lon1;   
    float lat2;   
    float lon2;   
    float dx;     
    float dy;     
    float latin;  

    friend std::ostream& operator<< ( std::ostream& os,
                                      GRIB_GRID_mercator &g );
};

class GRIB_GRID_spaceview {
  public:
    void set(float lap, float lop, float dx, float dy,
             float Xp, float Yp, float orient, float Nr);

    float lap;     
    float lop;     
    float dx;      
    float dy;      
    float Xp;      
    float Yp;      
    float orient;  
    float Nr;      

    friend std::ostream& operator<< ( std::ostream& os,
                                      GRIB_GRID_spaceview &g );
};

class GRIB_GRID_spherical_harmonic {
  public:
    void set(int J, int K, int M, int rt, int csm);

    enum GRIB_GRID_SPECTRAL_REPRESENTATION
    {
      SR_associated_legendre_polynomials_first_kind = 1,
      SR_spherical_harmonics_complex_packing        = 2
    } representation;

    enum GRIB_GRID_COEFFICIENT_STORAGE_METHOD
    {
      CSM_normal  = 1,
      CSM_complex = 2
    } storage_method;

    int J;
    int K;
    int M;

    friend std::ostream& operator<< ( std::ostream& os,
                                      GRIB_GRID_spherical_harmonic &g );
};

// ############################################################################
// Interface to grid definitions
// ############################################################################

class GRIB_GRID {
  public:
    GRIB_GRID( );

    void Decode(unsigned char *pds, unsigned char *gds,
                unsigned char *bms, unsigned char *bds);

    unsigned char *Encode( );

    void set_size(int nx, int ny);

    void set_number(int code);

    void set_regular_latlon(float lat1, float lon1,
                            float lat2, float lon2,
                            float dlat, float dlon);

    void set_gaussian_latlon(float lat1, float lon1,
                             float lat2, float lon2,
                             float dlon, float N);

    void set_polar_stereo(float lat1, float lon1, float lov,
                          float dx, float dy, bool pole);

    void set_lambert_conformal(float lat1, float lon1, float lov,
                               float latin1, float latin2,
                               float latsp, float lonsp,
                               float dx, float dy,
                               bool pole, bool bipolar);

    void set_mercator(float lat1, float lon1, float lat2, float lon2,
                      float dx, float dy, float latin);

    void set_spaceview(float lap, float lop, float dx, float dy,
                       float Xp, float Yp, float orient, float Nr);

    void set_spherical_harmonic(int J, int K, int M, int rt, int csm);
    
    void set_earth_spheroid( );

    void set_uv_grid( );

    void set_x_negative( );

    void set_y_negative( );

    void set_fortran_indexing( );

    union {
      GRIB_GRID_regular_latlon ll;
      GRIB_GRID_polar_stereographic ps;
      GRIB_GRID_lambert_conformal lc;
      GRIB_GRID_gaussian_latlon gl;
      GRIB_GRID_mercator mc;
      GRIB_GRID_spherical_harmonic sa;
      GRIB_GRID_spaceview sp;
    };

    t_enum_GRIB_GRIDS type;

    int grid_code;

    bool is_dirincgiven;

    bool is_earth_spheroid;

    bool is_uv_grid;

    bool is_x_negative;

    bool is_y_negative;

    bool is_fortran;

    friend std::ostream& operator<< ( std::ostream& os, GRIB_GRID &g );

    long nxny;
    int nx;
    int ny;

    unsigned char gds[44];
};

// ############################################################################
// Interface to GRIB field
// ############################################################################

class GRIB_FIELD {
  public:
    GRIB_FIELD( );

    ~GRIB_FIELD( );

    void Decode(unsigned char *pds, unsigned char *bds,
                unsigned char *bms, size_t nxny);

    void set_table(int center, int subcenter, int table, int process);

    void set_field(int varcode, float *values, size_t size,
                   float undef_high, float undef_low);

    void set_scale(int scale);

    int center;
    int subcenter;
    int table;
    int process;

    int varcode;

    size_t size;
    float *vals;

    std::string VarName( );
    std::string VarUnit( );
    std::string VarDescription( );

    float undef_high;
    float undef_low;

    std::string varname;
    std::string varunit;
    std::string vardesc;

    int numbits;
    float refvalue;
    int decimalscale;
    int binscale;
};

// ############################################################################
// Interface to GRIB message
// ############################################################################

class GRIB_MESSAGE {
  public:
    GRIB_MESSAGE( );

    ~GRIB_MESSAGE( );

    int Decode(unsigned char *message, size_t reclen);

    void Encode( );

    void set_grid(GRIB_GRID &grid);

    void set_grid(int code);

    void set_time(GRIB_TIME &gtime);

    void set_level(GRIB_LEVEL &level);

    void set_field(GRIB_FIELD &field);

    size_t reclen;

    unsigned char *message;

    GRIB_GRID grid;
    GRIB_LEVEL level;
    GRIB_TIME gtime;
    GRIB_FIELD field;

  private:
    unsigned char *pds;
    unsigned char *gds;
    unsigned char *bms;
    unsigned char *bds;
};

// ############################################################################
// Overall GRIB FILE interface
// ############################################################################

class GRIB_FILE {
  public:
    GRIB_FILE();

    ~GRIB_FILE();

    int OpenRead(char *fname);

    int OpenRead(std::string fname);

    int OpenWrite(char *fname);

    int OpenWrite(std::string fname);

    int Append(char *fname);

    int Append(std::string fname);

    int ReadMessage(GRIB_MESSAGE &message);

    int WriteMessage(GRIB_MESSAGE &message);

    int Close( );

  private:
    int fd;    // input stream pointer
    FILE *fp;  // output stream pointer

    size_t size;  // input total file size
    size_t pos;   // position in file size
    size_t limit; // last message start

    unsigned char *data; // actual input data
};

// ############################################################################

---