Everglades Landscape Model (ELM) Home Page
Main Page | Data Structures | Directories | File List | Data Fields | Globals

grid_io.h File Reference

Header file for grid_io utility functions. More...

#include "stdlib.h"
#include "stdio.h"

Include dependency graph for grid_io.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Data Structures

struct  GR_HEADER
struct  GR_CONFIG
struct  GRID
struct  GR_FORTRAN_FILE_STRUC

Defines

#define MAX_GRID_ROWS   66
#define GRID_TITLE_LENGTH   80
#define GRID_TAG_LENGTH   80

Typedefs

typedef GR_FORTRAN_FILE_STRUC GR_FORTRAN_FILE

Functions

int grid_write_header (FILE *file, GRID *grid)
 UNUSED: writes the grid definition header to a file.
int grid_read_header (FILE *file, GRID *grid)
 reads grid definition information from a file
int grid_write (FILE *file, GRID *grid, char *tag, float *values)
 UNUSED writes a ``snapshot'' of areal data (defined by grid) to a binary file.
int grid_read (FILE *file, GRID *grid, char *tag, float *values)
 reads a snapshot of areal data
int grid_skip (FILE *file, GRID *grid, int num)
 This routine will move the file pointer the specified number of records.
int grid_tag_search (FILE *file, GRID *grid, char *string)
int grid_top (FILE *file, GRID *grid)
 This routine places the file pointer before the first data record in the file.
int grid_bottom (FILE *file, GRID *grid)
 UNUSED. This routine moves the file pointer to just before the final data record in the file.
int grid_count_snapshots (FILE *file, GRID *grid)
 UNUSED. This routine returns the num of snapshots in the given gridio binaryfile.
int grid_free (GRID *grid)
 UNUSED. free up memory allocated for grid header.


Detailed Description

Header file for grid_io utility functions.

This defines or declares variables & functions that are global to grid_io.c.

Note: documented with Doxygen, which expects specific syntax within special comments.

The Everglades Landscape Model (ELM).
last updated: Jan 2005

Definition in file grid_io.h.


Define Documentation

#define MAX_GRID_ROWS   66
 

maximum number of data array rows

Definition at line 54 of file grid_io.h.

Referenced by setgrid_().

#define GRID_TITLE_LENGTH   80
 

maximum string length of grid_io header title

Definition at line 57 of file grid_io.h.

Referenced by getgrid_(), grid_write_header(), and setgrid_().

#define GRID_TAG_LENGTH   80
 

the length of the tag identifying a grid-data snapshot

Definition at line 58 of file grid_io.h.

Referenced by gread_(), grid_read(), grid_skip(), grid_write(), and gwrite_().


Typedef Documentation

typedef struct GR_FORTRAN_FILE_STRUC GR_FORTRAN_FILE
 

Definition at line 88 of file grid_io.h.

Referenced by closefilef77_(), getfilep_(), and openfilef77_().


Function Documentation

int grid_write_header FILE *  file,
GRID grid
 

UNUSED: writes the grid definition header to a file.

Definition at line 146 of file grid_io.c.

References GRID::config, GR_CONFIG::cum_node_count, Flip_float_ip, Flip_int32, Flip_int32_ip, grid_io_fatal(), GRID_TITLE_LENGTH, GRID::header, GR_HEADER::number_of_nodes, GR_HEADER::number_of_rows, GR_HEADER::size, GR_HEADER::title, GR_HEADER::x, GR_CONFIG::xend, GR_CONFIG::xstart, and GR_HEADER::y.

Referenced by gridwhd_().

