MNCAPI int
MI2setfill(int fd, int fillmode)
{
if (MI2_ISH5OBJ(fd)) {
/* TODO: ??? */
return (MI_NOERROR);
}
else {
return (ncsetfill(fd, fillmode));
}
}
/*
* Set the fill mode of a netCDF file open for writing.
*/
static int
c_ncsfil (
int ncid, /* netCDF ID */
int fillmode, /* fill mode, NCNOFILL or NCFILL */
int* rcode /* returned error code */
)
{
int retval;
*rcode = ((retval = ncsetfill(ncid, fillmode)) == -1)
? ncerr
: 0;
return retval;
}
int ex_put_prop_array (int exoid,
int obj_type,
const char *prop_name,
const int *values)
{
int num_props, i, propid, dimid, dims[1], iresult;
int found = FALSE;
long start[1], count[1], num_obj;
nclong *lptr;
char name[MAX_VAR_NAME_LENGTH+1];
char tmpstr[MAX_STR_LENGTH+1];
char obj_stype[MAX_VAR_NAME_LENGTH+1];
char dim_name[MAX_VAR_NAME_LENGTH+1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* check if property has already been created */
num_props = ex_get_num_props(exoid, obj_type);
switch (obj_type)
{
case EX_ELEM_BLOCK:
strcpy (obj_stype, VAR_ID_EL_BLK);
strcpy (dim_name, DIM_NUM_EL_BLK);
break;
case EX_NODE_SET:
strcpy (obj_stype, VAR_NS_IDS);
strcpy (dim_name, DIM_NUM_NS);
break;
case EX_SIDE_SET:
strcpy (obj_stype, VAR_SS_IDS);
strcpy (dim_name, DIM_NUM_SS);
break;
case EX_ELEM_MAP:
strcpy (obj_stype, VAR_EM_PROP(1));
strcpy (dim_name, DIM_NUM_EM);
break;
case EX_NODE_MAP:
strcpy (obj_stype, VAR_NM_PROP(1));
strcpy (dim_name, DIM_NUM_NM);
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
/* inquire id of previously defined dimension (number of objects) */
if ((dimid = ncdimid (exoid, dim_name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of %s objects in file id %d",
obj_stype, exoid);
ex_err("ex_put_prop_array",errmsg, exerrval);
return (EX_FATAL);
}
/* get number of objects */
if (ncdiminq (exoid, dimid, dim_name, &num_obj) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of %s objects in file id %d",
obj_stype, exoid);
ex_err("ex_put_prop_array",errmsg, exerrval);
return (EX_FATAL);
}
for (i=1; i<=num_props; i++)
{
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(i));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(i));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(i));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(i));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(i));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return(EX_FATAL);
}
if ((propid = ncvarid (exoid, name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get property array id in file id %d",
exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
memset(tmpstr, 0, MAX_STR_LENGTH+1);
if ((ncattget (exoid, propid, ATT_PROP_NAME, tmpstr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get property name in file id %d", exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0)
{
found = TRUE;
break;
}
}
/* if property array has not been created, create it */
if (!found)
{
/* put netcdf file into define mode */
if (ncredef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
/* create a variable with a name xx_prop#, where # is the new number */
/* of properties */
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(num_props+1));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(num_props+1));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(num_props+1));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(num_props+1));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(num_props+1));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
dims[0] = dimid;
ncsetfill(exoid, NC_FILL); /* fill with zeros per routine spec */
if ((propid = ncvardef (exoid, name, NC_LONG, 1, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create property array variable in file id %d",
exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
ncsetfill(exoid, NC_NOFILL); /* default: nofill */
/* store property name as attribute of property array variable */
if ((ncattput (exoid, propid, ATT_PROP_NAME, NC_CHAR,
strlen(prop_name)+1, prop_name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store property name %s in file id %d",
prop_name,exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to leave define mode in file id %d",
exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
}
/* put num_obj values in property array */
/* this contortion is necessary because netCDF is expecting nclongs; fortunately
it's necessary only when ints and nclongs aren't the same size */
start[0] = 0;
count[0] = num_obj;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarput (exoid, propid, start, count, values);
} else {
lptr = itol (values, (int)num_obj);
iresult = ncvarput (exoid, propid, start, count, lptr);
free(lptr);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store property values in file id %d",
exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
ncsetfill(exoid, NC_NOFILL); /* default: nofill */
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_prop_array",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_create (const char *path,
int cmode,
int *comp_ws,
int *io_ws)
{
int exoid, time_dim, dims[1];
nclong lio_ws;
nclong filesiz;
float vers;
char errmsg[MAX_ERR_LENGTH];
char *mode_name;
int mode = 0;
exerrval = 0; /* clear error code */
/*
* See if "large file" mode was specified in a ex_create cmode. If
* so, then pass the NC_64BIT_OFFSET flag down to netcdf.
*/
if (cmode & EX_LARGE_MODEL || ex_large_model(-1) == 1) {
mode |= NC_64BIT_OFFSET;
}
/*
* set error handling mode to no messages, non-fatal errors
*/
ex_opts(exoptval); /* call required to set ncopts first time through */
if (cmode & EX_NOCLOBBER) {
mode |= NC_NOCLOBBER;
mode_name = "NOCLOBBER";
} else if (cmode & EX_CLOBBER) {
mode |= NC_CLOBBER;
mode_name = "CLOBBER";
} else {
exerrval = EX_BADFILEMODE;
sprintf(errmsg,"Error: invalid file create mode: %d, for file %s",
cmode,path);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
#ifndef TFLOP
mode |= NC_SHARE;
#endif
if ((exoid = nccreate (path, mode)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: file create failed for %s, mode: %s",
path, mode_name);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
/* turn off automatic filling of netCDF variables
*/
if (ncsetfill (exoid, NC_NOFILL) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to set nofill mode in file id %d",
exoid);
ex_err("ex_create", errmsg, exerrval);
return (EX_FATAL);
}
/* initialize floating point size conversion. since creating new file,
* i/o wordsize attribute from file is zero.
*/
if (ex_conv_ini( exoid, comp_ws, io_ws, 0 ) != EX_NOERR) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: failed to init conversion routines in file id %d",
exoid);
ex_err("ex_create", errmsg, exerrval);
return (EX_FATAL);
}
/* put the EXODUS version number, and i/o floating point word size as
* netcdf global attributes
*/
/* store Exodus API version # as an attribute */
vers = (float)(EX_API_VERS);
if (ncattput (exoid, NC_GLOBAL, ATT_API_VERSION, NC_FLOAT, 1, &vers) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store Exodus II API version attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* store Exodus file version # as an attribute */
vers = (float)(EX_VERS);
if (ncattput (exoid, NC_GLOBAL, ATT_VERSION, NC_FLOAT, 1, &vers) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store Exodus II file version attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* store Exodus file float word size as an attribute */
lio_ws = (nclong)(*io_ws);
if (ncattput (exoid, NC_GLOBAL, ATT_FLT_WORDSIZE, NC_LONG, 1, &lio_ws) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store Exodus II file float word size attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* store Exodus file size (1=large, 0=normal) as an attribute */
filesiz = (nclong)(((cmode & EX_LARGE_MODEL) != 0) || (ex_large_model(-1) == 1));
if (ncattput (exoid, NC_GLOBAL, ATT_FILESIZE, NC_LONG, 1, &filesiz) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store Exodus II file size attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* define some dimensions and variables
*/
/* create string length dimension */
if (ncdimdef (exoid, DIM_STR, (MAX_STR_LENGTH+1)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define string length in file id %d",exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
/* create line length dimension */
if (ncdimdef (exoid, DIM_LIN, (MAX_LINE_LENGTH+1)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define line length in file id %d",exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
/* create number "4" dimension; must be of type long */
if (ncdimdef (exoid, DIM_N4, 4L) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number \"4\" dimension in file id %d",exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
if ((time_dim = ncdimdef (exoid, DIM_TIME, NC_UNLIMITED)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define time dimension in file id %d", exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
dims[0] = time_dim;
if ((ncvardef (exoid, VAR_WHOLE_TIME, nc_flt_code(exoid), 1, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define whole time step variable in file id %d",
exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete definition for file id %d", exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
return (exoid);
}
int main(int argc, char *argv[])
{
unsigned char verbose=0; /* Print some progress information? */
unsigned char appendnc=0; /* Append to an existing netCDF file? */
unsigned char removein=0; /* Remove the ".####" decomposed input files? */
int nstart=0; /* PE number of the first input netCDF file */
int nend; /* PE number of the last input netCDF file */
int outputarg=(-1); /* Argument # of the output netCDF file */
int inputarg=(-1); /* Argument # of first input netCDF file */
struct stat statbuf; /* Dummy structure for file-testing "stat" call */
int outncfid; /* ID of the output netCDF file */
char outfilename[2048], *strptr; /* Name of the output netCDF file */
int outlen; /* Length of the output filename */
char infilename[2048]; /* Name of an input file */
unsigned char infileerror=0; /* Were there any file errors? */
int nfiles=(-1); /* Number of files in the decomposed domain */
int a; /* Loop variable */
/* Check the command-line arguments */
if (argc < 2)
{
usage();
return(1);
}
for (a=1; a < argc; a++)
{
if (!strcmp(argv[a],"-v")) verbose=1;
else if (!strcmp(argv[a],"-a")) appendnc=1;
else if (!strcmp(argv[a],"-r")) removein=1;
else if (!strcmp(argv[a],"-n"))
{
a++;
if (a < argc) nstart=atoi(argv[a]);
else
{
usage();
return(1);
}
}
else
{
outputarg=a;
break;
}
}
if (outputarg==(-1))
{
usage();
return(1);
}
if (argc-1 > outputarg) inputarg=outputarg+1;
sprintf(outfilename,argv[outputarg]);
outlen=strlen(outfilename);
if (outlen > 4)
{
strptr=outfilename+outlen-5;
if (!strcmp(strptr,".0000")) outfilename[outlen-5]='\0';
}
/* Disable fatal returns from netCDF library functions */
ncopts=0;
/* Create a new netCDF output file */
if (!appendnc)
{
if (stat(outfilename,&statbuf)==0)
{
fprintf(stderr,"Error: output file seems to exist already!\n");
return(1);
}
if ((outncfid=nccreate(outfilename,NC_NOCLOBBER))==(-1))
{
fprintf(stderr,"Error: cannot create the output netCDF file!\n");
return(1);
}
ncsetfill(outncfid,NC_NOFILL);
}
/* Open an existing netCDF file for appending */
else
{
if ((outncfid=ncopen(outfilename,NC_WRITE))==(-1))
{
fprintf(stderr,"Error: cannot open the output netCDF file for appending!\n");
return(1);
}
}
/* No input files are specified on the command-line */
if (inputarg==(-1))
{
nend=nstart+1;
for (a=nstart; a < nend; a++)
{
sprintf(infilename,"%s.%04d",outfilename,a);
if (verbose) printf("Processing... \"%s\"",infilename);
#if DEBUG==1
else if (!verbose) printf("\nfile=%s\n",infilename);
#endif
if (stat(infilename,&statbuf)!=0)
{
if (verbose) printf("\n");
fprintf(stderr,"Error: cannot read the input file \"%s\"!\n",
infilename);
if (a==0) infileerror=3;
else infileerror=1;
break;
}
infileerror=process_ncinfile(infilename,appendnc,outncfid,
outfilename,&nfiles,verbose);
if (infileerror==2)
{
printf("IEEE input files are not currently supported!\n");
infileerror=3;
break;
}
else if (infileerror==1) break;
if (a==nstart && nfiles > 0) nend=nstart+nfiles;
appendnc=1;
if (verbose)
{
if ((nend-a-1)==1) printf("\n(1 file to go)\n");
else printf("\n(%d files to go)\n",nend-a-1);
}
}
}
/* Loop over all the specified input files */
else
for (a=inputarg; a < argc; a++)
{
if (verbose) printf("Processing... \"%s\"",argv[a]);
#if DEBUG==1
else if (!verbose) printf("\nfile=%s\n",argv[a]);
#endif
if (stat(argv[a],&statbuf)!=0)
{
if (verbose) printf("\n");
fprintf(stderr,"Error: cannot read the input file \"%s\"!\n",
argv[a]);
if (a==inputarg) infileerror=3;
else infileerror=1;
break;
}
infileerror=process_ncinfile(argv[a],appendnc,outncfid,outfilename,
&nfiles,verbose);
if (infileerror==2)
{
printf("IEEE input files are not currently supported!\n");
infileerror=3;
break;
}
else if (infileerror==1) return(1);
appendnc=1;
if (verbose)
{
if ((argc-a-1)==1) printf("\n(1 file to go)\n");
else printf("\n(%d files to go)\n",argc-a-1);
}
}
/* Clean up... return 1 on error, otherwise 0 */
ncclose(outncfid);
if (!infileerror)
{
if (removein)
{
/* No input files are specified on the command-line */
if (inputarg==(-1))
{
for (a=nstart; a < nend; a++)
{
sprintf(infilename,"%s.%04d",outfilename,a);
if (verbose)
{
if ((nend-a-1)==1)
printf("Removing... \"%s\" (1 file to go)\n",infilename);
else
printf("Removing... \"%s\" (%d files to go)\n",infilename,
nend-a-1);
}
unlink(infilename);
}
}
/* Loop over all the specified input files */
else
for (a=inputarg; a < argc; a++)
{
printf("Removing... \"%s\" (%d files to go)\n",argv[a],
argc-a-1);
unlink(argv[a]);
}
}
}
else if (infileerror==3)
{
unlink(outfilename);
infileerror=1;
}
return(infileerror);
}
int ex_open (const char *path,
int mode,
int *comp_ws,
int *io_ws,
float *version)
{
int exoid;
nclong file_wordsize;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* set error handling mode to no messages, non-fatal errors */
ex_opts(exoptval); /* call required to set ncopts first time through */
if (mode == EX_READ) /* READ ONLY */
{
#if defined(__LIBCATAMOUNT__)
if ((exoid = ncopen (path, NC_NOWRITE)) < 0)
#else
if ((exoid = ncopen (path, NC_NOWRITE|NC_SHARE)) < 0)
#endif
{
/* NOTE: netCDF returns an id of -1 on an error - but no error code! */
if (ncerr == 0)
exerrval = EX_FATAL;
else
exerrval = ncerr;
sprintf(errmsg,"Error: failed to open %s read only",path);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
}
else if (mode == EX_WRITE) /* READ/WRITE */
{
#if defined(__LIBCATAMOUNT__)
if ((exoid = ncopen (path, NC_WRITE)) < 0)
#else
if ((exoid = ncopen (path, NC_WRITE|NC_SHARE)) < 0)
#endif
{
/* NOTE: netCDF returns an id of -1 on an error - but no error code! */
if (ncerr == 0)
exerrval = EX_FATAL;
else
exerrval = ncerr;
sprintf(errmsg,"Error: failed to open %s write only",path);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
/* turn off automatic filling of netCDF variables */
if (ncsetfill (exoid, NC_NOFILL) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to set nofill mode in file id %d",
exoid);
ex_err("ex_open", errmsg, exerrval);
return (EX_FATAL);
}
}
else
{
exerrval = EX_BADFILEMODE;
sprintf(errmsg,"Error: invalid file open mode: %d",mode);
ex_err("ex_open",errmsg,exerrval);
return (EX_FATAL);
}
/* determine version of EXODUS II file, and the word size of
* floating point values stored in the file
*/
if (ncattget (exoid, NC_GLOBAL, ATT_VERSION, version) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to get database version for file id: %d",
exoid);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
/* check ExodusII file version - old version 1.x files are not supported */
if (*version < 2.0)
{
exerrval = EX_FATAL;
sprintf(errmsg,"Error: Unsupported file version %.2f in file id: %d",
*version, exoid);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
if (ncattget (exoid, NC_GLOBAL, ATT_FLT_WORDSIZE, &file_wordsize) == -1)
{ /* try old (prior to db version 2.02) attribute name */
if (ncattget (exoid,NC_GLOBAL,ATT_FLT_WORDSIZE_BLANK,&file_wordsize) == -1)
{
exerrval = EX_FATAL;
sprintf(errmsg,"Error: failed to get file wordsize from file id: %d",
exoid);
ex_err("ex_open",errmsg,exerrval);
return(exerrval);
}
}
/* initialize floating point size conversion.
*/
if (ex_conv_ini( exoid, comp_ws, io_ws, file_wordsize ) != EX_NOERR ) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: failed to init conversion routines in file id %d",
exoid);
ex_err("ex_open", errmsg, exerrval);
return (EX_FATAL);
}
return (exoid);
}
int ex_put_prop_names (int exoid,
int obj_type,
int num_props,
char **prop_names)
{
int i, propid, dimid, dims[1];
char name[MAX_VAR_NAME_LENGTH+1];
long vals[1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* determine what type of object (element block, node set, or side set) */
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, DIM_NUM_EL_BLK);
break;
case EX_NODE_SET:
strcpy (name, DIM_NUM_NS);
break;
case EX_SIDE_SET:
strcpy (name, DIM_NUM_SS);
break;
case EX_ELEM_MAP:
strcpy (name, DIM_NUM_EM);
break;
case EX_NODE_MAP:
strcpy (name, DIM_NUM_NM);
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
return(EX_FATAL);
}
/* inquire id of previously defined dimension (number of objects) */
if ((dimid = ncdimid (exoid, name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of objects in file id %d",
exoid);
ex_err("ex_put_prop_names",errmsg, exerrval);
return(EX_FATAL);
}
ncsetfill(exoid, NC_FILL); /* fill with zeros per routine spec */
/* put netcdf file into define mode */
if (ncredef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
return (EX_FATAL);
}
/* define num_props variables; we postpend the netcdf variable name with */
/* a counter starting at 2 because "xx_prop1" is reserved for the id array*/
dims[0] = dimid;
for (i=0; i<num_props; i++)
{
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(i+2));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(i+2));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(i+2));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(i+2));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(i+2));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
if ((propid = ncvardef (exoid, name, NC_LONG, 1, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create property array variable in file id %d",
exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
vals[0] = 0; /* fill value */
/* create attribute to cause variable to fill with zeros per routine spec */
if ((ncattput (exoid, propid, _FillValue, NC_LONG, 1, vals)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create property name fill attribute in file id %d",
exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
/* store property name as attribute of property array variable */
if ((ncattput (exoid, propid, ATT_PROP_NAME, NC_CHAR,
strlen(prop_names[i])+1, prop_names[i])) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store property name %s in file id %d",
prop_names[i],exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to leave define mode in file id %d",
exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
return (EX_FATAL);
}
ncsetfill(exoid, NC_NOFILL); /* default: turn off fill */
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_prop (int exoid,
int obj_type,
int obj_id,
const char *prop_name,
int value)
{
int found = FALSE;
int num_props, i, dimid, propid, dims[1];
long start[1];
nclong ldum;
char name[MAX_VAR_NAME_LENGTH+1];
char obj_stype[MAX_VAR_NAME_LENGTH+1];
char obj_vtype[MAX_VAR_NAME_LENGTH+1];
char tmpstr[MAX_VAR_NAME_LENGTH+1];
char dim_name[MAX_VAR_NAME_LENGTH+1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* check if property has already been created */
num_props = ex_get_num_props(exoid, obj_type);
switch (obj_type)
{
case EX_ELEM_BLOCK:
strcpy (obj_vtype, VAR_ID_EL_BLK);
strcpy (obj_stype, "element block");
break;
case EX_NODE_SET:
strcpy (obj_vtype, VAR_NS_IDS);
strcpy (obj_stype, "node set");
break;
case EX_SIDE_SET:
strcpy (obj_vtype, VAR_SS_IDS);
strcpy (obj_stype, "side set");
break;
case EX_ELEM_MAP:
strcpy (obj_vtype, VAR_EM_PROP(1));
strcpy (obj_stype, "element map");
break;
case EX_NODE_MAP:
strcpy (obj_vtype, VAR_NM_PROP(1));
strcpy (obj_stype, "node map");
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return(EX_FATAL);
}
if (num_props > 1) /* any properties other than the default 1? */
{
for (i=1; i<=num_props; i++)
{
switch (obj_type)
{
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(i));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(i));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(i));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(i));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(i));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return(EX_FATAL);
}
if ((propid = ncvarid (exoid, name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get property array id in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
if ((ncattget (exoid, propid, ATT_PROP_NAME, tmpstr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get property name in file id %d", exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0)
{
found = TRUE;
break;
}
}
}
/* if property array has not been created, create it */
if (!found)
{
/* put netcdf file into define mode */
if (ncredef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
/* create a variable with a name xx_prop#, where # is the new number */
/* of the property */
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_EL_BLK);
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_NS);
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_SS);
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_EM);
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_NM);
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
/* inquire id of previously defined dimension (number of objects) */
if ((dimid = ncdimid (exoid, dim_name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of objects in file id %d",
exoid);
ex_err("ex_put_prop",errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
dims[0] = dimid;
ncsetfill(exoid, NC_FILL); /* fill with zeros per routine spec */
if ((propid = ncvardef (exoid, name, NC_LONG, 1, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create property array variable in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
ncsetfill(exoid, NC_NOFILL); /* default: nofill */
/* store property name as attribute of property array variable */
if ((ncattput (exoid, propid, ATT_PROP_NAME, NC_CHAR,
strlen(prop_name)+1, prop_name)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store property name %s in file id %d",
prop_name,exoid);
ex_err("ex_put_prop",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to leave define mode in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
}
/* find index into property array using obj_id; put value in property */
/* array at proper index; ex_id_lkup returns an index that is 1-based,*/
/* but netcdf expects 0-based arrays so subtract 1 */
/* special case: property name ID - check for duplicate ID assignment */
if (strcmp("ID",prop_name) == 0)
{
start[0] = ex_id_lkup (exoid, obj_vtype, value);
if (exerrval != EX_LOOKUPFAIL) /* found the id */
{
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: attempt to assign duplicate %s ID %d in file id %d",
obj_stype, value, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_WARN);
}
}
start[0] = ex_id_lkup (exoid, obj_vtype, obj_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: no properties allowed for NULL %s id %d in file id %d",
obj_stype, obj_id,exoid);
ex_err("ex_put_prop",errmsg,EX_MSG);
return (EX_WARN);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to find value %d in %s property array in file id %d",
obj_id, obj_stype, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
}
start[0] = start[0] - 1;
ldum = (nclong)value;
if (ncvarput1 (exoid, propid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store property value in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
ncsetfill(exoid, NC_NOFILL); /* default: nofill */
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
}
return (EX_FATAL);
}
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;
}