stream_gribapi.c 81.7 KB
Newer Older
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1
2
3
4
5
6
#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif

#include <stdio.h>

Uwe Schulzweida's avatar
Uwe Schulzweida committed
7
#include "dmemory.h"
Uwe Schulzweida's avatar
Uwe Schulzweida committed
8
9
10
11
12
13
#include "cdi.h"
#include "stream_int.h"
#include "file.h"
#include "varscan.h"
#include "datetime.h"
#include "vlist.h"
Uwe Schulzweida's avatar
Uwe Schulzweida committed
14
#include "stream_grb.h"
15
#include "calendar.h"
Uwe Schulzweida's avatar
Uwe Schulzweida committed
16
17
18
19


#if  defined  (HAVE_LIBGRIB_API)
#  include "cgribex.h"      /* gribGetSize, gribRead, gribGetZip */
Uwe Schulzweida's avatar
Uwe Schulzweida committed
20
#  include "gribapi.h"
Uwe Schulzweida's avatar
Uwe Schulzweida committed
21
22
23
24
25
26
27
#  include "grib_api.h"
#endif


extern int cdiInventoryMode;

typedef struct {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
28
  int param;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
29
30
31
32
33
34
35
36
  int level1;
  int level2;
  int ltype;
} compvar2_t; 


#if  defined  (HAVE_LIBGRIB_API)
static
37
int gribapiGetGridType(grib_handle *gh)
Uwe Schulzweida's avatar
Uwe Schulzweida committed
38
{
39
40
  int gridtype = GRID_GENERIC;
  int gribgridtype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
41
42
  long lpar;

43
44
45
46
47
48
    {
      GRIB_CHECK(grib_get_long(gh, "gridDefinitionTemplateNumber", &lpar), 0);
      gribgridtype = (int) lpar;

      switch (gribgridtype)
	{
49
	case  GRIB2_GTYPE_LATLON:     { GRIB_CHECK(grib_get_long(gh, "Ni", &lpar), 0);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
50
	                                if ( lpar == (long) GRIB_MISSING_LONG ) break;
51
                                      }
52
53
	case  GRIB2_GTYPE_LATLON_ROT: { gridtype = GRID_LONLAT;    break; }
	case  GRIB2_GTYPE_LCC:        { gridtype = GRID_LCC;       break; }
54
	case  GRIB2_GTYPE_GAUSSIAN:   { GRIB_CHECK(grib_get_long(gh, "Ni", &lpar), 0);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
55
	                                if ( lpar == (long) GRIB_MISSING_LONG )
56
57
58
59
60
					  gridtype = GRID_GAUSSIAN_REDUCED;
					else
					  gridtype = GRID_GAUSSIAN;
					break;
                                      }
61
62
63
	case  GRIB2_GTYPE_SPECTRAL:   { gridtype = GRID_SPECTRAL;  break; }
	case  GRIB2_GTYPE_GME:        { gridtype = GRID_GME;       break; }
	case  GRIB2_GTYPE_NUMBER:     { gridtype = GRID_REFERENCE; break; }
64
	}
Uwe Schulzweida's avatar
Uwe Schulzweida committed
65
66
67
68
69
    }

  return (gridtype);
}

70
static
71
int gribapiGetIsRotated(grib_handle *gh)
72
73
{
  int isRotated = 0;
74
75
  int gribgridtype;
  long lpar;
76
77

    {
78
79
80
81
      GRIB_CHECK(grib_get_long(gh, "gridDefinitionTemplateNumber", &lpar), 0);
      gribgridtype = (int) lpar;

      if ( gribgridtype == GRIB2_GTYPE_LATLON_ROT ) isRotated = 1;
82
83
84
85
86
    }

  return (isRotated);
}

