// TODO: Use Box class
int NetcdfFile::SetupBox(double* boxIn, NCTYPE typeIn) {
boxIn[0] = 0.0;
boxIn[1] = 0.0;
boxIn[2] = 0.0;
boxIn[3] = 0.0;
boxIn[4] = 0.0;
boxIn[5] = 0.0;
if ( nc_inq_varid(ncid_,NCCELL_LENGTHS,&cellLengthVID_)==NC_NOERR ) {
if (checkNCerr(nc_inq_varid(ncid_,NCCELL_ANGLES,&cellAngleVID_)) ) {
mprinterr("Error: Getting cell angles.\n");
return 1;
}
if (ncdebug_>0) mprintf(" Netcdf Box information found.\n");
// If present, get box angles. These will be used to determine the box
// type in TrajectoryFile.
start_[0]=0;
start_[1]=0;
start_[2]=0;
start_[3]=0;
switch (typeIn) {
case NC_AMBERRESTART:
count_[0]=3;
count_[1]=0;
count_[2]=0;
break;
case NC_AMBERTRAJ:
count_[0]=1;
count_[1]=3;
count_[2]=0;
break;
case NC_AMBERENSEMBLE:
count_[0]=1; // NOTE: All ensemble members must have same box type
count_[1]=1; // TODO: Check all members?
count_[2]=3;
break;
case NC_UNKNOWN:
return 1; // Sanity check
}
count_[3]=0;
if ( checkNCerr(nc_get_vara_double(ncid_, cellLengthVID_, start_, count_, boxIn )) )
{
mprinterr("Error: Getting cell lengths.\n");
return 1;
}
if ( checkNCerr(nc_get_vara_double(ncid_, cellAngleVID_, start_, count_, boxIn+3)) )
{
mprinterr("Error: Getting cell angles.\n");
return 1;
}
if (ncdebug_ > 0) mprintf("\tNetcdf Box: XYZ={%f %f %f} ABG={%f %f %f}\n",
boxIn[0], boxIn[1], boxIn[2], boxIn[3], boxIn[4], boxIn[5]);
return 0;
}
// No box information
return -1;
}
/** Get the specified frame from amber netcdf file
* Coords are a 1 dimensional array of format X1,Y1,Z1,X2,Y2,Z2,...
*/
int Traj_AmberNetcdf::readFrame(int set,double *X, double *V,double *box, double *T) {
// Get temperature
if (TempVID_!=-1) {
start_[0] = set;
count_[0] = 1;
if ( checkNCerr(nc_get_vara_double(ncid_, TempVID_, start_, count_, T)) ) {
mprinterr("Error: Getting replica temperature.\n");
return 1;
}
//fprintf(stderr,"DEBUG: Replica Temperature %lf\n",F->T);
}
// Read Coords
start_[0] = set;
start_[1] = 0;
start_[2] = 0;
count_[0] = 1;
count_[1] = Ncatom();
count_[2] = 3;
if ( checkNCerr(nc_get_vara_float(ncid_, coordVID_, start_, count_, Coord_)) ) {
mprinterr("Error: Getting frame %i\n", set);
return 1;
}
FloatToDouble(X, Coord_);
// Read Velocities
if (velocityVID_ != -1) {
if ( checkNCerr(nc_get_vara_float(ncid_, velocityVID_, start_, count_, Veloc_)) ) {
mprinterr("Error: Getting velocities for frame %i\n", set);
return 1;
}
FloatToDouble(V, Veloc_);
}
// Read box info
if (cellLengthVID_ != -1) {
count_[1] = 3;
count_[2] = 0;
if ( checkNCerr(nc_get_vara_double(ncid_, cellLengthVID_, start_, count_, box)) ) {
mprinterr("Getting cell lengths.\n");
return 1;
}
if ( checkNCerr(nc_get_vara_double(ncid_, cellAngleVID_, start_, count_, box+3)) ) {
mprinterr("Getting cell angles.\n");
return 1;
}
}
return 0;
}
int ex_get_glob_vars (int exoid,
int time_step,
int num_glob_vars,
void *glob_var_vals)
{
int varid;
int status;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire previously defined variable */
if ((status = nc_inq_varid (exoid, VAR_GLO_VAR, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: failed to locate global variables in file id %d",
exoid);
ex_err("ex_get_glob_vars",errmsg,exerrval);
return (EX_WARN);
}
/* Verify that time_step is within bounds */
{
int num_time_steps = ex_inquire_int (exoid, EX_INQ_TIME);
if (time_step <= 0 || time_step > num_time_steps) {
sprintf(errmsg,
"ERROR: time_step is out-of-range. Value = %d, valid range is 1 to %d in file id %d",
time_step, num_time_steps, exoid);
ex_err("ex_get_nodal_var",errmsg,EX_BADPARAM);
return (EX_FATAL);
}
}
/* read values of global variables */
start[0] = --time_step;
start[1] = 0;
count[0] = 1;
count[1] = num_glob_vars;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, varid, start, count, glob_var_vals);
} else {
status = nc_get_vara_double(exoid, varid, start, count, glob_var_vals);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get global variable values from file id %d",
exoid);
ex_err("ex_get_glob_vars",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
/** Get the specified frame from amber netcdf file
* Coords are a 1 dimensional array of format X1,Y1,Z1,X2,Y2,Z2,...
*/
int Traj_AmberRestartNC::readFrame(int set,double *X, double *V,double *box, double *T) {
// Get temperature
if (TempVID_!=-1) {
if ( checkNCerr(nc_get_var_double(ncid_, TempVID_, T)) ) {
mprinterr("Error: Getting replica temperature.\n");
return 1;
}
if (debug_>1) mprintf("DEBUG: %s: Replica Temperature %lf\n",filename_.base(), T);
}
// Read Coords
start_[0] = 0;
start_[1] = 0;
count_[0] = Ncatom();
count_[1] = 3;
if ( checkNCerr(nc_get_vara_double(ncid_, coordVID_, start_, count_, X)) ) {
mprinterr("Error: Getting Coords\n");
return 1;
}
// Read Velocity
if (velocityVID_!=-1 && V!=0) {
if ( checkNCerr(nc_get_vara_double(ncid_, velocityVID_, start_, count_, V)) ) {
mprinterr("Error: Getting velocities\n");
return 1;
}
}
// Read box info
if (cellLengthVID_ != -1) {
count_[0] = 3;
count_[1] = 0;
if ( checkNCerr(nc_get_vara_double(ncid_, cellLengthVID_, start_, count_, box)) ) {
mprinterr("Error: Getting cell lengths.\n");
return 1;
}
if ( checkNCerr(nc_get_vara_double(ncid_, cellAngleVID_, start_, count_, box+3)) ) {
mprinterr("Error: Getting cell angles.\n");
return 1;
}
}
return 0;
}
NcValues* NcVar::values( void ) const
{
int ndims = num_dims();
size_t crnr[NC_MAX_DIMS];
size_t edgs[NC_MAX_DIMS];
for (int i = 0; i < ndims; i++) {
crnr[i] = 0;
edgs[i] = get_dim(i)->size();
}
NcValues* valp = get_space();
int status;
switch (type()) {
case ncFloat:
status = NcError::set_err(
nc_get_vara_float(the_file->id(), the_id, crnr, edgs,
(float *)valp->base())
);
break;
case ncDouble:
status = NcError::set_err(
nc_get_vara_double(the_file->id(), the_id, crnr, edgs,
(double *)valp->base())
);
break;
case ncInt:
status = NcError::set_err(
nc_get_vara_int(the_file->id(), the_id, crnr, edgs,
(int *)valp->base())
);
break;
case ncShort:
status = NcError::set_err(
nc_get_vara_short(the_file->id(), the_id, crnr, edgs,
(short *)valp->base())
);
break;
case ncByte:
status = NcError::set_err(
nc_get_vara_schar(the_file->id(), the_id, crnr, edgs,
(signed char *)valp->base())
);
break;
case ncChar:
status = NcError::set_err(
nc_get_vara_text(the_file->id(), the_id, crnr, edgs,
(char *)valp->base())
);
break;
case ncNoType:
default:
return 0;
}
if (status != NC_NOERR)
return 0;
return valp;
}
int ex_get_glob_var_time (int exoid,
int glob_var_index,
int beg_time_step,
int end_time_step,
void *glob_var_vals)
{
int status;
int varid;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
if (end_time_step < 0) {
/* user is requesting the maximum time step; we find this out using the
* database inquire function to get the number of time steps
*/
end_time_step = ex_inquire_int(exoid, EX_INQ_TIME);
}
end_time_step--;
/* read values of global variables */
start[0] = --beg_time_step;
start[1] = --glob_var_index;
count[0] = end_time_step - beg_time_step + 1;
count[1] = 1;
/* inquire previously defined variable */
if ((status = nc_inq_varid (exoid, VAR_GLO_VAR, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate global variables in file id %d",
exoid);
ex_err("ex_get_glob_var_time",errmsg,exerrval);
return (EX_WARN);
}
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, varid, start, count, glob_var_vals);
} else {
status = nc_get_vara_double(exoid, varid, start, count, glob_var_vals);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get global variable %d values from file id %d",
glob_var_index, exoid);
ex_err("ex_get_glob_var_time",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
NCstate NCdsHandleGContLoadCache(NCdsHandleGCont_t *gCont, size_t sTStep, size_t nTSteps, size_t sLevel,
size_t nLevels) {
int status;
size_t start[4], count[4];
size_t ncidx, tStep, level, row, col;
double val;
count[0] = 1;
if (gCont->LVarIds[0] == NCundefined) {
start[1] = (size_t) 0;
count[1] = gCont->RowNum;
start[2] = (size_t) 0;
count[2] = gCont->ColNum;
}
else {
count[1] = 1;
start[2] = (size_t) 0;
count[2] = gCont->RowNum;
start[3] = (size_t) 0;
count[3] = gCont->ColNum;
}
for (row = 0; row < gCont->RowNum; row++)
for (col = 0; col < gCont->ColNum; col++) {
gCont->ObsNum[gCont->ColNum * row + col] = (size_t) 0;
gCont->Data[gCont->ColNum * row + col] = (double) 0.0;
}
for (tStep = sTStep; tStep < sTStep + nTSteps; tStep++)
for (level = sLevel; level < sLevel + nLevels; level++) {
ncidx = gCont->NCindex[tStep];
start[0] = tStep - gCont->NCoffset[ncidx];
if (gCont->LVarIds[ncidx] != NCundefined) start[1] = level;
if ((status = nc_sync(gCont->NCIds[ncidx])) != NC_NOERR) {
NCprintNCError (status, "NCdsHandleGContLoadCache");
return (NCfailed);
}
if ((status = nc_get_vara_double(gCont->NCIds[ncidx], gCont->GVarIds[ncidx], start, count,
gCont->AuxData)) != NC_NOERR) {
NCprintNCError (status, "NCdsHandleGContLoadCache");
return (NCfailed);
}
for (row = 0; row < gCont->RowNum; row++)
for (col = 0; col < gCont->ColNum; col++)
if (_NCdsHandleGContTestNodata(gCont, (val = gCont->AuxData[gCont->ColNum * row + col])) == false) {
gCont->Data[gCont->ColNum * row + col] += val;
gCont->ObsNum[gCont->ColNum * row + col] += 1;
}
}
for (row = 0; row < gCont->RowNum; row++)
for (col = 0; col < gCont->ColNum; col++)
if (gCont->ObsNum[gCont->ColNum * row + col] == 0) NCdsHandleGContSetFill(gCont, row, col);
else if (gCont->ObsNum[gCont->ColNum * row + col] > 1)
gCont->Data[gCont->ColNum * row + col] /= (double) gCont->ObsNum[gCont->ColNum * row + col];
return (NCsucceeded);
}
int ex_get_glob_vars_int(int exoid, int time_step, int num_glob_vars, void *glob_var_vals)
{
int varid;
int status;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* inquire previously defined variable */
if ((status = nc_inq_varid(exoid, VAR_GLO_VAR, &varid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: failed to locate global variables in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_WARN);
}
/* Verify that time_step is within bounds */
{
int num_time_steps = ex_inquire_int(exoid, EX_INQ_TIME);
if (time_step <= 0 || time_step > num_time_steps) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: time_step is out-of-range. Value = %d, valid "
"range is 1 to %d in file id %d",
time_step, num_time_steps, exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* read values of global variables */
start[0] = --time_step;
start[1] = 0;
count[0] = 1;
count[1] = num_glob_vars;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, varid, start, count, glob_var_vals);
}
else {
status = nc_get_vara_double(exoid, varid, start, count, glob_var_vals);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get global variable values from file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_get_nodal_varid_var(int exoid,
int time_step,
int nodal_var_index,
int num_nodes,
int varid,
void *nodal_var_vals)
{
int status;
size_t start[3], count[3];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire previously defined variable */
if (ex_large_model(exoid) == 0) {
start[0] = --time_step;
start[1] = --nodal_var_index;
start[2] = 0;
count[0] = 1;
count[1] = 1;
count[2] = num_nodes;
} else {
start[0] = --time_step;
start[1] = 0;
count[0] = 1;
count[1] = num_nodes;
}
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, varid, start, count, nodal_var_vals);
} else {
status = nc_get_vara_double(exoid, varid, start, count, nodal_var_vals);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get nodal variables in file id %d",
exoid);
ex_err("ex_get_nodal_varid_var",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_get_glob_vars (int exoid,
int time_step,
int num_glob_vars,
void *glob_var_vals)
{
int varid;
int status;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire previously defined variable */
if ((status = nc_inq_varid (exoid, VAR_GLO_VAR, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: failed to locate global variables in file id %d",
exoid);
ex_err("ex_get_glob_vars",errmsg,exerrval);
return (EX_WARN);
}
/* read values of global variables */
start[0] = --time_step;
start[1] = 0;
count[0] = 1;
count[1] = num_glob_vars;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, varid, start, count, glob_var_vals);
} else {
status = nc_get_vara_double(exoid, varid, start, count, glob_var_vals);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get global variable values from file id %d",
exoid);
ex_err("ex_get_glob_vars",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
CPLErr GMTRasterBand::IReadBlock( CPL_UNUSED int nBlockXOff, int nBlockYOff,
void * pImage )
{
size_t start[2], edge[2];
int nErr = NC_NOERR;
int cdfid = ((GMTDataset *) poDS)->cdfid;
CPLMutexHolderD(&hNCMutex);
start[0] = nBlockYOff * nBlockXSize;
edge[0] = nBlockXSize;
if( eDataType == GDT_Byte )
nErr = nc_get_vara_uchar( cdfid, nZId, start, edge,
(unsigned char *) pImage );
else if( eDataType == GDT_Int16 )
nErr = nc_get_vara_short( cdfid, nZId, start, edge,
(short int *) pImage );
else if( eDataType == GDT_Int32 )
{
if( sizeof(long) == 4 )
nErr = nc_get_vara_long( cdfid, nZId, start, edge,
(long *) pImage );
else
nErr = nc_get_vara_int( cdfid, nZId, start, edge,
(int *) pImage );
}
else if( eDataType == GDT_Float32 )
nErr = nc_get_vara_float( cdfid, nZId, start, edge,
(float *) pImage );
else if( eDataType == GDT_Float64 )
nErr = nc_get_vara_double( cdfid, nZId, start, edge,
(double *) pImage );
if( nErr != NC_NOERR )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GMT scanline fetch failed: %s",
nc_strerror( nErr ) );
return CE_Failure;
}
else
return CE_None;
}
double *NCdataGetVector(int ncid, int dimid, int varid, size_t *len) {
int status;
size_t start;
double *coords;
if ((dimid == NCfailed) || (varid == NCfailed)) return ((double *) NULL);
if ((status = nc_inq_dimlen(ncid, dimid, len)) != NC_NOERR) {
NCprintNCError (status, "NCdataGetVector");
return ((double *) NULL);
}
if ((coords = (double *) calloc(*len, sizeof(double))) == (double *) NULL) {
CMmsgPrint(CMmsgSysError, "Memory allocation error in: %s %d", __FILE__, __LINE__);
return ((double *) NULL);
}
start = 0;
if ((status = nc_get_vara_double(ncid, varid, &start, len, coords)) != NC_NOERR) {
NCprintNCError (status, "NCdataGetVector");
free(coords);
return ((double *) NULL);
}
return (coords);
}
void read_netcdf(char *filename, char *varname, size_t *start, size_t *count, double *snaps)
{
int ncid_rd, retval_rd;
int vel_varid_rd;
/* ******** PREPARE TO READ ************* */
/* Open the file. NC_NOWRITE tells netCDF we want read-only access to the file.*/
if ((retval_rd = nc_open(filename, NC_NOWRITE, &ncid_rd)))
ERR(retval_rd);
/* Get the varids of the velocity in netCDF */
if ((retval_rd = nc_inq_varid(ncid_rd, varname, &vel_varid_rd)))
ERR(retval_rd);
if ((retval_rd = nc_get_vara_double(ncid_rd, vel_varid_rd, start, count, &snaps[0])))
ERR(retval_rd);
/* Close the file, freeing all resources. */
if ((retval_rd = nc_close(ncid_rd)))
ERR(retval_rd);
printf("\n *** SUCCESS reading variables \"%s\" from \"%s\" \n", varname, filename);
}
void R_nc_get_vara_double( int *ncid, int *varid, int *start,
int *count, double *data, int *retval )
{
int i, err, ndims;
size_t s_start[MAX_NC_DIMS], s_count[MAX_NC_DIMS];
char vn[2048];
err = nc_inq_varndims(*ncid, *varid, &ndims );
if( err != NC_NOERR )
REprintf( "Error in R_nc_get_vara_double while getting ndims: %s\n",
nc_strerror(*retval) );
for( i=0; i<ndims; i++ ) {
s_start[i] = (size_t)start[i];
s_count[i] = (size_t)count[i];
}
*retval = nc_get_vara_double(*ncid, *varid, s_start, s_count, data );
if( *retval != NC_NOERR ) {
nc_inq_varname( *ncid, *varid, vn );
REprintf( "Error in R_nc_get_vara_double: %s\n",
nc_strerror(*retval) );
REprintf( "Var: %s Ndims: %d Start: ", vn, ndims );
for( i=0; i<ndims; i++ ) {
REprintf( "%u", (unsigned int)s_start[i] );
if( i < ndims-1 )
REprintf( "," );
}
REprintf( "Count: " );
for( i=0; i<ndims; i++ ) {
REprintf( "%u", (unsigned int)s_count[i] );
if( i < ndims-1 )
REprintf( "," );
}
}
}
/*********************************************************************
void mpp_get_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_get_var_value_block(int fid, int vid, const size_t *start, const size_t *nread, void *data)
{
int status;
char errmsg[512];
if(fid<0 || fid >=nfiles) mpp_error("mpp_io(mpp_get_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_get_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_get_vara_double(files[fid].ncid, files[fid].var[vid].fldid, start, nread, data);
break;
case NC_INT:
status = nc_get_vara_int(files[fid].ncid, files[fid].var[vid].fldid, start, nread, data);
break;
case NC_SHORT:
status = nc_get_vara_short(files[fid].ncid, files[fid].var[vid].fldid, start, nread, data);
break;
case NC_CHAR:
status = nc_get_vara_text(files[fid].ncid, files[fid].var[vid].fldid, start, nread, data);
break;
default:
sprintf(errmsg, "mpp_io(mpp_get_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_get_var_value_block): Error in getting value of variable %s from file %s",
files[fid].var[vid].name, files[fid].name );
netcdf_error(errmsg, status);
}
}; /* mpp_get_var_value_block */
int ex_get_partial_coord(int exoid, int64_t start_node_num, int64_t num_nodes, void *x_coor,
void *y_coor, void *z_coor)
{
int status;
int coordid;
int coordidx, coordidy, coordidz;
int numnoddim, ndimdim;
size_t num_nod;
size_t num_dim, start[2], count[2], i;
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* inquire id's of previously defined dimensions */
if (nc_inq_dimid(exoid, DIM_NUM_NODES, &numnoddim) != NC_NOERR) {
/* If not found, then this file is storing 0 nodes.
Return immediately */
EX_FUNC_LEAVE(EX_NOERR);
}
if ((status = nc_inq_dimlen(exoid, numnoddim, &num_nod)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of nodes in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
--start_node_num;
if (start_node_num + num_nodes > num_nod) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: start index (%" PRId64 ") + node count (%" PRId64
") is larger than total number of nodes (%" ST_ZU ") in file id %d",
start_node_num, num_nodes, num_nod, exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
if (ex_get_dimension(exoid, DIM_NUM_DIM, "dimension count", &num_dim, &ndimdim, __func__) !=
NC_NOERR) {
EX_FUNC_LEAVE(EX_FATAL);
}
/* read in the coordinates */
if (ex_large_model(exoid) == 0) {
if ((status = nc_inq_varid(exoid, VAR_COORD, &coordid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate nodal coordinates in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
for (i = 0; i < num_dim; i++) {
char *which;
start[0] = i;
start[1] = start_node_num;
count[0] = 1;
count[1] = num_nodes;
if (count[1] == 0) {
start[1] = 0;
}
if (i == 0 && x_coor != NULL) {
which = "X";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, x_coor);
}
else {
status = nc_get_vara_double(exoid, coordid, start, count, x_coor);
}
}
else if (i == 1 && y_coor != NULL) {
which = "Y";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, y_coor);
}
else {
status = nc_get_vara_double(exoid, coordid, start, count, y_coor);
}
}
else if (i == 2 && z_coor != NULL) {
which = "Z";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, z_coor);
}
else {
status = nc_get_vara_double(exoid, coordid, start, count, z_coor);
}
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s coord array in file id %d", which,
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
}
else {
if ((status = nc_inq_varid(exoid, VAR_COORD_X, &coordidx)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate x nodal coordinates in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
if (num_dim > 1) {
if ((status = nc_inq_varid(exoid, VAR_COORD_Y, &coordidy)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate y nodal coordinates in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
else {
coordidy = 0;
}
if (num_dim > 2) {
if ((status = nc_inq_varid(exoid, VAR_COORD_Z, &coordidz)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate z nodal coordinates in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
else {
coordidz = 0;
}
/* write out the coordinates */
for (i = 0; i < num_dim; i++) {
void *coor = NULL;
char *which = NULL;
start[0] = start_node_num;
count[0] = num_nodes;
if (count[0] == 0) {
start[0] = 0;
}
if (i == 0) {
coor = x_coor;
which = "X";
coordid = coordidx;
}
else if (i == 1) {
coor = y_coor;
which = "Y";
coordid = coordidy;
}
else if (i == 2) {
coor = z_coor;
which = "Z";
coordid = coordidz;
}
if (coor != NULL && coordid != 0) {
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, coor);
}
else {
status = nc_get_vara_double(exoid, coordid, start, count, coor);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s coord array in file id %d",
which, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
}
}
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_get_var(int exoid, int time_step, ex_entity_type var_type, int var_index,
ex_entity_id obj_id, int64_t num_entry_this_obj, void *var_vals)
{
int status;
int varid, obj_id_ndx;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
ex_check_valid_file_id(exoid);
if (var_type == EX_NODAL) {
/* FIXME: Special case: ignore obj_id, possible large_file complications,
* etc. */
return ex_get_nodal_var_int(exoid, time_step, var_index, num_entry_this_obj, var_vals);
}
if (var_type == EX_GLOBAL) {
/* FIXME: Special case: all vars stored in 2-D single array. */
return ex_get_glob_vars_int(exoid, time_step, num_entry_this_obj, var_vals);
}
exerrval = 0; /* clear error code */
/* Determine index of obj_id in VAR_ID_EL_BLK array */
obj_id_ndx = ex_id_lkup(exoid, var_type, obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no %s variables for NULL block %" PRId64 " in file id %d",
ex_name_of_object(var_type), obj_id, exoid);
ex_err("ex_get_var", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate %s id %" PRId64 " in id variable in file id %d",
ex_name_of_object(var_type), obj_id, exoid);
ex_err("ex_get_var", errmsg, exerrval);
return (EX_FATAL);
}
/* inquire previously defined variable */
if ((status = nc_inq_varid(exoid, ex_name_var_of_object(var_type, var_index, obj_id_ndx),
&varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %s %" PRId64 " var %d in file id %d",
ex_name_of_object(var_type), obj_id, var_index, exoid);
ex_err("ex_get_var", errmsg, exerrval);
return (EX_FATAL);
}
/* Verify that time_step is within bounds */
#ifndef NDEBUG
{
int num_time_steps = ex_inquire_int(exoid, EX_INQ_TIME);
if (time_step <= 0 || time_step > num_time_steps) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: time_step is out-of-range. Value = %d, valid "
"range is 1 to %d in file id %d",
time_step, num_time_steps, exoid);
ex_err("ex_get_var", errmsg, EX_BADPARAM);
return (EX_FATAL);
}
}
#endif
/* read values of element variable */
start[0] = --time_step;
start[1] = 0;
count[0] = 1;
count[1] = num_entry_this_obj;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, varid, start, count, var_vals);
}
else {
status = nc_get_vara_double(exoid, varid, start, count, var_vals);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get %s %" PRId64 " variable %d in file id %d",
ex_name_of_object(var_type), obj_id, var_index, exoid);
ex_err("ex_get_var", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
GDALDataset *GMTDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Does this file have the GMT magic number? */
/* -------------------------------------------------------------------- */
if( poOpenInfo->fpL == NULL || poOpenInfo->nHeaderBytes < 50 )
return NULL;
if( poOpenInfo->pabyHeader[0] != 'C'
|| poOpenInfo->pabyHeader[1] != 'D'
|| poOpenInfo->pabyHeader[2] != 'F'
|| poOpenInfo->pabyHeader[3] != 1 )
return NULL;
CPLMutexHolderD(&hNCMutex);
/* -------------------------------------------------------------------- */
/* Try opening the dataset. */
/* -------------------------------------------------------------------- */
int cdfid, nm_id, dim_count, z_id;
if( nc_open( poOpenInfo->pszFilename, NC_NOWRITE, &cdfid ) != NC_NOERR )
return NULL;
if( nc_inq_varid( cdfid, "dimension", &nm_id ) != NC_NOERR
|| nc_inq_varid( cdfid, "z", &z_id ) != NC_NOERR )
{
#ifdef notdef
CPLError( CE_Warning, CPLE_AppDefined,
"%s is a GMT file, but not in GMT configuration.",
poOpenInfo->pszFilename );
#endif
nc_close( cdfid );
return NULL;
}
if( nc_inq_ndims( cdfid, &dim_count ) != NC_NOERR || dim_count < 2 )
{
nc_close( cdfid );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
nc_close( cdfid );
CPLError( CE_Failure, CPLE_NotSupported,
"The GMT driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
GMTDataset *poDS;
CPLReleaseMutex(hNCMutex); // Release mutex otherwise we'll deadlock with GDALDataset own mutex
poDS = new GMTDataset();
CPLAcquireMutex(hNCMutex, 1000.0);
poDS->cdfid = cdfid;
poDS->z_id = z_id;
/* -------------------------------------------------------------------- */
/* Get dimensions. If we can't find this, then this is a */
/* GMT file, but not a normal grid product. */
/* -------------------------------------------------------------------- */
size_t start[2], edge[2];
int nm[2];
start[0] = 0;
edge[0] = 2;
nc_get_vara_int(cdfid, nm_id, start, edge, nm);
poDS->nRasterXSize = nm[0];
poDS->nRasterYSize = nm[1];
/* -------------------------------------------------------------------- */
/* Fetch "z" attributes scale_factor, add_offset, and */
/* node_offset. */
/* -------------------------------------------------------------------- */
double scale_factor=1.0, add_offset=0.0;
int node_offset = 1;
nc_get_att_double( cdfid, z_id, "scale_factor", &scale_factor );
nc_get_att_double( cdfid, z_id, "add_offset", &add_offset );
nc_get_att_int( cdfid, z_id, "node_offset", &node_offset );
/* -------------------------------------------------------------------- */
/* Get x/y range information. */
/* -------------------------------------------------------------------- */
int x_range_id, y_range_id;
if( nc_inq_varid (cdfid, "x_range", &x_range_id) == NC_NOERR
&& nc_inq_varid (cdfid, "y_range", &y_range_id) == NC_NOERR )
{
double x_range[2], y_range[2];
nc_get_vara_double( cdfid, x_range_id, start, edge, x_range );
nc_get_vara_double( cdfid, y_range_id, start, edge, y_range );
// Pixel is area
if( node_offset == 1 )
{
poDS->adfGeoTransform[0] = x_range[0];
poDS->adfGeoTransform[1] =
(x_range[1] - x_range[0]) / poDS->nRasterXSize;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = y_range[1];
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] =
(y_range[0] - y_range[1]) / poDS->nRasterYSize;
}
// Pixel is point - offset by half pixel.
else /* node_offset == 0 */
{
poDS->adfGeoTransform[1] =
(x_range[1] - x_range[0]) / (poDS->nRasterXSize-1);
poDS->adfGeoTransform[0] =
x_range[0] - poDS->adfGeoTransform[1]*0.5;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] =
(y_range[0] - y_range[1]) / (poDS->nRasterYSize-1);
poDS->adfGeoTransform[3] =
y_range[1] - poDS->adfGeoTransform[5]*0.5;
}
}
else
{
poDS->adfGeoTransform[0] = 0.0;
poDS->adfGeoTransform[1] = 1.0;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = 0.0;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = 1.0;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->nBands = 1;
poDS->SetBand( 1, new GMTRasterBand( poDS, z_id, 1 ));
if( scale_factor != 1.0 || add_offset != 0.0 )
{
poDS->GetRasterBand(1)->SetOffset( add_offset );
poDS->GetRasterBand(1)->SetScale( scale_factor );
}
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
CPLReleaseMutex(hNCMutex); // Release mutex otherwise we'll deadlock with GDALDataset own mutex
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for external overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename, poOpenInfo->GetSiblingFiles() );
CPLAcquireMutex(hNCMutex, 1000.0);
return( poDS );
}
bool
QA::postProc_outlierTest(void)
{
bool retCode=false;
for( size_t i=0 ; i < qaExp.varMeDa.size() ; ++i )
{
VariableMetaData &vMD = qaExp.varMeDa[i] ;
if( ! vMD.qaData.enableOutlierTest )
continue ;
if( ! vMD.qaData.statAve.getSampleSize() )
{
// compatibility mode: determine the statistics of old-fashioned results
// note: the qa_<variable>.nc file becomes updated
std::vector<std::string> vars ;
std::string statStr;
size_t recNum=nc->getNumOfRecords(true); // force new inquiry
double val;
std::vector<double> dv;
MtrxArr<double> mv;
if( vMD.var->isNoData() )
continue;
vars.clear();
// post-processing of data before statistics was vMD inherent?
vars.push_back( vMD.var->name + "_min" );
vars.push_back( vMD.var->name + "_max" );
vars.push_back( vMD.var->name + "_ave" );
bool is=false;
bool is2=true;
for( size_t j=0 ; j < vars.size() ; ++j )
{
// read the statistics
nc->getAttValues( dv, "valid_range", vars[j]);
if( dv[0] == MAXDOUBLE )
{
is=true; // no valid statistics
break;
}
statStr ="sampleMin=" ;
statStr += hdhC::double2String( dv[0] );
statStr +=", sampleMax=" ;
statStr += hdhC::double2String( dv[1] );
statStr += ", ";
statStr += nc->getAttString("statistics", vars[j], is2) ;
if( ! is2 )
{
is=true; // no valid statistics
break;
}
if( j == 0 )
vMD.qaData.statMin.setSampleProperties( statStr );
else if( j == 1 )
vMD.qaData.statMax.setSampleProperties( statStr );
else if( j == 2 )
vMD.qaData.statAve.setSampleProperties( statStr );
is=false;
}
if( is )
{
val = nc->getData(mv, vars[0]);
if( val < MAXDOUBLE )
{
// build the statistics from scratch
int nRecs = static_cast<int>(recNum);
// constrain memory allocation to a buffer size
int sz_max=1000;
size_t start[] = {0};
size_t count[] = {0};
// buffer for netCDF data storage
double vals_min[sz_max];
double vals_max[sz_max];
double vals_ave[sz_max];
// read data from file, chunk by chunk
while (nRecs > 0)
{
int sz = nRecs > sz_max ? sz_max : nRecs;
nRecs -= sz;
count[0]=static_cast<size_t>(sz);
nc_get_vara_double(
nc->getNcid(), nc->getVarID(vars[0]),
start, count, vals_min );
nc_get_vara_double(
nc->getNcid(), nc->getVarID(vars[1]),
start, count, vals_max );
nc_get_vara_double(
nc->getNcid(), nc->getVarID(vars[2]),
start, count, vals_ave );
start[0] += static_cast<size_t>(sz) ;
// feed data to the statistics
vMD.qaData.statMin.add( vals_min, sz );
vMD.qaData.statMax.add( vals_max, sz );
vMD.qaData.statAve.add( vals_ave, sz );
}
// write statistics attributes
vMD.qaData.setStatisticsAttribute(nc);
}
}
}
// the test: regular post-processing on the basis of stored statistics
if( vMD.qaData.outlier->test(&vMD.qaData) )
retCode = true;
}
return retCode;
}
int ex_get_nodal_var (int exoid,
int time_step,
int nodal_var_index,
int num_nodes,
void *nodal_var_vals)
{
int varid;
int status;
size_t start[3], count[3];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire previously defined variable */
if (ex_large_model(exoid) == 0) {
/* read values of the nodal variable */
if ((status = nc_inq_varid(exoid, VAR_NOD_VAR, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: could not find nodal variables in file id %d",
exoid);
ex_err("ex_get_nodal_var",errmsg,exerrval);
return (EX_WARN);
}
start[0] = --time_step;
start[1] = --nodal_var_index;
start[2] = 0;
count[0] = 1;
count[1] = 1;
count[2] = num_nodes;
} else {
/* read values of the nodal variable -- stored as separate variables... */
/* Get the varid.... */
if ((status = nc_inq_varid(exoid, VAR_NOD_VAR_NEW(nodal_var_index), &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: could not find nodal variable %d in file id %d",
nodal_var_index, exoid);
ex_err("ex_get_nodal_var",errmsg,exerrval);
return (EX_WARN);
}
start[0] = --time_step;
start[1] = 0;
count[0] = 1;
count[1] = num_nodes;
}
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, varid, start, count, nodal_var_vals);
} else {
status = nc_get_vara_double(exoid, varid, start, count, nodal_var_vals);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get nodal variables in file id %d",
exoid);
ex_err("ex_get_nodal_var",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_get_coord (int exoid,
void *x_coor,
void *y_coor,
void *z_coor)
{
int status;
int coordid;
int coordidx, coordidy, coordidz;
int numnoddim, ndimdim;
size_t num_nod, num_dim, start[2], count[2], i;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0;
/* inquire id's of previously defined dimensions */
if (ex_get_dimension(exoid, DIM_NUM_DIM, "dimensions",
&num_dim, &ndimdim, "ex_get_coord") != NC_NOERR) {
return(EX_FATAL);
}
if (nc_inq_dimid (exoid, DIM_NUM_NODES, &numnoddim) != NC_NOERR)
{
/* If not found, then this file is storing 0 nodes.
Return immediately */
return (EX_NOERR);
}
if ((status = nc_inq_dimlen(exoid, numnoddim, &num_nod)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes in file id %d",
exoid);
ex_err("ex_get_coord",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the coordinates */
if (ex_large_model(exoid) == 0) {
if ((status = nc_inq_varid (exoid, VAR_COORD, &coordid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate nodal coordinates in file id %d", exoid);
ex_err("ex_get_coord",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i<num_dim; i++) {
char *which;
start[0] = i;
start[1] = 0;
count[0] = 1;
count[1] = num_nod;
if (i == 0 && x_coor != NULL) {
which = "X";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, x_coor);
} else {
status = nc_get_vara_double(exoid, coordid, start, count, x_coor);
}
}
else if (i == 1 && y_coor != NULL) {
which = "Y";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, y_coor);
} else {
status = nc_get_vara_double(exoid, coordid, start, count, y_coor);
}
}
else if (i == 2 && z_coor != NULL) {
which = "Z";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, z_coor);
} else {
status = nc_get_vara_double(exoid, coordid, start, count, z_coor);
}
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get %s coord array in file id %d", which, exoid);
ex_err("ex_get_coord",errmsg,exerrval);
return (EX_FATAL);
}
}
} else {
if ((status = nc_inq_varid (exoid, VAR_COORD_X, &coordidx)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate x nodal coordinates in file id %d", exoid);
ex_err("ex_get_coord",errmsg,exerrval);
return (EX_FATAL);
}
if (num_dim > 1) {
if ((status = nc_inq_varid (exoid, VAR_COORD_Y, &coordidy)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate y nodal coordinates in file id %d", exoid);
ex_err("ex_get_coord",errmsg,exerrval);
return (EX_FATAL);
}
} else {
coordidy = 0;
}
if (num_dim > 2) {
if ((status = nc_inq_varid (exoid, VAR_COORD_Z, &coordidz)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate z nodal coordinates in file id %d", exoid);
ex_err("ex_get_coord",errmsg,exerrval);
return (EX_FATAL);
}
} else {
coordidz = 0;
}
/* write out the coordinates */
for (i=0; i<num_dim; i++)
{
void *coor = NULL;
char *which = NULL;
if (i == 0) {
coor = x_coor;
which = "X";
coordid = coordidx;
} else if (i == 1) {
coor = y_coor;
which = "Y";
coordid = coordidy;
} else if (i == 2) {
coor = z_coor;
which = "Z";
coordid = coordidz;
}
if (coor != NULL && coordid != 0) {
if (ex_comp_ws(exoid) == 4) {
status = nc_get_var_float(exoid, coordid, coor);
} else {
status = nc_get_var_double(exoid, coordid, coor);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get %s coord array in file id %d", which, exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
}
}
}
return (EX_NOERR);
}
// Traj_NcEnsemble::readArray() //TODO RemdValues
int Traj_NcEnsemble::readArray(int set, FrameArray& f_ensemble) {
# ifdef HAS_PNETCDF
MPI_Offset pstart_[4];
MPI_Offset pcount_[4];
# define start_ pstart_
# define count_ pcount_
# endif
start_[0] = set; // Frame
start_[2] = 0; // Atoms
start_[3] = 0; // XYZ
count_[0] = 1; // Frame
count_[1] = 1; // Ensemble
count_[3] = 3; // XYZ
//rprintf("DEBUG: Reading frame %i\n", set+1);
for (int member = ensembleStart_; member != ensembleEnd_; member++) {
# ifdef MPI
Frame& frm = f_ensemble[0];
# else
Frame& frm = f_ensemble[member];
# endif
start_[1] = member; // Ensemble
count_[2] = Ncatom(); // Atoms
// Read Coords
# ifdef HAS_PNETCDF
if (checkPNCerr(ncmpi_get_vara_float_all(ncid_, coordVID_, start_, count_, Coord_)))
# else
if (NC::CheckErr(nc_get_vara_float(ncid_, coordVID_, start_, count_, Coord_)))
# endif
{
rprinterr("Error: Getting coordinates for frame %i\n", set+1);
return 1;
}
FloatToDouble(frm.xAddress(), Coord_);
//mprintf("Frm=%8i Rep=%8i ", set+1, member+1); // DEBUG
//frm.printAtomCoord(0); // DEBUG
// Read Velocities
if (velocityVID_ != -1) {
# ifdef HAS_PNETCDF
if (checkPNCerr(ncmpi_get_vara_float_all(ncid_, velocityVID_, start_, count_, Coord_)))
# else
if (NC::CheckErr(nc_get_vara_float(ncid_, velocityVID_, start_, count_, Coord_)))
# endif
{
rprinterr("Error: Getting velocities for frame %i\n", set+1);
return 1;
}
FloatToDouble(frm.vAddress(), Coord_);
}
// Read Box
if (cellLengthVID_ != -1) {
count_[2] = 3;
# ifdef HAS_PNETCDF
if (checkPNCerr(ncmpi_get_vara_double_all(ncid_, cellLengthVID_, start_, count_, frm.bAddress())))
# else
if (NC::CheckErr(nc_get_vara_double(ncid_, cellLengthVID_, start_, count_, frm.bAddress())))
# endif
{
rprinterr("Error: Getting cell lengths for frame %i.\n", set+1);
return 1;
}
# ifdef HAS_PNETCDF
if (checkPNCerr(ncmpi_get_vara_double_all(ncid_, cellAngleVID_, start_, count_, frm.bAddress()+3)))
# else
if (NC::CheckErr(nc_get_vara_double(ncid_, cellAngleVID_, start_, count_, frm.bAddress()+3)))
# endif
{
rprinterr("Error: Getting cell angles for frame %i.\n", set+1);
return 1;
}
}
// Read Temperature
if (TempVID_!=-1) {
# ifdef HAS_PNETCDF
if (checkPNCerr(ncmpi_get_vara_double_all(ncid_, TempVID_, start_, count_, frm.tAddress())))
# else
if (NC::CheckErr(nc_get_vara_double(ncid_, TempVID_, start_, count_, frm.tAddress())))
# endif
{
rprinterr("Error: Getting replica temperature for frame %i.\n", set+1);
return 1;
}
//fprintf(stderr,"DEBUG: Replica Temperature %lf\n",F->T);
}
// Read indices
if (indicesVID_!=-1) {
count_[2] = remd_dimension_;
# ifdef HAS_PNETCDF
if (checkPNCerr(ncmpi_get_vara_int_all(ncid_, indicesVID_, start_, count_, frm.iAddress())))
# else
if (NC::CheckErr(nc_get_vara_int(ncid_, indicesVID_, start_, count_, frm.iAddress())))
# endif
{
rprinterr("Error: Getting replica indices for frame %i.\n", set+1);
return 1;
}
// DEBUG
//char buffer[128];
//char* ptr = buffer;
//ptr += sprintf(buffer,"DEBUG:\tReplica indices:");
//for (int dim=0; dim < remd_dimension_; dim++) ptr += sprintf(ptr, " %i", frm.RemdIndices()[dim]);
//sprintf(ptr,"\n");
//rprintf("%s", buffer);
}
}
# ifdef HAS_PNETCDF
// DEBUG
# undef start_
# undef count_
# endif
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;
}
static int read_amber_cdf_timestep(void *mydata, int natoms, molfile_timestep_t *ts) {
cdfdata *cdf = (cdfdata *)mydata;
amberdata *amber = &cdf->amber;
int rc;
/* Read in the atom coordinates and unit cell information */
/* only save coords if we're given a valid ts pointer */
/* otherwise VMD wants us to skip it. */
if (ts != NULL) {
size_t start[3], count[3];
start[0] = cdf->curframe; /* frame */
start[1] = 0; /* atom */
start[2] = 0; /* spatial */
count[0] = 1;
count[1] = amber->atomdim;
count[2] = amber->spatialdim;
rc = nc_get_vara_float(cdf->ncid, amber->coordinates_id,
start, count, ts->coords);
if (rc != NC_NOERR)
return MOLFILE_ERROR;
/* apply coordinate scaling factor if not 1.0 */
if (amber->coordinates_scalefactor != 1.0) {
int i;
float s = amber->coordinates_scalefactor;
for (i=0; i<natoms*3; i++) {
ts->coords[i] *= s;
}
}
/* Read the PBC box info. */
if (amber->has_box) {
double lengths[3];
double angles[3];
start[0] = cdf->curframe; /* frame */
start[1] = 0; /* spatial */
count[0] = 1;
count[1] = amber->spatialdim;
rc = nc_get_vara_double(cdf->ncid, amber->cell_lengths_id,
start, count, lengths);
if (rc != NC_NOERR)
return MOLFILE_ERROR;
rc = nc_get_vara_double(cdf->ncid, amber->cell_angles_id,
start, count, angles);
if (rc != NC_NOERR)
return MOLFILE_ERROR;
ts->A = lengths[0] * amber->cell_lengths_scalefactor;
ts->B = lengths[1] * amber->cell_lengths_scalefactor;
ts->C = lengths[2] * amber->cell_lengths_scalefactor;
ts->alpha = angles[0] * amber->cell_angles_scalefactor;
ts->beta = angles[1] * amber->cell_angles_scalefactor;
ts->gamma = angles[2] * amber->cell_angles_scalefactor;
}
}
cdf->curframe++;
return MOLFILE_SUCCESS;
}
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;
}
NcValues* NcVar::get_rec(NcDim* rdim, long slice)
{
int idx = dim_to_index(rdim);
long size = num_dims();
size_t* start = new size_t[size];
long* startl = new long[size];
for (int i=1; i < size ; i++) {
start[i] = 0;
startl[i] = 0;
}
start[idx] = slice;
startl[idx] = slice;
NcBool result = set_cur(startl);
if (! result ) {
delete [] start;
delete [] startl;
return 0;
}
long* edgel = edges();
size_t* edge = new size_t[size];
for (int i=1; i < size ; i++) {
edge[i] = edgel[i];
}
edge[idx] = 1;
edgel[idx] = 1;
NcValues* valp = get_space(rec_size(rdim));
int status;
switch (type()) {
case ncFloat:
status = NcError::set_err(
nc_get_vara_float(the_file->id(), the_id, start, edge,
(float *)valp->base())
);
break;
case ncDouble:
status = NcError::set_err(
nc_get_vara_double(the_file->id(), the_id, start, edge,
(double *)valp->base())
);
break;
case ncInt:
status = NcError::set_err(
nc_get_vara_int(the_file->id(), the_id, start, edge,
(int *)valp->base())
);
break;
case ncShort:
status = NcError::set_err(
nc_get_vara_short(the_file->id(), the_id, start, edge,
(short *)valp->base())
);
break;
case ncByte:
status = NcError::set_err(
nc_get_vara_schar(the_file->id(), the_id, start, edge,
(signed char *)valp->base())
);
break;
case ncChar:
status = NcError::set_err(
nc_get_vara_text(the_file->id(), the_id, start, edge,
(char *)valp->base())
);
break;
case ncNoType:
default:
return 0;
}
delete [] start;
delete [] startl;
delete [] edge;
delete [] edgel;
if (status != NC_NOERR) {
delete valp;
return 0;
}
return valp;
}
/***************************************************************************************
* Given a numeric varid, this reads the data from the file.
* Does not return on errors.
*/
SEXP R_nc_get_vara_numvarid( SEXP sx_nc, SEXP sx_varid, SEXP sx_start, SEXP sx_count )
{
int varid, ncid, ndims, len_start, len_count, i, j, ierr,
start_arg[MAX_NC_DIMS], count_arg[MAX_NC_DIMS],
*data_addr_i, missval_i, ndims_cgt1;
SEXP rv_data = R_NilValue /* -Wall */, sx_dim;
size_t start[MAX_NC_DIMS], count[MAX_NC_DIMS], varsize[MAX_NC_DIMS], tot_var_size,
i_szt;
double *data_addr_d, missval_d, missval_tol;
nc_type vartype;
/*---------------------------------------------------------------------------
* On entry, the following are guaranteed to be integers:
* varid
* *start
* *count
*
* Note that varid, start, and/or count could be a single '-1' if the user
* has not specified the start and count to use.
* 'sx_nc' is guaranteed to be the full object of class 'ncdf'.
*----------------------------------------------------------------------------*/
varid = INTEGER(sx_varid)[0];
ncid = INTEGER(R_ncu_getListElement( sx_nc, "id" ))[0];
/*-----------------------------------------------------------------------
* Copy passed start and count to local vars so we can modify them safely
*----------------------------------------------------------------------*/
len_start = length(sx_start);
for( i=0; i<len_start; i++ )
start_arg[i] = INTEGER(sx_start)[i];
len_count = length(sx_count);
for( i=0; i<len_count; i++ )
count_arg[i] = INTEGER(sx_count)[i];
/*-----------------------------------------
* Get varid to use, if passed value is -1.
*----------------------------------------*/
if( varid == -1 ) {
/*----------------------------------------------------
* Get how many vars are in this file ... if only one,
* use that one. Otherwise, signal error.
*---------------------------------------------------*/
varid = R_ncu_varid_onlyvar( ncid );
if( varid == -1 )
error( "Error: no var specified, and the file has more than one valid var!" );
}
else
varid--; /* go from R to C indexing */
/*--------------------------------------------------------
* Get # of dims for this var, as a check to make sure any
* passed 'start' and 'count' are correct.
*-------------------------------------------------------*/
ierr = nc_inq_varndims( ncid, varid, &ndims );
if( ierr != NC_NOERR )
error( "Internal error in ncdf package, routine R_nc_get_vara_numvarid: failed to get ndims for var!\n" );
/*------------------------------------------------------
* Get our variable's size, and the start & count to use
*-----------------------------------------------------*/
R_ncu_get_varsize( ncid, varid, ndims, varsize );
R_ncu_calc_start_count( ncid, varid, start_arg, len_start, count_arg, len_count,
varsize, ndims, start, count );
/*------------------------------------------------------------
* Allocate space for data, depending on the type of var it is
*-----------------------------------------------------------*/
ierr = nc_inq_vartype( ncid, varid, &vartype );
if( ierr != NC_NOERR )
error( "Internal error in ncdf package, routine R_nc_get_vara_numvarid: failed to get type for var!\n" );
tot_var_size = 1L;
for( i=0; i<ndims; i++ ) {
tot_var_size *= count[i];
}
switch( vartype ) {
case NC_CHAR:
error( "chars not handled yet, use old interface" );
break;
case NC_BYTE:
case NC_SHORT:
case NC_INT:
/*---------------
* Allocate space
*--------------*/
PROTECT( rv_data = allocVector( INTSXP, tot_var_size ));
data_addr_i = &(INTEGER(rv_data)[0]); /* Is this guaranteed to work? Dunno. */
/*--------------
* Read the data
*-------------*/
ierr = nc_get_vara_int( ncid, varid, start, count, data_addr_i );
if( ierr != NC_NOERR )
error( "Error while trying to read int data from file!" );
/*---------------------
* Handle missing value
*--------------------*/
ierr = nc_get_att_int( ncid, varid, "missing_value", &missval_i );
if( ierr != NC_NOERR )
/* No missing value attribute found, use default value */
missval_i = NC_FILL_INT;
for( i_szt=0L; i_szt<tot_var_size; i_szt++ )
if( data_addr_i[i_szt] == missval_i )
data_addr_i[i_szt] = NA_INTEGER;
break;
case NC_FLOAT:
case NC_DOUBLE:
/*---------------
* Allocate space
*--------------*/
PROTECT( rv_data = allocVector( REALSXP, tot_var_size ));
data_addr_d = &(REAL(rv_data)[0]); /* Is this guaranteed to work? Dunno. */
/*--------------
* Read the data
*-------------*/
ierr = nc_get_vara_double( ncid, varid, start, count, data_addr_d );
if( ierr != NC_NOERR )
error( "Error while trying to read real data from file!" );
/*---------------------
* Handle missing value
*--------------------*/
ierr = nc_get_att_double( ncid, varid, "missing_value", &missval_d );
if( ierr != NC_NOERR )
/* No missing value attribute found, use default value */
missval_d = 1.e30;
missval_tol = 1.e-5*fabs(missval_d);
for( i_szt=0L; i_szt<tot_var_size; i_szt++ )
if( fabs(data_addr_d[i_szt] - missval_d) < missval_tol )
data_addr_d[i_szt] = NA_REAL;
break;
default:
error( "unhandled var type when allocating var space in R_nc_get_vara_numvarid");
}
/*-----------------------------------------
* Set our dims (note: non-degenerate only)
*----------------------------------------*/
ndims_cgt1 = 0;
for( i=0; i<ndims; i++ )
if( count[i] > 1 )
ndims_cgt1++;
if( ndims_cgt1 == 0 ) {
PROTECT( sx_dim = allocVector( INTSXP, 1 ));
INTEGER(sx_dim)[0] = 1;
}
else
{
PROTECT( sx_dim = allocVector( INTSXP, ndims_cgt1 ));
j = 0;
for( i=0; i<ndims; i++ )
if( count[i] > 1 ) {
INTEGER(sx_dim)[ndims_cgt1-j-1] = count[i];
j++;
}
}
setAttrib( rv_data, R_DimSymbol, sx_dim );
UNPROTECT(2);
return(rv_data);
}
int ex_get_partial_node_set_df (int exoid,
ex_entity_id node_set_id,
int64_t start_num,
int64_t num_df_to_get,
void *node_set_dist_fact)
{
int status;
int dimid, dist_id, node_set_id_ndx;
size_t num_nodes_in_set, start[1], count[1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any node sets are specified */
if ((status = nc_inq_dimid (exoid, DIM_NUM_NS, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: no node sets defined in file id %d",
exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_WARN);
}
/* Lookup index of node set id in VAR_NS_IDS array */
if ((node_set_id_ndx = ex_id_lkup(exoid,EX_NODE_SET,node_set_id)) < 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: node set %"PRId64" is NULL in file id %d",
node_set_id,exoid);
ex_err("ex_get_partial_node_set_df",errmsg,EX_MSG);
return (EX_WARN);
} else {
sprintf(errmsg,
"Error: failed to locate node set %"PRId64" in %s in file id %d",
node_set_id,VAR_NS_IDS,exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_dimid (exoid, DIM_NUM_NOD_NS(node_set_id_ndx), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of nodes in node set %"PRId64" in file id %d",
node_set_id,exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_nodes_in_set)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes in node set %"PRId64" in file id %d",
node_set_id, exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
/* Check input parameters for a valid range of numbers */
if (start_num < 0 || start_num > num_nodes_in_set) {
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: Invalid input");
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
if (num_df_to_get < 0) {
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: Invalid number of nodes in nodes set!");
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
/* start_num now starts at 1, not 0 */
if ((start_num + num_df_to_get - 1) > num_nodes_in_set) {
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: request larger than number of nodes in set!");
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid (exoid, VAR_FACT_NS(node_set_id_ndx), &dist_id)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: dist factors not stored for node set %"PRId64" in file id %d",
node_set_id,exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_WARN); /* complain - but not too loud */
}
/* read in the distribution factors array */
start[0] = --start_num;
count[0] = num_df_to_get;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, dist_id, start, count, node_set_dist_fact);
} else {
status = nc_get_vara_double(exoid, dist_id, start, count, node_set_dist_fact);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get distribution factors in file id %d",
exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_get_partial_attr(int exoid, ex_entity_type obj_type, ex_entity_id obj_id, int64_t start_num,
int64_t num_ent, void *attrib)
{
int status;
int attrid, obj_id_ndx;
int temp;
size_t num_entries_this_obj, num_attr;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
const char *dnumobjent;
const char *dnumobjatt;
const char *vattrbname;
ex_check_valid_file_id(exoid);
exerrval = 0; /* clear error code */
if (num_ent == 0) {
return 0;
}
/* Determine index of obj_id in vobjids array */
if (obj_type != EX_NODAL) {
obj_id_ndx = ex_id_lkup(exoid, obj_type, obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no attributes found for NULL %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", errmsg, EX_NULLENTITY);
return (EX_WARN); /* no attributes for this object */
}
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: failed to locate %s id%" PRId64 " in id array in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", errmsg, exerrval);
return (EX_WARN);
}
}
switch (obj_type) {
case EX_SIDE_SET:
dnumobjent = DIM_NUM_SIDE_SS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_SS(obj_id_ndx);
vattrbname = VAR_SSATTRIB(obj_id_ndx);
break;
case EX_NODE_SET:
dnumobjent = DIM_NUM_NOD_NS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_NS(obj_id_ndx);
vattrbname = VAR_NSATTRIB(obj_id_ndx);
break;
case EX_EDGE_SET:
dnumobjent = DIM_NUM_EDGE_ES(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_ES(obj_id_ndx);
vattrbname = VAR_ESATTRIB(obj_id_ndx);
break;
case EX_FACE_SET:
dnumobjent = DIM_NUM_FACE_FS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_FS(obj_id_ndx);
vattrbname = VAR_FSATTRIB(obj_id_ndx);
break;
case EX_ELEM_SET:
dnumobjent = DIM_NUM_ELE_ELS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_ELS(obj_id_ndx);
vattrbname = VAR_ELSATTRIB(obj_id_ndx);
break;
case EX_NODAL:
dnumobjent = DIM_NUM_NODES;
dnumobjatt = DIM_NUM_ATT_IN_NBLK;
vattrbname = VAR_NATTRIB;
break;
case EX_EDGE_BLOCK:
dnumobjent = DIM_NUM_ED_IN_EBLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_EBLK(obj_id_ndx);
vattrbname = VAR_EATTRIB(obj_id_ndx);
break;
case EX_FACE_BLOCK:
dnumobjent = DIM_NUM_FA_IN_FBLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_FBLK(obj_id_ndx);
vattrbname = VAR_FATTRIB(obj_id_ndx);
break;
case EX_ELEM_BLOCK:
dnumobjent = DIM_NUM_EL_IN_BLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_BLK(obj_id_ndx);
vattrbname = VAR_ATTRIB(obj_id_ndx);
break;
default:
exerrval = 1005;
snprintf(errmsg, MAX_ERR_LENGTH,
"Internal ERROR: unrecognized object type in switch: %d in file id %d", obj_type,
exoid);
ex_err("ex_get_partial_attr", errmsg, EX_MSG);
return (EX_FATAL); /* number of attributes not defined */
}
/* inquire id's of previously defined dimensions */
if (ex_get_dimension(exoid, dnumobjent, "entries", &num_entries_this_obj, &temp,
"ex_get_partial_attr") != NC_NOERR) {
return EX_FATAL;
}
if (start_num + num_ent - 1 > num_entries_this_obj) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: start index (%" PRId64 ") + count (%" PRId64
") is larger than total number of entities (%" ST_ZU ") in file id %d",
start_num, num_ent, num_entries_this_obj, exoid);
ex_err("ex_get_partial_attr", errmsg, exerrval);
return (EX_FATAL);
}
if (ex_get_dimension(exoid, dnumobjatt, "attributes", &num_attr, &temp, "ex_get_partial_attr") !=
NC_NOERR) {
return EX_FATAL;
}
if ((status = nc_inq_varid(exoid, vattrbname, &attrid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate attributes for %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", errmsg, exerrval);
return (EX_FATAL);
}
/* read in the attributes */
start[0] = start_num - 1;
start[1] = 0;
count[0] = num_ent;
count[1] = num_attr;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, attrid, start, count, attrib);
}
else {
status = nc_get_vara_double(exoid, attrid, start, count, attrib);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get attributes for %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
/*
* Read a hypercube of numeric values from a netCDF variable of an open
* netCDF file.
*/
static void
c_ncvgt(
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 */
void* value, /* block of data values to be read */
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_get_vara_schar(ncid, varid, start, count,
(signed char*)value);
# elif NF_INT1_IS_C_SHORT
status = nc_get_vara_short(ncid, varid, start, count,
(short*)value);
# elif NF_INT1_IS_C_INT
status = nc_get_vara_int(ncid, varid, start, count,
(int*)value);
# elif NF_INT1_IS_C_LONG
status = nc_get_vara_long(ncid, varid, start, count,
(long*)value);
# endif
break;
case NC_SHORT:
# if NF_INT2_IS_C_SHORT
status = nc_get_vara_short(ncid, varid, start, count,
(short*)value);
# elif NF_INT2_IS_C_INT
status = nc_get_vara_int(ncid, varid, start, count,
(int*)value);
# elif NF_INT2_IS_C_LONG
status = nc_get_vara_long(ncid, varid, start, count,
(long*)value);
# endif
break;
case NC_INT:
# if NF_INT_IS_C_INT
status = nc_get_vara_int(ncid, varid, start, count,
(int*)value);
# elif NF_INT_IS_C_LONG
status = nc_get_vara_long(ncid, varid, start, count,
(long*)value);
# endif
break;
case NC_FLOAT:
# if NF_REAL_IS_C_FLOAT
status = nc_get_vara_float(ncid, varid, start, count,
(float*)value);
# elif NF_REAL_IS_C_DOUBLE
status = nc_get_vara_double(ncid, varid, start, count,
(double*)value);
# endif
break;
case NC_DOUBLE:
# if NF_DOUBLEPRECISION_IS_C_FLOAT
status = nc_get_vara_float(ncid, varid, start, count,
(float*)value);
# elif NF_DOUBLEPRECISION_IS_C_DOUBLE
status = nc_get_vara_double(ncid, varid, start, count,
(double*)value);
# endif
break;
}
}
if (status == 0)
*rcode = 0;
else
{
nc_advise("NCVGT", status, "");
*rcode = ncerr;
}
}
