#include <stdio.h>
#include <strings.h>
#include "adj.h"
#include "util.h"
#include "FC.h"

Include dependency graph for write.cpp:

Typedefs
typedef double	REAL

typedef void(*	fn_fortran_write )(int block, int ni, int nj, int nk, REAL x, REAL y, REAL z, const char fName)

Functions
void	FC_GLOBAL (write_msh, WRITE_MSH)(int *block

void	FC_GLOBAL (write_grda, WRITE_GRDA)(int *block

void	FC_GLOBAL (write_grdb, WRITE_GRDB)(int *block

static void	write_fortran (int block, blockDim dim, const vector3d locs, const char fName, fn_fortran_write writeFn)

void	vecMax (const vector3d &a, vector3d &dest)

void	vecMin (const vector3d &a, vector3d &dest)

void	write_bounds (const blockDim &dim, const vector3d locs, const char filename_base)

const char *	write_hdf (const blockDim &dim, const vector3d locs, const char filename)

const char *	writeBlocks (vector< block * > &blocks, const char *outMesh)

Variables
void int *	ni

void int int *	nj

void int int int *	nk

void int int int REAL *	x

void int int int REAL REAL *	y

void int int int REAL REAL REAL *	z

void int int int REAL REAL REAL const char *	fName

Typedef Documentation

typedef void(* fn_fortran_write)(int *block, int *ni, int *nj, int *nk, REAL *x, REAL *y, REAL *z, const char *fName)

Definition at line 70 of file write.cpp.

typedef double REAL

Definition at line 67 of file write.cpp.

Function Documentation

void FC_GLOBAL	(	write_msh	,
		WRITE_MSH
	)

void FC_GLOBAL	(	write_grda	,
		WRITE_GRDA
	)

void FC_GLOBAL	(	write_grdb	,
		WRITE_GRDB
	)

void vecMax	(	const vector3d &	a,
		vector3d &	dest
	)

Definition at line 109 of file write.cpp.

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

Referenced by write_bounds().

 {
         if (a.x>dest.x) dest.x=a.x;
         if (a.y>dest.y) dest.y=a.y;
         if (a.z>dest.z) dest.z=a.z;
 }

Here is the caller graph for this function:

void vecMin	(	const vector3d &	a,
		vector3d &	dest
	)

Definition at line 115 of file write.cpp.

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

Referenced by write_bounds().

 {
         if (a.x<dest.x) dest.x=a.x;
         if (a.y<dest.y) dest.y=a.y;
         if (a.z<dest.z) dest.z=a.z;
 }

Here is the caller graph for this function:

void write_bounds	(	const blockDim &	dim,
		const vector3d *	locs,
		const char *	filename_base
	)

Definition at line 122 of file write.cpp.

References cimg_library::cimg::fclose(), cimg_library::cimg::fopen(), i, max(), min(), vecMax(), vecMin(), vector3d::x, vector3d::y, and vector3d::z.

 {
         char filename[1024];
         sprintf(filename,"%s.bounds",filename_base);
         FILE *f=fopen(filename,"w");
         if (f==NULL) return;
         //Find the bounds of all locations
         double big=1.0e25;
         vector3d max(-big,-big,-big),min(big,big,big);
         blockLoc i;
         for (i[2]=0; i[2]<dim[2]; i[2]++)
         for (i[1]=0; i[1]<dim[1]; i[1]++)
         for (i[0]=0; i[0]<dim[0]; i[0]++) {
                 vecMax(locs[dim[i]],max);
                 vecMin(locs[dim[i]],min);
         }
         fprintf(f,"%f %f %f %f %f %f\n",min.x,max.x,min.y,max.y,min.z,max.z);
         fclose(f);
 }

Here is the call graph for this function:

static void write_fortran	(	int	block,
		blockDim	dim,
		const vector3d *	locs,
		const char *	fName,
		fn_fortran_write	writeFn
	)

static

Definition at line 85 of file write.cpp.

References fortranifyString(), blockDim::getSize(), i, x, vector3d::x, y, vector3d::y, z, and vector3d::z.

Referenced by writeBlocks().

 {
         //Copy the data from C array to fortran arrays
         int len=dim.getSize();
         REAL *x=new REAL[len];
         REAL *y=new REAL[len];
         REAL *z=new REAL[len];
         blockLoc i;
         for (i[2]=0; i[2]<dim[2]; i[2]++)
         for (i[1]=0; i[1]<dim[1]; i[1]++)
         for (i[0]=0; i[0]<dim[0]; i[0]++) 
         { //Copy data into fortran array
                 int c_i=dim[i], f_i=dim[i];
                 x[f_i]=locs[c_i].x;
                 y[f_i]=locs[c_i].y;
                 z[f_i]=locs[c_i].z;
         }
 
         //Send the data off to fortran (JB: added block)
         (writeFn)(&block,&dim[0],&dim[1],&dim[2],x,y,z,fortranifyString(fName));
         delete[] x; delete[] y; delete[] z;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* write_hdf	(	const blockDim &	dim,
		const vector3d *	locs,
		const char *	filename
	)

Definition at line 77 of file writehdf.cpp.

References chk, blockDim::getSize(), i, cimg_library::cimg::time(), x, vector3d::x, y, vector3d::y, z, and vector3d::z.

Referenced by writeBlocks().

 {
         const int dataType=6;//double precision float
         REAL time=0.0;
         int32 timeLen=1;
         chk(DFSDsetdims(1,&timeLen));
         chk(DFSDsetNT(dataType));
         chk(DFSDputdata(filename, 1, &timeLen, &time));
 
         //Copy the data from C++ array to C arrays
         int len=dim.getSize();
         REAL *x=new REAL[len];
         REAL *y=new REAL[len];
         REAL *z=new REAL[len];
         blockLoc i;
         for (i[2]=0; i[2]<dim[2]; i[2]++)
         for (i[1]=0; i[1]<dim[1]; i[1]++)
         for (i[0]=0; i[0]<dim[0]; i[0]++) 
         { //Copy data into separate, coordinate-wise arrays
                 int c_i=dim[i], f_i=dim[i];
                 x[f_i]=locs[c_i].x;
                 y[f_i]=locs[c_i].y;
                 z[f_i]=locs[c_i].z;
         }
 
         //Send the data off to HDF
         int32 dSize[3]; //Swap dimensions
         dSize[0]=dim[2]; dSize[1]=dim[1]; dSize[2]=dim[0];
         chk(DFSDsetdims(3,dSize));
         chk(DFSDsetNT(dataType));
         chk(DFSDadddata(filename, 3, dSize, x));
         chk(DFSDadddata(filename, 3, dSize, y));
         chk(DFSDadddata(filename, 3, dSize, z));
 
         //Clean up output arrays
         delete[] x; delete[] y; delete[] z;
 
         return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* writeBlocks	(	vector< block * > &	blocks,
		const char *	outMesh
	)

Definition at line 147 of file write.cpp.

References endsWith(), FC_GLOBAL, i, incrementAscii(), write_fortran(), write_grda(), write_grdb(), write_hdf(), and write_msh().

Referenced by main().

 {
         char oName[1024];
         bool isFortran=false, isHDF=false;
         bool incrementFilenames=true;
         fn_fortran_write writeFn=NULL;
         strcpy(oName,outMesh);
         if (endsWith(outMesh,".msh"))
         { //Write .msh files:
                 isFortran=true;
                 writeFn=FC_GLOBAL(write_msh,WRITE_MSH);
         }
         else if (endsWith(outMesh,"1")||
                  endsWith(outMesh,".grda")||
                  endsWith(outMesh,".grdb")) 
         { //Probably a grda or grdb file:
                 isFortran=true;
                 incrementFilenames=false; //Same filename every time
                 char tmp[1024];
                 strcpy(tmp,outMesh);
                 //Clip off any trailing numbers:
                 int endIdx=strlen(tmp)-1;
                 while (endIdx>0&&(isdigit(tmp[endIdx])||(tmp[endIdx]=='_')))
                         tmp[endIdx--]=0;
                 if (endsWith(tmp,".grda"))
                   writeFn=FC_GLOBAL(write_grda,WRITE_GRDA);
                 else if (endsWith(tmp,".grdb")) 
                   writeFn=FC_GLOBAL(write_grdb,WRITE_GRDB);
                 else return "Unrecognized output mesh extension! (2)";
         }
 #ifdef USE_HDF
         else if (endsWith(outMesh,".hdf"))
         {
                 isHDF=true;
         }
 #endif
         else if (endsWith(outMesh,".null"))
                 {/*Just skip output*/}
         else
                 return "Unrecognized output mesh file extension! (1)";
                 
         
         for (unsigned int i=0;i<blocks.size();i++) {
                 const blockDim &dim=blocks[i]->getDim();
                 const vector3d *locs=&blocks[i]->getLoc(blockLoc(0,0,0));
 
                 if (isFortran)
                   if (i+1==blocks.size())
                   { /* Last time around, pass a negative block number
                        so fortran code can close its file. */
                     write_fortran(-(i+1),dim,locs,oName,writeFn);
                   } else {
                     write_fortran(  i+1 ,dim,locs,oName,writeFn);
                   }
                
 #ifdef USE_HDF
                 else if (isHDF)
                         write_hdf(dim,locs,oName);
 #endif
                 
                 printf("."); fflush(stdout);
                 if (incrementFilenames) {
                   if (!incrementAscii(oName)) 
                         return "Cannot increment output filename!  Use something like 'foo_0001.msh'\n";
                 }
         }
         printf("\n");
 
         return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function: