Databox *ReadSimpleB(
char *file_name,
double default_value)
{
Databox *v;
FILE *fp;
int nx, ny, nz;
double *ptr;
/* open the input file */
if ((fp = fopen(file_name, "rb")) == NULL)
return((Databox *)NULL);
/* read in header info */
tools_ReadInt(fp, &nx, 1);
tools_ReadInt(fp, &ny, 1);
tools_ReadInt(fp, &nz, 1);
/* create the new databox structure */
if ((v = NewDataboxDefault(nx, ny, nz, 0, 0, 0, 0, 0, 0, default_value)) == NULL)
{
fclose(fp);
return((Databox *)NULL);
}
/* read in the databox data */
ptr = DataboxCoeffs(v);
tools_ReadDouble(fp, ptr, nx*ny*nz);
fclose(fp);
return v;
}
Databox *ReadSimpleA(
char *file_name,
double default_value)
{
Databox *v;
FILE *fp;
int nx, ny, nz;
int m;
double *ptr;
/* open the input file */
if ((fp = fopen(file_name, "r")) == NULL)
return ((Databox *)NULL);
/* read in header info */
fscanf(fp, "%d %d %d", &nx, &ny, &nz);
/* create the new databox structure */
if ((v = NewDataboxDefault(nx, ny, nz, 0, 0, 0, 0, 0, 0, default_value)) == NULL)
{
fclose(fp);
return((Databox *)NULL);
}
/* read in the databox data */
ptr = DataboxCoeffs(v);
for (m = nx * ny * nz; m--;)
fscanf(fp, "%lf", ptr++);
fclose(fp);
return v;
}
Databox *CompFlux(
Databox *k,
Databox *h)
{
Databox *flux;
int nx, ny, nz;
double x, y, z;
double dx, dy, dz;
double *fluxp, *kp, *hp;
double qxp, qxm, qyp, qym, qzp, qzm;
int cell,
cell_xm1, cell_xp1,
cell_ym1, cell_yp1,
cell_zm1, cell_zp1;
int ii, jj, kk;
nx = DataboxNx(k);
ny = DataboxNy(k);
nz = DataboxNz(k);
x = DataboxX(k);
y = DataboxY(k);
z = DataboxZ(k);
dx = DataboxDx(k);
dy = DataboxDy(k);
dz = DataboxDz(k);
#if 0 /* ADD LATER */
if ((dx != DataboxDx(h)) ||
(dy != DataboxDy(h)) ||
(dz != DataboxDz(h)))
{
Error("Spacings are not compatible\n");
return NULL;
}
#endif
if ((flux = NewDatabox(nx, ny, nz, x, y, z, dx, dy, dz)) == NULL)
return((Databox*)NULL);
kp = DataboxCoeffs(k);
hp = DataboxCoeffs(h);
fluxp = DataboxCoeffs(flux);
cell = 0;
cell_xm1 = cell - 1;
cell_xp1 = cell + 1;
cell_ym1 = cell - nx;
cell_yp1 = cell + nx;
cell_zm1 = cell - nx * ny;
cell_zp1 = cell + nx * ny;
kp += nx * ny;
hp += nx * ny;
fluxp += nx * ny;
for (kk = 1; kk < (nz - 1); kk++)
{
kp += nx;
hp += nx;
fluxp += nx;
for (jj = 1; jj < (ny - 1); jj++)
{
kp++;
hp++;
fluxp++;
for (ii = 1; ii < (nx - 1); ii++)
{
qxp = -Mean(kp[cell_xp1], kp[cell]) * (hp[cell_xp1] - hp[cell]) / dx;
qxm = -Mean(kp[cell], kp[cell_xm1]) * (hp[cell] - hp[cell_xm1]) / dx;
qyp = -Mean(kp[cell_yp1], kp[cell]) * (hp[cell_yp1] - hp[cell]) / dy;
qym = -Mean(kp[cell], kp[cell_ym1]) * (hp[cell] - hp[cell_ym1]) / dy;
qzp = -Mean(kp[cell_zp1], kp[cell]) * (hp[cell_zp1] - hp[cell]) / dz;
qzm = -Mean(kp[cell], kp[cell_zm1]) * (hp[cell] - hp[cell_zm1]) / dz;
fluxp[cell] = (qxp - qxm) * dy * dz + (qyp - qym) * dx * dz + (qzp - qzm) * dx * dy;
kp++;
hp++;
fluxp++;
}
kp++;
hp++;
fluxp++;
}
kp += nx;
hp += nx;
fluxp += nx;
}
return flux;
}
void SigDiff(
Databox *v1,
Databox *v2,
int m,
double absolute_zero,
FILE *fp)
{
double *v1_p, *v2_p;
double sig_dig_rhs;
double adiff, amax, sdiff;
double max_adiff = 0.0, max_sdiff;
int i, j, k;
int mi = 0, mj = 0, mk = 0;
int nx, ny, nz;
int sig_digs;
int m_sig_digs, m_sig_digs_everywhere;
/*-----------------------------------------------------------------------
* check that dimensions are the same
*-----------------------------------------------------------------------*/
nx = DataboxNx(v1);
ny = DataboxNy(v1);
nz = DataboxNz(v1);
/*-----------------------------------------------------------------------
* diff the values and print the results
*-----------------------------------------------------------------------*/
if (m >= 0)
sig_dig_rhs = 0.5 / pow(10.0, ((double) m));
else
sig_dig_rhs = 0.0;
v1_p = DataboxCoeffs(v1);
v2_p = DataboxCoeffs(v2);
m_sig_digs_everywhere = TRUE;
max_sdiff = 0.0;
for (k = 0; k < nz; k++)
{
for (j = 0; j < ny; j++)
{
for (i = 0; i < nx; i++)
{
adiff = fabs((*v1_p) - (*v2_p));
amax = max(fabs(*v1_p), fabs(*v2_p));
m_sig_digs = TRUE;
if (amax > absolute_zero)
{
sdiff = adiff / amax;
if ( sdiff > sig_dig_rhs )
m_sig_digs = FALSE;
}
if (!m_sig_digs)
{
if (m >= 0)
{
fprintf(fp, "(%d,%d,%d) : %e, %e, %e\n",
i, j, k, adiff, *v1_p, *v2_p);
}
if (sdiff > max_sdiff)
{
max_sdiff = sdiff;
max_adiff = adiff;
mi = i;
mj = j;
mk = k;
}
m_sig_digs_everywhere = FALSE;
}
v1_p++;
v2_p++;
}
}
}
if (!m_sig_digs_everywhere)
{
/* compute min number of sig digs */
sig_digs = 0;
sdiff = max_sdiff;
while (sdiff <= 0.5e-01)
{
sdiff *= 10.0;
sig_digs++;
}
fprintf(fp, "Minimum significant digits at (% 3d, %3d, %3d) = %2d\n",
mi, mj, mk, sig_digs);
fprintf(fp, "Maximum absolute difference = %e\n", max_adiff);
}
}
void MSigDiff(
Tcl_Interp *interp,
Databox *v1,
Databox *v2,
int m,
double absolute_zero,
Tcl_Obj *result)
{
double *v1_p, *v2_p;
double sig_dig_rhs;
double adiff, amax, sdiff;
double max_adiff = 0.0, max_sdiff;
int i, j, k;
int mi = 0, mj = 0, mk = 0;
int nx, ny, nz;
int sig_digs;
int m_sig_digs, m_sig_digs_everywhere;
/*-----------------------------------------------------------------------
* check that dimensions are the same
*-----------------------------------------------------------------------*/
nx = DataboxNx(v1);
ny = DataboxNy(v1);
nz = DataboxNz(v1);
/*-----------------------------------------------------------------------
* diff the values and print the results
*-----------------------------------------------------------------------*/
if (m >= 0)
sig_dig_rhs = 0.5 / pow(10.0, ((double) m));
else
sig_dig_rhs = 0.0;
v1_p = DataboxCoeffs(v1);
v2_p = DataboxCoeffs(v2);
m_sig_digs_everywhere = TRUE;
max_sdiff = 0.0;
for (k = 0; k < nz; k++)
{
for (j = 0; j < ny; j++)
{
for (i = 0; i < nx; i++)
{
adiff = fabs((*v1_p) - (*v2_p));
amax = max(fabs(*v1_p), fabs(*v2_p));
if ( max_adiff < adiff )
max_adiff = adiff;
m_sig_digs = TRUE;
if (amax > absolute_zero)
{
sdiff = adiff / amax;
if ( sdiff > sig_dig_rhs )
m_sig_digs = FALSE;
}
if (!m_sig_digs)
{
if (sdiff > max_sdiff)
{
max_sdiff = sdiff;
mi = i;
mj = j;
mk = k;
}
m_sig_digs_everywhere = FALSE;
}
v1_p++;
v2_p++;
}
}
}
if (!m_sig_digs_everywhere)
{
Tcl_Obj *double_obj;
Tcl_Obj *int_obj;
Tcl_Obj *list_obj;
/* compute min number of sig digs */
sig_digs = 0;
sdiff = max_sdiff;
while (sdiff <= 0.5e-01)
{
sdiff *= 10.0;
sig_digs++;
}
/* Create a Tcl list of the form: {{mi mj mk sig_digs} max_adiff} */
/* and append it to the result string. */
list_obj = Tcl_NewListObj(0, NULL);
int_obj = Tcl_NewIntObj(mi);
Tcl_ListObjAppendElement(interp, list_obj, int_obj);
int_obj = Tcl_NewIntObj(mj);
Tcl_ListObjAppendElement(interp, list_obj, int_obj);
int_obj = Tcl_NewIntObj(mk);
Tcl_ListObjAppendElement(interp, list_obj, int_obj);
int_obj = Tcl_NewIntObj(sig_digs);
Tcl_ListObjAppendElement(interp, list_obj, int_obj);
Tcl_ListObjAppendElement(interp, result, list_obj);
double_obj = Tcl_NewDoubleObj(max_adiff);
Tcl_ListObjAppendElement(interp, result, double_obj);
}
}
Databox *ReadSDS(char *filename, int ds_num,
double default_value)
{
Databox *v;
int32 dim[MAX_VAR_DIMS];
int32 edges[3];
int32 start[3];
int i;
int z;
int32 type;
char name[MAX_NC_NAME];
int32 sd_id;
int32 sds_id;
int32 rank, nt, nattrs;
int nx, ny, nz;
int m;
double *double_ptr;
sd_id = SDstart(filename, DFACC_RDONLY);
sds_id = SDselect(sd_id, ds_num);
SDgetinfo(sds_id, name, &rank, dim, &type, &nattrs);
start[0] = start[1] = start[2] = 0;
/* create the new databox structure */
if((v = NewDatabox(dim[2], dim[1], dim[0], 0, 0, 0, 0, 0, 0, default_value)) == NULL)
return((Databox *)NULL);
double_ptr = DataboxCoeffs(v);
edges[0] = 1;
edges[1] = DataboxNy(v);
edges[2] = DataboxNx(v);
switch (type) {
case DFNT_FLOAT32 :
{
float32 *convert_ptr, *data;
if( (data = convert_ptr = (float32 *)malloc(dim[1]*dim[2] *
sizeof(float32))) == NULL)
{
exit(1);
}
for(z=0; z < dim[0]; z++)
{
start[0] = z;
SDreaddata(sds_id, start, NULL, edges, data);
convert_ptr = data;
for(i=dim[1]*dim[2]; i--;)
*double_ptr++ = *convert_ptr++;
}
free(data);
break;
};
case DFNT_FLOAT64 :
{
float64 *convert_ptr, *data;
if( (data = convert_ptr = (float64 *)malloc(dim[1]*dim[2] *
sizeof(float64))) == NULL)
{
exit(1);
}
for(z=0; z < dim[0]; z++)
{
start[0] = z;
SDreaddata(sds_id, start, NULL, edges, data);
convert_ptr = data;
for(i=dim[1]*dim[2]; i--;)
*double_ptr++ = *convert_ptr++;
}
free(data);
break;
};
case DFNT_INT8 :
{
int8 *convert_ptr, *data;
if( (data = convert_ptr = (int8 *)malloc(dim[1]*dim[2] *
sizeof(int8))) == NULL)
{
exit(1);
}
for(z=0; z < dim[0]; z++)
{
start[0] = z;
SDreaddata(sds_id, start, NULL, edges, data);
convert_ptr = data;
for(i=dim[1]*dim[2]; i--;)
*double_ptr++ = *convert_ptr++;
}
free(data);
break;
};
case DFNT_UINT8 :
{
uint8 *convert_ptr, *data;
if( (data = convert_ptr = (uint8 *)malloc(dim[1]*dim[2] *
sizeof(uint8))) == NULL)
{
exit(1);
}
for(z=0; z < dim[0]; z++)
{
start[0] = z;
SDreaddata(sds_id, start, NULL, edges, data);
convert_ptr = data;
for(i=dim[1]*dim[2]; i--;)
*double_ptr++ = *convert_ptr++;
}
free(data);
break;
};
case DFNT_INT16 :
{
int16 *convert_ptr, *data;
if( (data = convert_ptr = (int16 *)malloc(dim[1]*dim[2] *
sizeof(int16))) == NULL)
{
exit(1);
}
for(z=0; z < dim[0]; z++)
{
start[0] = z;
SDreaddata(sds_id, start, NULL, edges, data);
convert_ptr = data;
for(i=dim[1]*dim[2]; i--;)
*double_ptr++ = *convert_ptr++;
}
free(data);
break;
};
case DFNT_UINT16 :
{
uint16 *convert_ptr, *data;
if( (data = convert_ptr = (uint16 *)malloc(dim[1]*dim[2] *
sizeof(uint16))) == NULL)
{
exit(1);
}
for(z=0; z < dim[0]; z++)
{
start[0] = z;
SDreaddata(sds_id, start, NULL, edges, data);
convert_ptr = data;
for(i=dim[1]*dim[2]; i--;)
*double_ptr++ = *convert_ptr++;
}
free(data);
break;
};
case DFNT_INT32 :
{
int32 *convert_ptr, *data;
if( (data = convert_ptr = (int32 *)malloc(dim[1]*dim[2] *
sizeof(int32))) == NULL)
{
exit(1);
}
for(z=0; z < dim[0]; z++)
{
start[0] = z;
SDreaddata(sds_id, start, NULL, edges, data);
convert_ptr = data;
for(i=dim[1]*dim[2]; i--;)
*double_ptr++ = *convert_ptr++;
}
free(data);
break;
};
case DFNT_UINT32 :
{
uint32 *convert_ptr, *data;
if( (data = convert_ptr = (uint32 *)malloc(dim[1]*dim[2] *
sizeof(uint32))) == NULL)
{
exit(1);
}
for(z=0; z < dim[0]; z++)
{
start[0] = z;
SDreaddata(sds_id, start, NULL, edges, data);
convert_ptr = data;
for(i=dim[1]*dim[2]; i--;)
*double_ptr++ = *convert_ptr++;
}
free(data);
break;
};
}
SDendaccess(sds_id);
SDend(sd_id);
return v;
}
Databox *ReadAVSField(
char *file_name,
double default_value)
{
Databox *v;
FILE *fp;
char *header = NULL;
int header_size = 0;
int count;
int tokens;
int c;
char **token, **value;
char begin[64];
int i, j;
int NX = -1, NY = -1, NZ = -1;
int datatype = -1; /* 0 = byte, 1 = int, 2 = float, 3 = double */
int is_rect = 0;
int ndim = -1;
int veclen = 1;
double min[3], max[3];
double X, Y, Z;
double DX, DY, DZ;
double *ptr;
/* open the input file */
if ((fp = fopen(file_name, "rb")) == NULL)
return NULL;
/* read in header info */
fgets(begin,64,fp);
if (strncmp(begin,"# AVS",5) != 0)
return NULL;
while (begin[strlen(begin)-1] != '\n')
fgets(begin,64,fp);
header_size = HEADER_SIZE_INIT;
header = (char *)malloc(header_size);
count = 0;
while ((c = fgetc(fp)) != EOF) {
if (count == header_size) {
header_size += HEADER_SIZE_INC;
header = (char *)realloc(header,header_size);
}
if (c == 0xC) {
/* end of header */
header[count] = '\0';
break;
}
else
header[count++] = c;
}
fgetc(fp); /* == 0xC */
if (parse_fld_header(header,&tokens,&token,&value) != 1)
return NULL;
/* extract relevant info from token/value pairs */
for (i = 0; i < tokens; i++) {
if (strcmp(token[i],"dim1") == 0)
NX = atoi(value[i]);
else if (strcmp(token[i],"dim2") == 0)
NY = atoi(value[i]);
else if (strcmp(token[i],"dim3") == 0)
NZ = atoi(value[i]);
else if (strcmp(token[i],"ndim") == 0) {
switch (ndim = atoi(value[i])) {
case 1: NY = 1;
case 2: NZ = 1;
case 3: break;
default: free_pairs(tokens,token,value); return NULL;
}
}
else if (strcmp(token[i],"veclen") == 0) {
if ((veclen = atoi(value[i])) < 1) {
free_pairs(tokens,token,value); return NULL;
}
}
else if (strcmp(token[i],"field") == 0 && strcmp(value[i],"uniform") != 0)
{
if (strcmp(value[i],"rectilinear") == 0)
/* treat rectilinear grid as uniform to convert */
is_rect = 1;
else {
free_pairs(tokens,token,value); return NULL;
}
}
else if (strcmp(token[i],"data") == 0) {
if (strcmp(value[i],"byte") == 0)
datatype = 0;
else if (strcmp(value[i],"int") == 0 || strcmp(value[i],"integer") == 0)
datatype = 1;
else if (strcmp(value[i],"float") == 0 || strcmp(value[i],"single") == 0)
datatype = 2;
else if (strcmp(value[i],"double") == 0)
datatype = 3;
else {
free_pairs(tokens,token,value); return NULL;
}
}
}
free_pairs(tokens,token,value);
free(header);
if (NX == -1 || NY == -1 || NZ == -1) {
return NULL;
}
if (datatype == -1) {
/* datatype was not set */
return NULL;
}
/* create the new databox structure */
/* set X, Y, Z, DX, DY, DZ to 0 initially; will calculate and set later */
if ((v = NewDataboxDefault(NX, NY, NZ, 0, 0, 0, 0, 0, 0, default_value)) == NULL)
{
fclose(fp);
return((Databox *)NULL);
}
{
/* get data values */
char *barray;
int *iarray;
float *farray;
double *darray;
barray = (char *)malloc(veclen);
iarray = (int *)malloc(veclen*sizeof(int));
farray = (float *)malloc(veclen*sizeof(float));
darray = (double *)malloc(veclen*sizeof(double));
ptr = DataboxCoeffs(v);
for (i = 0; i < NX*NY*NZ; i++) {
switch (datatype) {
case 0:
{
fread(barray,sizeof(char),veclen,fp);
for (j = 0; j < veclen; j++)
darray[j] = barray[j];
break;
}
case 1:
{
fread(iarray,sizeof(int),veclen,fp);
for (j = 0; j < veclen; j++)
darray[j] = iarray[j];
break;
}
case 3:
{
fread(darray,sizeof(double),veclen,fp);
break;
}
case 2:
default:
{
fread(farray,sizeof(float),veclen,fp);
for (j = 0; j < veclen; j++)
darray[j] = farray[j];
break;
}
}
/* use first component by default */
ptr[i] = darray[0];
}
}
if (is_rect) {
/* hack in rectilinear data by keeping the min and max coordinates */
float *f;
int xcoords, ycoords, zcoords;
int coords;
xcoords = NX; ycoords = NY; zcoords = NZ;
switch (ndim) {
case 1: ycoords = 0;
case 2: zcoords = 0; break;
case 3: break;
default: return NULL;
}
coords = xcoords + ycoords + zcoords;
f = (float *)malloc((coords)*sizeof(float));
fread(f,sizeof(float),coords,fp);
min[0] = f[0]; max[0] = f[xcoords-1];
if (ndim == 2)
min[2] = max[2] = 0;
else
min[2] = f[xcoords+ycoords]; max[2] = f[xcoords+ycoords+zcoords-1];
if (ndim == 1)
min[1] = max[1] = 0;
else
min[1] = f[xcoords]; max[1] = f[xcoords+ycoords-1];
free(f);
}
else {
/* true uniform data */
float f[6];
fread(f,sizeof(float),6,fp);
min[0] = f[0]; min[1] = f[2]; min[2] = f[4];
max[0] = f[1]; max[1] = f[3]; max[2] = f[5];
}
X = min[0]; Y = min[1]; Z = min[2];
/* set DX/DY/DZ to 1 if grid is only 1 wide in that dimension */
if (NX != 1)
DX = (max[0]-min[0])/(NX-1);
else
DX = 1;
if (NY != 1)
DY = (max[1]-min[1])/(NY-1);
else
DY = 1;
if (NZ != 1)
DZ = (max[2]-min[2])/(NZ-1);
else
DZ = 1;
DataboxX(v) = X;
DataboxY(v) = Y;
DataboxZ(v) = Z;
DataboxDx(v) = DX;
DataboxDy(v) = DY;
DataboxDz(v) = DZ;
fclose(fp);
return v;
}
