grid_io.c File Reference

Read and write grid data for the SFWMD's SFWMM (ELM boundary conditions). More...

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdarg.h>
#include <stdlib.h>
#include "grid_io.h"

Include dependency graph for grid_io.c:

Go to the source code of this file.

Defines
#define	GCC_COMPILER   1
#define	TOO_MANY_NODES   10000
#define	TRUE   1
#define	FALSE   0
#define	Flip_int16(type)   (type)
#define	Flip_int16_ip(type)   (*(type))
#define	Flip_int32(type)   (type)
#define	Flip_int32_ip(type)   (*(type))
#define	Flip_float_ip(type)   (*(type))
Functions
void	grid_io_fatal (char *name, char *message)
	prints fatal error messages.
void	F77_to_C_string (char *dest, char *src, int length)
	UNUSED converts fortran style strings to C style strings.
void	C_to_F77_string (char *dest, char *src, int length)
	UNUSED converts C style strings to Fortran style.
int	openfilef77_ (int *unit, char *filename, char *access, int filename_len, int access_len)
	UNUSED fortran stuff.
int	closefilef77_ (int *unit)
	UNUSED fortran stuff.
FILE *	getfilep_ (int *unit)
	UNUSED fortran stuff.
int	grid_write_header (FILE *file, GRID *grid)
	UNUSED: writes the grid definition header to a file.
void	gridwhd_ (int *fd, int *errs)
	UNUSED: Fortran interface to the grid_write_header.
int	grid_read_header (FILE *file, GRID *grid)
	reads grid definition information from a file
void	gridrhd_ (int *fd, int *errs)
	UNUSED Fortran interface to the grid_read_header routine.
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.
void	gwrite_ (int *fd, char *tag, float *values, int *errs, int tag_len)
	UNUSED Fortran interface to the grid_write routine.
int	grid_read (FILE *file, GRID *grid, char *tag, float *values)
	reads a snapshot of areal data
void	gread_ (int *fd, char *tag, float *values, int *errs, int tag_len)
	UNUSED Fortran interface to the grid_read routine.
int	grid_skip (FILE *file, GRID *grid, int count)
	This routine will move the file pointer the specified number of records.
void	gridskp_ (int *fd, int *cnt, int *errs)
	UNUSED Fortran interface to the grid_skip routine.
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.
char *	strsed (register char *string, register char *pattern, int *range)
	UNUSED.
int	grid_node (GRID *grid, int row, int column)
	UNUSED. This routine returns the array index of the node cooresponding to the row and column number passed.
void	setgrid_ (char *title, int *nrows, int *nnodes, float *xsize, float *ysize, int *xstart, int *xend, int *cum_count, int title_len)
	UNUSED Fortran call to set internal grid definition record.
void	getgrid_ (char *title, int *nrows, int *nnodes, float *xsize, float *ysize, int *xstart, int *xend, int *cum_count, int title_len)
	UNUSED Fortran call to get internal grid definition record.
int	grid_free (GRID *grid)
	UNUSED. free up memory allocated for grid header.
Variables
GR_FORTRAN_FILE *	gr_fortran_file_list = 0

---

Detailed Description

Read and write grid data for the SFWMD's SFWMM (ELM boundary conditions).

Non-native code for ELM, developed elsewhere in South Florida Water Management District (SFWMD). This source contains routines to read and write the grid for the South Florida Water Managment Model (SFWMM) and other SFWMD-generated models (e.g. Natural System Model, NSM) and data-sets that use "grid_io" as a binary spatial data managment system.

The grid_io data used by ELM can (does, in ELMv2.3) include rainfall and potential evapotranspiration boundary-condition (ELM domain-wide) inputs that are shared by ELM and SFWMM/NSM, and stage/depth outputs from the SFWMM (or NSM) that are used as boundary-condition (edge of ELM domain) inputs to ELM.

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

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

Remarks:

The only changes ("ELMchange" tag) needed for the portable-platform-ELM involved incorporation of byte-swapping routines for little/big endian- based processor chips (and include diff standard lib for newer compiler). We didn't put much effort into documenting this external code, and (TODO) should get around to cleaning up the unused code etc.

Note:

