io_cpp.h File Reference

Function declarations for file I/O functions. More...

Go to the source code of this file.

Functions
int	ReadArray (int, int, int *, int *, int, void *, void *, double *, double *, char *, int *)
int	ReadArraywInterp (int, int, int *, int *, int *, int, void *, void *, double *, double *, char *, int *)
int	WriteArray (int, int, int *, int *, int, double *, double *, void *, void *, char *)
int	WriteBinary (int, int, int *, double *, double *, char *, int *)
int	WriteText (int, int, int *, double *, double *, char *, int *)
int	WriteTecplot2D (int, int, int *, double *, double *, char *, int *)
int	WriteTecplot3D (int, int, int *, double *, double *, char *, int *)

Detailed Description

Function declarations for file I/O functions.

Author

Debojyoti Ghosh

Definition in file io_cpp.h.

Function Documentation

ReadArray()

int ReadArray	(	int	ndims,
		int	nvars,
		int *	dim_global,
		int *	dim_local,
		int	ghosts,
		void *	s,
		void *	m,
		double *	x,
		double *	u,
		char *	fname_root,
		int *	read_flag
	)

Read in a vector field from file: wrapper function that calls the appropriate function depending on input mode (HyPar::input_mode).

The mode and type of input are specified through HyPar::input_mode and HyPar::ip_file_type. A vector field is read from file and stored in an array.

Parameters

ndims	Number of spatial dimensions
nvars	Number of variables per grid point
dim_global	Integer array of size ndims with global grid size in each dimension
dim_local	Integer array of size ndims with local grid size in each dimension
ghosts	Number of ghost points
s	Solver object of type HyPar
m	MPI object of type MPIVariables
x	Grid associated with the array (can be NULL)
u	Array to hold the vector field
fname_root	Filename root
read_flag	Flag to indicate if the file was read

Definition at line 25 of file ReadArray.c.

{
  HyPar         *solver = (HyPar*) s;
  MPIVariables  *mpi    = (MPIVariables*) m;
  _DECLARE_IERR_;

  if      (!strcmp(solver->input_mode,"serial")) {
    IERR ReadArraySerial(ndims,nvars,dim_global,dim_local,ghosts,s,m,x,u,fname_root,read_flag);
    CHECKERR(ierr);
#ifndef serial
  } else if (!strcmp(solver->input_mode,"parallel")) {
    ReadArrayParallel(ndims,nvars,dim_global,dim_local,ghosts,s,m,x,u,fname_root,read_flag);
    CHECKERR(ierr);
  } else if (!strcmp(solver->input_mode,"mpi-io"  )) {
    ReadArrayMPI_IO(ndims,nvars,dim_global,dim_local,ghosts,s,m,x,u,fname_root,read_flag);
    CHECKERR(ierr);
#endif
  } else {
    fprintf(stderr,"Error: Illegal value (%s) for input_mode.\n",solver->input_mode);
    return(1);
  }

  if (x) {
    int offset, d;
    /* exchange MPI-boundary values of x between processors */
    offset = 0;
    for (d = 0; d < ndims; d++) {
      IERR MPIExchangeBoundaries1D(mpi,&x[offset],dim_local[d],
                                   ghosts,d,ndims); CHECKERR(ierr);
      offset  += (dim_local [d] + 2*ghosts);
    }
    /* fill in ghost values of x at physical boundaries by extrapolation */
    offset = 0;
    for (d = 0; d < ndims; d++) {
      double *X     = &x[offset];
      int    *dim   = dim_local, i;
      if (mpi->ip[d] == 0) {
        /* fill left boundary along this dimension */
        for (i = 0; i < ghosts; i++) {
          int delta = ghosts - i;
          X[i] = X[ghosts] + ((double) delta) * (X[ghosts]-X[ghosts+1]);
        }
      }
      if (mpi->ip[d] == mpi->iproc[d]-1) {
        /* fill right boundary along this dimension */
        for (i = dim[d]+ghosts; i < dim[d]+2*ghosts; i++) {
          int delta = i - (dim[d]+ghosts-1);
          X[i] =  X[dim[d]+ghosts-1] 
                  + ((double) delta) * (X[dim[d]+ghosts-1]-X[dim[d]+ghosts-2]);
        }
      }
      offset  += (dim[d] + 2*ghosts);
    }
  }

  return(0);
}

