int ex_get_time (int exoid,
int time_step,
void *time_value)
{
int varid;
long start[1];
char var_name[MAX_VAR_NAME_LENGTH+1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire previously defined dimensions */
strcpy (var_name, VAR_WHOLE_TIME);
/* inquire previously defined variable */
if ((varid = ncvarid (exoid, var_name)) < 0)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate time variable in file id %d", exoid);
ex_err("ex_get_time",errmsg,exerrval);
return (EX_FATAL);
}
/* read time value */
start[0] = --time_step;
if (ncvarget1 (exoid, varid, start,
ex_conv_array(exoid,RTN_ADDRESS,time_value,1)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get time value in file id %d", exoid);
ex_err("ex_get_time",errmsg,exerrval);
return (EX_FATAL);
}
ex_conv_array( exoid, READ_CONVERT, time_value, 1 );
return (EX_NOERR);
}
int
cpy_var_val(int in_id,int out_id,char *var_nm)
/*
int in_id: input netCDF input-file ID
int out_id: input netCDF output-file ID
char *var_nm: input variable name
*/
{
/* Routine to copy the variable data from an input netCDF file
* to an output netCDF file.
*/
int *dim_id;
int idx;
int nbr_dim;
int var_in_id;
int var_out_id;
long *dim_cnt;
long *dim_sz;
long *dim_srt;
long var_sz=1L;
nc_type var_type_in, var_type_out;
void *void_ptr;
/* Get the var_id for the requested variable from both files. */
var_in_id=ncvarid(in_id,var_nm);
var_out_id=ncvarid(out_id,var_nm);
/* Get the number of dimensions for the variable. */
ncvarinq(out_id,var_out_id,(char *)NULL,&var_type_out,&nbr_dim,
(int *)NULL,(int *)NULL);
ncvarinq(in_id,var_in_id,(char *)NULL,&var_type_in,&nbr_dim,
(int *)NULL,(int *)NULL);
/* Allocate space to hold the dimension IDs */
dim_cnt = malloc(nbr_dim*sizeof(long));
dim_id=malloc(nbr_dim*sizeof(int));
dim_sz=malloc(nbr_dim*sizeof(long));
dim_srt=malloc(nbr_dim*sizeof(long));
/* Get the dimension IDs from the input file */
ncvarinq(in_id,var_in_id,(char *)NULL,(nc_type *)NULL,
(int *)NULL,dim_id,(int *)NULL);
/* Get the dimension sizes and names from the input file */
for(idx=0;idx<nbr_dim;idx++){
/* NB: For the unlimited dimension, ncdiminq() returns the maximum
value used so far in writing data for that dimension.
Thus if you read the dimension sizes from the output file, then
the ncdiminq() returns dim_sz=0 for the unlimited dimension
until a variable has been written with that dimension. This is
the reason for always reading the input file for the dimension
sizes. */
ncdiminq(in_id,dim_id[idx],(char *)NULL,dim_cnt+idx);
/* Initialize the indicial offset and stride arrays */
dim_srt[idx]=0L;
var_sz*=dim_cnt[idx];
} /* end loop over dim */
/* Allocate enough space to hold the variable */
void_ptr=malloc(var_sz*nctypelen(var_type_in));
/* Get the variable */
/* if variable is float or double, convert if necessary */
if(nbr_dim==0){ /* variable is a scalar */
ncvarget1(in_id,var_in_id,0L,void_ptr);
if ( ( (var_type_in == NC_FLOAT) && (var_type_out == NC_FLOAT) ) ||
( (var_type_in == NC_DOUBLE) && (var_type_out == NC_DOUBLE) ) ) {
/* no conversion necessary */
ncvarput1(out_id,var_out_id,0L,void_ptr);
} else if ( (var_type_in == NC_FLOAT) && (var_type_out == NC_DOUBLE) ) {
/* convert up */
ncvarput1(out_id,var_out_id,0L,
ex_conv_array (out_id, WRITE_CONVERT_UP, void_ptr, 1));
} else if ( (var_type_in == NC_DOUBLE) && (var_type_out == NC_FLOAT) ) {
/* convert down */
ncvarput1(out_id,var_out_id,0L,
ex_conv_array (out_id, WRITE_CONVERT_DOWN, void_ptr, 1));
} else { /* variable isn't float or double */
/* no conversion necessary */
ncvarput1(out_id,var_out_id,0L,void_ptr);
}
} else { /* variable is a vector */
ncvarget(in_id,var_in_id,dim_srt,dim_cnt,void_ptr);
if ( ( (var_type_in == NC_FLOAT) && (var_type_out == NC_FLOAT) ) ||
( (var_type_in == NC_DOUBLE) && (var_type_out == NC_DOUBLE) ) ) {
/* no conversion necessary */
ncvarput(out_id,var_out_id,dim_srt,dim_cnt,void_ptr);
} else if ( (var_type_in == NC_FLOAT) && (var_type_out == NC_DOUBLE) ) {
/* convert up */
ncvarput(out_id,var_out_id,dim_srt,dim_cnt,
ex_conv_array (out_id,WRITE_CONVERT_UP,void_ptr,var_sz));
} else if ( (var_type_in == NC_DOUBLE) && (var_type_out == NC_FLOAT) ) {
/* convert down */
ncvarput(out_id,var_out_id,dim_srt,dim_cnt,
ex_conv_array (out_id,WRITE_CONVERT_DOWN,void_ptr,var_sz));
} else { /* variable isn't float or double */
/* no conversion necessary */
ncvarput(out_id,var_out_id,dim_srt,dim_cnt,void_ptr);
}
} /* end if variable is an array */
/* Free the space that held the dimension IDs */
(void)free(dim_cnt);
(void)free(dim_id);
(void)free(dim_sz);
(void)free(dim_srt);
/* Free the space that held the variable */
(void)free(void_ptr);
return(EX_NOERR);
} /* end cpy_var_val() */
int ex_get_var_name (int exoid,
const char *var_type,
int var_num,
char *var_name)
{
int j, varid;
long start[2];
char *ptr;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire previously defined variables */
if (*var_type == 'g' || *var_type == 'G')
{
if ((varid = ncvarid (exoid, VAR_NAME_GLO_VAR)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: no global variables names stored in file id %d", exoid);
ex_err("ex_get_var_name",errmsg,exerrval);
return (EX_WARN);
}
}
else if (*var_type == 'n' || *var_type == 'N')
{
if ((varid = ncvarid (exoid, VAR_NAME_NOD_VAR)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: no nodal variable names stored in file id %d",
exoid);
ex_err("ex_get_var_name",errmsg,exerrval);
return (EX_WARN);
}
}
else if (*var_type == 'e' || *var_type == 'E')
{
if ((varid = ncvarid (exoid, VAR_NAME_ELE_VAR)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: no element variable names stored in file id %d",
exoid);
ex_err("ex_get_var_name",errmsg,exerrval);
return (EX_WARN);
}
}
else /* invalid variable type */
{
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid variable type %c specified in file id %d",
*var_type, exoid);
ex_err("ex_put_var_name",errmsg,exerrval);
return (EX_WARN);
}
/* read the variable name */
start[0] = var_num;
start[1] = 0;
j = 0;
ptr=var_name;
if (ncvarget1 (exoid, varid, start, ptr) == -1) /* get first character */
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get results variable name type %c, index %d from file id %d",
*var_type, var_num, exoid);
ex_err("ex_get_var_name",errmsg,exerrval);
return (EX_FATAL);
}
while ((*ptr++ != '\0') && (j < MAX_STR_LENGTH)) /* get remaining chars */
{
start[1] = ++j;
if (ncvarget1 (exoid, varid, start, ptr) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get results variable names from file id %d", exoid);
ex_err("ex_get_var_names",errmsg,exerrval);
return (EX_FATAL);
}
}
if (*(--ptr) != '\0')
{
--ptr;
while (*(--ptr) == ' '); /* strip right trailing blanks */
*(++ptr) = '\0';
}
return (EX_NOERR);
}
int ex_get_info (int exoid,
char **info)
{
int i, j, dimid, varid;
long num_info, start[2];
char *ptr;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire previously defined dimensions and variables */
if ((dimid = ncdimid (exoid, DIM_NUM_INFO)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: failed to locate number of info records in file id %d",
exoid);
ex_err("ex_get_info",errmsg,exerrval);
return (EX_WARN);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_info) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of info records in file id %d",
exoid);
ex_err("ex_get_info",errmsg,exerrval);
return (EX_FATAL);
}
/* do this only if there are any information records */
if (num_info > 0)
{
if ((varid = ncvarid (exoid, VAR_INFO)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate info record data in file id %d", exoid);
ex_err("ex_get_info",errmsg,exerrval);
return (EX_FATAL);
}
/* read the information records */
for (i=0; i<num_info; i++)
{
start[0] = i;
start[1] = 0;
j = 0;
ptr = info[i];
if (ncvarget1 (exoid, varid, start, ptr) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get info record data in file id %d", exoid);
ex_err("ex_get_info",errmsg,exerrval);
return (EX_FATAL);
}
while ((*ptr++ != '\0') && (j < MAX_LINE_LENGTH))
{
start[1] = ++j;
if (ncvarget1 (exoid, varid, start, ptr) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get info record data in file id %d", exoid);
ex_err("ex_get_info",errmsg,exerrval);
return (EX_FATAL);
}
}
/* delete trailing blanks */
--ptr;
while ( --ptr >= info[i] && *ptr == ' ' );
*(++ptr) = '\0';
}
}
return (EX_NOERR);
}
int ex_get_coord_names (int exoid,
char **coord_names)
{
int i, j, ndimdim, varid;
long num_dim, start[2];
char *ptr;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0;
/* inquire previously defined dimensions and variables */
if ((ndimdim = ncdimid (exoid, DIM_NUM_DIM)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of dimensions in file id %d",
exoid);
ex_err("ex_get_coord_names",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, ndimdim, (char *) 0, &num_dim) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of dimensions in file id %d",
exoid);
ex_err("ex_get_coord_names",errmsg,exerrval);
return (EX_FATAL);
}
if ((varid = ncvarid (exoid, VAR_NAME_COOR)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: failed to locate coordinate names in file id %d",
exoid);
ex_err("ex_get_coord_names",errmsg,exerrval);
return (EX_WARN);
}
/* read the coordinate names */
for (i=0; i<num_dim; i++)
{
start[0] = i;
start[1] = 0;
j = 0;
ptr = coord_names[i];
if (ncvarget1 (exoid, varid, start, ptr) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get coordinate names in file id %d", exoid);
ex_err("ex_get_coord_names",errmsg,exerrval);
return (EX_FATAL);
}
while ((*ptr++ != '\0') && (j < MAX_STR_LENGTH))
{
start[1] = ++j;
if (ncvarget1 (exoid, varid, start, ptr) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get coordinate names in file id %d", exoid);
ex_err("ex_get_coord_names",errmsg,exerrval);
return (EX_FATAL);
}
}
--ptr;
if (ptr > coord_names[i]) {
/* get rid of trailing blanks */
while (*(--ptr) == ' ');
}
*(++ptr) = '\0';
}
return (EX_NOERR);
}
void
mexFunction (
INT nlhs,
Matrix * plhs[],
INT nrhs,
const Matrix * prhs[]
)
{
char * opname;
OPCODE opcode;
Matrix * mat;
int status;
char * path;
int cmode;
int mode;
int cdfid;
int ndims;
int nvars;
int natts;
int recdim;
char * name;
long length;
int dimid;
nc_type datatype;
int * dim;
int varid;
long * coords;
VOIDP value;
long * start;
long * count;
int * intcount;
long * stride;
long * imap;
long recnum;
int nrecvars;
int * recvarids;
long * recsizes;
VOIDPP datap; /* pointers for record access. */
int len;
int incdf;
int invar;
int outcdf;
int outvar;
int attnum;
char * attname;
char * newname;
int fillmode;
int i;
int m;
int n;
char * p;
char buffer[MAX_BUFFER];
DOUBLE * pr;
DOUBLE addoffset;
DOUBLE scalefactor;
int autoscale; /* do auto-scaling if this flag is non-zero. */
/* Disable the NC_FATAL option from ncopts. */
if (ncopts & NC_FATAL) {
ncopts -= NC_FATAL;
}
/* Display usage if less than one input argument. */
if (nrhs < 1) {
Usage();
return;
}
/* Convert the operation name to its opcode. */
opname = Mat2Str(prhs[0]);
for (i = 0; i < strlen(opname); i++) {
opname[i] = (char) tolower((int) opname[i]);
}
p = opname;
if (strncmp(p, "nc", 2) == 0) { /* Trim away "nc". */
p += 2;
}
i = 0;
opcode = NONE;
while (ops[i].opcode != NONE) {
if (!strcmp(p, ops[i].opname)) {
opcode = ops[i].opcode;
if (ops[i].nrhs > nrhs) {
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: Too few input arguments.\n");
}
else if (0 && ops[i].nlhs > nlhs) { /* Disabled. */
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: Too few output arguments.\n");
}
break;
}
else {
i++;
}
}
if (opcode == NONE) {
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: No such operation.\n");
}
Free((VOIDPP) & opname);
/* Extract the cdfid by number. */
switch (opcode) {
case USAGE:
case CREATE:
case OPEN:
case TYPELEN:
case SETOPTS:
case ERR:
case PARAMETER:
break;
default:
cdfid = Scalar2Int(prhs[1]);
break;
}
/* Extract the dimid by number or name. */
switch (opcode) {
case DIMINQ:
case DIMRENAME:
if (mxIsNumeric(prhs[2])) {
dimid = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[2]);
dimid = ncdimid(cdfid, name);
Free((VOIDPP) & name);
}
break;
default:
break;
}
/* Extract the varid by number or name. */
switch (opcode) {
case VARINQ:
case VARPUT1:
case VARGET1:
case VARPUT:
case VARGET:
case VARPUTG:
case VARGETG:
case VARRENAME:
case VARCOPY:
case ATTPUT:
case ATTINQ:
case ATTGET:
case ATTCOPY:
case ATTNAME:
case ATTRENAME:
case ATTDEL:
if (mxIsNumeric(prhs[2])) {
varid = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[2]);
varid = ncvarid(cdfid, name);
Free((VOIDPP) & name);
if (varid == -1) {
varid = Parameter(prhs[2]);
}
}
break;
default:
break;
}
/* Extract the attname by name or number. */
switch (opcode) {
case ATTPUT:
case ATTINQ:
case ATTGET:
case ATTCOPY:
case ATTRENAME:
case ATTDEL:
if (mxIsNumeric(prhs[3])) {
attnum = Scalar2Int(prhs[3]);
attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncattname(cdfid, varid, attnum, attname);
}
else {
attname = Mat2Str(prhs[3]);
}
break;
default:
break;
}
/* Extract the "add_offset" and "scale_factor" attributes. */
switch (opcode) {
case VARPUT1:
case VARGET1:
case VARPUT:
case VARGET:
case VARPUTG:
case VARGETG:
addoffset = Add_Offset(cdfid, varid);
scalefactor = Scale_Factor(cdfid, varid);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
break;
default:
break;
}
/* Perform the NetCDF operation. */
switch (opcode) {
case USAGE:
Usage();
break;
case CREATE:
path = Mat2Str(prhs[1]);
if (nrhs > 2) {
cmode = Parameter(prhs[2]);
}
else {
cmode = NC_NOCLOBBER; /* Default. */
}
cdfid = nccreate(path, cmode);
plhs[0] = Int2Scalar(cdfid);
plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1);
Free((VOIDPP) & path);
break;
case OPEN:
path = Mat2Str(prhs[1]);
if (nrhs > 2) {
mode = Parameter(prhs[2]);
}
else {
mode = NC_NOWRITE; /* Default. */
}
cdfid = ncopen(path, mode);
plhs[0] = Int2Scalar(cdfid);
plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1);
Free((VOIDPP) & path);
break;
case REDEF:
status = ncredef(cdfid);
plhs[0] = Int2Scalar(status);
break;
case ENDEF:
status = ncendef(cdfid);
plhs[0] = Int2Scalar(status);
break;
case CLOSE:
status = ncclose(cdfid);
plhs[0] = Int2Scalar(status);
break;
case INQUIRE:
status = ncinquire(cdfid, & ndims, & nvars, & natts, & recdim);
if (nlhs > 1) {
plhs[0] = Int2Scalar(ndims);
plhs[1] = Int2Scalar(nvars);
plhs[2] = Int2Scalar(natts);
plhs[3] = Int2Scalar(recdim);
plhs[4] = Int2Scalar(status);
}
else { /* Default to 1 x 5 row vector. */
plhs[0] = mxCreateFull(1, 5, REAL);
pr = mxGetPr(plhs[0]);
if (status == 0) {
pr[0] = (DOUBLE) ndims;
pr[1] = (DOUBLE) nvars;
pr[2] = (DOUBLE) natts;
pr[3] = (DOUBLE) recdim;
}
pr[4] = (DOUBLE) status;
}
break;
case SYNC:
status = ncsync(cdfid);
plhs[0] = Int2Scalar(status);
break;
case ABORT:
status = ncabort(cdfid);
plhs[0] = Int2Scalar(status);
break;
case DIMDEF:
name = Mat2Str(prhs[2]);
length = Parameter(prhs[3]);
dimid = ncdimdef(cdfid, name, length);
plhs[0] = Int2Scalar(dimid);
plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid);
Free((VOIDPP) & name);
break;
case DIMID:
name = Mat2Str(prhs[2]);
dimid = ncdimid(cdfid, name);
plhs[0] = Int2Scalar(dimid);
plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid);
Free((VOIDPP) & name);
break;
case DIMINQ:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncdiminq(cdfid, dimid, name, & length);
plhs[0] = Str2Mat(name);
plhs[1] = Long2Scalar(length);
plhs[2] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case DIMRENAME:
name = Mat2Str(prhs[3]);
status = ncdimrename(cdfid, dimid, name);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case VARDEF:
name = Mat2Str(prhs[2]);
datatype = (nc_type) Parameter(prhs[3]);
ndims = Scalar2Int(prhs[4]);
if (ndims == -1) {
ndims = Count(prhs[5]);
}
dim = Mat2Int(prhs[5]);
varid = ncvardef(cdfid, name, datatype, ndims, dim);
Free((VOIDPP) & name);
plhs[0] = Int2Scalar(varid);
plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid);
break;
case VARID:
name = Mat2Str(prhs[2]);
varid = ncvarid(cdfid, name);
Free((VOIDPP) & name);
plhs[0] = Int2Scalar(varid);
plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid);
break;
case VARINQ:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
plhs[0] = Str2Mat(name);
plhs[1] = Int2Scalar(datatype);
plhs[2] = Int2Scalar(ndims);
plhs[3] = Int2Mat(dim, 1, ndims);
plhs[4] = Int2Scalar(natts);
plhs[5] = Int2Scalar(status);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
break;
case VARPUT1:
coords = Mat2Long(prhs[3]);
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[4]);
}
else {
mat = prhs[4];
}
if (mat == NULL) {
mat = prhs[4];
}
pr = mxGetPr(mat);
autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr);
status = ncvarput1(cdfid, varid, coords, buffer);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & coords);
break;
case VARGET1:
coords = Mat2Long(prhs[3]);
autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
mat = Int2Scalar(0);
pr = mxGetPr(mat);
status = ncvarget1(cdfid, varid, coords, buffer);
status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[0] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & coords);
break;
case VARPUT:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
autoscale = (nrhs > 6 && Scalar2Int(prhs[6]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[5]);
}
else {
mat = prhs[5];
}
if (mat == NULL) {
mat = prhs[5];
}
pr = mxGetPr(mat);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
len = 0;
if (ndims > 0) {
len = 1;
for (i = 0; i < ndims; i++) {
len *= count[i];
}
}
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
status = ncvarput(cdfid, varid, start, count, value);
Free((VOIDPP) & value);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & start);
Free((VOIDPP) & count);
break;
case VARGET:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
intcount = Mat2Int(prhs[4]);
autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
m = 0;
n = 0;
if (ndims > 0) {
m = count[0];
n = count[0];
for (i = 1; i < ndims; i++) {
n *= count[i];
if (count[i] > 1) {
m = count[i];
}
}
n /= m;
}
len = m * n;
if (ndims < 2) {
m = 1;
n = len;
}
for (i = 0; i < ndims; i++) {
intcount[i] = count[ndims-i-1]; /* Reverse order. */
}
if (MEXCDF_4 || ndims < 2) {
mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */
}
# if MEXCDF_5
else {
mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL);
}
# endif
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncvarget(cdfid, varid, start, count, value);
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
Free((VOIDPP) & value);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
plhs[0] = mat;
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & intcount);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARPUTG:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
if (nrhs > 7) {
if (datatype == NC_CHAR) {
mat = SetStr(prhs[7]);
}
else {
mat = prhs[7];
}
if (mat == NULL) {
mat = prhs[7];
}
}
else {
if (datatype == NC_CHAR) {
mat = SetStr(prhs[6]);
}
else {
mat = prhs[6];
}
if (mat == NULL) {
mat = prhs[6];
}
}
pr = mxGetPr(mat);
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
stride = Mat2Long(prhs[5]);
imap = NULL;
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
len = 0;
if (ndims > 0) {
len = 1;
for (i = 0; i < ndims; i++) {
len *= count[i];
}
}
autoscale = (nrhs > 8 && Scalar2Int(prhs[8]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
status = ncvarputg(cdfid, varid, start, count, stride, imap, value);
Free((VOIDPP) & value);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & stride);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARGETG:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
intcount = Mat2Int(prhs[4]);
stride = Mat2Long(prhs[5]);
imap = NULL;
autoscale = (nrhs > 7 && Scalar2Int(prhs[7]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
m = 0;
n = 0;
if (ndims > 0) {
m = count[0];
n = count[0];
for (i = 1; i < ndims; i++) {
n *= count[i];
if (count[i] > 1) {
m = count[i];
}
}
n /= m;
}
len = m * n;
if (ndims < 2) {
m = 1;
n = len;
}
for (i = 0; i < ndims; i++) {
intcount[i] = count[ndims-i-1]; /* Reverse order. */
}
if (MEXCDF_4 || ndims < 2) {
mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */
}
# if MEXCDF_5
else {
mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL);
}
# endif
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncvargetg(cdfid, varid, start, count, stride, imap, value);
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
Free((VOIDPP) & value);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[0] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & stride);
Free((VOIDPP) & intcount);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARRENAME:
name = Mat2Str(prhs[3]);
status = ncvarrename(cdfid, varid, name);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case VARCOPY:
incdf = cdfid;
invar = varid;
outcdf = Scalar2Int(prhs[3]);
outvar = -1;
/* outvar = ncvarcopy(incdf, invar, outcdf); */
plhs[0] = Int2Scalar(outvar);
plhs[1] = Int2Scalar((outvar >= 0) ? 0 : outvar);
break;
case ATTPUT:
datatype = (nc_type) Parameter(prhs[4]);
datatype = RepairBadDataType(datatype);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[6]);
}
else {
mat = prhs[6];
}
if (mat == NULL) {
mat = prhs[6];
}
len = Scalar2Int(prhs[5]);
if (len == -1) {
len = Count(mat);
}
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr);
status = ncattput(cdfid, varid, attname, datatype, len, value);
if (value != NULL) {
Free((VOIDPP) & value);
}
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTINQ:
status = ncattinq(cdfid, varid, attname, & datatype, & len);
datatype = RepairBadDataType(datatype);
plhs[0] = Int2Scalar((int) datatype);
plhs[1] = Int2Scalar(len);
plhs[2] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTGET:
status = ncattinq(cdfid, varid, attname, & datatype, & len);
datatype = RepairBadDataType(datatype);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncattget(cdfid, varid, attname, value);
mat = mxCreateDoubleMatrix(1, len, mxREAL);
pr = mxGetPr(mat);
status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr);
if (value != NULL) {
Free((VOIDPP) & value);
}
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[4] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTCOPY:
incdf = cdfid;
invar = varid;
outcdf = Scalar2Int(prhs[4]);
if (mxIsNumeric(prhs[5])) {
outvar = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[5]);
outvar = ncvarid(cdfid, name);
Free((VOIDPP) & name);
}
status = ncattcopy(incdf, invar, attname, outcdf, outvar);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTNAME:
attnum = Scalar2Int(prhs[3]);
attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncattname(cdfid, varid, attnum, attname);
plhs[0] = Str2Mat(attname);
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTRENAME:
newname = Mat2Str(prhs[4]);
status = ncattrename(cdfid, varid, attname, newname);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
Free((VOIDPP) & newname);
break;
case ATTDEL:
status = ncattdel(cdfid, varid, attname);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case RECPUT:
recnum = Scalar2Long(prhs[2]);
pr = mxGetPr(prhs[3]);
autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status == -1) {
plhs[0] = Int2Scalar(status);
break;
}
length = 0;
n = 0;
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length += recsizes[i];
n += (recsizes[i] / nctypelen(datatype));
}
if (Count(prhs[3]) < n) {
status = -1;
plhs[0] = Int2Scalar(status);
break;
}
if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) {
status = -1;
plhs[0] = Int2Scalar(status);
break;
}
length = 0;
p = value;
for (i = 0; i < nrecvars; i++) {
datap[i] = p;
p += recsizes[i];
}
p = (char *) value;
pr = mxGetPr(prhs[3]);
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length = recsizes[i] / nctypelen(datatype);
if (autoscale) {
addoffset = Add_Offset(cdfid, recvarids[i]);
scalefactor = Scale_Factor(cdfid, recvarids[i]);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
}
Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr);
pr += length;
p += recsizes[i];
}
status = ncrecput(cdfid, recnum, datap);
plhs[0] = Int2Scalar(status);
Free ((VOIDPP) & value);
Free ((VOIDPP) & datap);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case RECGET:
recnum = Scalar2Long(prhs[2]);
autoscale = (nrhs > 3 && Scalar2Int(prhs[3]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status == -1) {
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
plhs[1] = Int2Scalar(status);
break;
}
if (nrecvars == 0) {
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
plhs[0] = mxCreateFull(0, 0, REAL);
break;
}
length = 0;
n = 0;
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length += recsizes[i];
n += (recsizes[i] / nctypelen(datatype));
}
if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
if (value == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
length = 0;
p = value;
for (i = 0; i < nrecvars; i++) {
datap[i] = p;
p += recsizes[i];
}
if ((status = ncrecget(cdfid, recnum, datap)) == -1) {
plhs[1] = Int2Scalar(status);
break;
}
m = 1;
plhs[0] = mxCreateFull(m, n, REAL);
if (plhs[0] == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
pr = mxGetPr(plhs[0]);
p = (char *) value;
for (i = 0; i < nrecvars; i++) {
status = ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
if (status == -1) {
plhs[1] = Int2Scalar(status);
break;
}
length = recsizes[i] / nctypelen(datatype);
if (autoscale) {
addoffset = Add_Offset(cdfid, recvarids[i]);
scalefactor = Scale_Factor(cdfid, recvarids[i]);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
}
Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr);
pr += length;
p += recsizes[i];
}
plhs[1] = Int2Scalar(status);
Free ((VOIDPP) & value);
Free ((VOIDPP) & datap);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case RECINQ:
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status != -1) {
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
recsizes[i] /= nctypelen(datatype);
}
m = 1;
n = nrecvars;
plhs[0] = Int2Mat(recvarids, m, n);
plhs[1] = Long2Mat(recsizes, m, n);
}
plhs[2] = Int2Scalar(status);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case TYPELEN:
datatype = (nc_type) Parameter(prhs[1]);
len = nctypelen(datatype);
plhs[0] = Int2Scalar(len);
plhs[1] = Int2Scalar((len >= 0) ? 0 : 1);
break;
case SETFILL:
fillmode = Scalar2Int(prhs[1]);
status = ncsetfill(cdfid, fillmode);
plhs[0] = Int2Scalar(status);
plhs[1] = Int2Scalar(0);
break;
case SETOPTS:
plhs[0] = Int2Scalar(ncopts);
plhs[1] = Int2Scalar(0);
ncopts = Scalar2Int(prhs[1]);
break;
case ERR:
plhs[0] = Int2Scalar(ncerr);
ncerr = 0;
plhs[1] = Int2Scalar(0);
break;
case PARAMETER:
if (nrhs > 1) {
plhs[0] = Int2Scalar(Parameter(prhs[1]));
plhs[1] = Int2Scalar(0);
}
else {
i = 0;
while (strcmp(parms[i].name, "NONE") != 0) {
mexPrintf("%12d %s\n", parms[i].code, parms[i].name);
i++;
}
plhs[0] = Int2Scalar(0);
plhs[1] = Int2Scalar(-1);
}
break;
default:
break;
}
return;
}
/*
* reads the attribute names for an element block
*/
int ex_get_attr_names( int exoid,
int obj_type,
int obj_id,
char **names)
{
int varid, numattrdim, obj_id_ndx;
long num_attr, start[2];
char *ptr;
char errmsg[MAX_ERR_LENGTH];
int i, j;
const char* tname;
const char* vobjids;
const char* dnumobjatt = 0;
const char* vattrbname = 0;
switch (obj_type) {
case EX_EDGE_BLOCK:
tname = "edge block";
vobjids = VAR_ID_ED_BLK;
break;
case EX_FACE_BLOCK:
tname = "face block";
vobjids = VAR_ID_FA_BLK;
break;
case EX_ELEM_BLOCK:
tname = "element block";
vobjids = VAR_ID_EL_BLK;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg, "Error: Invalid object type (%d) specified for file id %d",
obj_type, exoid );
ex_err( "ex_get_attr_names", errmsg, exerrval );
return (EX_FATAL);
}
exerrval = 0; /* clear error code */
/* Determine index of obj_id in vobjids array */
obj_id_ndx = ex_id_lkup(exoid,vobjids,obj_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: no attributes found for NULL block %d in file id %d",
obj_id,exoid);
ex_err("ex_get_attr_names",errmsg,EX_MSG);
return (EX_WARN); /* no attributes for this object */
}
else
{
sprintf(errmsg,
"Warning: failed to locate %s id %d in %s array in file id %d",
tname, obj_id,vobjids, exoid);
ex_err("ex_get_attr_names",errmsg,exerrval);
return (EX_WARN);
}
}
switch (obj_type) {
case EX_EDGE_BLOCK:
dnumobjatt = DIM_NUM_ATT_IN_EBLK(obj_id_ndx);
vattrbname = VAR_NAME_EATTRIB(obj_id_ndx);
break;
case EX_FACE_BLOCK:
dnumobjatt = DIM_NUM_ATT_IN_FBLK(obj_id_ndx);
vattrbname = VAR_NAME_FATTRIB(obj_id_ndx);
break;
case EX_ELEM_BLOCK:
dnumobjatt = DIM_NUM_ATT_IN_BLK(obj_id_ndx);
vattrbname = VAR_NAME_ATTRIB(obj_id_ndx);
break;
}
/* inquire id's of previously defined dimensions */
if ((numattrdim = ncdimid(exoid, dnumobjatt)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: no attributes found for %s %d in file id %d",
tname,obj_id,exoid);
ex_err("ex_get_attr_names",errmsg,EX_MSG);
return (EX_WARN); /* no attributes for this object */
}
if (ncdiminq (exoid, numattrdim, (char *) 0, &num_attr) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of attributes for block %d in file id %d",
obj_id,exoid);
ex_err("ex_get_attr_names",errmsg,exerrval);
return (EX_FATAL);
}
/* It is OK if we don't find the attribute names since they were
added at version 4.26; earlier databases won't have the names.
*/
varid = ncvarid (exoid, vattrbname);
/* read in the attributes */
if (varid != -1) {
/* read the names */
for (i=0; i < num_attr; i++) {
start[0] = i;
start[1] = 0;
j = 0;
ptr = names[i];
if (ncvarget1 (exoid, varid, start, ptr) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get names for %s %d in file id %d",
tname, obj_id, exoid);
ex_err("ex_get_attr_names",errmsg,exerrval);
return (EX_FATAL);
}
while ((*ptr++ != '\0') && (j < MAX_STR_LENGTH)) {
start[1] = ++j;
if (ncvarget1 (exoid, varid, start, ptr) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get names for %s %d in file id %d",
tname, obj_id, exoid);
ex_err("ex_get_attr_names",errmsg,exerrval);
return (EX_FATAL);
}
}
--ptr;
if (ptr > names[i]) {
/* get rid of trailing blanks */
while (*(--ptr) == ' ');
}
*(++ptr) = '\0';
}
} else {
/* Names variable does not exist on the database; probably since this is an
* older version of the database. Return an empty array...
*/
for (i=0; i<num_attr; i++) {
names[i][0] = '\0';
}
}
return(EX_NOERR);
}
int ex_get_qa (int exoid,
char *qa_record[][4])
{
int i, j, k, dimid, varid;
long num_qa_records, start[3];
char *ptr;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire previously defined dimensions and variables */
if ((dimid = ncdimid (exoid, DIM_NUM_QA)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: no qa records stored in file id %d",
exoid);
ex_err("ex_get_qa",errmsg,exerrval);
return (EX_WARN);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_qa_records) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of qa records in file id %d",
exoid);
ex_err("ex_get_qa",errmsg,exerrval);
return (EX_FATAL);
}
/* do this only if there are any QA records */
if (num_qa_records > 0)
{
if ((varid = ncvarid (exoid, VAR_QA_TITLE)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate qa record data in file id %d", exoid);
ex_err("ex_get_qa",errmsg,exerrval);
return (EX_FATAL);
}
/* read the QA records */
for (i=0; i<num_qa_records; i++)
{
for (j=0; j<4; j++)
{
start[0] = i;
start[1] = j;
start[2] = 0;
k = 0;
ptr = qa_record[i][j];
if (ncvarget1 (exoid, varid, start, ptr) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get qa record data in file id %d", exoid);
ex_err("ex_get_qa",errmsg,exerrval);
return (EX_FATAL);
}
while ((*(ptr++) != '\0') && (k < MAX_STR_LENGTH))
{
start[2] = ++k;
if (ncvarget1 (exoid, varid, start, ptr) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get qa record data in file id %d", exoid);
ex_err("ex_get_qa",errmsg,exerrval);
return (EX_FATAL);
}
}
/* remove trailing blanks */
if(start[2] != 0)
{
--ptr;
while ( --ptr >= qa_record[i][j] && *ptr == ' ' );
*(++ptr) = '\0';
}
}
}
}
return (EX_NOERR);
}
int ex_get_name (int exoid,
int obj_type,
int entity_id,
char *name)
{
int j, varid, ent_ndx;
long num_entity, start[2];
char *ptr;
char errmsg[MAX_ERR_LENGTH];
const char *routine = "ex_get_name";
exerrval = 0;
/* inquire previously defined dimensions and variables */
if (obj_type == EX_ELEM_BLOCK) {
ex_get_dimension(exoid, DIM_NUM_EL_BLK, "element block", &num_entity, routine);
varid = ncvarid (exoid, VAR_NAME_EL_BLK);
ent_ndx = ex_id_lkup(exoid, VAR_ID_EL_BLK, entity_id);
}
else if (obj_type == EX_NODE_SET) {
ex_get_dimension(exoid, DIM_NUM_NS, "nodeset", &num_entity, routine);
varid = ncvarid (exoid, VAR_NAME_NS);
ent_ndx = ex_id_lkup(exoid, VAR_NS_IDS, entity_id);
}
else if (obj_type == EX_SIDE_SET) {
ex_get_dimension(exoid, DIM_NUM_SS, "sideset", &num_entity, routine);
varid = ncvarid (exoid, VAR_NAME_SS);
ent_ndx = ex_id_lkup(exoid, VAR_SS_IDS, entity_id);
}
else if (obj_type == EX_NODE_MAP) {
ex_get_dimension(exoid, DIM_NUM_NM, "node map", &num_entity, routine);
varid = ncvarid (exoid, VAR_NAME_NM);
ent_ndx = ex_id_lkup(exoid, VAR_NM_PROP(1), entity_id);
}
else if (obj_type == EX_ELEM_MAP) {
ex_get_dimension(exoid, DIM_NUM_EM, "element map", &num_entity, routine);
varid = ncvarid (exoid, VAR_NAME_EM);
ent_ndx = ex_id_lkup(exoid, VAR_EM_PROP(1), entity_id);
}
else {/* invalid variable type */
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: Invalid type specified in file id %d", exoid);
ex_err(routine,errmsg,exerrval);
return(EX_FATAL);
}
if (varid != -1) {
/* If this is a null entity, then 'ent_ndx' will be negative.
* We don't care in this routine, so make it positive and continue...
*/
if (ent_ndx < 0) ent_ndx = -ent_ndx;
/* read the name */
start[0] = ent_ndx-1;
start[1] = 0;
j = 0;
ptr = name;
if (ncvarget1 (exoid, varid, start, ptr) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get entity name for id %d in file id %d",
ent_ndx, exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
while ((*ptr++ != '\0') && (j < MAX_STR_LENGTH)) {
start[1] = ++j;
if (ncvarget1 (exoid, varid, start, ptr) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get name in file id %d", exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
}
--ptr;
if (ptr > name) {
while (*(--ptr) == ' '); /* get rid of trailing blanks */
}
*(++ptr) = '\0';
} else {
/* Name variable does not exist on the database; probably since this is an
* older version of the database. Return an empty array...
*/
name[0] = '\0';
}
return (EX_NOERR);
}