The native ELM code (i.e., the Spatial Modeling Environment, SME) has binary data I/O functions at a low level that do not require the byte-swapping switches that were put into this grid_io code.

Definition in file grid_io.c.

---

Define Documentation

#define GCC_COMPILER   1

Definition at line 80 of file grid_io.c.

#define TOO_MANY_NODES   10000

Definition at line 90 of file grid_io.c.

#define TRUE   1

Definition at line 92 of file grid_io.c.

#define FALSE   0

Definition at line 93 of file grid_io.c.

#define Flip_int16

(

type

)

(type)

Remarks:

Byte-swapping background.
"Little Endian" means that the low-order byte of the number is stored in memory at the lowest address, and the high-order byte at the highest address. (The little end comes first.) For example, a 4 byte LongInt
Byte3 Byte2 Byte1 Byte0
will be arranged in memory as follows:

• Base Address+0 Byte0
• Base Address+1 Byte1
• Base Address+2 Byte2
• Base Address+3 Byte3 Intel processors (those used in "PC's") use "Little Endian" byte order.
  

"Big Endian" means that the high-order byte of the number is stored in memory at the lowest address, and the low-order byte at the highest address. (The big end comes first.) Our LongInt, would then be stored as:

• Base Address+0 Byte3
• Base Address+1 Byte2
• Base Address+2 Byte1
• Base Address+3 Byte0 Motorola processors (those used in Apple and Sun machines) use "Big Endian" byte order.

Definition at line 122 of file grid_io.c.

#define Flip_int16_ip

(

type

)

(*(type))

Definition at line 123 of file grid_io.c.

#define Flip_int32

(

type

)

(type)

Definition at line 124 of file grid_io.c.

Referenced by grid_write_header().

#define Flip_int32_ip

(

type

)

(*(type))

Definition at line 125 of file grid_io.c.

Referenced by grid_read_header(), and grid_write_header().

#define Flip_float_ip

(

type

)

(*(type))

Definition at line 126 of file grid_io.c.

Referenced by grid_read(), grid_read_header(), grid_write(), and grid_write_header().

---

Function Documentation

void grid_io_fatal	(	char *	name,
		char *	message
	)

prints fatal error messages.

Parameters:

	name	name of function
	message	text of message

Definition at line 658 of file grid_io.c.

Referenced by grid_read(), grid_read_header(), grid_write(), and grid_write_header().

{ 
  (void) fprintf(stderr, "ERROR in %s: ", name);
  (void) fprintf(stderr, message);
  (void) abort();
}

void F77_to_C_string	(	char *	dest,
		char *	src,
		int	length
	)

UNUSED converts fortran style strings to C style strings.

Definition at line 670 of file grid_io.c.

Referenced by gwrite_(), openfilef77_(), and setgrid_().

{
  int i;
  strncpy(dest, src, length);
  for (i = length - 1; isspace(dest[i]); i--)
    dest[i] = '\0';
}

void C_to_F77_string	(	char *	dest,
		char *	src,
		int	length
	)

UNUSED converts C style strings to Fortran style.

Definition at line 684 of file grid_io.c.

Referenced by getgrid_(), and gread_().

{
  int i;

  strncpy(dest,src,length);
  for (i = strlen(dest); i < length; i++)
    dest[i] = ' ';
}

int openfilef77_	(	int *	unit,
		char *	filename,
		char *	access,
		int	filename_len,
		int	access_len
	)

UNUSED fortran stuff.

Definition at line 715 of file grid_io.c.

References F77_to_C_string(), GR_FORTRAN_FILE_STRUC::fptr, GR_FORTRAN_FILE_STRUC::next, and GR_FORTRAN_FILE_STRUC::unit_number.