ReadArraywInterp()

int ReadArraywInterp	(	int	ndims,
		int	nvars,
		int *	dim_global,
		int *	dim_local,
		int *	dim_global_src,
		int	ghosts,
		void *	s,
		void *	m,
		double *	x,
		double *	u,
		char *	fname_root,
		int *	read_flag
	)

Read in a vector field from file: This version allows reading data with different dimensions than the array being read in. The data is read in and stored in a new global array with the appropriate size, and the array to be read is filled by interpolation. Currently, the dimensions of the array to be read and the those of the actual data can only differ by factors that are integer powers of 2.

This is a wrapper function that calls the appropriate function depending on input mode (HyPar::input_mode).

The mode and type of input are specified through HyPar::input_mode and HyPar::ip_file_type. A vector field is read from file and stored in an array.

Parameters

ndims	Number of spatial dimensions
nvars	Number of variables per grid point
dim_global	Integer array of size ndims with global size in each dimension
dim_local	Integer array of size ndims with local size in each dimension
dim_global_src	Integer array of size ndims with global size of the data in each dimension
ghosts	Number of ghost points
s	Solver object of type HyPar
m	MPI object of type MPIVariables
x	Grid associated with the array (can be NULL)
u	Array to hold the vector field
fname_root	Filename root
read_flag	Flag to indicate if the file was read

Definition at line 28 of file ReadArraywInterp.c.

{
  HyPar         *solver = (HyPar*) s;
  MPIVariables  *mpi    = (MPIVariables*) m;
  _DECLARE_IERR_;

  int retval = ReadArraywInterpSerial(  ndims,
                                        nvars,
                                        dim_global,
                                        dim_local,
                                        dim_global_src,
                                        ghosts,
                                        s,
                                        m,
                                        x,
                                        u,
                                        fname_root,
                                        read_flag );
  if (retval) return retval;

  if (x) {
    int offset, d;
    /* exchange MPI-boundary values of x between processors */
    offset = 0;
    for (d = 0; d < ndims; d++) {
      IERR MPIExchangeBoundaries1D(mpi,&x[offset],dim_local[d],
                                   ghosts,d,ndims); CHECKERR(ierr);
      offset  += (dim_local [d] + 2*ghosts);
    }
    /* fill in ghost values of x at physical boundaries by extrapolation */
    offset = 0;
    for (d = 0; d < ndims; d++) {
      double *X     = &x[offset];
      int    *dim   = dim_local, i;
      if (mpi->ip[d] == 0) {
        /* fill left boundary along this dimension */
        for (i = 0; i < ghosts; i++) {
          int delta = ghosts - i;
          X[i] = X[ghosts] + ((double) delta) * (X[ghosts]-X[ghosts+1]);
        }
      }
      if (mpi->ip[d] == mpi->iproc[d]-1) {
        /* fill right boundary along this dimension */
        for (i = dim[d]+ghosts; i < dim[d]+2*ghosts; i++) {
          int delta = i - (dim[d]+ghosts-1);
          X[i] =  X[dim[d]+ghosts-1] 
                  + ((double) delta) * (X[dim[d]+ghosts-1]-X[dim[d]+ghosts-2]);
        }
      }
      offset  += (dim[d] + 2*ghosts);
    }
  }

  return 0;
}

WriteArray()

int WriteArray	(	int	ndims,
		int	nvars,
		int *	dim_global,
		int *	dim_local,
		int	ghosts,
		double *	x,
		double *	u,
		void *	s,
		void *	m,
		char *	fname_root
	)

Write out a vector field, stored as an array, to file: wrapper function that calls the appropriate function depending on output mode (HyPar::output_mode). The output file format is determined by HyPar::op_file_format

Parameters

