stream_grb.c 61.2 KB
Newer Older
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif

#include <stdio.h>
#include <string.h>
#include <math.h>  /* modf */
#include <float.h>  /* FLT_EPSILON */
#include <sys/types.h>

#include "dmemory.h"
#include "cdi.h"
#include "stream_int.h"
#include "grib.h"
#include "file.h"
#include "varscan.h"
#include "datetime.h"
#include "taxis.h"
#include "vlist.h"


#undef  UNDEFID
#define UNDEFID  CDI_UNDEFID


typedef struct {
  int code;
  int table;
  int level1;
  int level2;
  int ltype;
} COMPVAR; 


int gribGetGridType(int *isec2)
{
  /*  static char func[] = "gribGetGridType"; */
  int gridtype = 0;

  switch (ISEC2_GridType)
    {
    case   0:
    case  10:
      {
	gridtype = GRID_LONLAT;
	break;
      }
    case   4:
      {
	if ( ISEC2_Reduced )
	  gridtype = GRID_GAUSSIAN_REDUCED;
	else
	  gridtype = GRID_GAUSSIAN;
	break;
      }
    case  50:
      {
	gridtype = GRID_SPECTRAL;
	break;
      }
    case 192:
      {
	gridtype = GRID_GME;
	break;
      }
    default:
      {
	gridtype = GRID_GENERIC;
	break;
      }
    }

  return (gridtype);
}


int gribGetIsRotated(int *isec2)
{
  /*  static char func[] = "gribGetIsRotated"; */
  int isRotated = 0;

  if ( ISEC2_GridType == 10 )
    {
      isRotated = 1;
    }

  return (isRotated);
}


int grbInqRecord(int streamID, int *varID, int *levelID)
{
  static char func[] = "grbInqRecord";
  int status = 0;
  int fileID;
  void *gribbuffer;
  int iret = 0, iword = 0;
  int isec4size = 0;
  int isec0[2], isec1[4096], isec2[4096], isec3[2], isec4[512];
  double fsec2[512], fsec3[2], *fsec4 = NULL;
  int gridID = -1, zaxisID = -1;
  int gridtype;
  int gribsize;
  size_t readsize;
  int vlistID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
106
  STREAM *streamptr;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
107

Uwe Schulzweida's avatar
Uwe Schulzweida committed
108
109
110
  streamptr = stream_to_pointer(streamID);

  stream_check_ptr(func, streamptr);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
111
112
113
114
115
116
117
118
119
120

  vlistID  = streamInqVlist(streamID);
  fileID   = streamInqFileID(streamID);

  *varID   = -1;
  *levelID = -1;

  gribsize = gribGetSize(fileID);
  if ( gribsize == 0 ) return (0);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
121
  gribbuffer = streamptr->record->buffer;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
122
123
  gribbuffer = realloc(gribbuffer, gribsize);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
124
125
  streamptr->record->buffer = gribbuffer;
  streamptr->record->buffersize = gribsize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

  readsize = gribsize;
  status = gribRead(fileID, (unsigned char *) gribbuffer, &readsize);
  if ( status ) return (-1);

  gribExDP(isec0, isec1, isec2, fsec2, isec3, fsec3, isec4, fsec4,
	   isec4size, (int *) gribbuffer, gribsize, &iword, "J", &iret);

  *varID = vlistInqVarID(vlistID, ISEC1_Parameter);

  if ( *varID == UNDEFID )
    Error(func, "code %d undefined", ISEC1_Parameter);

  gridID  = vlistInqVarGrid(vlistID, *varID);
  zaxisID = vlistInqVarZaxis(vlistID, *varID);

  gridtype = gribGetGridType(isec2);

  switch (gridtype)
    {
    case GRID_LONLAT:
      {
	if ( gridInqType(gridID) == GRID_TRAJECTORY )
	  {
	    double xfirst, yfirst;
	    xfirst = ISEC2_FirstLon * 0.001;
	    yfirst = ISEC2_FirstLat * 0.001;
	    gridDefXvals(gridID, &xfirst);
	    gridDefYvals(gridID, &yfirst);
	  }
	break;
      }
    case GRID_GAUSSIAN:
      {
	if ( ISEC4_NumValues != ISEC2_NumLon*ISEC2_NumLat )
	  Error(func, "wrong datasize! isec4len = %d isec2len = %d",
		ISEC4_NumValues, ISEC2_NumLon*ISEC2_NumLat);
	break;
      }
    case GRID_SPECTRAL:
      {
	break;
      }
    case GRID_GME:
      {
	break;
      }
    default:
      {
	Error(func, "%s grid unsupported", gridNamePtr(gridtype));
	break;
      }
    }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
180
181
182
183
184
185
  streamptr->record->code     = ISEC1_Parameter;
  streamptr->record->level    = ISEC1_Level1;
  gribDateTime(isec1, &streamptr->record->date, &streamptr->record->time);
  streamptr->record->gridID   = gridID;
  streamptr->record->zaxisID  = zaxisID;
  streamptr->record->nrec++;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
186
187
188
189
190
191
192
193
194
195
196
197
198
199

  *levelID = zaxisInqLevelID(zaxisID, (double) ISEC1_Level1);

  status = 1;

  return (status);
}