{
  GR_FORTRAN_FILE *iFile=gr_fortran_file_list;
  GR_FORTRAN_FILE *prevFile=gr_fortran_file_list;
  char *filename_buf = (char *) malloc(sizeof(char)*(filename_len+1));
  char *access_buf = (char *) malloc(sizeof(char)*(access_len+1));

  F77_to_C_string(filename_buf, filename, filename_len);
  F77_to_C_string(access_buf, access, access_len);

  while (iFile != 0) {
    if(iFile->unit_number == *unit) {
       fprintf(stderr,"Error: unit %d already open, can not open file %s as unit %d\n", *unit, filename, *unit);
      return 0;

  }
    prevFile=iFile;
    iFile = iFile->next;
  }

  iFile = (GR_FORTRAN_FILE *) malloc(sizeof(GR_FORTRAN_FILE));
  if(prevFile == 0 )
    gr_fortran_file_list = iFile;
  else
    prevFile->next = iFile;
  iFile->fptr = fopen(filename_buf, access_buf);
  if (iFile->fptr == 0) {
     fprintf(stderr,"Error: can not open file \"%s\" as unit %d\n",
             filename_buf, *unit);
  }
  iFile->unit_number = *unit;
  iFile->next = 0;
  return 1;
}

Here is the call graph for this function:

int closefilef77_

(

int *

unit

)

UNUSED fortran stuff.

Definition at line 751 of file grid_io.c.

References GR_FORTRAN_FILE_STRUC::next, and GR_FORTRAN_FILE_STRUC::unit_number.

{
  GR_FORTRAN_FILE *iFile=gr_fortran_file_list;
  GR_FORTRAN_FILE *prevFile=gr_fortran_file_list;
  while (iFile != 0) {
    if(iFile->unit_number == *unit) {
      if(iFile == gr_fortran_file_list)
        gr_fortran_file_list = iFile->next;
      else
        prevFile->next = iFile->next;
      free(iFile);
      return 1;
    }
  }
  return 0;
}

FILE * getfilep_

(

int *

unit

)

UNUSED fortran stuff.

Definition at line 769 of file grid_io.c.

References GR_FORTRAN_FILE_STRUC::fptr, GR_FORTRAN_FILE_STRUC::next, and GR_FORTRAN_FILE_STRUC::unit_number.

Referenced by gread_(), gridrhd_(), gridskp_(), gridwhd_(), and gwrite_().

{
  GR_FORTRAN_FILE *iFile;
  for(iFile = gr_fortran_file_list; iFile!=0; iFile =iFile->next) {
    if(iFile->unit_number == *unit) return iFile->fptr;
  }
  return 0;
}

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, MAX_GRID_ROWS, 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_().

{
  int array_size, errs;
  int *tmp_xstart, *tmp_xend, *tmp_cum_node_count;
  errs = 0;
  tmp_xstart = grid->config.xstart;
  tmp_xend = grid->config.xend;
  tmp_cum_node_count = grid->config.cum_node_count;

  {
    GR_HEADER tmpHeader;
    strncpy(tmpHeader.title, grid->header.title, GRID_TITLE_LENGTH);
    tmpHeader.number_of_rows = Flip_int32(grid->header.number_of_rows);
    tmpHeader.number_of_nodes = Flip_int32(grid->header.number_of_nodes);
    tmpHeader.size.x =  grid->header.size.x;
    Flip_float_ip(&(tmpHeader.size.x));
    tmpHeader.size.y =  grid->header.size.y;
    Flip_float_ip(&(tmpHeader.size.y));
    if (fwrite(&tmpHeader, sizeof(GR_HEADER), 1, file) == 0) 
      ++errs;
  }

  if (grid->header.number_of_rows < MAX_GRID_ROWS)
    array_size = MAX_GRID_ROWS;
  else
    array_size = grid->header.number_of_rows;

#ifdef i386
  {
    int i;
    tmp_xstart =  (int *) malloc(array_size * sizeof(int));
    memcpy(tmp_xstart, grid->config.xstart, array_size * sizeof(int));

    tmp_xend =  (int *) malloc(array_size * sizeof(int));
    memcpy(tmp_xend, grid->config.xend, array_size * sizeof(int));

    tmp_cum_node_count =  (int *) malloc(array_size * sizeof(int));
    memcpy(tmp_cum_node_count, grid->config.cum_node_count, array_size * sizeof(int));

    for (i=0; i<array_size; ++i) {
      Flip_int32_ip(tmp_xstart+i);
      Flip_int32_ip(tmp_xend+i);
      Flip_int32_ip(tmp_cum_node_count+i);
    }
  }
#endif
  if (fwrite(tmp_xstart, sizeof(int), array_size, file) == 0)
    ++errs;
  if (fwrite(tmp_xend, sizeof(int), array_size, file) == 0)
    ++errs;
  if (fwrite(tmp_cum_node_count, sizeof(int), array_size, file) == 0)
    ++errs;

  if (errs)
    grid_io_fatal("write_grid_header", "Unable to write file header\n");

#ifdef i386
  free(tmp_xstart); free(tmp_xend); free(tmp_cum_node_count);
#endif
  
  return (0);
}

