stream_gribapi.c 81.9 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
  int level1;
  int level2;
  int ltype;
32
} compvar2_t;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
33
34
35
36


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

43
    {
44
45
46
47
      int status;
      status = grib_get_long(gh, "gridDefinitionTemplateNumber", &lpar);

      if ( status ==  0 ) gribgridtype = (int) lpar;
48
49
50

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

  return (gridtype);
}

72
static
73
int gribapiGetIsRotated(grib_handle *gh)
74
75
{
  int isRotated = 0;
76
  int gribgridtype = -1;
77
  long lpar;
78
  int status;
79

80
  status = grib_get_long(gh, "gridDefinitionTemplateNumber", &lpar);
81

82
83
84
  if ( status ==  0 ) gribgridtype = (int) lpar;

  if ( gribgridtype == GRIB2_GTYPE_LATLON_ROT ) isRotated = 1;
85
86
87
88

  return (isRotated);
}

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

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

  return (zaxistype);
}

106
static
107
int getTimeunits(long unitsOfTime)
108
109
{
  int timeunits = -1;
110
111
112
113
114
115
116
117
118
119
120
121
122

  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;
    }

123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
  return (timeunits);
}

static
double timeunit_factor(int tu1, int tu2)
{
  double factor = 1;

  if ( tu2 == TUNIT_HOUR )
    {
      switch (tu1)
        {
        case TUNIT_SECOND:  factor = 3600;   break;
        case TUNIT_MINUTE:  factor = 60;     break;
        case TUNIT_HOUR:    factor = 1;      break;
        case TUNIT_3HOURS:  factor = 1./3;   break;
        case TUNIT_6HOURS:  factor = 1./6;   break;
        case TUNIT_12HOURS: factor = 1./12;  break;
        case TUNIT_DAY:     factor = 1./24;  break;
        }
    }

  return (factor);
}

static
int gribapiGetEndStep(grib_handle *gh, int startStep, int timeunits)
{
  int endStep = startStep;
  int timeunits2;
153
  int status;
154
155
156
  long unitsOfTime;
  long lpar;

157
  status = grib_get_long(gh, "stepUnits", &unitsOfTime);
158
159
160

  timeunits2 = getTimeunits(unitsOfTime);

161
  status = grib_get_long(gh, "endStep", &lpar);
162

163
164
  if ( status == 0 )
    endStep = (int) ((lpar * timeunit_factor(timeunits, timeunits2)) + 0.5);
165
166
167
168
169
170
171
172

  return (endStep);
}

static
int gribapiGetTimeUnits(grib_handle *gh)
{
  int timeunits = -1;
173
174
  long unitsOfTime = -1;
  int status;
175
176
177
178
  // size_t len = 8;
  //char stepunits[8];
  //static int lprint = TRUE;

179
  status = grib_get_long(gh, "indicatorOfUnitOfTimeRange", &unitsOfTime);
180
181
182

  timeunits = getTimeunits(unitsOfTime);

183
  /*
184
185
  GRIB_CHECK(grib_get_string(gh, "stepUnits", stepunits, &len), 0);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
186
187
188
189
190
191
192
193
194
195
196
  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;
197
  else if ( lprint )
198
    {
199
      Message("Step units >%s< unsupported!", stepunits);
200
      lprint = FALSE;
201
    }
202
  */
203
204
205
206
207
208
209

  return (timeunits);
}

static
int gribapiTimeIsFC(grib_handle *gh)
{
210
  long editionNumber;
211
212
  int isFC = TRUE;

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

215
  if ( editionNumber > 1 )
216
217
218
219
220
221
222
    {
      long sigofrtime;

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

      if ( sigofrtime == 3 ) isFC = FALSE;
    }
223
224
225
226
227
228
229

  return (isFC);
}

static
int gribapiGetTsteptype(grib_handle *gh)
{
230
  int tsteptype = TSTEP_INSTANT;
231
232
233
234
  static int lprint = TRUE;

  if ( gribapiTimeIsFC(gh) )
    {
235
      int status;
236
237
      size_t len = 256;
      char stepType[256];
238

239
240
      status = grib_get_string(gh, "stepType", stepType, &len);
      if ( status == 0 && len > 1 && len < 256 )
241
	{
242
	  if      ( strncmp("instant", stepType, len) == 0 ) tsteptype = TSTEP_INSTANT;
243
	  else if ( strncmp("avg",     stepType, len) == 0 ) tsteptype = TSTEP_AVG;
244
	  else if ( strncmp("accum",   stepType, len) == 0 ) tsteptype = TSTEP_ACCUM;
245
246
247
248
249
250
251
	  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;
252
	  else if ( lprint )
253
	    {
254
255
	      Message("stepType %s unsupported, set to instant!", stepType);
	      lprint = FALSE;
256
	    }
257
258

	  // printf("stepType: %s %ld %d\n", stepType, len, tsteptype);
259
260
261
262
263
264
	}
    }

  return (tsteptype);
}