00147 {
00148   int array_size, errs;
00149   int *tmp_xstart, *tmp_xend, *tmp_cum_node_count;
00150   errs = 0;
00151   tmp_xstart = grid->config.xstart;
00152   tmp_xend = grid->config.xend;
00153   tmp_cum_node_count = grid->config.cum_node_count;
00154 
00155   {
00156     GR_HEADER tmpHeader;
00157     strncpy(tmpHeader.title, grid->header.title, GRID_TITLE_LENGTH);
00158     tmpHeader.number_of_rows = Flip_int32(grid->header.number_of_rows);
00159     tmpHeader.number_of_nodes = Flip_int32(grid->header.number_of_nodes);
00160     tmpHeader.size.x =  grid->header.size.x;
00161     Flip_float_ip(&(tmpHeader.size.x));
00162     tmpHeader.size.y =  grid->header.size.y;
00163     Flip_float_ip(&(tmpHeader.size.y));
00164     if (fwrite(&tmpHeader, sizeof(GR_HEADER), 1, file) == 0) 
00165       ++errs;
00166   }
00167 
00168   if (grid->header.number_of_rows < MAX_GRID_ROWS)
00169     array_size = MAX_GRID_ROWS;
00170   else
00171     array_size = grid->header.number_of_rows;
00172 
00173 #ifdef i386
00174   {
00175     int i;
00176     tmp_xstart =  (int *) malloc(array_size * sizeof(int));
00177     memcpy(tmp_xstart, grid->config.xstart, array_size * sizeof(int));
00178 
00179     tmp_xend =  (int *) malloc(array_size * sizeof(int));
00180     memcpy(tmp_xend, grid->config.xend, array_size * sizeof(int));
00181 
00182     tmp_cum_node_count =  (int *) malloc(array_size * sizeof(int));
00183     memcpy(tmp_cum_node_count, grid->config.cum_node_count, array_size * sizeof(int));
00184 
00185     for (i=0; i<array_size; ++i) {
00186       Flip_int32_ip(tmp_xstart+i);
00187       Flip_int32_ip(tmp_xend+i);
00188       Flip_int32_ip(tmp_cum_node_count+i);
00189     }
00190   }
00191 #endif
00192   if (fwrite(tmp_xstart, sizeof(int), array_size, file) == 0)
00193     ++errs;
00194   if (fwrite(tmp_xend, sizeof(int), array_size, file) == 0)
00195     ++errs;
00196   if (fwrite(tmp_cum_node_count, sizeof(int), array_size, file) == 0)
00197     ++errs;
00198 
00199   if (errs)
00200     grid_io_fatal("write_grid_header", "Unable to write file header\n");
00201 
00202 #ifdef i386
00203   free(tmp_xstart); free(tmp_xend); free(tmp_cum_node_count);
00204 #endif
00205   
00206   return (0);
00207 }

Here is the call graph for this function:

int grid_read_header FILE *  file,
GRID grid
 

reads grid definition information from a file

Parameters:
file The data file
grid The struct containing grid_io info
Returns:
errs level of success

Definition at line 235 of file grid_io.c.

References GRID::config, GR_CONFIG::cum_node_count, Flip_float_ip, Flip_int32_ip, grid_io_fatal(), GRID::header, GR_HEADER::number_of_nodes, GR_HEADER::number_of_rows, GR_HEADER::size, GR_HEADER::x, GR_CONFIG::xend, GR_CONFIG::xstart, and GR_HEADER::y.

Referenced by grid_top(), gridrhd_(), initDataStruct(), and processData().

00236 {
00237   int errs = 0, num_read, array_size;
00238 
00239   if ((num_read = fread(&grid->header, sizeof(GR_HEADER), 1, file)) == 0) {
00240     if (feof(file))
00241       errs = -1;
00242     else 
00243       grid_io_fatal("read_grid_header", "Unable to read header from file\n");
00244   }
00245   Flip_int32_ip(&(grid->header.number_of_rows));
00246   Flip_int32_ip(&(grid->header.number_of_nodes));
00247   Flip_float_ip(&(grid->header.size.x));
00248   Flip_float_ip(&(grid->header.size.y));
00249 
00250   if (grid->header.number_of_rows < MAX_GRID_ROWS)
00251     array_size = MAX_GRID_ROWS;
00252   else
00253     array_size = grid->header.number_of_rows;
00254 
00255   /* allocate space for configuration arrays */
00256   grid->config.xstart = (int *) malloc(array_size * sizeof(int));
00257 
00258   grid->config.xend = (int *) malloc(array_size * sizeof(int));
00259 
00260   grid->config.cum_node_count = (int *) malloc(array_size * sizeof(int));
00261 
00262   if ((num_read = fread(grid->config.xstart, sizeof(int), array_size, file)) == 0) {
00263     if (feof(file))
00264       errs = -1;
00265     else 
00266       grid_io_fatal("read_grid_header", "Unable to read header from file\n");
00267   }
00268 
00269   if ((num_read = fread(grid->config.xend, sizeof(int), array_size, file)) == 0) {
00270     if (feof(file))
00271       errs = -1;
00272     else
00273       grid_io_fatal("read_grid_header", "Unable to read header from file\n");
00274   }
00275 
00276   if ((num_read = fread(grid->config.cum_node_count, sizeof(int), array_size, file)) == 0) {
00277     if (feof(file))
00278       errs = -1;
00279     else
00280       grid_io_fatal("read_grid_header", "Unable to read header from file\n");
00281   }
00282   
00283 #ifdef i386
00284   {
00285     int i;
00286     for (i=0; i<array_size; ++i) {
00287       Flip_int32_ip(grid->config.xstart+i);
00288       Flip_int32_ip(grid->config.xend+i);
00289       Flip_int32_ip(grid->config.cum_node_count+i);
00290     }
00291   }
00292 #endif
00293   return(errs);
00294 }

