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", ¢er,&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