265
static
266
int gribapiGetValidityDateTime(grib_handle *gh, int *vdate, int *vtime)
267
{
268
  int rdate, rtime;
269
  int timeUnits, startStep = 0, endStep;
270
271
  int tstepRange = 0;
  int range;
272
  int status;
273
  long lpar;
274
275
276
277
278
  long sigofrtime = 3;
  long editionNumber;

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

279
  if ( editionNumber > 1 )
280
281
282
    {
      GRIB_CHECK(grib_get_long(gh, "significanceOfReferenceTime", &sigofrtime), 0);
    }
283
284
285
286
287
288
289
290
291
292

  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
    {
293
294
295
      GRIB_CHECK(grib_get_long(gh, "dataDate", &lpar), 0);
      rdate = (int) lpar;
      GRIB_CHECK(grib_get_long(gh, "dataTime", &lpar), 0);
296
      rtime = (int) lpar*100;
297
298
      status = grib_get_long(gh, "forecastTime", &lpar);
      if ( status == 0 ) startStep = (int) lpar;
299
      timeUnits = gribapiGetTimeUnits(gh);
300
      endStep = gribapiGetEndStep(gh, startStep, timeUnits);
301
302
303
304
305
306
307
308
309

      range = endStep - startStep;

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

310
311
312
313
      {
	static int lprint = TRUE;
	extern int grib_calendar;
	int ryear, rmonth, rday, rhour, rminute, rsecond;
314
	int time_period = endStep;
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
	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;
	      }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
338
	    break;
339
340
341
342
343
344
345
346
347
348
349
	  }

	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);
      }
350
    }
351
352

  return (tstepRange);
353
354
}