Here is the call graph for this function:

int grid_write FILE *  file,
GRID grid,
char *  tag,
float *  values
 

UNUSED writes a ``snapshot'' of areal data (defined by grid) to a binary file.

Definition at line 317 of file grid_io.c.

References Flip_float_ip, grid_io_fatal(), GRID_TAG_LENGTH, GRID::header, and GR_HEADER::number_of_nodes.

Referenced by gwrite_().

00318 {
00319   char *char_ptr;
00320   int written, errs = 0;
00321   float *tmp_values = values;
00322 
00323   if ((written = fwrite(tag, sizeof(char), GRID_TAG_LENGTH, file)) == 0)
00324     grid_io_fatal("grid_write", "Unable to write grid tag\n");
00325   if (written < GRID_TAG_LENGTH) errs++;
00326 #ifdef i386
00327   {
00328     int i;
00329     tmp_values = (float *) malloc(grid->header.number_of_nodes * sizeof(float));
00330     memcpy(tmp_values, values, grid->header.number_of_nodes * sizeof(float));
00331     for (i=0; i<grid->header.number_of_nodes; ++i) {
00332       Flip_float_ip(tmp_values+i);
00333     }
00334   }
00335 #endif
00336     if ((written = fwrite(tmp_values, sizeof(float), grid->header.number_of_nodes, file)) == 0)
00337       grid_io_fatal("grid_write", "Unable to write grid data\n");
00338 
00339   if (written < grid->header.number_of_nodes) errs++;
00340 #ifdef i386
00341   free (tmp_values);
00342 #endif
00343   return(errs);
00344 
00345 }

Here is the call graph for this function:

int grid_read FILE *  file,
GRID grid,
char *  tag,
float *  values
 

reads a snapshot of areal data

Parameters:
file The data file
grid The struct containing grid_io info
tag the special grid tag identifier
values data values
Returns:
errs level of success

Definition at line 374 of file grid_io.c.

References Flip_float_ip, grid_io_fatal(), GRID_TAG_LENGTH, GRID::header, and GR_HEADER::number_of_nodes.

Referenced by gread_(), grid_count_snapshots(), initDataStruct(), and processData().

00375 {
00376   int num_read, errs = 0;
00377 
00378   /* read the tag */
00379   if ((num_read = fread(tag, sizeof(char), GRID_TAG_LENGTH, file)) == 0) {
00380     if (feof(file))
00381       return (-1);
00382     else
00383       grid_io_fatal("grid_read", "Uable to read grid tag\n");
00384   }
00385   if (num_read != GRID_TAG_LENGTH) errs++;
00386 
00387   /* read the values */
00388   if ((num_read = fread(values, sizeof(float), grid->header.number_of_nodes, file)) == 0) 
00389     grid_io_fatal("grid_read", "Unable to read data\n");
00390 #ifdef i386
00391   {
00392     int i;
00393     for (i=0; i<grid->header.number_of_nodes; ++i) {
00394       Flip_float_ip(values+i);
00395     }
00396   }
00397 #endif
00398   if (num_read != grid->header.number_of_nodes) errs++;
00399   return (errs);
00400 }

Here is the call graph for this function:

int grid_skip FILE *  file,
GRID grid,
int  count
 