Here is the call graph for this function:

void gridwhd_	(	int *	fd,
		int *	errs
	)

UNUSED: Fortran interface to the grid_write_header.

Definition at line 216 of file grid_io.c.

References getfilep_(), and grid_write_header().

{
  FILE *file;
  file = getfilep_(fd);   

  *errs = grid_write_header(file, &fortran_grid);
}

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, MAX_GRID_ROWS, 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().

{
  int errs = 0, num_read, array_size;

  if ((num_read = fread(&grid->header, sizeof(GR_HEADER), 1, file)) == 0) {
    if (feof(file))
      errs = -1;
    else 
      grid_io_fatal("read_grid_header", "Unable to read header from file\n");
  }
  Flip_int32_ip(&(grid->header.number_of_rows));
  Flip_int32_ip(&(grid->header.number_of_nodes));
  Flip_float_ip(&(grid->header.size.x));
  Flip_float_ip(&(grid->header.size.y));

  if (grid->header.number_of_rows < MAX_GRID_ROWS)
    array_size = MAX_GRID_ROWS;
  else
    array_size = grid->header.number_of_rows;

  /* allocate space for configuration arrays */
  grid->config.xstart = (int *) malloc(array_size * sizeof(int));

  grid->config.xend = (int *) malloc(array_size * sizeof(int));

  grid->config.cum_node_count = (int *) malloc(array_size * sizeof(int));

  if ((num_read = fread(grid->config.xstart, sizeof(int), array_size, file)) == 0) {
    if (feof(file))
      errs = -1;
    else 
      grid_io_fatal("read_grid_header", "Unable to read header from file\n");
  }

  if ((num_read = fread(grid->config.xend, sizeof(int), array_size, file)) == 0) {
    if (feof(file))
      errs = -1;
    else
      grid_io_fatal("read_grid_header", "Unable to read header from file\n");
  }

  if ((num_read = fread(grid->config.cum_node_count, sizeof(int), array_size, file)) == 0) {
    if (feof(file))
      errs = -1;
    else
      grid_io_fatal("read_grid_header", "Unable to read header from file\n");
  }
  
#ifdef i386
  {
    int i;
    for (i=0; i<array_size; ++i) {
      Flip_int32_ip(grid->config.xstart+i);
      Flip_int32_ip(grid->config.xend+i);
      Flip_int32_ip(grid->config.cum_node_count+i);
    }
  }
#endif
  return(errs);
}

Here is the call graph for this function:

void gridrhd_	(	int *	fd,
		int *	errs
	)

UNUSED Fortran interface to the grid_read_header routine.

Fortran interface to the grid_read_header routine.

Note that it changes the contents of the fortran_grid. To get the header info a call to getgrid_

Definition at line 304 of file grid_io.c.

References getfilep_(), and grid_read_header().

{
  FILE *file;
  file = getfilep_(fd);   
  *errs = grid_read_header(file, &fortran_grid);
}

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_().

{
  char *char_ptr;
  int written, errs = 0;
  float *tmp_values = values;

  if ((written = fwrite(tag, sizeof(char), GRID_TAG_LENGTH, file)) == 0)
    grid_io_fatal("grid_write", "Unable to write grid tag\n");
  if (written < GRID_TAG_LENGTH) errs++;
#ifdef i386
  {
    int i;
    tmp_values = (float *) malloc(grid->header.number_of_nodes * sizeof(float));
    memcpy(tmp_values, values, grid->header.number_of_nodes * sizeof(float));
    for (i=0; i<grid->header.number_of_nodes; ++i) {
      Flip_float_ip(tmp_values+i);
    }
  }
#endif
    if ((written = fwrite(tmp_values, sizeof(float), grid->header.number_of_nodes, file)) == 0)
      grid_io_fatal("grid_write", "Unable to write grid data\n");

  if (written < grid->header.number_of_nodes) errs++;
#ifdef i386
  free (tmp_values);
#endif
  return(errs);

}