355
static
356
void gribapiGetGrid(grib_handle *gh, grid_t *grid)
Uwe Schulzweida's avatar
Uwe Schulzweida committed
357
{
358
  long editionNumber;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
359
  int gridtype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
360
  size_t datasize;
361
362
  long numberOfPoints;
  long lpar;
363
364
365

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

366
  gridtype = gribapiGetGridType(gh);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
367
368
369
370
371
372
373
374
  /*
  if ( streamptr->unreduced && gridtype == GRID_GAUSSIAN_REDUCED )
    {
      gridtype = GRID_GAUSSIAN;
      ISEC2_NumLon = 2*ISEC2_NumLat;
      ISEC4_NumValues = ISEC2_NumLon*ISEC2_NumLat;
    }
  */
375
  memset(grid, 0, sizeof(grid_t));
Uwe Schulzweida's avatar
Uwe Schulzweida committed
376

Uwe Schulzweida's avatar
Uwe Schulzweida committed
377
378
379
  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
380
381
382
383
384
385
386
387
388
389
390
391
  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;

392
393
394
395
396
397
	if ( gridtype == GRID_GAUSSIAN )
          {
            GRIB_CHECK(grib_get_long(gh, "numberOfParallelsBetweenAPoleAndTheEquator", &lpar), 0);
            grid->np = lpar;
          }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
398
	if ( numberOfPoints != nlon*nlat )
399
	  Error("numberOfPoints (%d) and gridSize (%d) differ!", (int)numberOfPoints, nlon*nlat);
400

401
402
403
404
405
406
407
408
409
410
411
	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
412
	if ( gridtype == GRID_LONLAT )
413
	  GRIB_CHECK(grib_get_double(gh, "jDirectionIncrementInDegrees", &grid->yinc), 0);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
414

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

417
	/* if ( IS_NOT_EQUAL(grid->xfirst, 0) || IS_NOT_EQUAL(grid->xlast, 0) ) */
Uwe Schulzweida's avatar
Uwe Schulzweida committed
418
	  {
419
	    if ( grid->xsize > 1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
420
	      {
421
		if ( (grid->xfirst >= grid->xlast) && (grid->xfirst >= 180) ) grid->xfirst -= 360;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
422

423
424
425
		if ( editionNumber <= 1 )
		  {
		    /* correct xinc if necessary */
426
		    if ( IS_EQUAL(grid->xfirst, 0) && grid->xlast > 354 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
427
		      {
428
			double xinc = 360. / grid->xsize;
429

430
			if ( fabs(grid->xinc-xinc) > 0.0 )
431
			  {
432
433
			    grid->xinc = xinc;
			    if ( CDI_Debug ) Message("set xinc to %g", grid->xinc);
434
			  }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
435
436
437
		      }
		  }
	      }
438
	    grid->xdef = 2;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
439
	  }
440
	grid->ydef = 0;
441
        /* if ( IS_NOT_EQUAL(grid->yfirst, 0) || IS_NOT_EQUAL(grid->ylast, 0) ) */
Uwe Schulzweida's avatar
Uwe Schulzweida committed
442
	  {
443
	    if ( grid->ysize > 1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
444
	      {
445
446
447
		if ( editionNumber <= 1 )
		  {
		  }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
448
	      }
449
	    grid->ydef = 2;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
450
451
452
453
454
	  }
	break;
      }
    case GRID_GAUSSIAN_REDUCED:
      {
455
456
457
458
	int nlat, i;
	size_t dummy;
	long *pl;

459
460
461
        GRIB_CHECK(grib_get_long(gh, "numberOfParallelsBetweenAPoleAndTheEquator", &lpar), 0);
        grid->np = lpar;

462
463
464
	GRIB_CHECK(grib_get_long(gh, "Nj", &lpar), 0);
	nlat = lpar;

465
	grid->size   = numberOfPoints;
466

467
        grid->rowlon = (int *) malloc(nlat*sizeof(int));
468
469
470
        pl          = (long *) malloc(nlat*sizeof(long));
	dummy       = nlat;
	GRIB_CHECK(grib_get_long_array(gh, "pl", pl, &dummy), 0);
471
	for ( i = 0; i < nlat; ++i ) grid->rowlon[i] = pl[i];
472
473
	free(pl);

474
475
476
477
478
479
480
481
482
	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);
483

484
	if ( IS_EQUAL(grid->xinc, GRIB_MISSING_DOUBLE) ) grid->xinc = 0;
485

486
	/* if ( IS_NOT_EQUAL(grid->xfirst, 0) || IS_NOT_EQUAL(grid->xlast, 0) ) */
Uwe Schulzweida's avatar
Uwe Schulzweida committed
487
	  {
488
	    if ( grid->xsize > 1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
489
	      {
490
		if ( (grid->xfirst > grid->xlast) && (grid->xfirst >= 180) ) grid->xfirst -= 360;
491
492
493
494

		if ( editionNumber <= 1 )
		  {
		    /* correct xinc if necessary */
495
		    if ( IS_EQUAL(grid->xfirst, 0) && grid->xlast > 354 )
496
		      {
497
			double xinc = 360. / grid->xsize;
498

499
			if ( fabs(grid->xinc-xinc) > 0.0 )
500
			  {
501
502
			    grid->xinc = xinc;
			    if ( CDI_Debug ) Message("set xinc to %g", grid->xinc);
503
504
505
			  }
		      }
		  }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
506
	      }
507
	    grid->xdef = 2;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
508
	  }
509
510
	grid->ydef  = 0;
        /* if ( IS_NOT_EQUAL(grid->yfirst, 0) || IS_NOT_EQUAL(grid->ylast, 0) ) */
Uwe Schulzweida's avatar
Uwe Schulzweida committed
511
	  {
512
	    if ( grid->ysize > 1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
513
	      {
514
515
516
		if ( editionNumber <= 1 )
		  {
		  }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
517
	      }
518
	    grid->ydef = 2;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
519
520
521
	  }
	break;
      }
522
      /*
Uwe Schulzweida's avatar
Uwe Schulzweida committed
523
524
525
    case GRID_LCC:
      {
	if ( ISEC4_NumValues != ISEC2_NumLon*ISEC2_NumLat )
526
	  Error("numberOfPoints (%d) and gridSize (%d) differ!",
Uwe Schulzweida's avatar
Uwe Schulzweida committed
527
528
		ISEC4_NumValues, ISEC2_NumLon*ISEC2_NumLat);

529
530
531
	grid->size  = ISEC4_NumValues;
	grid->xsize = ISEC2_NumLon;
	grid->ysize = ISEC2_NumLat;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
532

533
534
535
536
537
538
539
540
541
	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
542

543
	grid->xdef   = 0;
544
	grid->ydef   = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
545
546
547

	break;
      }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
548
      */
Uwe Schulzweida's avatar
Uwe Schulzweida committed
549
550
    case GRID_SPECTRAL:
      {
551
552
	size_t len = 256;
	char typeOfPacking[256];
553
	GRIB_CHECK(grib_get_string(gh, "packingType", typeOfPacking, &len), 0);
554
555
	grid->lcomplex = 0;
	if ( strncmp(typeOfPacking, "spectral_complex", len) == 0 ) grid->lcomplex = 1;
556

557
	grid->size  = datasize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
558
	GRIB_CHECK(grib_get_long(gh, "J", &lpar), 0);
559
	grid->trunc = lpar;
560

Uwe Schulzweida's avatar
Uwe Schulzweida committed
561
562
563
564
	break;
      }
    case GRID_GME:
      {
565
566
567
568
569
	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;
570
571
572

	break;
      }
573
    case GRID_REFERENCE:
574
      {
575
        char uuid[17];
576
577
578
579
	char reference_link[8192];
	size_t len = sizeof(reference_link);
	reference_link[0] = 0;

580
	grid->size  = numberOfPoints;
581
582
	if ( grib_get_long(gh, "numberOfGridUsed", &lpar) == 0 )
	  {
583
584
	    grid->number   = lpar;
	    if ( grib_get_long(gh, "numberOfGridInReference", &lpar) == 0 ) grid->position = lpar;
585
586
	    if ( grib_get_string(gh, "gridDescriptionFile", reference_link, &len) == 0 )
	      {
587
		if ( strncmp(reference_link, "file://", 7) == 0 )
588
		  grid->reference = strdupx(reference_link);
589
	      }
590
591
592
593
594
            len = (size_t) 16;
            if ( grib_get_string(gh, "uuidOfHGrid", uuid, &len) == 0)
              {
                strncpy(grid->uuid, uuid, 16);
              }
595
	  }
596

Uwe Schulzweida's avatar
Uwe Schulzweida committed
597
598
599
600
	break;
      }
    case GRID_GENERIC:
      {
601
602
603
604
605
	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;

606
	grid->size  = numberOfPoints;
607

608
	if ( nlon > 0 && nlat > 0 && nlon*nlat == grid->size )
609
	  {
610
611
	    grid->xsize = nlon;
	    grid->ysize = nlat;
612
613
614
	  }
	else
	  {
615
616
	    grid->xsize = 0;
	    grid->ysize = 0;
617
618
	  }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
619
620
621
622
	break;
      }
    default:
      {
623
	Error("Unsupported grid type: %s", gridNamePtr(gridtype));
Uwe Schulzweida's avatar
Uwe Schulzweida committed
624
625
626
627
	break;
      }
    }

628
  grid->isRotated = FALSE;
629
  if ( gribapiGetIsRotated(gh) )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
630
    {
631
632
633
634
      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);
635
      /* change from south to north pole */
636
637
638
639
640
641
642
643
644
645
      grid->ypole = -grid->ypole;
      grid->xpole =  grid->xpole - 180;
    }

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

static
646
void grib1GetLevel(grib_handle *gh, int *leveltype, int *lbounds, int *level1, int *level2)
647
{
648
649
650
  int status;
  long lpar;
  double dlevel;
651

652
653
654
655
  *leveltype = 0;
  *lbounds = 0;
  *level1  = 0;
  *level2  = 0;
656

657
658
  status = grib_get_long(gh, "indicatorOfTypeOfLevel", &lpar);
  if ( status == 0 )
659
    {
660
      *leveltype = (int) lpar;
661

662
      switch (*leveltype)
663
664
665
666
	{
	case GRIB1_LTYPE_SIGMA_LAYER:
	case GRIB1_LTYPE_HYBRID_LAYER:
	case GRIB1_LTYPE_LANDDEPTH_LAYER:
667
	  { *lbounds = 1; break; }
668
	}
669

670
671
672
673
674
675
      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;
676

677
678
679
680
681
682
683
684
685
686
	  *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;
	}
687
    }
688
689
690
}

static
691
void grib2GetLevel(grib_handle *gh, int *leveltype, int *lbounds, int *level1, int *level2)
692
{
693
694
695
696
  int status;
  int leveltype2 = -1;
  long lpar;
  long factor;
697
698
  double dlevel;

699
700
701
702
703
704
705
  *leveltype = 0;
  *lbounds = 0;
  *level1  = 0;
  *level2  = 0;

  status = grib_get_long(gh, "typeOfFirstFixedSurface", &lpar);
  if ( status == 0 )
706
    {
707
      *leveltype = (int) lpar;
708

709
710
      status = grib_get_long(gh, "typeOfSecondFixedSurface", &lpar);
      if ( status == 0 ) leveltype2 = lpar;
711

712
      if ( *leveltype == leveltype2 && *leveltype != 255 ) *lbounds = 1;
713

714
      if ( *lbounds == 0 )
715
	{
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
	  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;
	    }

732
	  *level1 = (int) dlevel;
733
	  *level2 = 0;
734
735
736
	}
      else
	{
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
	  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;
	    }
759
760
	}
    }