Uwe Schulzweida's avatar
Uwe Schulzweida committed
87
static
88
int gribapiGetZaxisType(long editionNumber, int grib_ltype)
Uwe Schulzweida's avatar
Uwe Schulzweida committed
89
{
Uwe Schulzweida's avatar
Uwe Schulzweida committed
90
91
92
  int zaxistype = ZAXIS_GENERIC;

  if ( editionNumber <= 1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
93
    {
94
      zaxistype = grib1ltypeToZaxisType(grib_ltype);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
95
96
97
    }
  else
    {
98
      zaxistype = grib2ltypeToZaxisType(grib_ltype);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
99
100
101
102
103
    }

  return (zaxistype);
}

104
105
106
107
static
int gribapiGetTimeUnits(grib_handle *gh)
{
  int timeunits = -1;
108
  long unitsOfTime;
109
110
111
  // size_t len = 8;
  //char stepunits[8];
  //static int lprint = TRUE;
112

113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
  GRIB_CHECK(grib_get_long(gh, "indicatorOfUnitOfTimeRange", &unitsOfTime), 0);  

  switch (unitsOfTime)
    {
    case 13:  timeunits = TUNIT_SECOND;  break;
    case  0:  timeunits = TUNIT_MINUTE;  break;
    case  1:  timeunits = TUNIT_HOUR;    break;
    case 10:  timeunits = TUNIT_3HOURS;  break;
    case 11:  timeunits = TUNIT_6HOURS;  break;
    case 12:  timeunits = TUNIT_12HOURS; break;
    case  2:  timeunits = TUNIT_DAY;     break;
    default:  timeunits = TUNIT_HOUR;    break;
    }

  /*
128
129
  GRIB_CHECK(grib_get_string(gh, "stepUnits", stepunits, &len), 0);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
130
131
132
133
134
135
136
137
138
139
140
  len--;

  if      ( memcmp(stepunits, "s",   len) == 0 ) timeunits = TUNIT_SECOND;
  else if ( memcmp(stepunits, "m",   len) == 0 ) timeunits = TUNIT_MINUTE;
  else if ( memcmp(stepunits, "h",   len) == 0 ) timeunits = TUNIT_HOUR;
  else if ( memcmp(stepunits, "3h",  len) == 0 ) timeunits = TUNIT_3HOURS;
  else if ( memcmp(stepunits, "6h",  len) == 0 ) timeunits = TUNIT_6HOURS;
  else if ( memcmp(stepunits, "12h", len) == 0 ) timeunits = TUNIT_12HOURS;
  else if ( memcmp(stepunits, "D",   len) == 0 ) timeunits = TUNIT_DAY;
  else if ( memcmp(stepunits, "M",   len) == 0 ) timeunits = TUNIT_MONTH;
  else if ( memcmp(stepunits, "Y",   len) == 0 ) timeunits = TUNIT_YEAR;
141
  else if ( lprint )
142
    {
143
      Message("Step units >%s< unsupported!", stepunits);
144
      lprint = FALSE;
145
    }
146
  */
147
148
149
150
151
152
153

  return (timeunits);
}

static
int gribapiTimeIsFC(grib_handle *gh)
{
154
  long editionNumber;
155
156
  int isFC = TRUE;

157
  GRIB_CHECK(grib_get_long(gh, "editionNumber", &editionNumber), 0);
158

159
  if ( editionNumber > 1 )
160
161
162
163
164
165
166
    {
      long sigofrtime;

      GRIB_CHECK(grib_get_long(gh, "significanceOfReferenceTime", &sigofrtime), 0);

      if ( sigofrtime == 3 ) isFC = FALSE;
    }
167
168
169
170
171
172
173

  return (isFC);
}

static
int gribapiGetTsteptype(grib_handle *gh)
{
174
  int tsteptype = TSTEP_INSTANT;
175
176
177
178
  static int lprint = TRUE;

  if ( gribapiTimeIsFC(gh) )
    {
179
      int status;
180
181
      size_t len = 256;
      char stepType[256];
182

183
184
      status = grib_get_string(gh, "stepType", stepType, &len);
      if ( status == 0 && len > 1 && len < 256 )
185
	{
186
	  if      ( strncmp("instant", stepType, len) == 0 ) tsteptype = TSTEP_INSTANT;
187
	  else if ( strncmp("avg",     stepType, len) == 0 ) tsteptype = TSTEP_AVG;
188
	  else if ( strncmp("accum",   stepType, len) == 0 ) tsteptype = TSTEP_ACCUM;
189
190
191
192
193
194
195
	  else if ( strncmp("max",     stepType, len) == 0 ) tsteptype = TSTEP_MAX;
	  else if ( strncmp("min",     stepType, len) == 0 ) tsteptype = TSTEP_MIN;
	  else if ( strncmp("diff",    stepType, len) == 0 ) tsteptype = TSTEP_DIFF;
	  else if ( strncmp("rms",     stepType, len) == 0 ) tsteptype = TSTEP_RMS;
	  else if ( strncmp("sd",      stepType, len) == 0 ) tsteptype = TSTEP_SD;
	  else if ( strncmp("cov",     stepType, len) == 0 ) tsteptype = TSTEP_COV;
	  else if ( strncmp("ratio",   stepType, len) == 0 ) tsteptype = TSTEP_RATIO;
196
	  else if ( lprint )
197
	    {
198
199
	      Message("stepType %s unsupported, set to instant!", stepType);
	      lprint = FALSE;
200
	    }
201
202

	  // printf("stepType: %s %ld %d\n", stepType, len, tsteptype);
203
204
205
206
207
208
	}
    }

  return (tsteptype);
}

209
static
210
int gribapiGetValidityDateTime(grib_handle *gh, int *vdate, int *vtime)
211
{
212
  int rdate, rtime;
213
214
215
  int timeUnits, startStep, endStep;
  int tstepRange = 0;
  int range;
216
  long lpar;
217
218
219
220
221
  long sigofrtime = 3;
  long editionNumber;

  GRIB_CHECK(grib_get_long(gh, "editionNumber", &editionNumber), 0);

222
  if ( editionNumber > 1 )
223
224
225
    {
      GRIB_CHECK(grib_get_long(gh, "significanceOfReferenceTime", &sigofrtime), 0);
    }
226
227
228
229
230
231
232
233
234
235

  if ( sigofrtime == 3 )
    {
      GRIB_CHECK(grib_get_long(gh, "dataDate", &lpar), 0);
      *vdate = (int) lpar;
      GRIB_CHECK(grib_get_long(gh, "dataTime", &lpar), 0);
      *vtime = (int) lpar*100;
    }
  else
    {
236
237
238
      GRIB_CHECK(grib_get_long(gh, "dataDate", &lpar), 0);
      rdate = (int) lpar;
      GRIB_CHECK(grib_get_long(gh, "dataTime", &lpar), 0);
239
      rtime = (int) lpar*100;
240
      GRIB_CHECK(grib_get_long(gh, "forecastTime", &lpar), 0);
241
242
243
      startStep = (int) lpar;
      GRIB_CHECK(grib_get_long(gh, "endStep", &lpar), 0);
      endStep = (int) lpar;
244
      timeUnits = gribapiGetTimeUnits(gh);
245
246
247
248
249
250
251
252
253

      range = endStep - startStep;

      if ( range > 0 )
	{
	  if ( startStep == 0 ) tstepRange = -1;
	  else                  tstepRange =  1;
	}

254
255
256
257
      {
	static int lprint = TRUE;
	extern int grib_calendar;
	int ryear, rmonth, rday, rhour, rminute, rsecond;
258
	int time_period = endStep;
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
	int julday, secofday, addsec;

	cdiDecodeDate(rdate, &ryear, &rmonth, &rday);
	cdiDecodeTime(rtime, &rhour, &rminute, &rsecond);

	encode_caldaysec(grib_calendar, ryear, rmonth, rday, rhour, rminute, rsecond, &julday, &secofday);

	addsec = 0;
	switch ( timeUnits )
	  {
	  case TUNIT_SECOND:  addsec =         time_period; break;
	  case TUNIT_MINUTE:  addsec =    60 * time_period; break;
	  case TUNIT_HOUR:    addsec =  3600 * time_period; break;
	  case TUNIT_3HOURS:  addsec = 10800 * time_period; break;
	  case TUNIT_6HOURS:  addsec = 21600 * time_period; break;
	  case TUNIT_12HOURS: addsec = 43200 * time_period; break;
	  case TUNIT_DAY:     addsec = 86400 * time_period; break;
	  default:
	    if ( lprint )
	      {
	        Warning("Time unit %d unsupported", timeUnits);
		lprint = FALSE;
	      }
	  }

	julday_add_seconds(addsec, &julday, &secofday);

	decode_caldaysec(grib_calendar, julday, secofday, &ryear, &rmonth, &rday, &rhour, &rminute, &rsecond);
	/*
	  printf("new %d/%d/%d %d:%d\n", ryear, rmonth, rday, rhour, rminute);
	*/
	*vdate = cdiEncodeDate(ryear, rmonth, rday);
	*vtime = cdiEncodeTime(rhour, rminute, rsecond);
      }
293
    }
294
295

  return (tstepRange);
296
297
}

298
static
299
void gribapiGetGrid(grib_handle *gh, grid_t *grid)
Uwe Schulzweida's avatar
Uwe Schulzweida committed
300
{
301
  long editionNumber;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
302
  int gridtype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
303
  size_t datasize;
304
305
  long numberOfPoints;
  long lpar;
306
307
308

  GRIB_CHECK(grib_get_long(gh, "editionNumber", &editionNumber), 0);

309
  gridtype = gribapiGetGridType(gh);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
310
311
312
313
314
315
316
317
  /*
  if ( streamptr->unreduced && gridtype == GRID_GAUSSIAN_REDUCED )
    {
      gridtype = GRID_GAUSSIAN;
      ISEC2_NumLon = 2*ISEC2_NumLat;
      ISEC4_NumValues = ISEC2_NumLon*ISEC2_NumLat;
    }
  */
318
  memset(grid, 0, sizeof(grid_t));
Uwe Schulzweida's avatar
Uwe Schulzweida committed
319

Uwe Schulzweida's avatar
Uwe Schulzweida committed
320
321
322
  GRIB_CHECK(grib_get_size(gh, "values", &datasize), 0);
  GRIB_CHECK(grib_get_long(gh, "numberOfPoints", &numberOfPoints), 0);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
323
324
325
326
327
328
329
330
331
332
333
334
  switch (gridtype)
    {
    case GRID_LONLAT:
    case GRID_GAUSSIAN:
      {
	int nlon, nlat;

	GRIB_CHECK(grib_get_long(gh, "Ni", &lpar), 0);
	nlon = lpar;
	GRIB_CHECK(grib_get_long(gh, "Nj", &lpar), 0);
	nlat = lpar;

335
336
337
338
339
340
	if ( gridtype == GRID_GAUSSIAN )
          {
            GRIB_CHECK(grib_get_long(gh, "numberOfParallelsBetweenAPoleAndTheEquator", &lpar), 0);
            grid->np = lpar;
          }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
341
	if ( numberOfPoints != nlon*nlat )
342
	  Error("numberOfPoints (%d) and gridSize (%d) differ!",
Uwe Schulzweida's avatar
Uwe Schulzweida committed
343
		(int)numberOfPoints, nlon*nlat);
344

345
346
347
348
349
350
351
352
353
354
355
	grid->size  = numberOfPoints;
	grid->xsize = nlon;
	grid->ysize = nlat;
	grid->xinc  = 0;
	grid->yinc  = 0;
	grid->xdef  = 0;
	GRIB_CHECK(grib_get_double(gh, "longitudeOfFirstGridPointInDegrees", &grid->xfirst), 0);
	GRIB_CHECK(grib_get_double(gh, "longitudeOfLastGridPointInDegrees",  &grid->xlast), 0);
	GRIB_CHECK(grib_get_double(gh, "latitudeOfFirstGridPointInDegrees",  &grid->yfirst), 0);
	GRIB_CHECK(grib_get_double(gh, "latitudeOfLastGridPointInDegrees",   &grid->ylast), 0);
	GRIB_CHECK(grib_get_double(gh, "iDirectionIncrementInDegrees", &grid->xinc), 0);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
356
	if ( gridtype == GRID_LONLAT )
357
	  GRIB_CHECK(grib_get_double(gh, "jDirectionIncrementInDegrees", &grid->yinc), 0);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
358

359
	if ( IS_EQUAL(grid->xinc, GRIB_MISSING_DOUBLE) ) grid->xinc = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
360

361
	/* if ( IS_NOT_EQUAL(grid->xfirst, 0) || IS_NOT_EQUAL(grid->xlast, 0) ) */
Uwe Schulzweida's avatar
Uwe Schulzweida committed
362
	  {
363
	    if ( grid->xsize > 1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
364
	      {
365
		if ( (grid->xfirst >= grid->xlast) && (grid->xfirst >= 180) ) grid->xfirst -= 360;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
366

367
368
369
		if ( editionNumber <= 1 )
		  {
		    /* correct xinc if necessary */
370
		    if ( IS_EQUAL(grid->xfirst, 0) && grid->xlast > 354 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
371
		      {
372
			double xinc = 360. / grid->xsize;
373

374
			if ( fabs(grid->xinc-xinc) > 0.0 )
375
			  {
376
377
			    grid->xinc = xinc;
			    if ( CDI_Debug ) Message("set xinc to %g", grid->xinc);
378
			  }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
379
380
381
		      }
		  }
	      }
382
	    grid->xdef = 2;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
383
	  }
384
	grid->ydef = 0;
385
        /* if ( IS_NOT_EQUAL(grid->yfirst, 0) || IS_NOT_EQUAL(grid->ylast, 0) ) */
Uwe Schulzweida's avatar
Uwe Schulzweida committed
386
	  {
387
	    if ( grid->ysize > 1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
388
	      {
389
390
391
		if ( editionNumber <= 1 )
		  {
		  }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
392
	      }
393
	    grid->ydef = 2;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
394
395
396
397
398
	  }
	break;
      }
    case GRID_GAUSSIAN_REDUCED:
      {
399
400
401
402
	int nlat, i;
	size_t dummy;
	long *pl;

403
404
405
        GRIB_CHECK(grib_get_long(gh, "numberOfParallelsBetweenAPoleAndTheEquator", &lpar), 0);
        grid->np = lpar;

406
407
408
	GRIB_CHECK(grib_get_long(gh, "Nj", &lpar), 0);
	nlat = lpar;

409
	grid->size   = numberOfPoints;
410

411
        grid->rowlon = (int *) malloc(nlat*sizeof(int));
412
413
414
        pl          = (long *) malloc(nlat*sizeof(long));
	dummy       = nlat;
	GRIB_CHECK(grib_get_long_array(gh, "pl", pl, &dummy), 0);
415
	for ( i = 0; i < nlat; ++i ) grid->rowlon[i] = pl[i];
416
417
	free(pl);

418
419
420
421
422
423
424
425
426
	grid->ysize  = nlat;
	grid->xinc   = 0;
	grid->yinc   = 0;
	grid->xdef   = 0;
	GRIB_CHECK(grib_get_double(gh, "longitudeOfFirstGridPointInDegrees", &grid->xfirst), 0);
	GRIB_CHECK(grib_get_double(gh, "longitudeOfLastGridPointInDegrees",  &grid->xlast), 0);
	GRIB_CHECK(grib_get_double(gh, "latitudeOfFirstGridPointInDegrees",  &grid->yfirst), 0);
	GRIB_CHECK(grib_get_double(gh, "latitudeOfLastGridPointInDegrees",   &grid->ylast), 0);
	GRIB_CHECK(grib_get_double(gh, "iDirectionIncrementInDegrees", &grid->xinc), 0);
427

428
	if ( IS_EQUAL(grid->xinc, GRIB_MISSING_DOUBLE) ) grid->xinc = 0;
429

430
	/* if ( IS_NOT_EQUAL(grid->xfirst, 0) || IS_NOT_EQUAL(grid->xlast, 0) ) */
Uwe Schulzweida's avatar
Uwe Schulzweida committed
431
	  {
432
	    if ( grid->xsize > 1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
433
	      {
434
		if ( (grid->xfirst > grid->xlast) && (grid->xfirst >= 180) ) grid->xfirst -= 360;
435
436
437
438

		if ( editionNumber <= 1 )
		  {
		    /* correct xinc if necessary */
439
		    if ( IS_EQUAL(grid->xfirst, 0) && grid->xlast > 354 )
440
		      {
441
			double xinc = 360. / grid->xsize;
442

443
			if ( fabs(grid->xinc-xinc) > 0.0 )
444
			  {
445
446
			    grid->xinc = xinc;
			    if ( CDI_Debug ) Message("set xinc to %g", grid->xinc);
447
448
449
			  }
		      }
		  }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
450
	      }
451
	    grid->xdef = 2;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
452
	  }
453
454
	grid->ydef  = 0;
        /* if ( IS_NOT_EQUAL(grid->yfirst, 0) || IS_NOT_EQUAL(grid->ylast, 0) ) */
Uwe Schulzweida's avatar
Uwe Schulzweida committed
455
	  {
456
	    if ( grid->ysize > 1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
457
	      {
458
459
460
		if ( editionNumber <= 1 )
		  {
		  }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
461
	      }
462
	    grid->ydef = 2;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
463
464
465
	  }
	break;
      }
466
      /*
Uwe Schulzweida's avatar
Uwe Schulzweida committed
467
468
469
    case GRID_LCC:
      {
	if ( ISEC4_NumValues != ISEC2_NumLon*ISEC2_NumLat )
470
	  Error("numberOfPoints (%d) and gridSize (%d) differ!",
Uwe Schulzweida's avatar
Uwe Schulzweida committed
471
472
		ISEC4_NumValues, ISEC2_NumLon*ISEC2_NumLat);

473
474
475
	grid->size  = ISEC4_NumValues;
	grid->xsize = ISEC2_NumLon;
	grid->ysize = ISEC2_NumLat;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
476

477
478
479
480
481
482
483
484
485
	grid->lcc_xinc      = ISEC2_Lambert_dx;
	grid->lcc_yinc      = ISEC2_Lambert_dy;
	grid->lcc_originLon = ISEC2_FirstLon * 0.001;
	grid->lcc_originLat = ISEC2_FirstLat * 0.001;
	grid->lcc_lonParY   = ISEC2_Lambert_Lov * 0.001;
	grid->lcc_lat1      = ISEC2_Lambert_LatS1 * 0.001;
	grid->lcc_lat2      = ISEC2_Lambert_LatS2 * 0.001;
	grid->lcc_projflag  = ISEC2_Lambert_ProjFlag;
	grid->lcc_scanflag  = ISEC2_ScanFlag;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
486

487
	grid->xdef   = 0;
488
	grid->ydef   = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
489
490
491

	break;
      }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
492
      */
Uwe Schulzweida's avatar
Uwe Schulzweida committed
493
494
    case GRID_SPECTRAL:
      {
495
496
	size_t len = 256;
	char typeOfPacking[256];
497
	GRIB_CHECK(grib_get_string(gh, "packingType", typeOfPacking, &len), 0);
498
499
	grid->lcomplex = 0;
	if ( strncmp(typeOfPacking, "spectral_complex", len) == 0 ) grid->lcomplex = 1;
500

501
	grid->size  = datasize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
502
	GRIB_CHECK(grib_get_long(gh, "J", &lpar), 0);
503
	grid->trunc = lpar;
504

Uwe Schulzweida's avatar
Uwe Schulzweida committed
505
506
507
508
	break;
      }
    case GRID_GME:
      {
509
510
511
512
513
	grid->size  = numberOfPoints;
	if ( grib_get_long(gh, "nd", &lpar) == 0 ) grid->nd  = lpar;
	if ( grib_get_long(gh, "Ni", &lpar) == 0 ) grid->ni  = lpar;
	if ( grib_get_long(gh, "n2", &lpar) == 0 ) grid->ni2 = lpar;
	if ( grib_get_long(gh, "n3", &lpar) == 0 ) grid->ni3 = lpar;
514
515
516

	break;
      }
517
    case GRID_REFERENCE:
518
      {
519
        char uuid[17];
520
521
522
523
	char reference_link[8192];
	size_t len = sizeof(reference_link);
	reference_link[0] = 0;

524
	grid->size  = numberOfPoints;
525
526
	if ( grib_get_long(gh, "numberOfGridUsed", &lpar) == 0 )
	  {
527
528
	    grid->number   = lpar;
	    if ( grib_get_long(gh, "numberOfGridInReference", &lpar) == 0 ) grid->position = lpar;
529
530
	    if ( grib_get_string(gh, "gridDescriptionFile", reference_link, &len) == 0 )
	      {
531
		if ( strncmp(reference_link, "file://", 7) == 0 )
532
		  grid->reference = strdupx(reference_link);
533
	      }
534
535
536
537
538
            len = (size_t) 16;
            if ( grib_get_string(gh, "uuidOfHGrid", uuid, &len) == 0)
              {
                strncpy(grid->uuid, uuid, 16);
              }
539
	  }
540

Uwe Schulzweida's avatar
Uwe Schulzweida committed
541
542
543
544
	break;
      }
    case GRID_GENERIC:
      {
545
546
547
548
549
	int nlon = 0, nlat = 0;

	if ( grib_get_long(gh, "Ni", &lpar) == 0 ) nlon = lpar;
	if ( grib_get_long(gh, "Nj", &lpar) == 0 ) nlat = lpar;

550
	grid->size  = numberOfPoints;
551

552
	if ( nlon > 0 && nlat > 0 && nlon*nlat == grid->size )
553
	  {
554
555
	    grid->xsize = nlon;
	    grid->ysize = nlat;
556
557
558
	  }
	else
	  {
559
560
	    grid->xsize = 0;
	    grid->ysize = 0;
561
562
	  }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
563
564
565
566
	break;
      }
    default:
      {
567
	Error("Unsupported grid type: %s", gridNamePtr(gridtype));
Uwe Schulzweida's avatar
Uwe Schulzweida committed
568
569
570
571
	break;
      }
    }

572
  grid->isRotated = FALSE;
573
  if ( gribapiGetIsRotated(gh) )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
574
    {
575
576
577
578
      grid->isRotated = TRUE;
      GRIB_CHECK(grib_get_double(gh, "latitudeOfSouthernPoleInDegrees",  &grid->ypole), 0);
      GRIB_CHECK(grib_get_double(gh, "longitudeOfSouthernPoleInDegrees", &grid->xpole), 0);
      GRIB_CHECK(grib_get_double(gh, "angleOfRotation", &grid->angle), 0);
579
      /* change from south to north pole */
580
581
582
583
584
585
586
587
588
589
      grid->ypole = -grid->ypole;
      grid->xpole =  grid->xpole - 180;
    }

  grid->xvals = NULL;
  grid->yvals = NULL;
  grid->type  = gridtype;
}

static
590
void grib1GetLevel(grib_handle *gh, int *leveltype, int *lbounds, int *level1, int *level2)
591
{
592
593
594
  int status;
  long lpar;
  double dlevel;
595

596
597
598
599
  *leveltype = 0;
  *lbounds = 0;
  *level1  = 0;
  *level2  = 0;
600

601
602
  status = grib_get_long(gh, "indicatorOfTypeOfLevel", &lpar);
  if ( status == 0 )
603
    {
604
      *leveltype = (int) lpar;
605

606
      switch (*leveltype)
607
608
609
610
	{
	case GRIB1_LTYPE_SIGMA_LAYER:
	case GRIB1_LTYPE_HYBRID_LAYER:
	case GRIB1_LTYPE_LANDDEPTH_LAYER:
611
	  { *lbounds = 1; break; }
612
	}
613

614
615
616
617
618
619
      if ( *lbounds == 0 )
	{
	  GRIB_CHECK(grib_get_double(gh, "level", &dlevel), 0);
	  if ( *leveltype == 100 ) dlevel *= 100;
	  if ( dlevel < -2.e9 || dlevel > 2.e9 ) dlevel = 0;
	  if ( *leveltype == 99 ) *leveltype = 100;
620

621
622
623
624
625
626
627
628
629
630
	  *level1 = (int) dlevel;
	  *level2 = 0;
	}
      else
	{
	  GRIB_CHECK(grib_get_long(gh, "topLevel", &lpar), 0);
	  *level1 = lpar;
	  GRIB_CHECK(grib_get_long(gh, "bottomLevel", &lpar), 0);
	  *level2 = lpar;
	}
631
    }
632
633
634
}

static
635
void grib2GetLevel(grib_handle *gh, int *leveltype, int *lbounds, int *level1, int *level2)
636
{
637
638
639
640
  int status;
  int leveltype2 = -1;
  long lpar;
  long factor;
641
642
  double dlevel;

643
644
645
646
647
648
649
  *leveltype = 0;
  *lbounds = 0;
  *level1  = 0;
  *level2  = 0;

  status = grib_get_long(gh, "typeOfFirstFixedSurface", &lpar);
  if ( status == 0 )
650
    {
651
      *leveltype = (int) lpar;
652

653
654
      status = grib_get_long(gh, "typeOfSecondFixedSurface", &lpar);
      if ( status == 0 ) leveltype2 = lpar;
655

656
      if ( *leveltype == leveltype2 && *leveltype != 255 ) *lbounds = 1;
657

658
      if ( *lbounds == 0 )
659
	{
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
	  if ( *leveltype == GRIB2_LTYPE_LANDDEPTH )
	    {
	      GRIB_CHECK(grib_get_long(gh, "scaleFactorOfFirstFixedSurface", &factor), 0);
	      GRIB_CHECK(grib_get_double(gh, "scaledValueOfFirstFixedSurface", &dlevel), 0);
	      if      ( factor == 0 ) dlevel *= 100;   //  m to cm
	      else if ( factor == 1 ) dlevel *=  10;   // dm to cm
	      else if ( factor == 3 ) dlevel *=   0.1; // mm to cm
	    }
	  else
	    {
	      GRIB_CHECK(grib_get_double(gh, "level", &dlevel), 0);
	      if ( *leveltype == GRIB2_LTYPE_ISOBARIC ) dlevel *= 100;
	      if ( dlevel < -2.e9 || dlevel > 2.e9 ) dlevel = 0;
	      if ( *leveltype == 99 ) *leveltype = 100;
	    }

676
	  *level1 = (int) dlevel;
677
	  *level2 = 0;
678
679
680
	}
      else
	{
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
	  if ( *leveltype == GRIB2_LTYPE_LANDDEPTH )
	    {
	      GRIB_CHECK(grib_get_long(gh, "scaleFactorOfFirstFixedSurface", &factor), 0);
	      GRIB_CHECK(grib_get_double(gh, "scaledValueOfFirstFixedSurface", &dlevel), 0);
	      if      ( factor == 0 ) dlevel *= 100;   //  m to cm
	      else if ( factor == 1 ) dlevel *=  10;   // dm to cm
	      else if ( factor == 3 ) dlevel *=   0.1; // mm to cm
	      *level1 = (int) dlevel;
	      GRIB_CHECK(grib_get_long(gh, "scaleFactorOfSecondFixedSurface", &factor), 0);
	      GRIB_CHECK(grib_get_double(gh, "scaledValueOfSecondFixedSurface", &dlevel), 0);
	      if      ( factor == 0 ) dlevel *= 100;   //  m to cm
	      else if ( factor == 1 ) dlevel *=  10;   // dm to cm
	      else if ( factor == 3 ) dlevel *=   0.1; // mm to cm
	      *level2 = (int) dlevel;
	    }
	  else
	    {
	      GRIB_CHECK(grib_get_long(gh, "topLevel", &lpar), 0);
	      *level1 = lpar;
	      GRIB_CHECK(grib_get_long(gh, "bottomLevel", &lpar), 0);
	      *level2 = lpar;
	    }
703
704
	}
    }
705
706
707
708
}

static
void gribapiAddRecord(int streamID, int param, grib_handle *gh,
709
		      long recsize, off_t position, int datatype, int comptype)
710
711
712
713
714
715
{
  long editionNumber;
  int zaxistype;
  int gridID = CDI_UNDEFID, varID;
  int levelID = 0;
  int tsID, recID;
716
  int level1 = 0, level2 = 0;
717
718
719
720
721
722
723
724
725
726
727
  int numavg;
  int tsteptype;
  int lbounds = 0;
  record_t *record;
  grid_t grid;
  int vlistID;
  stream_t *streamptr;
  int leveltype;
  long lpar;
  int status;
  char name[256], longname[256], units[256];
728
  size_t vlen;
729
  long ens_index = 0, ens_count = 0, ens_forecast_type = 0;
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744

  streamptr = stream_to_pointer(streamID);

  vlistID = streamInqVlist(streamID);
  tsID    = streamptr->curTsID;
  recID   = recordNewEntry(streamID, tsID);
  record  = &streamptr->tsteps[tsID].records[recID];

  tsteptype = gribapiGetTsteptype(gh);
  // numavg  = ISEC1_AvgNum;
  numavg  = 0;

  GRIB_CHECK(grib_get_long(gh, "editionNumber", &editionNumber), 0);

  if ( editionNumber <= 1 )
745
    grib1GetLevel(gh, &leveltype, &lbounds, &level1, &level2);
746
  else
747
    grib2GetLevel(gh, &leveltype, &lbounds, &level1, &level2);
748

749
750
751
752
753
754
755
756
757
758
  // fprintf(stderr, "param %d %d %d %d\n", param, level1, level2, leveltype);

  (*record).size     = recsize;
  (*record).position = position;
  (*record).param    = param;
  (*record).ilevel   = level1;
  (*record).ilevel2  = level2;
  (*record).ltype    = leveltype;

  gribapiGetGrid(gh, &grid);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
759
760
761

  gridID = varDefGrid(vlistID, grid, 0);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
762
  zaxistype = gribapiGetZaxisType(editionNumber, leveltype);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
763

764
  switch (zaxistype)
Uwe Schulzweida's avatar
Uwe Schulzweida committed
765
    {
766
767
768
769
770
771
    case ZAXIS_HYBRID:
    case ZAXIS_HYBRID_HALF:
      {
        int vctsize;
        size_t dummy;
        double *vctptr;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
772

773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
        GRIB_CHECK(grib_get_long(gh, "NV", &lpar), 0);
        vctsize = lpar;
        if ( vctsize > 0 )
          {
            vctptr = (double *) malloc(vctsize*sizeof(double));
            dummy = vctsize;
            GRIB_CHECK(grib_get_double_array(gh, "pv", vctptr, &dummy), 0);
            varDefVCT(vctsize, vctptr);
            free(vctptr);
          }
        break;
      }
    case ZAXIS_REFERENCE:
      {
        size_t len;
        char uuid[17];
        long nlev, nvgrid;

        GRIB_CHECK(grib_get_long(gh, "NV", &lpar), 0);
792
        if ( lpar != 3 )
793
794
795
796
797
798
799
800
801
802
803
804
          {
            fprintf(stderr, "Warning ...\n");
          }
        GRIB_CHECK(grib_get_long(gh, "nlev", &nlev), 0);
        GRIB_CHECK(grib_get_long(gh, "numberOfVGridUsed", &nvgrid), 0);

        len = (size_t) 16;
        uuid[16] = 0;
        GRIB_CHECK(grib_get_string(gh, "uuidOfVGrid", uuid, &len), 0);
        varDefZAxisReference((int) nlev, (int) nvgrid, uuid);
        break;
      }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
805
    }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
806

807
  // if ( datatype > 32 ) datatype = DATATYPE_PACK32;
808
  if ( datatype <  0 ) datatype = DATATYPE_PACK;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
809

810
811
812
813
  name[0] = 0;
  longname[0] = 0;
  units[0] = 0;

Uwe Schulzweida's avatar
Uwe Schulzweida committed
814
815
  vlen = 256;
  GRIB_CHECK(grib_get_string(gh, "shortName", name, &vlen), 0);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
816
817
818
819
820
821
822
823
824
825
826
827
  if      ( vlen == 8 && memcmp(name, "unknown", vlen) == 0 ) name[0] = 0;
  else if ( vlen == 2 && memcmp(name, "~", vlen)       == 0 ) name[0] = 0;

  if ( name[0] != 0 )
    {
      vlen = 256;
      GRIB_CHECK(grib_get_string(gh, "name", longname, &vlen), 0);
      if ( vlen == 8 && memcmp(longname, "unknown", vlen) == 0 ) longname[0] = 0;
      vlen = 256;
      GRIB_CHECK(grib_get_string(gh, "units", units, &vlen), 0);
      if ( vlen == 8 && memcmp(units, "unknown", vlen) == 0 ) units[0] = 0;
    }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
828
  // fprintf(stderr, "param %d name %s %s %s\n", param, name, longname, units); 
Uwe Schulzweida's avatar
Uwe Schulzweida committed
829

Uwe Schulzweida's avatar
Uwe Schulzweida committed
830
  varAddRecord(recID, param, gridID, zaxistype, lbounds, level1, level2,
831
	       datatype, &varID, &levelID, tsteptype, numavg, leveltype,
Uwe Schulzweida's avatar
Uwe Schulzweida committed
832
	       name, longname, units);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
833
834
835
836

  (*record).varID   = varID;
  (*record).levelID = levelID;

837
  varDefCompType(varID, comptype);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
838

839
840
841
842
  /*
    Get the ensemble Info from the grib-2 Tables and update the intermediate datastructure.
    Further update to the "vlist" is handled in the same way as for GRIB-1 by "cdiGenVars"
  */
843
844
845
846
847
848
849
850
851
  {
    int status;
    status = grib_get_long(gh, "typeOfEnsembleForecast", &ens_forecast_type );
    if ( status == 0 )
      {
        GRIB_CHECK(grib_get_long(gh, "numberOfForecastsInEnsemble", &ens_count ), 0);
        GRIB_CHECK(grib_get_long(gh, "perturbationNumber", &ens_index ), 0);
      }
  }
852
853
854
855
  if ( ens_index > 0 )
    varDefEnsembleInfo(varID, (int)ens_index, (int)ens_count, (int)ens_forecast_type);


Uwe Schulzweida's avatar
Uwe Schulzweida committed
856
857
  if ( varInqInst(varID) == CDI_UNDEFID )
    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
858
859
860
861
862
      long center, subcenter;
      int instID;
      GRIB_CHECK(grib_get_long(gh, "centre", &center), 0);
      GRIB_CHECK(grib_get_long(gh, "subCentre", &subcenter), 0);
      instID    = institutInq((int)center, (int)subcenter, NULL, NULL);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
863
      if ( instID == CDI_UNDEFID )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
864
	instID = institutDef((int)center, (int)subcenter, NULL, NULL);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
865
866
867
868
869
870
      varDefInst(varID, instID);
    }

  if ( varInqModel(varID) == CDI_UNDEFID )
    {
      int modelID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
871
      long processID;
872
873
874
875
876
877
878
879
      status = grib_get_long(gh, "generatingProcessIdentifier", &processID);
      if ( status == 0 )
	{
	  modelID = modelInq(varInqInst(varID), processID, NULL);
	  if ( modelID == CDI_UNDEFID )
	    modelID = modelDef(varInqInst(varID), processID, NULL);
	  varDefModel(varID, modelID);
	}
Uwe Schulzweida's avatar
Uwe Schulzweida committed
880
881
882
883
    }

  if ( varInqTable(varID) == CDI_UNDEFID )
    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
884
      int pdis, pcat, pnum;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
885

Uwe Schulzweida's avatar
Uwe Schulzweida committed
886
      cdiDecodeParam(param, &pnum, &pcat, &pdis);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
887

Uwe Schulzweida's avatar
Uwe Schulzweida committed
888
889
890
891
      if ( pdis == 255 )
	{
	  int tableID;
	  int tabnum = pcat;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
892

Uwe Schulzweida's avatar
Uwe Schulzweida committed
893
	  tableID = tableInq(varInqModel(varID), tabnum, NULL);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
894

Uwe Schulzweida's avatar
Uwe Schulzweida committed
895
896
897
	  if ( tableID == CDI_UNDEFID )
	    tableID = tableDef(varInqModel(varID), tabnum, NULL);
	  varDefTable(varID, tableID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
898
899
900
901
902
903
904
	}
    }

  streamptr->tsteps[tsID].nallrecs++;
  streamptr->nrecs++;

  if ( CDI_Debug )
905
    Message("varID = %d  param = %d  zaxistype = %d  gridID = %d  levelID = %d",
Uwe Schulzweida's avatar
Uwe Schulzweida committed
906
	    varID, param, zaxistype, gridID, levelID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
907
908
909
}
#endif

910
int gribapiScanTimestep1(int streamID)
Uwe Schulzweida's avatar
Uwe Schulzweida committed
911
912
913
914
915
{
#if  defined  (HAVE_LIBGRIB_API)
  off_t recpos = 0;
  unsigned char *gribbuffer = NULL;
  long buffersize = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
916
  int rstatus;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
917
918
  int status;
  int fileID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
919
  int rtabnum = 0;
920
921
  int rcode = 0, level1 = 0, level2 = 0;
  int vdate = 0, vtime = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
922
  int param = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
923
924
925
926
927
  DateTime datetime, datetime0;
  int tsID;
  int varID;
  size_t readsize;
  int nrecords, nrecs, recID;
928
  int datatype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
929
930
  long recsize = 0;
  int warn_time = TRUE;
931
  // int warn_numavg = TRUE;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
932
933
  int taxisID = -1;
  int rdate = 0, rtime = 0, tunit = 0, fcast = 0;
934
  taxis_t *taxis;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
935
  int vlistID;
936
  int comptype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
937
938
939
940
941
  long unzipsize;
  compvar2_t compVar, compVar0;
  stream_t *streamptr;
  grib_handle *gh = NULL;
  int leveltype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
942
  int pdis = 0, pcat = 0, pnum = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
943
944
  long editionNumber;
  long lpar;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
945
  int bitsPerValue;
946
  int lieee = FALSE;
947
  int lbounds;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
948
949
950

  streamptr = stream_to_pointer(streamID);

951
  stream_check_ptr(__func__, streamptr);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
952
953
954
955
956
957
958

  streamptr->curTsID = 0;

  tsID  = tstepsNewEntry(streamID);
  taxis = &streamptr->tsteps[tsID].taxis;

  if ( tsID != 0 )
959
    Error("Internal problem! tstepsNewEntry returns %d", tsID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
960
961
962
963
964
965

  fileID = streamInqFileID(streamID);

  nrecs = 0;
  while ( TRUE )
    {
966
967
      level1 = 0;
      level2 = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
      recsize = gribGetSize(fileID);
      recpos  = fileGetPos(fileID);

      if ( recsize == 0 )
	{
	  streamptr->ntsteps = 1;
	  break;
	}
      if ( recsize > buffersize )
	{
	  buffersize = recsize;
	  gribbuffer = (unsigned char *) realloc(gribbuffer, buffersize);
	}

      readsize = recsize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
983
984
      rstatus = gribRead(fileID, gribbuffer, &readsize);
      if ( rstatus ) break;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
985

986
987
      lieee = FALSE;

988
      comptype = COMPRESS_NONE;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
989
990
      if ( gribGetZip(recsize, gribbuffer, &unzipsize) > 0 )
	{
991
	  comptype = COMPRESS_SZIP;
992
	  unzipsize += 100;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
993
994
995
996
997
998
999
1000
	  if ( (long) buffersize < unzipsize )
	    {
	      buffersize = unzipsize;
	      gribbuffer = (unsigned char *) realloc(gribbuffer, buffersize);
	    }
	}

      gh = grib_handle_new_from_message(NULL, (void *) gribbuffer, recsize);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1001
      GRIB_CHECK(grib_set_double(gh, "missingValue", GRIBAPI_MISSVAL), 0);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1002
1003
1004
1005
1006

      GRIB_CHECK(grib_get_long(gh, "editionNumber", &editionNumber), 0);

      if ( editionNumber <= 1 )
	{
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1007
1008
	  GRIB_CHECK(grib_get_long(gh, "table2Version", &lpar), 0);
	  rtabnum = (int) lpar;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1009
1010
	  GRIB_CHECK(grib_get_long(gh, "indicatorOfParameter", &lpar), 0);
	  rcode = (int) lpar;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1011

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1012
	  param = cdiEncodeParam(rcode, rtabnum, 255);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1013

1014
	  grib1GetLevel(gh, &leveltype, &lbounds, &level1, &level2);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1015
1016
1017
	}
      else
	{
1018
1019
	  size_t len = 256;
	  char typeOfPacking[256];
1020

1021
	  status = grib_get_string(gh, "packingType", typeOfPacking, &len);
1022
1023
	  if ( status == 0 )
	    {
1024
	      // fprintf(stderr, "packingType %d %s\n", len, typeOfPacking);
1025
1026
	      if      ( strncmp(typeOfPacking, "grid_jpeg", len) == 0 ) comptype = COMPRESS_JPEG;
	      else if ( strncmp(typeOfPacking, "grid_ieee", len) == 0 ) lieee = TRUE;
1027
	    }
1028

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1029
	  GRIB_CHECK(grib_get_long(gh, "discipline", &lpar), 0);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1030
1031
	  pdis = (int) lpar;

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1032
	  GRIB_CHECK(grib_get_long(gh, "parameterCategory", &lpar), 0);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1033
	  pcat = (int) lpar;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1034

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1035
	  GRIB_CHECK(grib_get_long(gh, "parameterNumber", &lpar), 0);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1036
1037
	  pnum = (int) lpar;

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1038
	  param = cdiEncodeParam(pnum, pcat, pdis);
1039

1040
	  grib2GetLevel(gh, &leveltype, &lbounds, &level1, &level2);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1041
1042
	}

1043
1044
      gribapiGetValidityDateTime(gh, &vdate, &vtime);
      /*
Uwe Schulzweida's avatar