source: lmdz_wrf/WRFV3/external/io_grib1/gribmap.c @ 13

Last change on this file since 13 was 1, checked in by lfita, 11 years ago
  • -- --- Opening of the WRF+LMDZ coupling repository --- -- -

WRF: version v3.3
LMDZ: version v1818

More details in:

File size: 13.5 KB
RevLine 
[1]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
14int findchar(char *line, char thechar);
15
16#ifdef TEST
17int 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
44int 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
260int 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
313int 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
345int 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
368int 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
381int 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
394int 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
414int 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
427Grib1_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
Note: See TracBrowser for help on using the repository browser.