761
762
763
}

static
764
void gribapiAddRecord(stream_t * streamptr, int param, grib_handle *gh,
765
		      long recsize, off_t position, int datatype, int comptype)
766
767
768
769
770
771
{
  long editionNumber;
  int zaxistype;
  int gridID = CDI_UNDEFID, varID;
  int levelID = 0;
  int tsID, recID;
772
  int level1 = 0, level2 = 0;
773
774
775
776
777
778
779
780
781
782
  int numavg;
  int tsteptype;
  int lbounds = 0;
  record_t *record;
  grid_t grid;
  int vlistID;
  int leveltype;
  long lpar;
  int status;
  char name[256], longname[256], units[256];
783
  size_t vlen;
784
  long ens_index = 0, ens_count = 0, ens_forecast_type = 0;
785

Uwe Schulzweida's avatar
Uwe Schulzweida committed
786
  vlistID = streamptr->vlistID;
787
  tsID    = streamptr->curTsID;
788
  recID   = recordNewEntry(streamptr, tsID);
789
790
791
792
793
794
795
796
797
  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 )
798
    grib1GetLevel(gh, &leveltype, &lbounds, &level1, &level2);
799
  else
800
    grib2GetLevel(gh, &leveltype, &lbounds, &level1, &level2);
801

802
803
804
805
806
807
808
809
810
811
  // 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
