#include <cstring>
#include <cstdio>
#include <strings.h>
#include "gridutil.h"
#include "util.h"
#include "FC.h"

Include dependency graph for read.cpp:

Typedefs
typedef double	REAL

Functions
void	FC_GLOBAL (accept_locations, ACCEPT_LOCATIONS)(int *ni

	for (i[0]=0;i[0]< dim[0];i[0]++)

curConsumer	consume (dim, v)

curConsumer	freeBlock (v)

void	FC_GLOBAL (read_msh, READ_MSH)(const char *fName)

const char *	read_grd (const char *gridFile, blockConsumer &dest)

const char *	read_grds (const char *gridFile, blockConsumer &dest)

const char *	read_grdd (const char *gridFile, blockConsumer &dest)

const char *	read_reg (const char *regFile, blockConsumer &dest)

const char *	read_hdf (const char *hdfName, blockConsumer &dest)

const char *	read_file (const char *file, blockConsumer &dest)

const char *	read_multiple (const char *file, blockConsumer &dest)

Variables
static blockConsumer *	curConsumer =NULL

void int *	nj

void int int *	nk

void int int REAL *	x

void int int REAL REAL *	y

void int int REAL REAL REAL z blockDim dim	ni

vector3d *	v =curConsumer->allocateBlock(dim)

blockLoc	i

Typedef Documentation

typedef double REAL

Definition at line 70 of file read.cpp.

Function Documentation

curConsumer consume	(	dim	,
		v
	)

void FC_GLOBAL	(	accept_locations	,
		ACCEPT_LOCATIONS
	)

void FC_GLOBAL	(	read_msh	,
		READ_MSH
	)		const

for ( )

Definition at line 82 of file read.cpp.

References i, x, vector3d::x, y, vector3d::y, z, and vector3d::z.

         { //Copy data from Fortran array
                 int c_i=dim[i], f_i=dim[i];
                 v[c_i].x=x[f_i];
                 v[c_i].y=y[f_i];
                 v[c_i].z=z[f_i];
         }

curConsumer freeBlock ( v )

const char* read_file	(	const char *	file,
		blockConsumer &	dest
	)

Definition at line 102 of file read.cpp.

References endsWith(), FC_GLOBAL, fortranifyString(), read_grd(), read_grdd(), read_grds(), read_hdf(), read_msh(), and read_reg().

 {
         curConsumer=&dest;
         if (endsWith(file,".msh"))
           FC_GLOBAL(read_msh,READ_MSH)(fortranifyString(file));
         else if (endsWith(file,".grd"))
                 return read_grd(file,dest);
         else if (endsWith(file,".grds"))
                 return read_grds(file,dest);
         else if (endsWith(file,".grdd"))
                 return read_grdd(file,dest);
 #ifdef USE_HDF
         else if (endsWith(file,".hdf"))
                 return read_hdf(file,dest);
 #endif
         else if (endsWith(file,".reg"))
                 return read_reg(file,dest);
         else
                 return "Unrecognized input mesh file extension! ("__FILE__")";
         return NULL;
 }

Here is the call graph for this function:

const char* read_grd	(	const char *	gridFile,
		blockConsumer &	dest
	)

Definition at line 196 of file readgrd.cpp.

References read_general().

Referenced by read_file().

 {
         gridgenAsciiFormatter fmt;
         return read_general(gridFile,fmt,dest);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* read_grdd	(	const char *	gridFile,
		blockConsumer &	dest
	)

Definition at line 206 of file readgrd.cpp.

References read_general().

Referenced by read_file().

 {
         gridgenBinaryDoubleFormatter fmt;
         return read_general(gridFile,fmt,dest);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* read_grds	(	const char *	gridFile,
		blockConsumer &	dest
	)

Definition at line 201 of file readgrd.cpp.

References read_general().

Referenced by read_file().

 {
         gridgenBinaryFloatFormatter fmt;
         return read_general(gridFile,fmt,dest);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* read_hdf	(	const char *	hdfName,
		blockConsumer &	dest
	)

Definition at line 76 of file readhdf.cpp.

References blockConsumer::allocateBlock(), chk, blockConsumer::consume(), coord, d, blockConsumer::freeBlock(), blockDim::getSize(), i, and rank.

Referenced by read_file().

 {
         int32 i, d;
         //Open the input file
         int32 sd_id = SDstart(filename, DFACC_READ);
         if (sd_id==-1) return "Couldn't open HDF input file!";
 
         //Select the X, Y, and Z components
         int32 sds_id[3];
         for (i=0;i<3;i++) sds_id[i]=chk(SDselect(sd_id,5+4*i));
         
         //Determine the ni, nj, and nk dimensions
         blockDim dim;
         /* This doesn't work.
         for (d=0;d<3;d++) {
                 int32 dim_id = chk(SDgetdimid(sds_id[0],d));
                 char dim_name[200];
                 int32 dim_size, data_type, n_attrs;
                 chk(SDdiminfo(dim_id, dim_name, &dim_size, &data_type, &n_attrs));
                 dim[2-d]=dim_size;
         }
         */
         char name[200];
         int32 rank, size[3], data_type, n_attrs;
         chk(SDgetinfo(sds_id[0], name, &rank, size, &data_type, &n_attrs));
         dim[0]=size[2];
         dim[1]=size[1];
         dim[2]=size[0];
         
         //Allocate storage for the X, Y, and Z output
         vector3d *locs=dest.allocateBlock(dim);
 
         //Read each of X, Y, and Z
         int nLocs=dim.getSize();
         double *coord=new double[nLocs];
         for (i=0;i<3;i++)
         {
                 int32 start[3]={0,0,0};
                 int32 edges[3];
                 for (d=0;d<3;d++) edges[d]=dim[2-d];
                 chk(SDreaddata(sds_id[i], start, NULL, edges, coord));
                 //Copy this coordinate into locs
                 for (int l=0;l<nLocs;l++) locs[l][i]=coord[l];
         }
         delete[] coord;
 
         //Pass locations to consumer
         dest.consume(dim,locs);
         dest.freeBlock(locs);
         
         //Close the file and return
         for (i=0;i<3;i++) chk(SDendaccess(sds_id[i]));
         chk(SDend(sd_id));
         return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* read_multiple	(	const char *	file,
		blockConsumer &	dest
	)

Definition at line 126 of file read.cpp.

References fileExists(), incrementAscii(), and read_file().

Referenced by blockConsumer::read().

 {
         char tmp[1024];
         strcpy(tmp,file);
         do {
                 printf("Reading block file '%s'...\n",tmp);
                 const char *ret=read_file(tmp,dest);
                 if (ret!=NULL) return ret;
                 if (!incrementAscii(tmp)) return NULL;
         } while (fileExists(tmp));
         return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* read_reg	(	const char *	regFile,
		blockConsumer &	dest
	)

Definition at line 63 of file readreg.cpp.

References blockConsumer::allocateBlock(), BLOCKSPAN_FOR, blockConsumer::consume(), cimg_library::cimg::fclose(), cimg_library::cimg::fopen(), blockConsumer::freeBlock(), i, max(), min(), s, and v.

Referenced by read_file().

 {
         //Open the input file
         FILE *in=fopen(regFile,"r");
         if (in==NULL) return "Couldn't open input .reg file";
 
         //Read the block size
         int dimArr[3];
         vector3d min,max;
         for (int axis=0;axis<3;axis++)
         {
                 double m;
                 if (1!=fscanf(in,"%d",&dimArr[axis]))
                         return "Couldn't read block dimension"; 
                 if (1!=fscanf(in,"%lf",&m)) return "Couldn't read block min";
                 min[axis]=m;
                 if (1!=fscanf(in,"%lf",&m)) return "Couldn't read block max";
                 max[axis]=m;
         }
         fclose(in);
 
         //Allocate return grid
         blockDim dim(dimArr[0],dimArr[1],dimArr[2]);
         vector3d *locs=dest.allocateBlock(dim);
         
         //Fill in the grid
         blockLoc i;
         blockSpan s(blockLoc(0,0,0),dim);
         BLOCKSPAN_FOR(i,s) {
                 vector3d v;
                 for (int axis=0;axis<3;axis++) {
                         double scl=i[axis]/(float)(dim[axis]-1);
                         v[axis]=min[axis]+scl*(max[axis]-min[axis]);
                 }
                 locs[dim[i]]=v;
         }
         
         dest.consume(dim,locs); 
         dest.freeBlock(locs);
 
         return NULL; //Everything worked
 }