gribmap.c

References to this file elsewhere.
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