812
813
814

  gridID = varDefGrid(vlistID, grid, 0);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
815
  zaxistype = gribapiGetZaxisType(editionNumber, leveltype);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
816

817
  switch (zaxistype)
Uwe Schulzweida's avatar
Uwe Schulzweida committed
818
    {
819
820
821
822
823
824
    case ZAXIS_HYBRID:
    case ZAXIS_HYBRID_HALF:
      {
        int vctsize;
        size_t dummy;
        double *vctptr;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
825

826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
        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);
845
        if ( lpar != 3 )
846
847
848
849
850
851
852
853
854
855
856
857
          {
            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
858
    }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
859

860
  // if ( datatype > 32 ) datatype = DATATYPE_PACK32;
861
  if ( datatype <  0 ) datatype = DATATYPE_PACK;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
862

863
864
865
866
  name[0] = 0;
  longname[0] = 0;
  units[0] = 0;

Uwe Schulzweida's avatar
Uwe Schulzweida committed
867
868
  vlen = 256;
  GRIB_CHECK(grib_get_string(gh, "shortName", name, &vlen), 0);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
869
870
871
872
873
874
875
876
877
878
879
880
  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
881
  // fprintf(stderr, "param %d name %s %s %s\n", param, name, longname, units); 
Uwe Schulzweida's avatar
Uwe Schulzweida committed
882

Uwe Schulzweida's avatar
Uwe Schulzweida committed
883
  varAddRecord(recID, param, gridID, zaxistype, lbounds, level1, level2,
884
	       datatype, &varID, &levelID, tsteptype, numavg, leveltype,
Uwe Schulzweida's avatar
Uwe Schulzweida committed
885
	       name, longname, units);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
886
887
888
889

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

890
  varDefCompType(varID, comptype);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
891

892
893
  /*
    Get the ensemble Info from the grib-2 Tables and update the intermediate datastructure.
894
    Further update to the "vlist" is handled in the same way as for GRIB-1 by "cdi_generate_vars"
895
  */
896
897
898
899
900
901
902
903
904
  {
    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);
      }
  }