ndims	Number of spatial dimensions
nvars	Number of variables per grid point
dim_global	Integer array of size ndims with global grid size in each dimension
dim_local	Integer array of size ndims with local grid size in each dimension
ghosts	Number of ghost points
x	Array of spatial coordinates (i.e. the grid)
u	Vector field to write
s	Solver object of type HyPar
m	MPI object of type MPIVariables
fname_root	Filename root (extension is added automatically). For unsteady output, a numerical index is added that is the same as for the solution output files.

Definition at line 27 of file WriteArray.c.

{
  HyPar         *solver = (HyPar*)       s;
  MPIVariables  *mpi    = (MPIVariables*)m;
  _DECLARE_IERR_;
  
  /* if WriteOutput() is NULL, then return */
  if (!solver->WriteOutput) return(0);

#ifndef serial
  if (!strcmp(solver->output_mode,"serial")) {
#endif
    IERR WriteArraySerial(ndims,nvars,dim_global,dim_local,ghosts,x,u,
                          solver,mpi,fname_root); CHECKERR(ierr);
#ifndef serial
  } else {
    IERR WriteArrayParallel(ndims,nvars,dim_global,dim_local,ghosts,x,u,
                            solver,mpi,fname_root); CHECKERR(ierr);
  }
#endif
  
  return(0);
}

WriteBinary()

int WriteBinary	(	int	ndims,
		int	nvars,
		int *	dim,
		double *	x,
		double *	u,
		char *	f,
		int *	index
	)

Write a vector field and its grid to a binary file. The data is written in the following format:

{
ndims
nvars
dim[0] dim[1] dim[2] ... dim[ndims-1]
x0_i (0 <= i < dim[0])
x1_i (0 <= i < dim[1])
...
x{ndims-1}_i (0 <= i < dim[ndims-1])
[u0,u1,...,u{nvars-1}]_p (0 <= p < N) (with no commas)
}

where
x0, x1, ..., x{ndims-1} represent the spatial dimensions (for a 3D problem, x0 = x, x1 = y, x2 = z),
u0, u1, ..., u{nvars-1} are each component of the vector u at a grid point,
N = dim[0]*dim[1]*...*dim[ndims-1] is the total number of points,
and p = i0 + dim[0]*( i1 + dim[1]*( i2 + dim[2]*( ... + dim[ndims-2] * i{ndims-1} ))) (see _ArrayIndexnD_)
with i0, i1, i2, etc representing grid indices along each spatial dimension, i.e.,
0 <= i0 < dim[0]-1
0 <= i1 < dim[1]-1
...
0 <= i{ndims-1} < dim[ndims=1]-1

Parameters

ndims	Number of spatial dimensions
nvars	Number of variables at each grid point
dim	Integer array with the number of grid points in each spatial dimension as its entries
x	Array of spatial coordinates representing a Cartesian grid (no ghost points)
u	Array containing the vector field to write (no ghost points)
f	Filename
index	Preallocated integer array of size ndims

Definition at line 34 of file WriteBinary.c.

{
  int size, d;
  size_t bytes;
  FILE *out;
  out = fopen(f,"wb");
  if (!out) {
    fprintf(stderr,"Error: could not open %s for writing.\n",f);
    return(1);
  }

  /* write ndims, nvars */
  bytes = fwrite(&ndims,sizeof(int),1,out);
  if ((int)bytes != 1) {
    fprintf(stderr,"Error in WriteBinary(): Unable to write ndims to output file.\n");
  }
  bytes = fwrite(&nvars,sizeof(int),1,out);
  if ((int)bytes != 1) {
    fprintf(stderr,"Error in WriteBinary(): Unable to write nvars to output file.\n");
  }

  /* write dimensions */
  bytes = fwrite(dim,sizeof(int),ndims,out);
  if ((int)bytes != ndims) {
    fprintf(stderr,"Error in WriteBinary(): Unable to write dimensions to output file.\n");
  }

  /* write grid */
  size = 0;
  for (d = 0; d < ndims; d++) size += dim[d];
  bytes = fwrite(x,sizeof(double),size,out);
  if ((int)bytes != size) {
    fprintf(stderr,"Error in WriteBinary(): Unable to write grid to output file.\n");
  }

  /* write solution */
  size = 1;
  for (d = 0; d < ndims; d++) size *= dim[d]; size *= nvars;
  bytes = fwrite(u,sizeof(double),size,out);
  if ((int)bytes != size) {
    fprintf(stderr,"Error in WriteBinary(): Unable to write solution to output file.\n");
  }

  fclose(out);
  return(0);
}

