/*
* This program tests the fix for a large file bug in versions
* previous to netCDF-4.1.2 for 32-bit platforms, writing to a
* variable with more than 1 dimension and more than 2**32 values,
* where the write starts after the first 2**32 elements. The bug
* applies to record variables with more than 2**32 values per record
* as well, but that's not tested here.
*/
static int
test_big_var(const char *testfile)
{
int ncid, varid, dimids[NUMDIMS];
size_t start[NUMDIMS] = {0, 0, 0, 0};
size_t count[NUMDIMS] = {1, 1, 1, DIM3};
short data[DIM3];
int i, j, k;
int nerrs = 0;
/* Create a file with one big 4D variable. */
if (nc_create(testfile, NC_CLOBBER, &ncid)) ERR;
if (nc_set_fill(ncid, NC_NOFILL, NULL)) ERR;
if (nc_def_dim(ncid, "dim0", DIM0, &dimids[0])) ERR;
if (nc_def_dim(ncid, "dim1", DIM1, &dimids[1])) ERR;
if (nc_def_dim(ncid, "dim2", DIM2, &dimids[2])) ERR;
if (nc_def_dim(ncid, "dim3", DIM3, &dimids[3])) ERR;
if (nc_def_var(ncid, "var", NC_SHORT, NUMDIMS, dimids, &varid)) ERR;
if (nc_enddef(ncid)) ERR;
/* write var(0,0,4294,*) as all FIRST_VAL */
start[0] = 0;
start[1] = 0;
start[2] = 4294;
for (j = 0; j < DIM3; j++)
data[j] = FIRST_VAL;
if (nc_put_vara_short(ncid, varid, start, count, &data[0])) ERR;
/* write var(0,1,0,*) as all 8588 */
start[0] = 0;
start[1] = 1;
start[2] = 0;
for (j = 0; j < DIM3; j++)
data[j] = SECOND_VAL;
if (nc_put_vara_short(ncid, varid, start, count, &data[0])) ERR;
/* Read and check var(0,0,4294,*) */
start[0] = 0;
start[1] = 0;
start[2] = 4294;
if (nc_get_vara_short(ncid, varid, start, count, &data[0])) ERR;
for (j = 0; j < DIM3; j++) {
if (data[j] != FIRST_VAL ) {
printf("error on start[0..2]: %d,%d,%d j: %d, expected %d got %d\n",
start[0], start[1], start[2], j, FIRST_VAL, data[j]);
ERR;
if(nerrs++ > 1)
return nerrs;
}
}
if (nc_close(ncid)) ERR;
return NC_NOERR;
}
int main(int argc, char *argv[])
{
int i, err, nerrs=0, ncid, dimid[2], varid[2];
short buf[10];
size_t start, count;
err = nc_create(FILE_NAME, NC_CLOBBER|NC_64BIT_DATA, &ncid); ERR;
err = nc_def_dim(ncid, "dim0", NC_MAX_UINT, &dimid[0]); ERR
err = nc_def_dim(ncid, "dim1", 10, &dimid[1]); ERR
/* define one small variable after one big variable */
err = nc_def_var(ncid, "var_big", NC_SHORT, 1, &dimid[0], &varid[0]); ERR
err = nc_def_var(ncid, "var_small", NC_SHORT, 1, &dimid[1], &varid[1]); ERR
err = nc_set_fill(ncid, NC_NOFILL, NULL); ERR
err = nc_enddef(ncid); ERR
/* write to var_big in location overlapping with var_small when using
* netCDF 4.4.x or prior */
start = NC_MAX_UINT/sizeof(short);
count = 10;
for (i=0; i<10; i++) buf[i] = i;
err = nc_put_vara_short(ncid, varid[0], &start, &count, buf); ERR
/* write var_small */
for (i=0; i<10; i++) buf[i] = -1;
err = nc_put_var_short(ncid, varid[1], buf); ERR
/* read back var_big and check contents */
for (i=0; i<10; i++) buf[i] = -1;
err = nc_get_vara_short(ncid, varid[0], &start, &count,buf); ERR
for (i=0; i<10; i++) {
if (buf[i] != i) {
printf("Error at buf[%d] expect %d but got %hd\n",i,i,buf[i]);
nerrs++;
}
}
err = nc_close(ncid); ERR
return (nerrs > 0);
}
/*********************************************************************
void mpp_put_var_value_block(int fid, int vid, const size_t *start, const size_t *nread, void *data)
read part of var data, the part is defined by start and nread.
*********************************************************************/
void mpp_put_var_value_block(int fid, int vid, const size_t *start, const size_t *nwrite, const void *data)
{
int status;
char errmsg[512];
if( mpp_pe() != mpp_root_pe() ) return;
if(fid<0 || fid >=nfiles) mpp_error("mpp_io(mpp_put_var_value_block): invalid fid number, fid should be "
"a nonnegative integer that less than nfiles");
if(vid<0 || vid >=files[fid].nvar) mpp_error("mpp_io(mpp_put_var_value_block): invalid vid number, vid should be "
"a nonnegative integer that less than nvar");
switch(files[fid].var[vid].type) {
case NC_DOUBLE:case NC_FLOAT:
status = nc_put_vara_double(files[fid].ncid, files[fid].var[vid].fldid, start, nwrite, data);
break;
case NC_INT:
status = nc_put_vara_int(files[fid].ncid, files[fid].var[vid].fldid, start, nwrite, data);
break;
case NC_SHORT:
status = nc_put_vara_short(files[fid].ncid, files[fid].var[vid].fldid, start, nwrite, data);
break;
case NC_CHAR:
status = nc_put_vara_text(files[fid].ncid, files[fid].var[vid].fldid, start, nwrite, data);
break;
default:
sprintf(errmsg, "mpp_io(mpp_put_var_value_block): field %s in file %s has an invalid type, "
"the type should be NC_DOUBLE, NC_FLOAT, NC_INT, NC_SHORT or NC_CHAR",
files[fid].var[vid].name, files[fid].name );
mpp_error(errmsg);
}
if(status != NC_NOERR) {
sprintf(errmsg, "mpp_io(mpp_put_var_value_block): Error in putting value of variable %s from file %s",
files[fid].var[vid].name, files[fid].name );
netcdf_error(errmsg, status);
}
}; /* mpp_put_var_value_block */
void nc_put_vara(TYPE type,int ncid,int varid,const size_t start[],const size_t count[],const void *dp){
switch(type){
case(BYTE):
nc_put_vara_uchar(ncid,varid,start,count,(const unsigned char *)dp);
break;
case(SHORT):
nc_put_vara_short(ncid,varid,start,count,(const short *)dp);
break;
case(INT):
nc_put_vara_int(ncid,varid,start,count,(const int *)dp);
break;
case(LONG):
nc_put_vara_long(ncid,varid,start,count,(const long *)dp);
break;
case(FLOAT):
nc_put_vara_float(ncid,varid,start,count,(const float *)dp);
break;
case(DOUBLE):
nc_put_vara_double(ncid,varid,start,count,(const double *)dp);
break;
default:
printf("unkown types in nc_put_vara()!\n");
}
}
int main(int argc,char *argv[]) {
struct DataMap *ptr;
struct DataMapScalar *sx,*sy;
struct DataMapArray *ax,*ay;
size_t index[256];
size_t start[256];
size_t count[256];
int s;
unsigned char vbflg=0;
unsigned char help=0;
unsigned char option=0;
unsigned char zflg=0;
FILE *fp=NULL;
gzFile zfp=0;
FILE *mapfp;
int n,c,x;
int ncid;
int block=0;
int varid;
int strsze;
char **strptr;
char *tmpbuf=NULL;
OptionAdd(&opt,"-help",'x',&help);
OptionAdd(&opt,"-option",'x',&option);
OptionAdd(&opt,"vb",'x',&vbflg);
OptionAdd(&opt,"z",'x',&zflg);
if (argc>1) {
arg=OptionProcess(1,argc,argv,&opt,NULL);
if (help==1) {
OptionPrintInfo(stdout,hlpstr);
exit(0);
}
if (option==1) {
OptionDump(stdout,&opt);
exit(0);
}
if (zflg) {
zfp=gzopen(argv[arg],"r");
if (zfp==0) {
fprintf(stderr,"File not found.\n");
exit(-1);
}
} else {
fp=fopen(argv[arg],"r");
if (fp==NULL) {
fprintf(stderr,"File not found.\n");
exit(-1);
}
}
} else {
OptionPrintInfo(stdout,errstr);
exit(-1);
}
/* load the map */
mapfp=fopen(argv[arg+1],"r");
loadmap(mapfp);
fclose(mapfp);
s=nc_open(argv[arg+2],NC_WRITE,&ncid);
if (s !=NC_NOERR) {
fprintf(stderr,"Error opening CDF file.\n");
exit(-1);
}
block=0;
while (1) {
if (zflg) ptr=DataMapReadZ(zfp);
else ptr=DataMapFread(fp);
if (ptr==NULL) break;
for (c=0;c<ptr->snum;c++) {
sx=ptr->scl[c];
for (n=0;n<snum;n++) {
sy=sptr[n];
if (strcmp(sx->name,sy->name) !=0) continue;
if (sx->type !=sy->type) continue;
break;
}
if (n !=snum) { /* mapped variable */
s=nc_inq_varid(ncid,cdfsname[n],&varid);
if (s !=NC_NOERR) {
fprintf(stderr,"Error accessing CDF file.\n");
exit(-1);
}
index[0]=block;
switch (sx->type) {
case DATACHAR:
s=nc_put_var1_text(ncid,varid,index,sx->data.cptr);
break;
case DATASHORT:
s=nc_put_var1_short(ncid,varid,index,sx->data.sptr);
break;
case DATAINT:
s=nc_put_var1_int(ncid,varid,index,sx->data.iptr);
break;
case DATAFLOAT:
s=nc_put_var1_float(ncid,varid,index,sx->data.fptr);
break;
case DATADOUBLE:
s=nc_put_var1_double(ncid,varid,index,sx->data.dptr);
break;
case DATASTRING:
start[0]=block;
start[1]=0;
count[0]=1;
count[1]=strlen(*((char **) sx->data.vptr))+1;
s=nc_put_vara_text(ncid,varid,start,count,
*((char **) sx->data.vptr));
break;
}
if (s !=NC_NOERR) {
fprintf(stderr,"Error writing CDF file (%d).\n",s);
exit(-1);
}
}
}
for (c=0;c<ptr->anum;c++) {
ax=ptr->arr[c];
for (n=0;n<anum;n++) {
ay=aptr[n];
if (strcmp(ax->name,ay->name) !=0) continue;
if (ax->type !=ay->type) continue;
if (ax->dim !=ay->dim) continue;
break;
}
if (n !=anum) { /* mapped variable */
s=nc_inq_varid(ncid,cdfaname[n],&varid);
if (s !=NC_NOERR) {
fprintf(stderr,"Error accessing CDF file.\n");
exit(-1);
}
start[0]=block;
count[0]=1;
n=1;
for (x=0;x<ax->dim;x++) {
start[1+x]=0;
count[1+x]=ax->rng[x];
n=n*ax->rng[x];
}
if (ax->type==DATASTRING) {
int ndims;
int dimids[NC_MAX_VAR_DIMS];
size_t dimlen;
s=nc_inq_varndims(ncid,varid,&ndims);
if (s !=NC_NOERR) {
fprintf(stderr,"Error accessing CDF file.\n");
exit(-1);
}
s=nc_inq_vardimid(ncid,varid,dimids);
if (s !=NC_NOERR) {
fprintf(stderr,"Error accessing CDF file.\n");
exit(-1);
}
if (ndims-2!=ax->dim) {
fprintf(stderr,"Error matching dimensions.\n");
exit(-1);
}
s=nc_inq_dimlen(ncid,dimids[ndims-1],&dimlen);
if (s !=NC_NOERR) {
fprintf(stderr,"Error accessing CDF file.\n");
exit(-1);
}
strsze=dimlen;
tmpbuf=malloc(n*strsze);
if (tmpbuf==NULL) {
fprintf(stderr,"Failed to allocate buffer.\n");
exit(-1);
}
memset(tmpbuf,0,n*strsze);
start[1+ax->dim]=0;
count[1+ax->dim]=strsze;
strptr=(char **) ax->data.vptr;
for (x=0;x<n;x++) strncpy(tmpbuf+x*strsze,strptr[x],strsze);
}
switch (ax->type) {
case DATACHAR:
s=nc_put_vara_text(ncid,varid,start,count,ax->data.cptr);
break;
case DATASHORT:
s=nc_put_vara_short(ncid,varid,start,count,ax->data.sptr);
break;
case DATAINT:
s=nc_put_vara_int(ncid,varid,start,count,ax->data.iptr);
break;
case DATAFLOAT:
s=nc_put_vara_float(ncid,varid,start,count,ax->data.fptr);
break;
case DATADOUBLE:
s=nc_put_vara_double(ncid,varid,start,count,ax->data.dptr);
break;
case DATASTRING:
s=nc_put_vara_text(ncid,varid,start,count,tmpbuf);
break;
}
if (tmpbuf !=NULL) {
free(tmpbuf);
tmpbuf=NULL;
}
if (s !=NC_NOERR) {
fprintf(stderr,"Error writing CDF file (%d).\n",s);
exit(-1);
}
}
}
DataMapFree(ptr);
block++;
}
nc_close(ncid);
if (zflg) gzclose(zfp);
else fclose(fp);
return 0;
}
/* This function use the first dimension to parallel and reads and writes all needed data only once, there is no iteration. Stride is not supported */
int extract_unary_1D_all(int mpi_rank,int mpi_size, int ncid,int vlid,int ncidout,int vlidout,int ndims,nc_type vtype,size_t *shape,size_t *begins,size_t *ends,size_t preLen,size_t *outLen){
int i,res;
size_t *start=(size_t*)malloc(sizeof(size_t)*ndims); //start position for reading element from input file
size_t *countOut=(size_t *)malloc(sizeof(size_t)*ndims);
size_t *startOut=(size_t*)malloc(sizeof(size_t)*ndims); //start position for writing element to output file
size_t *shapeOut=(size_t*)malloc(sizeof(size_t)*ndims); //output dimension shape
size_t startOut0;
size_t countOut0;
int len0=1;
int lenOut=1;
for(i=0;i<ndims;++i){
/* shapeOut[0]=(ends[0]-begins[0])/strides[0]+1;*/
shapeOut[i]=ends[i]-begins[i]+1;
lenOut*=shapeOut[i];
if(i>0){
startOut[i]=0;
countOut[i]=shapeOut[i];
start[i]=begins[i];
len0*=ends[i]-begins[i]+1;
}
}
if(outLen!=NULL)
*outLen=lenOut;
if(shapeOut[0]>=mpi_size){
startOut0=mpi_rank*(shapeOut[0]/mpi_size);
if(mpi_rank!=mpi_size-1){
countOut0=(shapeOut[0]/mpi_size);
}else{
countOut0=shapeOut[0]-startOut0;
}
}else{
if(mpi_rank<shapeOut[0]){
startOut0=mpi_rank;
countOut0=1;
}else{
return 0;
}
}
int dataEnd=countOut0*len0;
printf("mpi_rank %d,countOut0 %d\n",mpi_rank,countOut0);
startOut[0]=startOut0+preLen/len0;
countOut[0]=countOut0;
/* start[0]=begins[0]+startOut0*strides[0];*/
start[0]=begins[0]+startOut0;
switch(vtype){
case NC_BYTE:
{
unsigned char* dataOut=(unsigned char *)malloc(sizeof(unsigned char)*dataEnd);
if((res=nc_get_vara_uchar(ncid,vlid,start,countOut,dataOut)))
BAIL(res);
if((res=nc_put_vara_uchar(ncidout,vlidout,startOut,countOut,(unsigned char *)dataOut)))
BAIL(res);
free(dataOut);
}
break;
case NC_CHAR:
{
char* dataOut=(char *)malloc(sizeof(char)*dataEnd);
if((res=nc_get_vara_schar(ncid,vlid,start,countOut,(signed char *)dataOut)))
BAIL(res);
if((res=nc_put_vara_schar(ncidout,vlidout,startOut,countOut,(signed char *)dataOut)))
BAIL(res);
free(dataOut);
}
break;
case NC_SHORT:
{
short *dataOut=(short *)malloc(sizeof(short)*dataEnd);
if((res=nc_get_vara_short(ncid,vlid,start,countOut,(short *)dataOut)))
BAIL(res);
if((res=nc_put_vara_short(ncidout,vlidout,startOut,countOut,(short *)dataOut)))
BAIL(res);
free(dataOut);
}
break;
case NC_INT:
{
int * dataOut=(int *)malloc(sizeof(int)*dataEnd);
if((res=nc_get_vara_int(ncid,vlid,start,countOut,(int *)dataOut)))
BAIL(res);
if((res=nc_put_vara_int(ncidout,vlidout,startOut,countOut,(int *)dataOut)))
BAIL(res);
free(dataOut);
}
break;
case NC_FLOAT:
{
float * dataOut=(float *)malloc(sizeof(float)*dataEnd);
if((res=nc_get_vara_float(ncid,vlid,start,countOut,(float *)dataOut)))
BAIL(res);
if((res=nc_put_vara_float(ncidout,vlidout,startOut,countOut,(float *)dataOut)))
BAIL(res);
free(dataOut);
}
break;
case NC_DOUBLE:
{
double* dataOut=(double *)malloc(sizeof(double)*dataEnd);
if((res=nc_get_vara_double(ncid,vlid,start,countOut,dataOut)))
BAIL(res);
if((res=nc_put_vara_double(ncidout,vlidout,startOut,countOut,(double *)dataOut)))
BAIL(res);
free(dataOut);
}
break;
default:
printf("Unknown data type\n");
}
free(start);
free(startOut);
free(shapeOut);
free(countOut);
return 0;
}
int extract_unary_1D(int mpi_rank,int mpi_size, int ncid,int vlid,int ncidout,int vlidout,int ndims,nc_type vtype,size_t *shape,size_t *begins,size_t *ends, ptrdiff_t *strides,size_t preLen,size_t *outLen){
int i,j,res;
size_t *divider=(size_t *)malloc(sizeof(size_t)*ndims); //input divider
size_t *dividerOut=(size_t *)malloc(sizeof(size_t)*ndims); // output divider
size_t *start=(size_t*)malloc(sizeof(size_t)*ndims); //start position for reading element from input file
size_t *count=(size_t*)malloc(sizeof(size_t)*ndims);
size_t *countOut=(size_t *)malloc(sizeof(size_t)*ndims);
size_t *startOut=(size_t*)malloc(sizeof(size_t)*ndims); //start position for writing element to output file
size_t *shapeOut=(size_t*)malloc(sizeof(size_t)*ndims); //output dimension shape
size_t startOut0;
size_t countOut0;
int len0=1;
int lenOut=1;
for(i=0;i<ndims;++i){
shapeOut[i]=(ends[i]-begins[i])/strides[i]+1;
lenOut*=shapeOut[i];
if(i>0){
startOut[i]=0;
countOut[i]=shapeOut[i];
start[i]=begins[i];
count[i]=ends[i]-begins[i]+1;
len0*=ends[i]-begins[i]+1;
}
}
if(outLen!=NULL)
*outLen=lenOut;
if(shapeOut[0]>=mpi_size){
startOut0=mpi_rank*(shapeOut[0]/mpi_size);
if(mpi_rank!=mpi_size-1){
countOut0=(shapeOut[0]/mpi_size);
}else{
countOut0=shapeOut[0]-startOut0;
}
}else{
if(mpi_rank<shapeOut[0]){
startOut0=mpi_rank;
countOut0=1;
}else{
return 0;
}
}
int dataEnd=lenOut/shapeOut[0];
void* data=(void*)malloc(sizeof(double)*len0);
void* dataOut=(void*)malloc(sizeof(double)*dataEnd);
size_t* poses=(size_t*)malloc(sizeof(size_t)*dataEnd);
getDivider(ndims,count,divider);
getDivider(ndims,countOut,dividerOut);
transfer_pos(poses,ndims-1,strides,dataEnd,dividerOut,divider);
printf("mpi_rank %d,countOut0 %d\n",mpi_rank,countOut0);
for(i=0;i<countOut0;++i){
startOut[0]=startOut0+i+preLen/len0;
countOut[0]=1;
start[0]=begins[0]+(startOut0+i)*strides[0];
count[0]=1;
switch(vtype){
case NC_BYTE:
if((res=nc_get_vara_uchar(ncid,vlid,start,count,(unsigned char *)data)))
BAIL(res);
if(len0==dataEnd){
if((res=nc_put_vara_uchar(ncidout,vlidout,startOut,countOut,(unsigned char *)data)))
BAIL(res);
}else{
for(j=0;j<dataEnd;++j){
((unsigned char *)dataOut)[j]=((unsigned char *)data)[poses[j]];
}
if((res=nc_put_vara_uchar(ncidout,vlidout,startOut,countOut,(unsigned char *)dataOut)))
BAIL(res);
}
break;
case NC_CHAR:
if((res=nc_get_vara_schar(ncid,vlid,start,count,(signed char *)data)))
BAIL(res);
if(len0==dataEnd){
if((res=nc_put_vara_schar(ncidout,vlidout,startOut,countOut,(signed char *)data)))
BAIL(res);
}else{
for(j=0;j<dataEnd;++j){
((signed char *)dataOut)[j]=((signed char *)data)[poses[j]];
}
if((res=nc_put_vara_schar(ncidout,vlidout,startOut,countOut,(signed char *)dataOut)))
BAIL(res);
}
break;
case NC_SHORT:
if((res=nc_get_vara_short(ncid,vlid,start,count,data)))
BAIL(res);
if(len0==dataEnd){
if((res=nc_put_vara_short(ncidout,vlidout,startOut,countOut,(short *)data)))
BAIL(res);
}else{
for(j=0;j<dataEnd;++j){
((short *)dataOut)[j]=((short *)data)[poses[j]];
}
if((res=nc_put_vara_short(ncidout,vlidout,startOut,countOut,(short *)dataOut)))
BAIL(res);
}
break;
case NC_INT:
if((res=nc_get_vara_int(ncid,vlid,start,count,(int *)data)))
BAIL(res);
if(len0==dataEnd){
if((res=nc_put_vara_int(ncidout,vlidout,startOut,countOut,(int *)data)))
BAIL(res);
}else{
for(j=0;j<dataEnd;++j){
((int *)dataOut)[j]=((int *)data)[poses[j]];
}
if((res=nc_put_vara_int(ncidout,vlidout,startOut,countOut,(int *)dataOut)))
BAIL(res);
}
break;
case NC_FLOAT:
if((res=nc_get_vara_float(ncid,vlid,start,count,data)))
BAIL(res);
if(len0==dataEnd){
if((res=nc_put_vara_float(ncidout,vlidout,startOut,countOut,(float *)data)))
BAIL(res);
}else{
for(j=0;j<dataEnd;++j){
((float *)dataOut)[j]=((float *)data)[poses[j]];
}
if((res=nc_put_vara_float(ncidout,vlidout,startOut,countOut,(float *)dataOut)))
BAIL(res);
}
break;
case NC_DOUBLE:
if((res=nc_get_vara_double(ncid,vlid,start,count,(double *)data)))
BAIL(res);
if(len0==dataEnd){
if((res=nc_put_vara_double(ncidout,vlidout,startOut,countOut,(double *)data)))
BAIL(res);
}else{
for(j=0;j<dataEnd;++j){
((double *)dataOut)[j]=((double *)data)[poses[j]];
}
if((res=nc_put_vara_double(ncidout,vlidout,startOut,countOut,(double *)dataOut)))
BAIL(res);
}
break;
default:
printf("Unknown data type\n");
}
}
/*free resourses*/
free(divider);
free(dividerOut);
free(start);
free(startOut);
free(shapeOut);
free(data);
free(dataOut);
free(poses);
return 0;
}
/*
* Write a hypercube of numeric values into a netCDF variable of an open
* netCDF file.
*/
static void
c_ncvpt (
int ncid, /* netCDF ID */
int varid, /* variable ID */
const size_t* start, /* multidimensional index of hypercube corner */
const size_t* count, /* multidimensional hypercube edge lengths */
const void* value, /* block of data values to be written */
int* rcode /* returned error code */
)
{
int status;
nc_type datatype;
if ((status = nc_inq_vartype(ncid, varid, &datatype)) == 0)
{
switch (datatype)
{
case NC_CHAR:
status = NC_ECHAR;
break;
case NC_BYTE:
# if NF_INT1_IS_C_SIGNED_CHAR
status = nc_put_vara_schar(ncid, varid, start, count,
(const signed char*)value);
# elif NF_INT1_IS_C_SHORT
status = nc_put_vara_short(ncid, varid, start, count,
(const short*)value);
# elif NF_INT1_IS_C_INT
status = nc_put_vara_int(ncid, varid, start, count,
(const int*)value);
# elif NF_INT1_IS_C_LONG
status = nc_put_vara_long(ncid, varid, start, count,
(const long*)value);
# endif
break;
case NC_SHORT:
# if NF_INT2_IS_C_SHORT
status = nc_put_vara_short(ncid, varid, start, count,
(const short*)value);
# elif NF_INT2_IS_C_INT
status = nc_put_vara_int(ncid, varid, start, count,
(const int*)value);
# elif NF_INT2_IS_C_LONG
status = nc_put_vara_long(ncid, varid, start, count,
(const long*)value);
# endif
break;
case NC_INT:
# if NF_INT_IS_C_INT
status = nc_put_vara_int(ncid, varid, start, count,
(const int*)value);
# elif NF_INT_IS_C_LONG
status = nc_put_vara_long(ncid, varid, start, count,
(const long*)value);
# endif
break;
case NC_FLOAT:
# if NF_REAL_IS_C_FLOAT
status = nc_put_vara_float(ncid, varid, start, count,
(const float*)value);
# elif NF_REAL_IS_C_DOUBLE
status = nc_put_vara_double(ncid, varid, start, count,
(const double*)value);
# endif
break;
case NC_DOUBLE:
# if NF_DOUBLEPRECISION_IS_C_FLOAT
status = nc_put_vara_float(ncid, varid, start, count,
(const float*)value);
# elif NF_DOUBLEPRECISION_IS_C_DOUBLE
status = nc_put_vara_double(ncid, varid, start, count,
(const double*)value);
# endif
break;
}
}
if (status == 0)
*rcode = 0;
else
{
nc_advise("NCVPT", status, "");
*rcode = ncerr;
}
}
int
main(int argc, char **argv)
{
int i;
char* filename = "tst_diskless.nc";
/* Set defaults */
persist = 0;
usenetcdf4 = 0;
mmap = 0;
for(i=1;i<argc;i++) {
if(strcmp(argv[i],"netcdf4")==0) usenetcdf4=1;
else if(strcmp(argv[i],"persist")==0) persist=1;
else if(strcmp(argv[i],"mmap")==0) mmap=1;
/* ignore anything not recognized */
}
#ifndef USE_NETCDF4
usenetcdf4 = 0;
#endif
if(mmap)
usenetcdf4 = 0;
flags = usenetcdf4?FLAGS4:FLAGS3;
if(persist) flags |= PERSIST;
if(mmap) flags |= NC_MMAP;
printf("\n*** Testing the diskless API.\n");
printf("*** testing diskless file with scalar vars...");
{
int ncid, varid0, varid1, varid2;
int ndims_in, nvars_in, natts_in, unlimdimid_in;
char name_in[NC_MAX_NAME + 1];
nc_type type_in;
float float_data = 3.14, float_data_in;
int int_data = 42, int_data_in;
short short_data = 2, short_data_in;
removefile(persist,filename);
/* Create a netCDF file (which exists only in memory). */
if (nc_create(filename, flags, &ncid)) ERR;
/* Create some variables. */
if (nc_def_var(ncid, RESISTOR, NC_INT, 0, NULL, &varid0)) ERR;
if (nc_def_var(ncid, CAPACITOR, NC_FLOAT, 0, NULL, &varid1)) ERR;
if (nc_def_var(ncid, NUM555, NC_SHORT, 0, NULL, &varid2)) ERR;
if (nc_enddef(ncid)) ERR;
/* Write some data to this file. */
if (nc_put_vara_int(ncid, varid0, NULL, NULL, &int_data)) ERR;
if (nc_put_vara_float(ncid, varid1, NULL, NULL, &float_data)) ERR;
if (nc_put_vara_short(ncid, varid2, NULL, NULL, &short_data)) ERR;
/* Now check the phony file. */
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 0 || nvars_in != 3 || natts_in != 0 || unlimdimid_in != -1) ERR;
/* Check variables. */
if (nc_inq_var(ncid, varid0, name_in, &type_in, &ndims_in, NULL, &natts_in)) ERR;
if (strcmp(name_in, RESISTOR) || type_in != NC_INT || ndims_in != 0 ||
natts_in != 0) ERR;
if (nc_inq_var(ncid, varid1, name_in, &type_in, &ndims_in, NULL, &natts_in)) ERR;
if (strcmp(name_in, CAPACITOR) || type_in != NC_FLOAT || ndims_in != 0 ||
natts_in != 0) ERR;
if (nc_inq_var(ncid, varid2, name_in, &type_in, &ndims_in, NULL, &natts_in)) ERR;
if (strcmp(name_in, NUM555) || type_in != NC_SHORT || natts_in != 0) ERR;
/* Read my absolutely crucial data. */
if (nc_get_vara_int(ncid, varid0, NULL, NULL, &int_data_in)) ERR;
if (int_data_in != int_data) ERR;
if (nc_get_vara_float(ncid, varid1, NULL, NULL, &float_data_in)) ERR;
if (float_data_in != float_data) ERR;
if (nc_get_vara_short(ncid, varid2, NULL, NULL, &short_data_in)) ERR;
if (short_data_in != short_data) ERR;
/* Close the file. */
if (nc_close(ncid))
abort(); //ERR;
}
SUMMARIZE_ERR;
if(!usenetcdf4 && persist) {
int ncid, varid0, varid1, varid2;
float float_data = 3.14, float_data_in;
int int_data = 42, int_data_in;
short short_data = 2, short_data_in;
printf("*** testing diskless open of previously created file...");
if (nc_open(filename, flags, &ncid)) ERR;
/* Read and compare */
if (nc_inq_varid(ncid, RESISTOR, &varid0)) ERR;
if (nc_inq_varid(ncid, CAPACITOR, &varid1)) ERR;
if (nc_inq_varid(ncid, NUM555, &varid2)) ERR;
if (nc_get_vara_int(ncid, varid0, NULL, NULL, &int_data_in)) ERR;
if (int_data_in != int_data) ERR;
if (nc_get_vara_float(ncid, varid1, NULL, NULL, &float_data_in)) ERR;
if (float_data_in != float_data) ERR;
if (nc_get_vara_short(ncid, varid2, NULL, NULL, &short_data_in)) ERR;
if (short_data_in != short_data) ERR;
nc_close(ncid);
}
SUMMARIZE_ERR;
printf("*** testing creation of simple diskless file...");
{
#define NDIMS 2
#define DIM0_NAME "Fun"
#define DIM1_NAME "Money"
#define DIM1_LEN 200
#define ATT0_NAME "home"
#define ATT0_TEXT "earthship"
#define VAR0_NAME "nightlife"
#define VAR1_NAME "time"
#define VAR2_NAME "taxi_distance"
int ncid, dimid[NDIMS], dimid_in[NDIMS], varid0, varid1, varid2;
int ndims_in, nvars_in, natts_in, unlimdimid_in;
char name_in[NC_MAX_NAME + 1], att0_in[NC_MAX_NAME + 1];
nc_type type_in;
size_t len_in;
short short_data[DIM1_LEN];
size_t start[1] = {0};
size_t count[1] = {DIM1_LEN};
int i;
float float_data = 42.22, float_data_in;
/* This is some really important data that I want to save. */
for (i = 0; i < DIM1_LEN; i++)
short_data[i] = i;
removefile(persist,filename);
/* Create a netCDF file (which exists only in memory). I am
* confident that the world-famous netCDF format is the way to
* store my data! */
if (nc_create(filename, flags, &ncid)) ERR;
/* Create some atts. They will help document my data forever. */
if (nc_put_att_text(ncid, NC_GLOBAL, ATT0_NAME,
sizeof(ATT0_TEXT) + 1, ATT0_TEXT)) ERR;
/* Create dimensions: money is limited, but fun is not! */
if (nc_def_dim(ncid, DIM0_NAME, NC_UNLIMITED, &dimid[0])) ERR;
if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimid[1])) ERR;
/* Create some variables. The data they hold must persist
* through the ages. */
if (nc_def_var(ncid, VAR0_NAME, NC_INT, NDIMS, dimid, &varid0)) ERR;
if (nc_def_var(ncid, VAR1_NAME, NC_FLOAT, 0, NULL, &varid1)) ERR;
if (nc_def_var(ncid, VAR2_NAME, NC_SHORT, 1, &dimid[1], &varid2)) ERR;
if (nc_enddef(ncid)) ERR;
/* Write some data to this file. I'm glad I'm saving this
* important data in such a safe format! */
if (nc_put_vara_float(ncid, varid1, NULL, NULL, &float_data)) ERR;
if (nc_put_vara_short(ncid, varid2, start, count, short_data)) ERR;
/* Now check the phony file. Is my data safe? */
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 2 || nvars_in != 3 || natts_in != 1 || unlimdimid_in != 0) ERR;
/* Check attributes - they will be needed by future generations
* of scientists to understand my data. */
if (nc_get_att_text(ncid, NC_GLOBAL, ATT0_NAME, att0_in)) ERR;
if (strcmp(att0_in, ATT0_TEXT)) ERR;
/* Check dimensions. */
if (nc_inq_dim(ncid, dimid[0], name_in, &len_in)) ERR;
if (strcmp(name_in, DIM0_NAME) || len_in != 0) ERR;
if (nc_inq_dim(ncid, dimid[1], name_in, &len_in)) ERR;
if (strcmp(name_in, DIM1_NAME) || len_in != DIM1_LEN) ERR;
/* Check variables. */
if (nc_inq_var(ncid, varid0, name_in, &type_in, &ndims_in, dimid_in, &natts_in)) ERR;
if (strcmp(name_in, VAR0_NAME) || type_in != NC_INT || ndims_in != NDIMS ||
dimid_in[0] != 0 || dimid_in[1] != 1 || natts_in != 0) ERR;
if (nc_inq_var(ncid, varid1, name_in, &type_in, &ndims_in, dimid_in, &natts_in)) ERR;
if (strcmp(name_in, VAR1_NAME) || type_in != NC_FLOAT || ndims_in != 0 ||
natts_in != 0) ERR;
if (nc_inq_var(ncid, varid2, name_in, &type_in, &ndims_in, dimid_in, &natts_in)) ERR;
if (strcmp(name_in, VAR2_NAME) || type_in != NC_SHORT || ndims_in != 1 ||
dimid_in[0] != 1 || natts_in != 0) ERR;
/* Read my absolutely crucial data. */
if (nc_get_vara_float(ncid, varid1, NULL, NULL, &float_data_in)) ERR;
if (float_data_in != float_data) ERR;
/* Close the file, losing all information. Hey! What kind of
* storage format is this, anyway? */
if (nc_close(ncid))
abort(); //ERR;
}
SUMMARIZE_ERR;
printf("*** testing diskless file with scalar vars and type conversion...");
{
#define DUNE "dune"
#define STAR_TREK "capacitor_value"
#define STAR_WARS "number_of_555_timer_chips"
int ncid, varid0, varid1, varid2;
int ndims_in, nvars_in, natts_in, unlimdimid_in;
char name_in[NC_MAX_NAME + 1];
nc_type type_in;
float float_data = 3.14, float_data_in;
int int_data = 42, int_data_in;
short short_data = 2, short_data_in;
removefile(persist,filename);
/* Create a netCDF file (which exists only in memory). */
if (nc_create(filename, flags, &ncid)) ERR;
/* Create some variables. */
if (nc_def_var(ncid, DUNE, NC_INT, 0, NULL, &varid0)) ERR;
if (nc_def_var(ncid, STAR_TREK, NC_FLOAT, 0, NULL, &varid1)) ERR;
if (nc_def_var(ncid, STAR_WARS, NC_SHORT, 0, NULL, &varid2)) ERR;
if (nc_enddef(ncid)) ERR;
/* Write some data to this file. */
if (nc_put_vara_int(ncid, varid0, NULL, NULL, &int_data)) ERR;
if (nc_put_vara_float(ncid, varid1, NULL, NULL, &float_data)) ERR;
if (nc_put_vara_short(ncid, varid2, NULL, NULL, &short_data)) ERR;
/* Now check the phony file. */
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 0 || nvars_in != 3 || natts_in != 0 || unlimdimid_in != -1) ERR;
/* Check variables. */
if (nc_inq_var(ncid, varid0, name_in, &type_in, &ndims_in, NULL, &natts_in)) ERR;
if (strcmp(name_in, DUNE) || type_in != NC_INT || ndims_in != 0 ||
natts_in != 0) ERR;
if (nc_inq_var(ncid, varid1, name_in, &type_in, &ndims_in, NULL, &natts_in)) ERR;
if (strcmp(name_in, STAR_TREK) || type_in != NC_FLOAT || ndims_in != 0 ||
natts_in != 0) ERR;
if (nc_inq_var(ncid, varid2, name_in, &type_in, &ndims_in, NULL, &natts_in)) ERR;
if (strcmp(name_in, STAR_WARS) || type_in != NC_SHORT || natts_in != 0) ERR;
/* Read my absolutely crucial data. */
if (nc_get_vara_int(ncid, varid0, NULL, NULL, &int_data_in)) ERR;
if (int_data_in != int_data) ERR;
if (nc_get_vara_float(ncid, varid1, NULL, NULL, &float_data_in)) ERR;
if (float_data_in != float_data) ERR;
if (nc_get_vara_short(ncid, varid2, NULL, NULL, &short_data_in)) ERR;
if (short_data_in != short_data) ERR;
/* Close the file. */
if (nc_close(ncid))
abort(); //ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
/* Unnecessary exit(0), FINAL_RESULTS returns. */
//exit(0);
}
int main(int argc, char* argv[])
{
char filename[100];
FILE* f;
if(argc<3){
printf("error: ");
printf("Call this program by \"%s filenamebase%%03d.sin out.nc\"\n",argv[0]);
return -1;
}
char line[MAXLINE];
//char Shortline[100];
int i,j,max=0,temp;
int ncid, x_dimid, y_dimid, z_dimid, varid;
int dimids[3],retval;
size_t start[3],count[3];
int x, y;
int nx,ny;
int datatype=0;
void* data;
int* intdata;
short* shortdata;
sprintf(filename,argv[1],0);
printf("%s \n",filename);
if((f=fopen(filename,"r"))){
fgets(line,MAXLINE,f);
fscanf(f,"%d",&nx);
fscanf(f,"%d",&ny);
fgets(line,MAXLINE,f);
printf("Volume Size: %dx%d\n",nx,ny);
for(j=0; j<3; j++) fgets(line,MAXLINE,f);
//printf("last line : %s\n",line);
for(j=0; j<10; j++) for(y=0; y<ny; y++) for(x=0; x<nx; x++){
fscanf(f,"%d",&temp);
if(temp>max) max=temp;
}
}
if(max>=SHRT_MAX) datatype=1;
if ((retval = nc_create(argv[2], NC_NETCDF4|NC_CLOBBER, &ncid))) ERR(retval);
if ((retval = nc_def_dim(ncid, "y", nx, &x_dimid))) ERR(retval);
if ((retval = nc_def_dim(ncid, "x", ny, &y_dimid))) ERR(retval);
if ((retval = nc_def_dim(ncid, "z", NC_UNLIMITED, &z_dimid))) ERR(retval);
dimids[0] = z_dimid;
dimids[1] = y_dimid;
dimids[2] = x_dimid;
printf("Start to convert sin to NetCDF format ...\n");
switch(datatype){
case 0: // short
printf("Use data type: short ...\n");
data = calloc(nx*ny, sizeof(short));
retval = nc_def_var(ncid, "density", NC_SHORT, 3, dimids, &varid);
break;
case 1: // int
printf("Use data type: int ...\n");
data = calloc(nx*ny, sizeof(int));
retval = nc_def_var(ncid, "density", NC_INT, 3, dimids, &varid);
break;
}
if (retval) ERR(retval);
if ((retval = nc_enddef(ncid))) ERR(retval);
count[0] = 1;
count[1] = ny;
count[2] = nx;
start[0] = 0;
start[1] = 0;
start[2] = 0;
for(i=0; i<100; i++){
sprintf(filename,argv[1],i);
printf("%s \n",filename);
if((f=fopen(filename,"r"))){
for(j=0; j<5; j++) fgets(line,MAXLINE,f);
for(j=0; j<10; j++){
shortdata = (short*)data;
intdata = (int*)data;
for(y=0; y<ny; y++)
for(x=0; x<nx; x++){
fscanf(f,"%d",&temp);
switch(datatype){
case 0:
*shortdata=temp;
shortdata++;
break;
case 1:
*intdata=temp;
intdata++;
break;
}
if(temp>SHRT_MAX && datatype==0)
printf("error: data %d is larger than max %d\n",temp,max);
if(temp<0)
printf("error: data %d is negative\n",temp);
}
switch(datatype){
case 0:
retval = nc_put_vara_short(ncid, varid, start, count, (short*)data);
break;
case 1:
retval = nc_put_vara_int(ncid, varid, start, count, (int*)data);
break;
}
if(retval) ERR(retval);
start[0]++;
}
fclose(f);
}else
break;
}
if ((retval = nc_close(ncid))) ERR(retval);
printf("The maximum data is %d\n",max);
return 0;
}
/* write out variable's data from in-memory structure */
void
load_netcdf(
void *rec_start
)
{
int idim;
int stat = NC_NOERR;
size_t start[NC_MAX_VAR_DIMS];
size_t count[NC_MAX_VAR_DIMS];
char *charvalp;
short *shortvalp;
int *intvalp;
float *floatvalp;
double *doublevalp;
/* load values into variable */
switch (vars[varnum].type) {
case NC_CHAR:
case NC_BYTE:
charvalp = (char *) rec_start;
break;
case NC_SHORT:
shortvalp = (short *) rec_start;
break;
case NC_INT:
intvalp = (int *) rec_start;
break;
case NC_FLOAT:
floatvalp = (float *) rec_start;
break;
case NC_DOUBLE:
doublevalp = (double *) rec_start;
break;
default: break;
}
if (vars[varnum].ndims > 0) {
/* initialize start to upper left corner (0,0,0,...) */
start[0] = 0;
if (vars[varnum].dims[0] == rec_dim) {
count[0] = vars[varnum].nrecs;
}
else {
count[0] = dims[vars[varnum].dims[0]].size;
}
}
for (idim = 1; idim < vars[varnum].ndims; idim++) {
start[idim] = 0;
count[idim] = dims[vars[varnum].dims[idim]].size;
}
switch (vars[varnum].type) {
case NC_BYTE:
stat = nc_put_vara_schar(ncid, varnum, start, count,
(signed char *)charvalp);
break;
case NC_CHAR:
stat = nc_put_vara_text(ncid, varnum, start, count, charvalp);
break;
case NC_SHORT:
stat = nc_put_vara_short(ncid, varnum, start, count, shortvalp);
break;
case NC_INT:
stat = nc_put_vara_int(ncid, varnum, start, count, intvalp);
break;
case NC_FLOAT:
stat = nc_put_vara_float(ncid, varnum, start, count, floatvalp);
break;
case NC_DOUBLE:
stat = nc_put_vara_double(ncid, varnum, start, count, doublevalp);
break;
default: break;
}
check_err(stat);
}