905
906
907
908
  if ( ens_index > 0 )
    varDefEnsembleInfo(varID, (int)ens_index, (int)ens_count, (int)ens_forecast_type);


Uwe Schulzweida's avatar
Uwe Schulzweida committed
909
910
  if ( varInqInst(varID) == CDI_UNDEFID )
    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
911
912
913
914
915
      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
916
      if ( instID == CDI_UNDEFID )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
917
	instID = institutDef((int)center, (int)subcenter, NULL, NULL);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
918
919
920
921
922
923
      varDefInst(varID, instID);
    }

  if ( varInqModel(varID) == CDI_UNDEFID )
    {
      int modelID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
924
      long processID;
925
926
927
928
929
930
931
932
      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
933
934
935
936
    }

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

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

Uwe Schulzweida's avatar
Uwe Schulzweida committed
941
942
943
944
      if ( pdis == 255 )
	{
	  int tableID;
	  int tabnum = pcat;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
945

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

Uwe Schulzweida's avatar
Uwe Schulzweida committed
948
949
950
	  if ( tableID == CDI_UNDEFID )
	    tableID = tableDef(varInqModel(varID), tabnum, NULL);
	  varDefTable(varID, tableID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
951
952
953
954
955
956
957
	}
    }

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

  if ( CDI_Debug )
958
    Message("varID = %d  param = %d  zaxistype = %d  gridID = %d  levelID = %d",
Uwe Schulzweida's avatar
Uwe Schulzweida committed
959
	    varID, param, zaxistype, gridID, levelID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
960
}
961
962
963
964
965
966

static
int gribapiGetParam(grib_handle *gh)
{
  int pdis = 0, pcat = 0, pnum = 0;
  int param = 0;
967
  int status;
968
969
970
971
972
  long lpar;

  GRIB_CHECK(grib_get_long(gh, "discipline", &lpar), 0);
  pdis = (int) lpar;

973
974
  status = grib_get_long(gh, "parameterCategory", &lpar);
  if ( status == 0 ) pcat = (int) lpar;
975

976
977
  status = grib_get_long(gh, "parameterNumber", &lpar);
  if ( status == 0 ) pnum = (int) lpar;
978
979

  param = cdiEncodeParam(pnum, pcat, pdis);
980

981
982
  return (param);
}
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011

static
compvar2_t gribapiVarSet(int param, int level1, int level2, int leveltype)
{
  compvar2_t compVar;

  compVar.param  = param;
  compVar.level1 = level1;
  compVar.level2 = level2;
  compVar.ltype  = leveltype;

  return (compVar);
}

static
int gribapiVarCompare(compvar2_t compVar, record_t record)
{
  int rstatus;
  compvar2_t compVar0;

  compVar0.param  = record.param;
  compVar0.level1 = record.ilevel;
  compVar0.level2 = record.ilevel2;
  compVar0.ltype  = record.ltype;

  rstatus = memcmp(&compVar0, &compVar, sizeof(compvar2_t));

  return (rstatus);
}
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1012
1013
#endif

1014
int gribapiScanTimestep1(stream_t * streamptr)
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1015
1016
1017
1018
1019
{
#if  defined  (HAVE_LIBGRIB_API)
  off_t recpos = 0;
  unsigned char *gribbuffer = NULL;
  long buffersize = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1020
  int rstatus;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1021
1022
  int status;
  int fileID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1023
  int rtabnum = 0;
1024
1025
  int rcode = 0, level1 = 0, level2 = 0;
  int vdate = 0, vtime = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1026
  int param = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1027
1028
1029
1030
1031
  DateTime datetime, datetime0;
  int tsID;
  int varID;
  size_t readsize;
  int nrecords, nrecs, recID;
1032
  int nrecs_scanned;
1033
  int datatype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1034
1035
  long recsize = 0;
  int warn_time = TRUE;
1036
  // int warn_numavg = TRUE;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1037
1038
  int taxisID = -1;
  int rdate = 0, rtime = 0, tunit = 0, fcast = 0;
1039
  taxis_t *taxis;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1040
  int vlistID;
1041
  int comptype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1042
  long unzipsize;
1043
  compvar2_t compVar;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1044
1045
1046
1047
  grib_handle *gh = NULL;
  int leveltype;
  long editionNumber;
  long lpar;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1048
  int bitsPerValue;
1049
  int lieee = FALSE;