WriteText()

int WriteText	(	int	ndims,
		int	nvars,
		int *	dim,
		double *	x,
		double *	u,
		char *	f,
		int *	index
	)

Write a vector field and its associated grid to a text file. The data is written to the text file in the following format:

Each line of the file contains
i0 i1 ... i{ndims-1} x0[i0] x1[i1] ... x{ndims-1}[i{ndims-1}] u0[p] u1[p] ... u{nvars-1}[p]

where
(i0,i1,...,i{ndims-1}) represents a ndims-dimensional grid index,
x0, x1, ..., x{ndims-1} are the spatial dimensions (e.g. in 3D, ndims = 3, x0 = x, x1 = y, x2 = z)
u0, u1, ..., u{nvars-1} are the components of the vector field u
p = i0 + dim[0] * (i1 + dim[1] * (i2 + dim[2] * ( ... + dim[ndims-2] * i{ndims-1} ))) (see _ArrayIndexnD_)
Thus, the number of lines is dim[0]*dim[1]*...*dim[ndims-1]

This is a plain text file, so it can be visualized using, say MATLAB, or any software that can read data from a plain text file. For 1D (ndims = 1), the data can be easily plotted in Gnuplot (for example).

Parameters

ndims	Number of spatial dimensions
nvars	Number of variables at each grid point
dim	Integer array with the number of grid points in each spatial dimension as its entries
x	Array of spatial coordinates representing a Cartesian grid (no ghost points)
u	Array containing the vector field to write (no ghost points)
f	Filename
index	Preallocated integer array of size ndims

Definition at line 27 of file WriteText.c.

{
  FILE *out;
  out = fopen(f,"w");
  if (!out) {
    fprintf(stderr,"Error: could not open %s for writing.\n",f);
    return(1);
  }

  int done = 0; _ArraySetValue_(index,ndims,0);
  while (!done) {
    int i, p;
    _ArrayIndex1D_(ndims,dim,index,0,p);
    for (i=0; i<ndims; i++) fprintf(out,"%4d ",index[i]);
    for (i=0; i<ndims; i++) {
      int j,offset = 0; for (j=0; j<i; j++) offset += dim[j];
      fprintf(out,"%+1.16E ",x[offset+index[i]]);
    }
    for (i=0; i<nvars; i++) fprintf(out,"%+1.16E ",u[nvars*p+i]);
    fprintf(out,"\n");
    _ArrayIncrementIndex_(ndims,dim,index,done);
  }
  fclose(out);
  return(0);
}

WriteTecplot2D()

int WriteTecplot2D	(	int	ndims,
		int	nvars,
		int *	dim,
		double *	x,
		double *	u,
		char *	f,
		int *	index
	)