int grbDefRecord(int streamID)
{
  static char func[] = "grbDefRecord";
  int fileID;
  int gridID;
  int status = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
200
201
202
  STREAM *streamptr;

  streamptr = stream_to_pointer(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
203

Uwe Schulzweida's avatar
Uwe Schulzweida committed
204
  stream_check_ptr(func, streamptr);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
205
206

  fileID = streamInqFileID(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
207
  gridID = streamptr->record->gridID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
208
209
210
211
212
213

  return (status);
}


int grbDecodeDataDP(unsigned char *gribbuffer, int gribsize, double *data, int gridsize,
214
		    int unreduced, int *nmiss, int *zip)
Uwe Schulzweida's avatar
Uwe Schulzweida committed
215
216
217
218
219
220
221
222
223
224
{
  static char func[] = "grbDecodeDataDP";
  int status = 0;
  int iret = 0, iword = 0;
  int isec0[2], isec1[4096], isec2[4096], isec3[2], isec4[512];
  int izip;
  long unzipsize;
  double fsec2[512], fsec3[2];
  char hoper[2];

225
226
  *zip = 0;

Uwe Schulzweida's avatar
Uwe Schulzweida committed
227
228
229
230
231
232
233
  if ( unreduced ) strcpy(hoper, "R");
  else             strcpy(hoper, "D");

  FSEC3_MissVal = cdiDefaultMissval;

  if ( (izip = gribGetZip(gribsize, gribbuffer, &unzipsize)) > 0 )
    {
234
          *zip = izip;
235
236
237
238
239
240
241
242
243
244
245
246
	  if ( izip == 128 ) /* szip */
	    {
	      unsigned char *itmpbuffer = NULL;
	      size_t itmpbuffersize = 0;

	      if ( unzipsize < (long) gribsize )
		{
		  fprintf(stderr, "Decompressed size smaller than compressed size (in %d; out %ld)!\n",
			  gribsize, unzipsize);
		  return (status);
		}

Uwe Schulzweida's avatar
Uwe Schulzweida committed
247
	      if ( itmpbuffersize < (size_t) gribsize )
248
249
250
251
252
253
254
255
256
257
258
		{
		  itmpbuffersize = gribsize;
		  itmpbuffer = (unsigned char *) realloc(itmpbuffer, itmpbuffersize);
		}

	      memcpy(itmpbuffer, gribbuffer, itmpbuffersize);

	      unzipsize += 100; /* need 0 to 1 bytes for rounding of bds */

	      gribsize = gribUnzip(gribbuffer, unzipsize, itmpbuffer, gribsize);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
259
260
261
	      if ( gribsize <= 0 )
		Error(func, "Decompression problem!\n");
	   
262
263
264
265
	      free(itmpbuffer);
	    }
	  else
	    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
266
	      Error(func, "Decompression for %d not implemented!\n", izip);
267
	    }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
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
    }

  gribExDP(isec0, isec1, isec2, fsec2, isec3, fsec3, isec4, data,
	   gridsize, (int *) gribbuffer, gribsize, &iword, hoper, &iret);

  if ( ISEC1_Sec2Or3Flag & 64 )
    *nmiss = ISEC4_NumValues - ISEC4_NumNonMissValues;
  else
    *nmiss = 0;

  return (status);
}


int grbReadRecord(int streamID, double *data, int *nmiss)
{
  static char func[] = "grbReadRecord";
  int status = 0;
  unsigned char *gribbuffer;
  int fileID;
  int recID, vrecID, tsID, gridID, varID;
  long recsize;
  off_t recpos;
  int gridsize;
  int vlistID;
293
  int zip;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
294
295
296
  STREAM *streamptr;

  streamptr = stream_to_pointer(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
297

Uwe Schulzweida's avatar
Uwe Schulzweida committed
298
  stream_check_ptr(func, streamptr);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
299

Uwe Schulzweida's avatar
Uwe Schulzweida committed
300
  gribbuffer = (unsigned char *) streamptr->record->buffer;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
301
302
303

  vlistID = streamInqVlist(streamID);
  fileID  = streamInqFileID(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
304
305
306
307
308
309
  tsID    = streamptr->curTsID;
  vrecID  = streamptr->tsteps[tsID].curRecID;
  recID   = streamptr->tsteps[tsID].recIDs[vrecID];
  recpos  = streamptr->tsteps[tsID].records[recID].position;
  recsize = streamptr->tsteps[tsID].records[recID].size;
  varID   = streamptr->tsteps[tsID].records[recID].varID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
310
311
312
313

  gridID   = vlistInqVarGrid(vlistID, varID);
  gridsize = gridInqSize(gridID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
314
  streamptr->numvals += gridsize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
315

Uwe Schulzweida's avatar
Uwe Schulzweida committed
316
317
  fileSetPos(fileID, recpos, SEEK_SET);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
318
  fileRead(fileID, gribbuffer, (size_t) recsize);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
319

Uwe Schulzweida's avatar
Uwe Schulzweida committed
320
  grbDecodeDataDP(gribbuffer, recsize, data, gridsize, streamptr->unreduced, nmiss, &zip);
321

Uwe Schulzweida's avatar
Uwe Schulzweida committed
322
  streamptr->tsteps[tsID].records[recID].zip = zip;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354

  return (status);
}


int gribGetZaxisType(int grbleveltype)
{
  int leveltype = 0;

  switch ( grbleveltype )
    {
    case LTYPE_SURFACE:
      {
	leveltype = ZAXIS_SURFACE;
	break;
      }
    case LTYPE_99:
    case LTYPE_ISOBARIC:
      {
	leveltype = ZAXIS_PRESSURE;
	break;
      }
    case LTYPE_HEIGHT:
      {
	leveltype = ZAXIS_HEIGHT;
	break;
      }
    case LTYPE_ALTITUDE:
      {
	leveltype = ZAXIS_ALTITUDE;
	break;
      }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
355
356
357
358
359
    case LTYPE_SIGMA:
      {
	leveltype = ZAXIS_SIGMA;
	break;
      }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
360
361
362
363
364
365
366
367
368
369
370
371
    case LTYPE_HYBRID:
    case LTYPE_HYBRID_LAYER:
      {
	leveltype = ZAXIS_HYBRID;
	break;
      }
    case LTYPE_LANDDEPTH:
    case LTYPE_LANDDEPTH_LAYER:
      {
	leveltype = ZAXIS_DEPTH_BELOW_LAND;
	break;
      }
372
373
374
375
376
    case LTYPE_ISENTROPIC:
      {
	leveltype = ZAXIS_ISENTROPIC;
	break;
      }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
    case LTYPE_SEADEPTH:
      {
	leveltype = ZAXIS_DEPTH_BELOW_SEA;
	break;
      }
    default:
      {
	leveltype = ZAXIS_GENERIC;
	break;
      }
    }

  return (leveltype);
}


int gribGetZaxisHasBounds(int grbleveltype)
{
  int lbounds = 0;

  switch (grbleveltype)
    {
    case LTYPE_HYBRID_LAYER:
    case LTYPE_LANDDEPTH_LAYER:
      {
	lbounds = 1;
	break;
      }
    }

  return (lbounds);
}


int gribTimeUnit(int *isec1)
{
  static char func[] = "gribTimeUnit";
  int timeunit = -1;
  static int lprint = TRUE;

  switch ( ISEC1_TimeUnit )
    {
    case ISEC1_TABLE4_MINUTE:  timeunit = TUNIT_MINUTE; break;
    case ISEC1_TABLE4_HOUR:    timeunit = TUNIT_HOUR;   break;
    case ISEC1_TABLE4_DAY:     timeunit = TUNIT_DAY;    break;
    default:
      if ( lprint )
	{
	  Message(func, "Time unit %d unsupported", ISEC1_TimeUnit);
	  lprint = FALSE;
	}
    }

  return (timeunit);
}


int grbScanTimestep(int streamID)
{
  static char func[] = "grbScanTimestep";
  int *isec0, *isec1, *isec2, *isec3, *isec4;
  double fsec2[512], fsec3[2], *fsec4 = NULL;
  long recsize = 0;
  off_t recpos = 0;
  unsigned char *gribbuffer;
  long buffersize = 0;
  int iret = 0, ipunp = 0, iword = 0;
  int status;
  int fileID;
  int rcode = 0, level1 = 0, level2 = 0, vdate = 0, vtime = 0;
  int tsID;
  int vrecID, recID;
  int warn_numavg = TRUE;
  size_t readsize;
  int taxisID = -1;
  TAXIS *taxis;
  int vlistID;
  int rindex, nrecs = 0;
455
  long unzipsize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
456
  COMPVAR compVar, compVar0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
457
  STREAM *streamptr;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
458

Uwe Schulzweida's avatar
Uwe Schulzweida committed
459
460
461
  streamptr = stream_to_pointer(streamID);

  stream_check_ptr(func, streamptr);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
462
463
464
465
466
467

  vlistID = streamInqVlist(streamID);

  if ( CDI_Debug )
    {
      Message(func, "streamID = %d", streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
468
469
470
      Message(func, "cts = %d", streamptr->curTsID);
      Message(func, "rts = %d", streamptr->rtsteps);
      Message(func, "nts = %d", streamptr->ntsteps);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
471
472
    }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
473
474
475
476
477
  isec0 = streamptr->record->sec0;
  isec1 = streamptr->record->sec1;
  isec2 = streamptr->record->sec2;
  isec3 = streamptr->record->sec3;
  isec4 = streamptr->record->sec4;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
478

Uwe Schulzweida's avatar
Uwe Schulzweida committed
479
480
  tsID  = streamptr->rtsteps;
  taxis = &streamptr->tsteps[tsID].taxis;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
481

Uwe Schulzweida's avatar
Uwe Schulzweida committed
482
  if ( streamptr->tsteps[tsID].recordSize == 0 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
483
    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
484
485
      gribbuffer = (unsigned char *) streamptr->record->buffer;
      buffersize = streamptr->record->buffersize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
486
487
488

      cdiCreateRecords(streamID, tsID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
489
      nrecs = streamptr->tsteps[1].nrecs;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
490

Uwe Schulzweida's avatar
Uwe Schulzweida committed
491
492
      streamptr->tsteps[tsID].nrecs = nrecs;
      streamptr->tsteps[tsID].recIDs = (int *) malloc(nrecs*sizeof(int));
Uwe Schulzweida's avatar
Uwe Schulzweida committed
493
      for ( recID = 0; recID < nrecs; recID++ )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
494
	streamptr->tsteps[tsID].recIDs[recID] = streamptr->tsteps[1].recIDs[recID];
Uwe Schulzweida's avatar
Uwe Schulzweida committed
495
496
497

      fileID = streamInqFileID(streamID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
498
      fileSetPos(fileID, streamptr->tsteps[tsID].position, SEEK_SET);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
499
500
501
502
503
504
505

      for ( rindex = 0; rindex <= nrecs; rindex++ )
	{
	  recsize = gribGetSize(fileID);
	  recpos  = fileGetPos(fileID);
	  if ( recsize == 0 )
	    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
506
	      streamptr->ntsteps = streamptr->rtsteps + 1;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
507
508
509
510
511
512
513
514
515
516
517
518
519
	      break;
	    }
	  if ( recsize > buffersize )
	    {
	      buffersize = recsize;
	      gribbuffer = (unsigned char *) realloc(gribbuffer, buffersize);
	    }

	  readsize = recsize;
	  status = gribRead(fileID, gribbuffer, &readsize);
	  if ( status )
	    {
	      Error(func, "Inconsistent timestep %d (GRIB record %d/%d)!\n", tsID+1, rindex+1,
Uwe Schulzweida's avatar
Uwe Schulzweida committed
520
		    streamptr->tsteps[tsID].recordSize);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
521
522
	      break;
	    }
523
524
525
526
527
528
529
530
531
532
533

	  if ( gribGetZip(recsize, gribbuffer, &unzipsize) > 0 )
	    {
	      unzipsize += 100; /* need 0 to 1 bytes for rounding of bds */
	      if ( (long) buffersize < unzipsize )
		{
		  buffersize = unzipsize;
		  gribbuffer = (unsigned char *) realloc(gribbuffer, buffersize);
		}
	    }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
534
535
	  gribExDP(isec0, isec1, isec2, fsec2, isec3, fsec3, isec4, fsec4,
		   ipunp, (int *) gribbuffer, recsize, &iword, "J", &iret);
536

Uwe Schulzweida's avatar
Uwe Schulzweida committed
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
	  rcode    = ISEC1_Parameter;
	  level1   = ISEC1_Level1;
	  level2   = ISEC1_Level2;
	  if ( ISEC1_LevelType == 100 ) level1 *= 100;

	  gribDateTime(isec1, &vdate, &vtime);

	  if ( rindex == nrecs ) break;

	  if ( rindex == 0 )
	    {
	      taxisID = vlistInqTaxis(vlistID);
	      if ( taxisInqType(taxisID) == TAXIS_RELATIVE )
		{
		  taxis->type  = TAXIS_RELATIVE;
		  taxis->rdate = gribRefDate(isec1);
		  taxis->rtime = gribRefTime(isec1);
		  taxis->unit  = gribTimeUnit(isec1);
		}
	      else
		{
		  taxis->type  = TAXIS_ABSOLUTE;
		}
	      taxis->vdate = vdate;
	      taxis->vtime = vtime;
	    }

	  if ( ISEC1_AvgNum )
	    {
	      if (  taxis->numavg && warn_numavg &&
		   (taxis->numavg != ISEC1_AvgNum) )
		{
	      /*
		  Message(func, "Change numavg from %d to %d not allowed!",
Uwe Schulzweida's avatar
Uwe Schulzweida committed
571
			  streamptr->tsteps[tsID].taxis.numavg, ISEC1_AvgNum);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
	      */
		  warn_numavg = FALSE;
		}
	      else
		{
		  taxis->numavg = ISEC1_AvgNum;
		}
	    }
	  
	  compVar.code   = rcode;
          compVar.table  = ISEC1_CodeTable;
          compVar.level1 = level1;
          compVar.level2 = level2;
          compVar.ltype  = ISEC1_LevelType;
	  for ( vrecID = 0; vrecID < nrecs; vrecID++ )
	    {
588
	      recID   = streamptr->tsteps[1].recIDs[vrecID];
Uwe Schulzweida's avatar
Uwe Schulzweida committed
589
590
591
592
593
	      compVar0.code   = streamptr->tsteps[tsID].records[recID].code;
	      compVar0.table  = streamptr->tsteps[tsID].records[recID].table;
	      compVar0.level1 = streamptr->tsteps[tsID].records[recID].ilevel;
	      compVar0.level2 = streamptr->tsteps[tsID].records[recID].ilevel2;
	      compVar0.ltype  = streamptr->tsteps[tsID].records[recID].ltype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
594
595
	      if ( memcmp(&compVar0, &compVar, sizeof(COMPVAR)) == 0 )
		{
Uwe Schulzweida's avatar
Uwe Schulzweida committed
596
597
		  streamptr->tsteps[tsID].records[recID].used = TRUE;
		  streamptr->tsteps[tsID].recIDs[rindex] = recID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
598
599
600
601
602
603
604
605
606
607
608
609
610
		  break;
		}
	    }
	  if ( vrecID == nrecs )
	    {
	      Warning(func, "1 code %d level %d not found at timestep %d",
		      rcode, level1, tsID+1);
	      return (CDI_EUFSTRUCT);
	    }

	  if ( CDI_Debug )
	    Message(func, "%4d %8d %4d %8d %8d %6d", rindex+1, (int)recpos, rcode, level1, vdate, vtime);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
611
612
613
614
615
	  compVar0.code   = streamptr->tsteps[tsID].records[recID].code;
	  compVar0.table  = streamptr->tsteps[tsID].records[recID].table;
	  compVar0.level1 = streamptr->tsteps[tsID].records[recID].ilevel;
	  compVar0.level2 = streamptr->tsteps[tsID].records[recID].ilevel2;
	  compVar0.ltype  = streamptr->tsteps[tsID].records[recID].ltype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
616
617
618
619
620

	  if ( memcmp(&compVar0, &compVar, sizeof(COMPVAR)) != 0 )
	    {
	      Message(func, "tsID = %d recID = %d code = %3d new %3d  level = %3d new %3d",
		      tsID, recID,
Uwe Schulzweida's avatar
Uwe Schulzweida committed
621
622
		      streamptr->tsteps[tsID].records[recID].code, rcode,
		      streamptr->tsteps[tsID].records[recID].ilevel, level1);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
623
624
625
	      Error(func, "Invalid, unsupported or inconsistent record structure");
	    }
	  
Uwe Schulzweida's avatar
Uwe Schulzweida committed
626
627
	  streamptr->tsteps[tsID].records[recID].position = recpos;
	  streamptr->tsteps[tsID].records[recID].size = recsize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
628
629
630
631
632
633
634

	  if ( CDI_Debug )
	    Message(func, "%4d %8d %4d %8d %8d %6d", rindex, (int)recpos, rcode, level1, vdate, vtime);
	}

      for ( vrecID = 0; vrecID < nrecs; vrecID++ )
	{
Uwe Schulzweida's avatar
Uwe Schulzweida committed
635
636
	  recID   = streamptr->tsteps[tsID].recIDs[vrecID];
	  if ( ! streamptr->tsteps[tsID].records[recID].used ) break;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
637
638
639
640
641
	}

      if ( vrecID < nrecs )
	{
	  Warning(func, "2 code %d level %d not found at timestep %d",
Uwe Schulzweida's avatar
Uwe Schulzweida committed
642
643
		  streamptr->tsteps[tsID].records[recID].code,
		  streamptr->tsteps[tsID].records[recID].ilevel,
Uwe Schulzweida's avatar
Uwe Schulzweida committed
644
645
646
647
		  tsID+1);
	  return (CDI_EUFSTRUCT);
	}

Uwe Schulzweida's avatar
Uwe Schulzweida committed
648
      streamptr->rtsteps++;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
649

Uwe Schulzweida's avatar
Uwe Schulzweida committed
650
      if ( streamptr->ntsteps != streamptr->rtsteps )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
651
652
	{
	  tsID = tstepsNewEntry(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
653
	  if ( tsID != streamptr->rtsteps )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
654
655
	    Error(func, "Internal error. tsID = %d", tsID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
656
657
	  streamptr->tsteps[tsID-1].next   = 1;
	  streamptr->tsteps[tsID].position = recpos;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
658
659
	}

Uwe Schulzweida's avatar
Uwe Schulzweida committed
660
661
      fileSetPos(fileID, streamptr->tsteps[tsID].position, SEEK_SET);
      streamptr->tsteps[tsID].position = recpos;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
662

Uwe Schulzweida's avatar
Uwe Schulzweida committed
663
664
      streamptr->record->buffer     = gribbuffer;
      streamptr->record->buffersize = buffersize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
665
666
    }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
667
  if ( nrecs > 0 && nrecs < streamptr->tsteps[tsID].nrecs )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
668
669
    {
      Warning(func, "Incomplete timestep. Stop scanning at timestep %d.\n", tsID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
670
      streamptr->ntsteps = tsID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
671
672
    }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
673
  return (streamptr->ntsteps);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
674
675
676
677
678
679
}


int grbInqTimeSize(int streamID)
{
  static char func[] = "grbInqTimeSize";
Uwe Schulzweida's avatar
Uwe Schulzweida committed
680
681
682
  STREAM *streamptr;

  streamptr = stream_to_pointer(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
683

Uwe Schulzweida's avatar
Uwe Schulzweida committed
684
  stream_check_ptr(func, streamptr);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
685

Uwe Schulzweida's avatar
Uwe Schulzweida committed
686
  while ( ! streamptr->ntsteps )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
687
688
    grbScanTimestep(streamID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
689
  return (streamptr->ntsteps);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
690
691
692
693
}


void grbAddRecord(int streamID, int code, int *isec1, int *isec2, double *fsec2,
694
		  int *isec4, long recsize, off_t position, int prec, int szip)
Uwe Schulzweida's avatar
Uwe Schulzweida committed
695
696
697
698
699
700
701
702
703
704
705
706
707
{
  static char func[] = "grbAddRecord";
  int gridtype;
  int leveltype;
  int gridID = UNDEFID, varID;
  int levelID = 0;
  int tsID, recID;
  int level1, level2;
  int numavg;
  int lbounds = 0;
  RECORD *record;
  GRID grid;
  int vlistID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
708
709
710
  STREAM *streamptr;

  streamptr = stream_to_pointer(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
711
712

  vlistID = streamInqVlist(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
713
  tsID    = streamptr->curTsID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
714
  recID   = recordNewEntry(streamID, tsID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
715
  record  = &streamptr->tsteps[tsID].records[recID];
Uwe Schulzweida's avatar
Uwe Schulzweida committed
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734

  numavg  = ISEC1_AvgNum;

  level1  = ISEC1_Level1;
  if ( ISEC1_LevelType == 100 ) level1 *= 100;
  level2  = ISEC1_Level2;

  /* fprintf(stderr, "code %d %d %d\n", code, level1, level2); */

  (*record).size     = recsize;
  (*record).position = position;
  (*record).code     = code;
  (*record).table    = ISEC1_CodeTable;
  (*record).ilevel   = level1;
  (*record).ilevel2  = level2;
  (*record).ltype    = ISEC1_LevelType;

  gridtype = gribGetGridType(isec2);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
735
  if ( streamptr->unreduced && gridtype == GRID_GAUSSIAN_REDUCED )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
    {
      gridtype = GRID_GAUSSIAN;
      ISEC2_NumLon = 2*ISEC2_NumLat;
      ISEC4_NumValues = ISEC2_NumLon*ISEC2_NumLat;
    }

  memset(&grid, 0, sizeof(GRID));
  switch (gridtype)
    {
    case GRID_LONLAT:
    case GRID_GAUSSIAN:
      {
	if ( ISEC4_NumValues != ISEC2_NumLon*ISEC2_NumLat )
	  Error(func, "wrong datasize! isec4len = %d isec2len = %d",
		ISEC4_NumValues, ISEC2_NumLon*ISEC2_NumLat);
	grid.size  = ISEC4_NumValues;
	grid.xsize = ISEC2_NumLon;
	grid.ysize = ISEC2_NumLat;
	grid.xinc  = 0;
	grid.yinc  = 0;
	grid.xdef  = 0;
	/* if ( ISEC2_FirstLon != 0 || ISEC2_LastLon != 0 ) */
	  {
	    if ( grid.xsize > 1 )
	      {
		if ( ISEC2_ResFlag && ISEC2_LonIncr > 0 )
		  grid.xinc = ISEC2_LonIncr * 0.001;
		else
		  grid.xinc = (ISEC2_LastLon - ISEC2_FirstLon) * 0.001 / (grid.xsize - 1);

		/* correct xinc if necessary */
		if ( ISEC2_FirstLon == 0 && ISEC2_LastLon > 354000 )
		  {
		    double xinc = 360. / grid.xsize;

		    if ( fabs(grid.xinc-xinc) > 0.0 )
		      {
			grid.xinc = xinc;
			if ( CDI_Debug ) Message(func, "set xinc to %g", grid.xinc);
		      }
		  }
	      }
	    grid.xfirst = ISEC2_FirstLon * 0.001;
	    grid.xlast  = ISEC2_LastLon  * 0.001;
	    grid.xdef   = 2;	    
	  }
	grid.ydef  = 0;
	/* if ( ISEC2_FirstLat != 0 || ISEC2_LastLat != 0 ) */
	  {
	    if ( grid.ysize > 1 )
	      {
		if ( ISEC2_ResFlag && ISEC2_LatIncr > 0 )
		  grid.yinc = ISEC2_LatIncr * 0.001;
		else
		  grid.yinc = (ISEC2_LastLat - ISEC2_FirstLat) * 0.001 / (grid.ysize - 1);
	      }
	    grid.yfirst = ISEC2_FirstLat * 0.001;
	    grid.ylast  = ISEC2_LastLat  * 0.001;
	    grid.ydef   = 2;	    
	  }
	break;
      }
    case GRID_GAUSSIAN_REDUCED:
      {
	grid.size   = ISEC4_NumValues;
        grid.rowlon = ISEC2_RowLonPtr;
	grid.ysize  = ISEC2_NumLat;
	grid.xinc  = 0;
	grid.yinc  = 0;
	grid.xdef  = 0;
	/* if ( ISEC2_FirstLon != 0 || ISEC2_LastLon != 0 ) */
	  {
	    if ( grid.xsize > 1 )
	      {
		if ( ISEC2_ResFlag && ISEC2_LonIncr > 0 )
		  grid.xinc = ISEC2_LonIncr * 0.001;
		else
		  grid.xinc = (ISEC2_LastLon - ISEC2_FirstLon) * 0.001 / (grid.xsize - 1);
	      }
	    grid.xfirst = ISEC2_FirstLon * 0.001;
	    grid.xlast  = ISEC2_LastLon  * 0.001;
	    grid.xdef   = 2;	    
	  }
	grid.ydef  = 0;
	/* if ( ISEC2_FirstLat != 0 || ISEC2_LastLat != 0 ) */
	  {
	    if ( grid.ysize > 1 )
	      {
		if ( ISEC2_ResFlag && ISEC2_LatIncr > 0 )
		  grid.yinc = ISEC2_LatIncr * 0.001;
		else
		  grid.yinc = (ISEC2_LastLat - ISEC2_FirstLat) * 0.001 / (grid.ysize - 1);
	      }
	    grid.yfirst = ISEC2_FirstLat * 0.001;
	    grid.ylast  = ISEC2_LastLat  * 0.001;
	    grid.ydef   = 2;	    
	  }
	break;
      }
    case GRID_SPECTRAL:
      {
	grid.size  = ISEC4_NumValues;
	grid.trunc = ISEC2_PentaJ;
	break;
      }
    case GRID_GME:
      {
	grid.size  = ISEC4_NumValues;
	grid.nd    = ISEC2_GME_ND;
	grid.ni    = ISEC2_GME_NI;
	grid.ni2   = ISEC2_GME_NI2;
	grid.ni3   = ISEC2_GME_NI3;
	break;
      }
    case GRID_GENERIC:
      {
	grid.size  = ISEC4_NumValues;
	grid.xsize = 0;
	grid.ysize = 0;
	break;
      }
    default:
      {
	Error(func, "%s grid unsupported", gridNamePtr(gridtype));
	break;
      }
    }

  grid.isRotated = FALSE;
  if ( gribGetIsRotated(isec2) )
    {
      grid.isRotated = TRUE;
      grid.ypole     = - ISEC2_LatSP * 0.001;
      grid.xpole     =   ISEC2_LonSP * 0.001 - 180;
      grid.angle     = 0;
    }

  grid.xvals = NULL;
  grid.yvals = NULL;
  grid.type  = gridtype;

  gridID = varDefGrid(vlistID, grid, 0);

  leveltype = gribGetZaxisType(ISEC1_LevelType);

  if ( leveltype == ZAXIS_HYBRID )
    {
      int vctsize = ISEC2_NumVCP;
      double *vctptr = &fsec2[10];

      varDefVCT(vctsize, vctptr);
    }

  lbounds = gribGetZaxisHasBounds(ISEC1_LevelType);

891
892
  if ( prec > 32 ) prec = DATATYPE_PACK32;
  if ( prec <  0 ) prec = DATATYPE_PACK;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
893
894
895
896
897
898
899

  varAddRecord(recID, code, gridID, leveltype, lbounds, level1, level2,
	       prec, &varID, &levelID, numavg, ISEC1_CodeTable);

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

900
901
  varDefSzip(varID, szip);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
  if ( varInqInst(varID) == UNDEFID )
    {
      int center, subcenter, instID;
      center    = ISEC1_CenterID;
      subcenter = ISEC1_SubCenterID;
      instID    = institutInq(center, subcenter, NULL, NULL);
      if ( instID == UNDEFID )
	instID = institutDef(center, subcenter, NULL, NULL);
      varDefInst(varID, instID);
    }

  if ( varInqModel(varID) == UNDEFID )
    {
      int modelID;
      modelID = modelInq(varInqInst(varID), ISEC1_ModelID, NULL);
      if ( modelID == UNDEFID )
	modelID = modelDef(varInqInst(varID), ISEC1_ModelID, NULL);
      varDefModel(varID, modelID);
    }

  if ( varInqTable(varID) == UNDEFID )
    {
      int tableID;
      tableID = tableInq(varInqModel(varID), ISEC1_CodeTable, NULL);
      if ( tableID == UNDEFID )
	tableID = tableDef(varInqModel(varID), ISEC1_CodeTable, NULL);
      varDefTable(varID, tableID);
    }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
931
932
  streamptr->tsteps[tsID].nallrecs++;
  streamptr->nrecs++;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963

  if ( CDI_Debug )
    Message(func, "varID = %d  code = %d  leveltype = %d  gridID = %d  levelID = %d",
	    varID, code, leveltype, gridID, levelID);
}


void grbScanTimestep1(int streamID)
{
  static char func[] = "grbScanTimestep1";
  int *isec0, *isec1, *isec2, *isec3, *isec4;
  double fsec2[512], fsec3[2], *fsec4 = NULL;
  off_t recpos = 0;
  unsigned char *gribbuffer = NULL;
  long buffersize = 0;
  int iret = 0, ipunp = 0, iword = 0;
  int status;
  int fileID;
  int rcode = 0, level1 = 0, level2 = 0, vdate = 0, vtime = 0;
  DateTime datetime, datetime0;
  int tsID;
  int varID;
  size_t readsize;
  int nrecords, nrecs, recID;
  int prec;
  long recsize = 0;
  int warn_numavg = TRUE;
  int taxisID = -1;
  int rdate = 0, rtime = 0, tunit = 0, fcast = 0;
  TAXIS *taxis;
  int vlistID;
964
  int szip;
965
  long unzipsize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
966
  COMPVAR compVar, compVar0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
967
968
969
  STREAM *streamptr;

  streamptr = stream_to_pointer(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
970

Uwe Schulzweida's avatar
Uwe Schulzweida committed
971
  stream_check_ptr(func, streamptr);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
972

Uwe Schulzweida's avatar
Uwe Schulzweida committed
973
  streamptr->curTsID = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
974

Uwe Schulzweida's avatar
Uwe Schulzweida committed
975
976
977
978
979
  isec0 = streamptr->record->sec0;
  isec1 = streamptr->record->sec1;
  isec2 = streamptr->record->sec2;
  isec3 = streamptr->record->sec3;
  isec4 = streamptr->record->sec4;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
980
981

  tsID  = tstepsNewEntry(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
982
  taxis = &streamptr->tsteps[tsID].taxis;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
983
984
985
986
987
988
989
990
991
992
993
994
995
996

  if ( tsID != 0 )
    Error(func, "Internal problem! tstepsNewEntry returns %d", tsID);

  fileID = streamInqFileID(streamID);

  nrecs = 0;
  while ( TRUE )
    {
      recsize = gribGetSize(fileID);
      recpos  = fileGetPos(fileID);

      if ( recsize == 0 )
	{
Uwe Schulzweida's avatar
Uwe Schulzweida committed
997
	  streamptr->ntsteps = 1;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
	  break;
	}
      if ( recsize > buffersize )
	{
	  buffersize = recsize;
	  gribbuffer = (unsigned char *) realloc(gribbuffer, buffersize);
	}

      readsize = recsize;
      status = gribRead(fileID, gribbuffer, &readsize);
      if ( status ) break;

1010
      szip = FALSE;
1011
1012
      if ( gribGetZip(recsize, gribbuffer, &unzipsize) > 0 )
	{
1013
	  szip = TRUE;
1014
1015
1016
1017
1018
1019
1020
1021
	  unzipsize += 100; /* need 0 to 1 bytes for rounding of bds */
	  if ( (long) buffersize < unzipsize )
	    {
	      buffersize = unzipsize;
	      gribbuffer = (unsigned char *) realloc(gribbuffer, buffersize);
	    }
	}

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1022
1023
1024
1025
1026
1027
1028
1029
      gribExDP(isec0, isec1, isec2, fsec2, isec3, fsec3, isec4, fsec4,
	       ipunp, (int *) gribbuffer, recsize, &iword, "J", &iret);

      rcode    = ISEC1_Parameter;
      level1   = ISEC1_Level1;
      level2   = ISEC1_Level2;
      if ( ISEC1_LevelType == 100 ) level1 *= 100;

1030
1031
1032
1033
      if ( ISEC4_NumBits > 0 && ISEC4_NumBits <= 32 )
	prec = ISEC4_NumBits;
      else
        prec = DATATYPE_PACK;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056

      gribDateTime(isec1, &vdate, &vtime);

      if ( nrecs == 0 )
	{
	  datetime0.date = vdate;
	  datetime0.time = vtime;
	  rdate = gribRefDate(isec1);
	  rtime = gribRefTime(isec1);
	  tunit = gribTimeUnit(isec1);
	  fcast = gribTimeIsFC(isec1);
	}
      else
	{
	  datetime.date  = vdate;
	  datetime.time  = vtime;
	  compVar.code   = rcode;
          compVar.table  = ISEC1_CodeTable;
          compVar.level1 = level1;
          compVar.level2 = level2;
          compVar.ltype  = ISEC1_LevelType;
	  for ( recID = 0; recID < nrecs; recID++ )
	    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1057
1058
1059
1060
1061
	      compVar0.code   = streamptr->tsteps[0].records[recID].code;
	      compVar0.table  = streamptr->tsteps[0].records[recID].table;
	      compVar0.level1 = streamptr->tsteps[0].records[recID].ilevel;
	      compVar0.level2 = streamptr->tsteps[0].records[recID].ilevel2;
	      compVar0.ltype  = streamptr->tsteps[0].records[recID].ltype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088

	      if ( memcmp(&compVar0, &compVar, sizeof(COMPVAR)) == 0 ) break;
	    }
	  if ( recID < nrecs ) break;
	  if ( memcmp(&datetime, &datetime0, sizeof(DateTime)) )
	    Warning(func, "Inconsistent verification time for code %d level %d", rcode, level1);
	}

      if ( ISEC1_AvgNum )
	{
	  if (  taxis->numavg && warn_numavg && (taxis->numavg != ISEC1_AvgNum) )
	    {
	      Message(func, "Change numavg from %d to %d not allowed!",
		      taxis->numavg, ISEC1_AvgNum);
	      warn_numavg = FALSE;
	    }
	  else
	    {
	      taxis->numavg = ISEC1_AvgNum;
	    }
	}

      nrecs++;

      if ( CDI_Debug )
	Message(func, "%4d %8d %4d  %8d %8d %6d", nrecs, (int)recpos, rcode, level1, vdate, vtime);

1089
      grbAddRecord(streamID, rcode, isec1, isec2, fsec2, isec4, recsize, recpos, prec, szip);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1090
1091
    }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1092
  streamptr->rtsteps = 1;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1093
1094
1095
1096
1097

  cdiGenVars(streamID);

  if ( fcast )
    {
1098
      taxisID = taxisCreate(TAXIS_RELATIVE);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1099
1100
1101
1102
1103
1104
1105
      taxis->type  = TAXIS_RELATIVE;
      taxis->rdate = rdate;
      taxis->rtime = rtime;
      taxis->unit  = tunit;
    }
  else
    {
1106
      taxisID = taxisCreate(TAXIS_ABSOLUTE);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1107
1108
1109
1110
1111
1112
1113
1114
1115
      taxis->type  = TAXIS_ABSOLUTE;
    }

  taxis->vdate = datetime0.date;
  taxis->vtime = datetime0.time;

  vlistID = streamInqVlist(streamID);
  vlistDefTaxis(vlistID, taxisID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1116
1117
  nrecords = streamptr->tsteps[0].nallrecs;
  if ( nrecords < streamptr->tsteps[0].recordSize )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1118
    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1119
1120
1121
      streamptr->tsteps[0].recordSize = nrecords;
      streamptr->tsteps[0].records =
      (RECORD *) realloc(streamptr->tsteps[0].records, nrecords*sizeof(RECORD));
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1122
1123
    }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1124
1125
  streamptr->tsteps[0].recIDs = (int *) malloc(nrecords*sizeof(int));
  streamptr->tsteps[0].nrecs = nrecords;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1126
  for ( recID = 0; recID < nrecords; recID++ )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1127
    streamptr->tsteps[0].recIDs[recID] = recID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1128

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1129
1130
  streamptr->record->buffer     = gribbuffer;
  streamptr->record->buffersize = buffersize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1131

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1132
  if ( streamptr->ntsteps == -1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1133
1134
    {
      tsID = tstepsNewEntry(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1135
      if ( tsID != streamptr->rtsteps )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1136
1137
	Error(func, "Internal error. tsID = %d", tsID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1138
1139
      streamptr->tsteps[tsID-1].next   = TRUE;
      streamptr->tsteps[tsID].position = recpos;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1140
1141
    }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1142
  if ( streamptr->ntsteps == 1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1143
1144
1145
    {
      if ( taxis->vdate == 0 && taxis->vtime == 0 )
	{
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1146
1147
	  streamptr->ntsteps = 0;
	  for ( varID = 0; varID < streamptr->nvars; varID++ )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
	    {
	      vlistDefVarTime(vlistID, varID, TIME_CONSTANT);
	    }
	}
    }
}


int grbScanTimestep2(int streamID)
{
  static char func[] = "grbScanTimestep2";
  int *isec0, *isec1, *isec2, *isec3, *isec4;
  double fsec2[512], fsec3[2], *fsec4 = NULL;
  off_t recpos = 0;
  unsigned char *gribbuffer = NULL;
  long buffersize = 0;
  int iret = 0, ipunp = 0, iword = 0;
  int status;
  int fileID;
  int rcode = 0, level1 = 0, level2 = 0, vdate = 0, vtime = 0;
  int tsID;
  int varID, gridID;
  size_t readsize;
  int nrecords, nrecs, recID, rindex;
  long recsize = 0;
  int warn_numavg = TRUE;
  int taxisID = -1;
  int nextstep;
  TAXIS *taxis;
  int vlistID;
1178
  long unzipsize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1179
  COMPVAR compVar, compVar0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1180
  STREAM *streamptr;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1181

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1182
  streamptr = stream_to_pointer(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1183

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1184
  stream_check_ptr(func, streamptr);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1185

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1186
1187
1188
1189
1190
1191
1192
  streamptr->curTsID = 1;

  isec0 = streamptr->record->sec0;
  isec1 = streamptr->record->sec1;
  isec2 = streamptr->record->sec2;
  isec3 = streamptr->record->sec3;
  isec4 = streamptr->record->sec4;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1193
1194
1195
1196
1197

  fileID  = streamInqFileID(streamID);
  vlistID = streamInqVlist(streamID);
  taxisID = vlistInqTaxis(vlistID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1198
1199
  gribbuffer = (unsigned char *) streamptr->record->buffer;
  buffersize = streamptr->record->buffersize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1200
                                          
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1201
  tsID = streamptr->rtsteps;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1202
1203
1204
  if ( tsID != 1 )
    Error(func, "Internal problem! unexpeceted timestep %d", tsID+1);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1205
  taxis = &streamptr->tsteps[tsID].taxis;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1206

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1207
  fileSetPos(fileID, streamptr->tsteps[tsID].position, SEEK_SET);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1208
1209
1210

  cdiCreateRecords(streamID, tsID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1211
1212
1213
  nrecords = streamptr->tsteps[tsID].nallrecs;
  streamptr->tsteps[1].recIDs = (int *) malloc(nrecords*sizeof(int));
  streamptr->tsteps[1].nrecs = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1214
  for ( recID = 0; recID < nrecords; recID++ )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1215
    streamptr->tsteps[1].recIDs[recID] = -1;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1216
1217
1218
      
  for ( recID = 0; recID < nrecords; recID++ )
    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1219
1220
1221
1222
1223
      varID = streamptr->tsteps[0].records[recID].varID;
      streamptr->tsteps[tsID].records[recID].position = 
	streamptr->tsteps[0].records[recID].position;
      streamptr->tsteps[tsID].records[recID].size     = 
	streamptr->tsteps[0].records[recID].size;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1224
1225
1226
1227
1228
1229
1230
1231
    }

  for ( rindex = 0; rindex <= nrecords; rindex++ )
    {
      recsize = gribGetSize(fileID);
      recpos  = fileGetPos(fileID);
      if ( recsize == 0 )
	{
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1232
	  streamptr->ntsteps = 2;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1233
1234
1235
1236
1237
	  break;
	}
      if ( recsize > buffersize )
	{
	  buffersize = recsize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1238
	  gribbuffer = (unsigned char *) realloc(gribbuffer, (size_t)buffersize);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1239
1240
1241
1242
1243
1244
	}

      readsize = recsize;
      status = gribRead(fileID, gribbuffer, &readsize);
      if ( status ) break;

1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
      if ( gribGetZip(recsize, gribbuffer, &unzipsize) > 0 )
	{
	  unzipsize += 100; /* need 0 to 1 bytes for rounding of bds */
	  if ( (long) buffersize < unzipsize )
	    {
	      buffersize = unzipsize;
	      gribbuffer = (unsigned char *) realloc(gribbuffer, buffersize);
	    }
	}

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
      gribExDP(isec0, isec1, isec2, fsec2, isec3, fsec3, isec4, fsec4,
	       ipunp, (int *) gribbuffer, recsize, &iword, "J", &iret);

      rcode     = ISEC1_Parameter;
      level1    = ISEC1_Level1;
      level2    = ISEC1_Level2;
      if ( ISEC1_LevelType == 100 ) level1 *= 100;

      gribDateTime(isec1, &vdate, &vtime);

      if ( rindex == 0 )
	{
	  if ( taxisInqType(taxisID) == TAXIS_RELATIVE )
	    {
	      taxis->type  = TAXIS_RELATIVE;
	      taxis->rdate = gribRefDate(isec1);
	      taxis->rtime = gribRefTime(isec1);
	      taxis->unit  = gribTimeUnit(isec1);
	    }
	  else
	    {
	      taxis->type  = TAXIS_ABSOLUTE;
	    }
	  taxis->vdate = vdate;
	  taxis->vtime = vtime;
	}

      if ( ISEC1_AvgNum )
	{
	  if (  taxis->numavg && warn_numavg &&
		(taxis->numavg != ISEC1_AvgNum) )
	    {
	  /*
	      Message(func, "change numavg from %d to %d not allowed!",
		      taxis->numavg, ISEC1_AvgNum);
	  */
	      warn_numavg = FALSE;
	    }
	  else
	    {
	      taxis->numavg = ISEC1_AvgNum;
	    }
	}

      compVar.code   = rcode;
      compVar.table  = ISEC1_CodeTable;
      compVar.level1 = level1;
      compVar.level2 = level2;
      compVar.ltype  = ISEC1_LevelType;
      nextstep = FALSE;
      for ( recID = 0; recID < nrecords; recID++ )
	{
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1307
1308
1309
1310
1311
	  compVar0.code   = streamptr->tsteps[tsID].records[recID].code;
	  compVar0.table  = streamptr->tsteps[tsID].records[recID].table;
	  compVar0.level1 = streamptr->tsteps[tsID].records[recID].ilevel;
	  compVar0.level2 = streamptr->tsteps[tsID].records[recID].ilevel2;
	  compVar0.ltype  = streamptr->tsteps[tsID].records[recID].ltype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1312
1313
	  if ( memcmp(&compVar0, &compVar, sizeof(COMPVAR)) == 0 )
	    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1314
	      if ( streamptr->tsteps[tsID].records[recID].used )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1315
1316
1317
1318
1319
		{
		  nextstep = TRUE;
		}
	      else
		{
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1320
1321
		  streamptr->tsteps[tsID].records[recID].used = TRUE;
		  streamptr->tsteps[tsID].recIDs[rindex] = recID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
		}
	      break;
	    }
	}
      if ( recID == nrecords )
	{
	  Warning(func, "code %d level %d not found at timestep %d", rcode, level1, tsID+1);
	  return (CDI_EUFSTRUCT);
	}

      if ( nextstep ) break;

      if ( CDI_Debug )
	Message(func, "%4d %8d %4d %8d %8d %6d", rindex+1, (int)recpos, rcode, level1, vdate, vtime);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1337
      streamptr->tsteps[tsID].records[recID].size = recsize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1338

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1339
1340
1341
1342
1343
      compVar0.code   = streamptr->tsteps[tsID].records[recID].code;
      compVar0.table  = streamptr->tsteps[tsID].records[recID].table;
      compVar0.level1 = streamptr->tsteps[tsID].records[recID].ilevel;
      compVar0.level2 = streamptr->tsteps[tsID].records[recID].ilevel2;
      compVar0.ltype  = streamptr->tsteps[tsID].records[recID].ltype;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1344
1345
1346
1347
1348

      if ( memcmp(&compVar0, &compVar, sizeof(COMPVAR)) != 0 )
	{
	  Message(func, "tsID = %d recID = %d code = %3d new %3d  level = %3d new %3d",
		  tsID, recID,
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1349
1350
		  streamptr->tsteps[tsID].records[recID].code, rcode,
		  streamptr->tsteps[tsID].records[recID].ilevel, level1);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1351
1352
1353
	  return (CDI_EUFSTRUCT);
	}

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1354
1355
      streamptr->tsteps[1].records[recID].position = recpos;
      varID = streamptr->tsteps[tsID].records[recID].varID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1356
1357
1358
      gridID = vlistInqVarGrid(vlistID, varID);
      if ( gridInqSize(gridID) == 1 && gridInqType(gridID) == GRID_LONLAT )
	{
1359
1360
	  if ( !DBL_IS_EQUAL(gridInqXval(gridID, 0),ISEC2_FirstLon*0.001) ||
	       !DBL_IS_EQUAL(gridInqYval(gridID, 0),ISEC2_FirstLat*0.001) )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1361
1362
1363
1364
1365
1366
1367
	    gridChangeType(gridID, GRID_TRAJECTORY);
	}
    }

  nrecs = 0;
  for ( recID = 0; recID < nrecords; recID++ )
    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1368
      if ( ! streamptr->tsteps[tsID].records[recID].used )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1369
	{
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1370
	  varID = streamptr->tsteps[tsID].records[recID].varID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1371
1372
1373
1374
1375
1376
1377
	  vlistDefVarTime(vlistID, varID, TIME_CONSTANT);
	}
      else
	{
	  nrecs++;
	}
    }
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1378
  streamptr->tsteps[tsID].nrecs = nrecs;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1379

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1380
  streamptr->rtsteps = 2;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1381

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1382
  if ( streamptr->ntsteps == -1 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1383
1384
    {
      tsID = tstepsNewEntry(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1385
      if ( tsID != streamptr->rtsteps )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1386
1387
	Error(func, "Internal error. tsID = %d", tsID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1388
1389
      streamptr->tsteps[tsID-1].next   = TRUE;
      streamptr->tsteps[tsID].position = recpos;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1390
1391
    }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1392
1393
  streamptr->record->buffer     = gribbuffer;
  streamptr->record->buffersize = buffersize;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403

  return (0);
}


int grbInqContents(int streamID)
{
  static char func[] = "grbInqContents";
  int fileID;
  int status = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1404
1405
1406
  STREAM *streamptr;

  streamptr = stream_to_pointer(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1407

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1408
  stream_check_ptr(func, streamptr);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1409
1410
1411

  fileID = streamInqFileID(streamID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1412
  streamptr->curTsID = 0;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1413
1414
1415

  grbScanTimestep1(streamID);
 
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1416
  if ( streamptr->ntsteps == -1 ) status = grbScanTimestep2(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427

  fileSetPos(fileID, 0, SEEK_SET);

  return (status);
}


int grbInqTimestep(int streamID, int tsID)
{
  static char func[] = "grbInqTimestep";
  int ntsteps, nrecs;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1428
  STREAM *streamptr;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1429

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1430
  streamptr = stream_to_pointer(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1431

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1432
1433
1434
  stream_check_ptr(func, streamptr);

  if ( tsID == 0 && streamptr->rtsteps == 0 )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1435
1436
1437
    Error(func, "Call to cdiInqContents missing!");

  if ( CDI_Debug )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1438
    Message(func, "tsid = %d rtsteps = %d", tsID, streamptr->rtsteps);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1439
1440
  
  ntsteps = UNDEFID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1441
  while ( (tsID + 1) > streamptr->rtsteps && ntsteps == UNDEFID )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1442
1443
1444
1445
    {
      ntsteps = grbScanTimestep(streamID);
      if ( ntsteps == CDI_EUFSTRUCT )
	{
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1446
	  streamptr->ntsteps = streamptr->rtsteps;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1447
1448
1449
1450
	  break;
	}
    }

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1451
  if ( tsID >= streamptr->ntsteps && streamptr->ntsteps != CDI_UNDEFID )
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1452
1453
1454
1455
1456
    {
      nrecs = 0;
    }
  else
    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1457
1458
      streamptr->curTsID = tsID;
      nrecs = streamptr->tsteps[tsID].nrecs;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
    }

  return (nrecs);
}


void grbReadVarDP(int streamID, int varID, double *data, int *nmiss)
{
  static char func[] = "grbReadVarDP";
  int fileID;
  int levelID, nlevs, gridID, gridsize;
  unsigned char *gribbuffer;
  int tsID, recID;
  long recsize;
  off_t recpos, currentfilepos;
  int imiss;
  int vlistID;
1476
  int zip;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1477
1478
1479
  STREAM *streamptr;

  streamptr = stream_to_pointer(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1480

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1481
  stream_check_ptr(func, streamptr);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1482

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1483
  gribbuffer = (unsigned char *) streamptr->record->buffer;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1484
1485
1486

  vlistID  = streamInqVlist(streamID);
  fileID   = streamInqFileID(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1487
  tsID     = streamptr->curTsID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1488

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1489
  nlevs    = streamptr->vars[varID].nlevs;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
  gridID   = vlistInqVarGrid(vlistID, varID);
  gridsize = gridInqSize(gridID);

  if ( CDI_Debug )
    Message(func, "nlevs = %d gridID = %d gridsize = %d", nlevs, gridID, gridsize);

  currentfilepos = fileGetPos(fileID);

  *nmiss = 0;
  for ( levelID = 0; levelID < nlevs; levelID++ )
    {
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1501
1502
1503
      recID   = streamptr->vars[varID].level[levelID];
      recpos  = streamptr->tsteps[tsID].records[recID].position;
      recsize = streamptr->tsteps[tsID].records[recID].size;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1504
1505
1506
1507
1508

      fileSetPos(fileID, recpos, SEEK_SET);

      fileRead(fileID, gribbuffer, recsize);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1509
      grbDecodeDataDP(gribbuffer, recsize, &data[levelID*gridsize], gridsize, streamptr->unreduced, &imiss, &zip);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1510
1511

      *nmiss += imiss;
1512

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1513
      streamptr->tsteps[tsID].records[recID].zip = zip;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1514
1515
1516
1517
1518
    }

  fileSetPos(fileID, currentfilepos, SEEK_SET);
}

1519

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
void grbReadVarSliceDP(int streamID, int varID, int levelID, double *data, int *nmiss)
{
  static char func[] = "grbReadVarSliceDP";
  int fileID;
  int gridID, gridsize;
  unsigned char *gribbuffer;
  long recsize;
  off_t recpos, currentfilepos;
  int tsID, recID;
  int vlistID;
1530
  int zip;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1531
  STREAM *streamptr;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1532

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1533
  streamptr = stream_to_pointer(streamID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1534

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1535
1536
1537
  stream_check_ptr(func, streamptr);

  gribbuffer = (unsigned char *) streamptr->record->buffer;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1538
1539
1540
1541

  vlistID  = streamInqVlist(streamID);
  gridID   = vlistInqVarGrid(vlistID, varID);
  gridsize = gridInqSize(gridID);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1542
  tsID     = streamptr->curTsID;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1543
1544
1545
1546
1547
1548
1549
1550

  if ( CDI_Debug )
    Message(func, "gridID = %d gridsize = %d", gridID, gridsize);

  fileID = streamInqFileID(streamID);

  currentfilepos = fileGetPos(fileID);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1551
1552
1553
  recID   = streamptr->vars[varID].level[levelID];
  recpos  = streamptr->tsteps[tsID].records[recID].position;
  recsize = streamptr->tsteps[tsID].records[recID].size;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1554
1555
1556
1557
1558
1559
1560
1561
1562

  if ( recsize == 0 )
    Error(func, "Internal problem! Recordsize is zero for record %d at timestep %d",
	  recID+1, tsID+1);

  fileSetPos(fileID, recpos, SEEK_SET);

  fileRead(fileID, gribbuffer, recsize);

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1563
  grbDecodeDataDP(gribbuffer, recsize, data, gridsize, streamptr->unreduced, nmiss, &zip);
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1564
1565

  fileSetPos(fileID, currentfilepos, SEEK_SET);
1566

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1567
  streamptr->tsteps[tsID].records[recID].zip = zip;
Uwe Schulzweida's avatar
Uwe Schulzweida committed
1568
1569
}

1570

Uwe Schulzweida's avatar
Uwe Schulzweida committed
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
void grbDefInstitut(int *isec1, int center, int subcenter)
{
  ISEC1_CenterID    = center;
  ISEC1_SubCenterID = subcenter;
}


void grbDefModel(int *isec1, int model)
{
  ISEC1_ModelID = model;
}


void grbDefCode(int *isec1, int code, int codetable)
{
  ISEC1_CodeTable = codetable;
  if ( code < 0 ) code = -code;
  ISEC1_Parameter = code;
}


void grbDefTime(int *isec1, int date, int time, int numavg, int timeID)
{
  int year, month, day, hour, minute;
  int century = 0;
  int timetype = -1;

  if ( timeID != -1 ) timetype = taxisInqType(timeID);

  if ( timetype == TAXIS_RELATIVE )
    {
      sUnit tunit = {0, 1};
      int rdate, rtime;
      double value;
      
      rdate   = taxisInqRdate(timeID);
      rtime   = taxisInqRtime(timeID);
      year    =  rdate / 10000;
      month   = (rdate - year*10000) / 100;
      day     =  rdate - year*10000 -