external/io_grib1/gribmap.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include "gribmap.h"
   4
   5 /******************************************************************************
   6  *
   7  * The functions in this file are used for opening/reading, and searching for
   8  *   information in a grib table.
   9  *
  10  * All functions return 0 for success and 1 for failure, unless otherwise
  11  *   noted.
  12  *****************************************************************************/
  13
  14 int findchar(char *line, char thechar);
  15
  16 #ifdef TEST
  17 int main()
  18 {
  19   Grib1_Tables grib_tables;
  20   char filename[300];
  21   int parm_id;
  22   int ret;
  23   int tablenum;
  24   int center,subcenter,parmtbl;
  25
  26   strcpy(filename,"gribmap.txt");
  27   LOAD_GRIB1_TABLES(filename, &grib_tables, &ret);
  28
  29   GET_GRIB_PARAM (&grib_tables, "TSK", &center,&subcenter,&parmtbl,
  30                   &tablenum, &parm_id);
  31   fprintf(stderr,"got parm_id: %d center: %d subcenter: %d parmtbl: %d\n",
  32           parm_id,center,subcenter,parmtbl);
  33
  34 }
  35 #endif
  36
  37 /******************************************************************************
  38  *
  39  * read_gribmap - reads a gribmap file and puts the information into the
  40  *                 grib_table_info structure.
  41  *
  42  ******************************************************************************/
  43
  44 int READ_GRIBMAP (char *filename, Grib1_Tables *grib_tables, int *ret)
  45 {
  46
  47   FILE *mapptr;
  48   char line[MAX_LINE_CHARS];
  49   int dummy;
  50   int parmidx;
  51   int nxtidx, elemidx, charidx;
  52   char elems[6][MAX_LINE_CHARS];
  53   int tablenum;
  54
  55   /* Open parameter table file */
  56   mapptr = fopen(filename, "r");
  57   if (mapptr == NULL)
  58     {
  59       fprintf(stderr,"Could not open %s\n",filename);
  60       *ret=1;
  61       return 1;
  62     }
  63
  64   /* Skip over comments at begining of gribmap file */
  65   while (fgets(line,500,mapptr))
  66     {
  67       if (line[0] != '#') break;
  68     }
  69
  70   tablenum = 0;
  71   grib_tables->num_tables = 1;
  72   grib_tables->grib_table_info =
  73     (Grib1_Table_Info *)calloc(1,sizeof(Grib1_Table_Info));
  74
  75   if (grib_tables->grib_table_info == NULL)
  76     {
  77       fprintf(stderr,"Could not allocate space for grib_table_info\n");
  78       *ret = 1;
  79       return 1;
  80     }
  81   grib_tables->grib_table_info[tablenum].num_entries = 0;
  82
  83   sscanf(line,"%d:%d:%d:%d",&dummy,
  84          &(grib_tables->grib_table_info[tablenum].center),
  85          &(grib_tables->grib_table_info[tablenum].subcenter),
  86          &(grib_tables->grib_table_info[tablenum].parmtbl));
  87
  88   /*
  89    * Read each line of parameter table, and store information in the
  90    *   structure.
  91    */
  92   while (fgets(line,MAX_LINE_CHARS,mapptr) != NULL)
  93     {
  94       /* Split up the elements that are seperated by : */
  95       nxtidx = 0;
  96       elemidx = 0;
  97       while ((charidx = findchar(line + nxtidx,':')) >= 0)
  98         {
  99           strncpy(elems[elemidx],line + nxtidx,charidx);
 100           elems[elemidx][charidx] = '\0';
 101           elemidx++;
 102           nxtidx += (charidx + 1);
 103         }
 104
 105       parmidx = atoi(elems[0]);
 106
 107       /*
 108        * Check to see if this line specifies the next grib table.  If so,
 109        *   break out
 110        */
 111       if (parmidx == -1) {
 112         grib_tables->num_tables++;
 113         tablenum++;
 114         grib_tables->grib_table_info =
 115           (Grib1_Table_Info *)
 116           realloc(grib_tables->grib_table_info,
 117                   grib_tables->num_tables*sizeof(Grib1_Table_Info));
 118
 119         if (grib_tables->grib_table_info == NULL)
 120           {
 121             fprintf(stderr,
 122                     "Could not re-allocate space for grib_table_info\n");
 123             *ret = 1;
 124             return 1;
 125           }
 126         grib_tables->grib_table_info[tablenum].num_entries = 0;
 127         sscanf(line,"%d:%d:%d:%d",&dummy,
 128                &(grib_tables->grib_table_info[tablenum].center),
 129                &(grib_tables->grib_table_info[tablenum].subcenter),
 130                &(grib_tables->grib_table_info[tablenum].parmtbl));
 131         continue;
 132       }
 133
 134       /* Assure that we have not gone beyond 256 entries! */
 135       if (grib_tables->grib_table_info[tablenum].num_entries >= 256)
 136         {
 137           fprintf(stderr,
 138 "Error: Invalid number of lines in table %d in, \n skipping line: %s \n",
 139                   tablenum,line);
 140           break;
 141         }
 142
 143       /* Grab the last field */
 144       strcpy(elems[elemidx],line + nxtidx);
 145
 146       /* Split up comma-seperated field of wrf varnames */
 147       nxtidx = 0;
 148       elemidx = 0;
 149
 150       /* Allocate number of elements in wrf_param */
 151       grib_tables->grib_table_info[tablenum].wrf_param[parmidx] =
 152         (char **)malloc(1*sizeof(char *));
 153       if (grib_tables->grib_table_info[tablenum].wrf_param[parmidx] == NULL)
 154         {
 155           fprintf(stderr, "Error allocating space for wrf_param[%d], exiting\n",
 156                   parmidx);
 157           *ret = 1;
 158           return 1;
 159         }
 160
 161       while ((charidx = findchar(elems[3]+nxtidx,',')) >= 0)
 162         {
 163
 164           /* Allocate number of elements in wrf_param */
 165           grib_tables->grib_table_info[tablenum].wrf_param[parmidx] =
 166             (char **)
 167             realloc(grib_tables->grib_table_info[tablenum].wrf_param[parmidx],
 168                              (elemidx+2)*sizeof(char *));
 169           if (grib_tables->grib_table_info[tablenum].wrf_param[parmidx]
 170               == NULL)
 171             {
 172               perror("");
 173               fprintf(stderr,
 174                       "Error allocating space for wrf_param[%d], exiting\n",
 175                       parmidx);
 176               *ret = 1;
 177               return 1;
 178             }
 179
 180           grib_tables->grib_table_info[tablenum].wrf_param[parmidx][elemidx] =
 181             (char *)malloc((charidx+2)*sizeof(char));
 182           if (grib_tables->grib_table_info[tablenum].wrf_param[parmidx][elemidx]
 183               == NULL)
 184             {
 185               perror("");
 186               fprintf(stderr,
 187                       "Error allocating space for wrf_param[%d][%d], exiting\n",
 188                       parmidx,elemidx);
 189               *ret = 1;
 190               return 1;
 191             }
 192
 193           strncpy(grib_tables->grib_table_info[tablenum].wrf_param[parmidx][elemidx],
 194                   elems[3]+nxtidx,charidx);
 195           grib_tables->grib_table_info[tablenum].wrf_param[parmidx][elemidx][charidx] = '\0';
 196           elemidx++;
 197           nxtidx += (charidx + 1);
 198         }
 199
 200       /* Grab the last field */
 201       if (strlen(elems[3] + nxtidx) <= 0)
 202         {
 203           /* Case for no specified WRF fields */
 204           grib_tables->grib_table_info[tablenum].wrf_param[parmidx][elemidx] =
 205             (char *)malloc(1*sizeof(char));
 206           if (grib_tables->grib_table_info[tablenum].wrf_param[parmidx][elemidx]
 207               == NULL)
 208             {
 209               perror("");
 210               fprintf(stderr,
 211                       "Error allocating space for wrf_param[%d][%d], exiting\n",
 212                       parmidx,elemidx);
 213               *ret = 1;
 214               return 1;
 215             }
 216           grib_tables->grib_table_info[tablenum].wrf_param[parmidx][elemidx][0]
 217             = '\0';
 218           grib_tables->grib_table_info[tablenum].num_wrf_params[parmidx] = 0;
 219         }
 220       else
 221         {
 222           /* Allocate space for last element */
 223           grib_tables->grib_table_info[tablenum].wrf_param[parmidx][elemidx] =
 224             (char *)malloc((strlen(elems[3] + nxtidx)+1)*sizeof(char));
 225           if (grib_tables->grib_table_info[tablenum].wrf_param[parmidx][elemidx]
 226               == NULL)
 227             {
 228               perror("");
 229               fprintf(stderr,
 230                       "Error allocating space for wrf_param[%d][%d], exiting\n",
 231                       parmidx,elemidx);
 232               *ret = 1;
 233               return 1;
 234             }
 235
 236           strcpy(grib_tables->grib_table_info[tablenum].wrf_param[parmidx][elemidx],
 237                  elems[3] + nxtidx);
 238           grib_tables->grib_table_info[tablenum].num_wrf_params[parmidx] =
 239             elemidx + 1;
 240         }
 241
 242       grib_tables->grib_table_info[tablenum].parm_id[parmidx]=atoi(elems[0]);
 243       grib_tables->grib_table_info[tablenum].dec_sc_factor[parmidx]=atoi(elems[4]);
 244
 245       grib_tables->grib_table_info[tablenum].num_entries++;
 246     }
 247
 248   *ret=0;
 249   return 0;
 250 }
 251
 252 /******************************************************************************
 253  *
 254  * get_grib_param - searches through a grib_table_info structure and returns
 255  *                   the index for the input "varname".
 256  *
 257  * returns index number, or, -1 for failure.
 258  *****************************************************************************/
 259
 260 int GET_GRIB_PARAM (Grib1_Tables *grib_tables, char *varname, int *center,
 261                     int *subcenter, int *parmtbl, int *tablenum, int *index,
 262                     int strlen1, int strlen2)
 263 {
 264   int idx;
 265   int prm_idx;
 266   int tableidx;
 267   char varnametmp[200];
 268
 269   *index = -1;
 270
 271   strncpy(varnametmp,varname,strlen2);
 272   varnametmp[strlen2] = '\0';
 273   trim(varnametmp);
 274   for (tableidx = 0; tableidx < grib_tables->num_tables ;tableidx++)
 275     {
 276
 277
 278       for (idx = 0;
 279            idx < grib_tables->grib_table_info[tableidx].num_entries;
 280            idx++)
 281         {
 282           for (prm_idx = 0;
 283                prm_idx <
 284                  grib_tables->grib_table_info[tableidx].num_wrf_params[idx];
 285                prm_idx++)
 286             {
 287               if (strcmp(varnametmp,
 288                          grib_tables->grib_table_info[tableidx].wrf_param[idx][prm_idx])
 289                   == 0)
 290                 {
 291                   *center =
 292                     grib_tables->grib_table_info[tableidx].center;
 293                   *subcenter = grib_tables->grib_table_info[tableidx].subcenter;
 294                   *parmtbl = grib_tables->grib_table_info[tableidx].parmtbl;
 295                   *tablenum = tableidx;
 296                   *index = idx;
 297                   break;
 298                 }
 299             }
 300         }
 301
 302     }
 303   return *index;
 304 }
 305
 306 /******************************************************************************
 307  *
 308  * free_gribmap_ - returns the size (in bytes) of a grib_table_info
 309  *                         structure.
 310  *
 311  *****************************************************************************/
 312
 313 int FREE_GRIBMAP(Grib1_Tables *grib_tables)
 314 {
 315   int idx, idx2;
 316   int tablenum;
 317
 318   for (tablenum = 0; tablenum < grib_tables->num_tables; tablenum++)
 319     {
 320       for (idx = 0; idx < grib_tables->grib_table_info[tablenum].num_entries;
 321            idx++)
 322         {
 323           for (idx2 = 0;
 324                idx2 < grib_tables->grib_table_info[tablenum].num_wrf_params[idx];
 325                idx2++)
 326             {
 327               free(grib_tables->grib_table_info[tablenum].wrf_param[idx][idx2]);
 328             }
 329           if (grib_tables->grib_table_info[tablenum].num_wrf_params[idx] > 0)
 330             {
 331               free(grib_tables->grib_table_info[tablenum].wrf_param[idx]);
 332             }
 333         }
 334     }
 335   free(grib_tables->grib_table_info);
 336   return 0;
 337 }
 338
 339 /******************************************************************************
 340  *
 341  * Return the character index of the first instance of "thechar" in a string.
 342  *
 343  ******************************************************************************/
 344
 345 int findchar(char *line, char thechar)
 346 {
 347   int returnidx, charnum;
 348
 349   returnidx = -1;
 350   for (charnum = 0; charnum < strlen(line); charnum++)
 351     {
 352       if (line[charnum] == thechar)
 353         {
 354           returnidx = charnum;
 355           break;
 356         }
 357     }
 358   return returnidx;
 359 }
 360
 361 /******************************************************************************
 362  *
 363  * get_grib1_table_info_size - returns the size (in bytes) of a grib_table_info
 364  *                         structure.
 365  *
 366  *****************************************************************************/
 367
 368 int GET_GRIB1_TABLE_INFO_SIZE (int *size)
 369 {
 370   *size = sizeof(Grib1_Table_Info);
 371   return *size;
 372 }
 373
 374 /******************************************************************************
 375  *
 376  * get_grib1_tables_size - returns the size (in bytes) of a grib_tables
 377  *                         structure.
 378  *
 379  *****************************************************************************/
 380
 381 int GET_GRIB1_TABLES_SIZE (int *size)
 382 {
 383   *size = sizeof(Grib1_Tables);
 384   return *size;
 385 }
 386
 387 /******************************************************************************
 388  *
 389  * load_grib1_table_info - reads a gribmap file and puts the information into
 390  *                         the grib_table_info structure.
 391  *
 392  ******************************************************************************/
 393
 394 int LOAD_GRIB1_TABLES (char filename[],
 395                        Grib1_Tables *grib_tables, int *ret, int strlen1)
 396 {
 397
 398   char tmpfilename[300];
 399   strncpy(tmpfilename,filename,strlen1);
 400   tmpfilename[strlen1] = '\0';
 401
 402   READ_GRIBMAP(tmpfilename, grib_tables, ret);
 403
 404   return *ret;
 405 }
 406
 407 /******************************************************************************
 408  *
 409  * get_grid_info_size_ - returns the size (in bytes) of a grib_tables
 410  *                         structure.
 411  *
 412  *****************************************************************************/
 413
 414 int GET_GRID_INFO_SIZE (int *size)
 415 {
 416   *size = sizeof(Grib1_Tables);
 417   return *size;
 418 }
 419
 420
 421 /******************************************************************************
 422  *
 423  * copy_grib_tables - allocates and fills a grib_tables structure
 424  *
 425  *****************************************************************************/
 426
 427 Grib1_Tables *copy_grib_tables(Grib1_Tables *grib_tables)
 428 {
 429   int tblidx,prmidx,elmidx;
 430   int strsiz;
 431
 432   Grib1_Tables *tmp;
 433
 434   tmp = (Grib1_Tables *)malloc(sizeof(Grib1_Tables));
 435
 436   memcpy(tmp,grib_tables,sizeof(Grib1_Tables));
 437
 438   /* Now do the grib_table_info elements within grib_tables */
 439
 440   tmp->grib_table_info =
 441     (Grib1_Table_Info *)
 442     malloc(grib_tables->num_tables*sizeof(Grib1_Table_Info));
 443   if (tmp->grib_table_info == NULL)
 444     {
 445       fprintf(stderr,
 446               "copy_grib_tables: Could not allocate space for grib_table_info.  num_tables: %d\n",
 447               grib_tables->num_tables);
 448       exit(1);
 449     }
 450
 451   memcpy(tmp->grib_table_info,
 452          grib_tables->grib_table_info,
 453          grib_tables->num_tables*sizeof(Grib1_Table_Info));
 454
 455
 456   for (tblidx = 0; tblidx < grib_tables->num_tables; tblidx++)
 457     {
 458
 459       for (prmidx = 0; prmidx < MAX_PARAMS; prmidx++)
 460         {
 461           if (grib_tables->grib_table_info[tblidx].num_wrf_params[prmidx] <= 0)
 462             {
 463               continue;
 464             }
 465
 466           tmp->grib_table_info[tblidx].wrf_param[prmidx] = (char **)
 467             malloc(grib_tables->grib_table_info[tblidx].num_wrf_params[prmidx]
 468                    * sizeof(char *));
 469
 470           memcpy(tmp->grib_table_info[tblidx].wrf_param[prmidx],
 471                  grib_tables->grib_table_info[tblidx].wrf_param[prmidx],
 472                  grib_tables->grib_table_info[tblidx].num_wrf_params[prmidx]
 473                  * sizeof(char *));
 474
 475           for (elmidx = 0;
 476                elmidx < grib_tables->grib_table_info[tblidx].num_wrf_params[prmidx];
 477                elmidx++)
 478             {
 479
 480               strsiz =
 481                 strlen(grib_tables->grib_table_info[tblidx].wrf_param[prmidx][elmidx]) + 1;
 482               tmp->grib_table_info[tblidx].wrf_param[prmidx][elmidx] =
 483                 (char *)
 484                 malloc(strsiz * sizeof(char));
 485
 486               memcpy(tmp->grib_table_info[tblidx].wrf_param[prmidx][elmidx],
 487                      grib_tables->grib_table_info[tblidx].wrf_param[prmidx][elmidx],
 488                      strsiz * sizeof(char));
 489
 490             }
 491
 492         }
 493
 494     }
 495
 496   return tmp;
 497
 498 }
 499