Here is the call graph for this function:

void gwrite_	(	int *	fd,
		char *	tag,
		float *	values,
		int *	errs,
		int	tag_len
	)

UNUSED Fortran interface to the grid_write routine.

Definition at line 352 of file grid_io.c.

References F77_to_C_string(), getfilep_(), GRID_TAG_LENGTH, and grid_write().

{
  char buf[GRID_TAG_LENGTH];
  FILE *file;
  
  file = getfilep_(fd);   
  F77_to_C_string(buf, tag, ((tag_len < GRID_TAG_LENGTH) ? tag_len : GRID_TAG_LENGTH));
  *errs = grid_write(file, &fortran_grid, buf, values);
}

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().

{
  int num_read, errs = 0;

  /* read the tag */
  if ((num_read = fread(tag, sizeof(char), GRID_TAG_LENGTH, file)) == 0) {
    if (feof(file))
      return (-1);
    else
      grid_io_fatal("grid_read", "Uable to read grid tag\n");
  }
  if (num_read != GRID_TAG_LENGTH) errs++;

  /* read the values */
  if ((num_read = fread(values, sizeof(float), grid->header.number_of_nodes, file)) == 0) 
    grid_io_fatal("grid_read", "Unable to read data\n");
#ifdef i386
  {
    int i;
    for (i=0; i<grid->header.number_of_nodes; ++i) {
      Flip_float_ip(values+i);
    }
  }
#endif
  if (num_read != grid->header.number_of_nodes) errs++;
  return (errs);
}

Here is the call graph for this function:

void gread_	(	int *	fd,
		char *	tag,
		float *	values,
		int *	errs,
		int	tag_len
	)

UNUSED Fortran interface to the grid_read routine.

Definition at line 407 of file grid_io.c.

References C_to_F77_string(), getfilep_(), grid_read(), and GRID_TAG_LENGTH.

{
  char buf[GRID_TAG_LENGTH];
  FILE *file;
  
  file = getfilep_(fd);   
  *errs = grid_read(file, &fortran_grid, buf, values);
  C_to_F77_string(tag, buf, ((tag_len < GRID_TAG_LENGTH) ? tag_len : GRID_TAG_LENGTH));
}

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, MAX_GRID_ROWS, GR_HEADER::number_of_nodes, and GR_HEADER::number_of_rows.

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

{
  int header_size, array_size;
  int errs = 0;
  long int rec_len =  GRID_TAG_LENGTH*sizeof(char) +
    grid->header.number_of_nodes*sizeof(float);
  long int end, current;

  if (count < 0) {
    if (grid->header.number_of_rows < MAX_GRID_ROWS)
      array_size = MAX_GRID_ROWS;
    else
      array_size = grid->header.number_of_rows;
    header_size = sizeof(GRID) + 3 * sizeof(int) * array_size;
    if (ftell(file) <  header_size + abs(count)*rec_len)
      errs = grid_top(file, grid);
    else
      fseek(file, count*rec_len, 1);
  } else if (count > 0) {
    current = ftell(file);
    fseek(file, 0, 2);
    end = ftell(file);
    if ((end - current)/rec_len < count)
      errs = grid_bottom(file, grid);
    else 
      errs = fseek(file, (long)(current + count*rec_len), 0);
  }
  
  return(errs);
}

Here is the call graph for this function:

void gridskp_	(	int *	fd,
		int *	cnt,
		int *	errs
	)

UNUSED Fortran interface to the grid_skip routine.

Definition at line 465 of file grid_io.c.

References getfilep_(), and grid_skip().

{
  FILE *file; 
  file = getfilep_(fd);   
  *errs = grid_skip(file, &fortran_grid, *cnt);
}

Here is the call graph for this function:

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().