Write a vector field and its associated grid to a 2D Tecplot file. This file can then be visualized using Tecplot (http://www.tecplot.org) (if available).

Note: It's essentially a text file, and apart from the first two lines with Tecplot specific headers, the data is written out in the same format as WriteText().

Parameters

ndims	Number of spatial dimensions
nvars	Number of variables at each grid point
dim	Integer array with the number of grid points in each spatial dimension as its entries
x	Array of spatial coordinates representing a Cartesian grid (no ghost points)
u	Array containing the vector field to write (no ghost points)
f	Filename
index	Preallocated integer array of size ndims

Definition at line 19 of file WriteTecplot2D.c.

{
  if (ndims !=2) {
    fprintf(stderr,"Error in WriteTecplot2D(): This functions is hardcoded for 2-dimensional ");
    fprintf(stderr,"problems only. Instead, ndims=%d.\n",ndims);
    return(1);
  }
  int i;
  int imax = dim[0];
  int jmax = dim[1];

  FILE *out;
  out = fopen(f,"w");
  if (!out) {
    fprintf(stderr,"Error: could not open %s for writing.\n",f);
    return(1);
  }

  /* writing tecplot data file headers */
  fprintf(out,"VARIABLES=\"I\",\"J\",\"X\",\"Y\",");
  char varname[3] = "00";
  for (i = 0; i < nvars; i++) {
    fprintf(out,"\"%s\",",varname);
    if (varname[1] == '9') { varname[0]++; varname[1] = '0'; }
    else                     varname[1]++;
  }
  fprintf(out,"\n");
  fprintf(out,"ZONE I=%d,J=%d,F=POINT\n",imax,jmax);

  /* writing the data */
  int done = 0; _ArraySetValue_(index,ndims,0);
  while (!done) {
    int i, p;
    _ArrayIndex1D_(ndims,dim,index,0,p);
    for (i=0; i<ndims; i++) fprintf(out,"%4d ",index[i]);
    for (i=0; i<ndims; i++) {
      int j,offset = 0; for (j=0; j<i; j++) offset += dim[j];
      fprintf(out,"%+1.16E ",x[offset+index[i]]);
    }
    for (i=0; i<nvars; i++) fprintf(out,"%+1.16E ",u[nvars*p+i]);
    fprintf(out,"\n");
    _ArrayIncrementIndex_(ndims,dim,index,done);
  }
  fclose(out);
  return(0);
}

WriteTecplot3D()

int WriteTecplot3D	(	int	ndims,
		int	nvars,
		int *	dim,
		double *	x,
		double *	u,
		char *	f,
		int *	index
	)

Write a vector field and its associated grid to a 3D Tecplot file. This file can then be visualized using Tecplot (http://www.tecplot.org) (if available)

Note: It's essentially a text file, and apart from the first two lines with Tecplot specific headers, the data is written out in the same format as WriteText().

Parameters

ndims	Number of spatial dimensions
nvars	Number of variables at each grid point
dim	Integer array with the number of grid points in each spatial dimension as its entries
x	Array of spatial coordinates representing a Cartesian grid (no ghost points)
u	Array containing the vector field to write (no ghost points)
f	Filename
index	Preallocated integer array of size ndims

Definition at line 19 of file WriteTecplot3D.c.

{
  if (ndims !=3) {
    fprintf(stderr,"Error in WriteTecplot3D(): This functions is hardcoded for 3-dimensional ");
    fprintf(stderr,"problems only. Instead, ndims=%d.\n",ndims);
    return(1);
  }
  int i;
  int imax = dim[0];
  int jmax = dim[1];
  int kmax = dim[2];

  FILE *out;
  out = fopen(f,"w");
  if (!out) {
    fprintf(stderr,"Error: could not open %s for writing.\n",f);
    return(1);
  }

  /* writing tecplot data file headers */
  fprintf(out,"VARIABLES=\"I\",\"J\",\"K\",\"X\",\"Y\",\"Z\",");
  char varname[3] = "00";
  for (i = 0; i < nvars; i++) {
    fprintf(out,"\"%s\",",varname);
    if (varname[1] == '9') { varname[0]++; varname[1] = '0'; }
    else                     varname[1]++;
  }
  fprintf(out,"\n");
  fprintf(out,"ZONE I=%d,J=%d,K=%d,F=POINT\n",imax,jmax,kmax);

  /* writing the data */
  int done = 0; _ArraySetValue_(index,ndims,0);
  while (!done) {
    int i, p;
    _ArrayIndex1D_(ndims,dim,index,0,p);
    for (i=0; i<ndims; i++) fprintf(out,"%4d ",index[i]);
    for (i=0; i<ndims; i++) {
      int j,offset = 0; for (j=0; j<i; j++) offset += dim[j];
      fprintf(out,"%+1.16E ",x[offset+index[i]]);
    }
    for (i=0; i<nvars; i++) fprintf(out,"%+1.16E ",u[nvars*p+i]);
    fprintf(out,"\n");
    _ArrayIncrementIndex_(ndims,dim,index,done);
  }
  fclose(out);
  return(0);
}