This routine will move the file pointer the specified number of records.

Parameters:
file The data file
grid The struct containing grid_io info
count count
Returns:
errs level of success

Definition at line 427 of file grid_io.c.

References grid_bottom(), GRID_TAG_LENGTH, grid_top(), GRID::header, GR_HEADER::number_of_nodes, and GR_HEADER::number_of_rows.

Referenced by grid_bottom(), gridskp_(), initDataStruct(), and processData().

00428 {
00429   int header_size, array_size;
00430   int errs = 0;
00431   long int rec_len =  GRID_TAG_LENGTH*sizeof(char) +
00432     grid->header.number_of_nodes*sizeof(float);
00433   long int end, current;
00434 
00435   if (count < 0) {
00436     if (grid->header.number_of_rows < MAX_GRID_ROWS)
00437       array_size = MAX_GRID_ROWS;
00438     else
00439       array_size = grid->header.number_of_rows;
00440     header_size = sizeof(GRID) + 3 * sizeof(int) * array_size;
00441     if (ftell(file) <  header_size + abs(count)*rec_len)
00442       errs = grid_top(file, grid);
00443     else
00444       fseek(file, count*rec_len, 1);
00445   } else if (count > 0) {
00446     current = ftell(file);
00447     fseek(file, 0, 2);
00448     end = ftell(file);
00449     if ((end - current)/rec_len < count)
00450       errs = grid_bottom(file, grid);
00451     else 
00452       errs = fseek(file, (long)(current + count*rec_len), 0);
00453   }
00454   
00455   return(errs);
00456 }

Here is the call graph for this function:

int grid_tag_search FILE *  file,
GRID grid,
char *  string
 

int grid_top FILE *  file,
GRID grid
 

This routine places the file pointer before the first data record in the file.

Parameters:
file The data file
grid The struct containing grid_io info
Returns:
errs level of success

Definition at line 481 of file grid_io.c.

References grid_read_header().

Referenced by grid_count_snapshots(), and grid_skip().

00482 {
00483   fseek(file, 0L, 0);
00484   return(grid_read_header(file, grid));
00485 }

Here is the call graph for this function:

int grid_bottom FILE *  file,
GRID grid
 

UNUSED. This routine moves the file pointer to just before the final data record in the file.

While this is currently UNUSED, it could be useful in future.

Parameters:
file The data file
grid The struct containing grid_io info
Returns:
errs level of success

Definition at line 498 of file grid_io.c.

References grid_skip().

Referenced by grid_skip().

00499 {
00500   fseek(file, 0L, 2);
00501   return(grid_skip(file, grid, -1));
00502 }

Here is the call graph for this function:

int grid_count_snapshots FILE *  file,
GRID grid
 

UNUSED. This routine returns the num of snapshots in the given gridio binaryfile.

While this is currently UNUSED, it could be useful in future.

Parameters:
file The data file
grid The struct containing grid_io info
Returns:
i count

Definition at line 517 of file grid_io.c.

References grid_read(), grid_top(), GRID::header, and GR_HEADER::number_of_nodes.

00517                                                  {
00518   int i = 0;
00519   char tag[GRID_TAG_LENGTH];
00520   float *data = (float *)malloc(grid->header.number_of_nodes*sizeof(float));
00521 
00522   grid_top(file, grid);
00523   while (grid_read(file, grid, tag, data) == 0)
00524     i++;
00525   free(data);
00526   grid_top(file, grid);
00527   return(i);
00528 }

Here is the call graph for this function:

int grid_free GRID grid  ) 
 

UNUSED. free up memory allocated for grid header.

While this is currently UNUSED, it could be useful in future.

Parameters:
grid The struct containing grid_io info
Returns:
errs level of success

Definition at line 703 of file grid_io.c.

References GRID::config, GR_CONFIG::cum_node_count, GR_CONFIG::xend, and GR_CONFIG::xstart.

00704 {
00705   int errs = 0;
00706 
00707   free(grid->config.xstart);
00708   free(grid->config.xend);
00709   free(grid->config.cum_node_count);
00710 
00711   return(errs);
00712 }


Generated on Thu Jul 6 11:19:23 2006 for ELM source code by  doxygen 1.3.9.1