{
  fseek(file, 0L, 0);
  return(grid_read_header(file, grid));
}

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().

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

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_TAG_LENGTH, grid_top(), GRID::header, and GR_HEADER::number_of_nodes.

                                                 {
  int i = 0;
  char tag[GRID_TAG_LENGTH];
  float *data = (float *)malloc(grid->header.number_of_nodes*sizeof(float));

  grid_top(file, grid);
  while (grid_read(file, grid, tag, data) == 0)
    i++;
  free(data);
  grid_top(file, grid);
  return(i);
}

Here is the call graph for this function:

char* strsed	(	register char *	string,
		register char *	pattern,
		int *	range
	)

UNUSED.

int grid_node	(	GRID *	grid,
		int	row,
		int	column
	)

UNUSED. This routine returns the array index of the node cooresponding to the row and column number passed.

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

Parameters:

	grid	The struct containing grid_io info
	row	The row of the data
	column	The column of the data

Returns:

index of array

Definition at line 584 of file grid_io.c.

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

{
  if (row > 0 && row <= grid->header.number_of_rows) {
    if (column >= grid->config.xstart[row - 1] && column <= grid->config.xend[row - 1]) 
      return ((grid->config.cum_node_count[row - 1] - 1) + column - grid->config.xstart[row - 1] + 1);
  }
  return -1;
}

void setgrid_	(	char *	title,
		int *	nrows,
		int *	nnodes,
		float *	xsize,
		float *	ysize,
		int *	xstart,
		int *	xend,
		int *	cum_count,
		int	title_len
	)

UNUSED Fortran call to set internal grid definition record.

Definition at line 598 of file grid_io.c.

References GRID::config, GR_CONFIG::cum_node_count, F77_to_C_string(), GRID_TITLE_LENGTH, GRID::header, MAX_GRID_ROWS, 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.

{
  int i, array_size;

  F77_to_C_string(fortran_grid.header.title, title, 
                  ((title_len < GRID_TITLE_LENGTH) ? title_len : GRID_TITLE_LENGTH));

  fortran_grid.header.number_of_rows = *nrows;
  fortran_grid.header.number_of_nodes = *nnodes;
  fortran_grid.header.size.x = *xsize;
  fortran_grid.header.size.y = *ysize;

  /* allocate space for configuration arrays */
  array_size = (*nrows < MAX_GRID_ROWS) ? MAX_GRID_ROWS : *nrows;
  fortran_grid.config.xstart = (int *) malloc(array_size * sizeof(int));
  fortran_grid.config.xend = (int *) malloc(array_size * sizeof(int));
  fortran_grid.config.cum_node_count = (int *) malloc(array_size * sizeof(int));
  
  for (i = 0; i < fortran_grid.header.number_of_rows; i++) {
    fortran_grid.config.xstart[i] = xstart[i];
    fortran_grid.config.xend[i] = xend[i];
    fortran_grid.config.cum_node_count[i] = cum_count[i];
  }
}

Here is the call graph for this function:

void getgrid_	(	char *	title,
		int *	nrows,
		int *	nnodes,
		float *	xsize,
		float *	ysize,
		int *	xstart,
		int *	xend,
		int *	cum_count,
		int	title_len
	)

UNUSED Fortran call to get internal grid definition record.

Definition at line 631 of file grid_io.c.

References C_to_F77_string(), GRID::config, GR_CONFIG::cum_node_count, 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.

{
  int i;

  C_to_F77_string(title,fortran_grid.header.title,  
                  ((title_len < GRID_TITLE_LENGTH) ? title_len : GRID_TITLE_LENGTH));

  *nrows = fortran_grid.header.number_of_rows;
  *nnodes = fortran_grid.header.number_of_nodes;
  *xsize = fortran_grid.header.size.x;
  *ysize = fortran_grid.header.size.y;
  for (i = 0; i < fortran_grid.header.number_of_rows; i++) {
    xstart[i] = fortran_grid.config.xstart[i];
    xend[i] = fortran_grid.config.xend[i];
    cum_count[i] =fortran_grid.config.cum_node_count[i];
  }
}

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.

{
  int errs = 0;

  free(grid->config.xstart);
  free(grid->config.xend);
  free(grid->config.cum_node_count);

  return(errs);
}

---

Variable Documentation

GR_FORTRAN_FILE* gr_fortran_file_list = 0

Definition at line 138 of file grid_io.c.