/* * Create a new netCDF file, returning a netCDF ID. New netCDF * file is placed in define mode. */ extern int c_nccre( const char *pathname, /* file name of new netCDF file */ int clobmode, /* either NCCLOB or NCNOCLOB */ int *rcode /* returned error code */ ) { int ncid = -1; if (pathname == NULL) *rcode = NC_EINVAL; else { *rcode = ((ncid = nccreate (pathname, clobmode)) == -1) ? ncerr : 0; } if (*rcode != 0) { nc_advise("NCCRE", *rcode, ""); *rcode = ncerr; } return ncid; }
static void draw_error(char *cur, char *msg) { int width = wincols-5; nccreate(7, width, "Error!"); attron(A_BOLD); ncaddstr(2, 2, "Error:"); attroff(A_BOLD); ncprint(2, 9, "could not open %s", cropstr(cur, width-26)); ncprint(3, 4, "%s", cropstr(msg, width-8)); ncaddstr(5, width-30, "press any key to continue..."); }
static void browse_draw_info(struct dir *dr) { struct dir *t; int i; nccreate(11, 60, "Item info"); if(dr->hlnk) { if(info_page == 0) attron(A_REVERSE); ncaddstr(0, 41, "1:Info"); attroff(A_REVERSE); if(info_page == 1) attron(A_REVERSE); ncaddstr(0, 50, "2:Links"); attroff(A_REVERSE); } switch(info_page) { case 0: attron(A_BOLD); ncaddstr(2, 3, "Name:"); ncaddstr(3, 3, "Path:"); ncaddstr(4, 3, "Type:"); ncaddstr(6, 3, " Disk usage:"); ncaddstr(7, 3, "Apparent size:"); attroff(A_BOLD); ncaddstr(2, 9, cropstr(dr->name, 49)); ncaddstr(3, 9, cropstr(getpath(dr->parent), 49)); ncaddstr(4, 9, dr->flags & FF_DIR ? "Directory" : dr->flags & FF_FILE ? "File" : "Other (link, device, socket, ..)"); ncprint(6, 18, "%s (%s B)", formatsize(dr->size), fullsize(dr->size)); ncprint(7, 18, "%s (%s B)", formatsize(dr->asize), fullsize(dr->asize)); break; case 1: for(i=0,t=dr->hlnk; t!=dr; t=t->hlnk,i++) { if(info_start > i) continue; if(i-info_start > 5) break; ncaddstr(2+i-info_start, 3, cropstr(getpath(t), 54)); } if(t!=dr) ncaddstr(8, 25, "-- more --"); break; } ncaddstr(9, 32, "Press i to hide this window"); }
static void draw_progress() { static const char scantext[] = "Scanning..."; static const char loadtext[] = "Loading..."; static size_t anpos = 0; const char *antext = dir_import_active ? loadtext : scantext; char ani[16] = {}; size_t i; int width = wincols-5; nccreate(10, width, antext); ncprint(2, 2, "Total items: %-8d", dir_output.items); if(dir_output.size) ncprint(2, 23, "size: %s", formatsize(dir_output.size)); ncprint(3, 2, "Current item: %s", cropstr(dir_curpath, width-18)); if (confirm_quit_while_scanning_stage_1_passed) ncaddstr(8, width-26, "Press y to confirm abort"); else ncaddstr(8, width-18, "Press q to abort"); /* show warning if we couldn't open a dir */ if(lasterr) { attron(A_BOLD); ncaddstr(5, 2, "Warning:"); attroff(A_BOLD); ncprint(5, 11, "error scanning %-32s", cropstr(lasterr, width-28)); ncaddstr(6, 3, "some directory sizes may not be correct"); } /* animation - but only if the screen refreshes more than or once every second */ if(update_delay <= 1000) { if(++anpos == strlen(antext)*2) anpos = 0; memset(ani, ' ', strlen(antext)); if(anpos < strlen(antext)) for(i=0; i<=anpos; i++) ani[i] = antext[i]; else for(i=strlen(antext)-1; i>anpos-strlen(antext); i--) ani[i] = antext[i]; } else strcpy(ani, antext); ncaddstr(8, 3, ani); }
/* * Create a new netCDF file, returning a netCDF ID. New netCDF * file is placed in define mode. */ static int c_nccre( const char *pathname, /* file name of new netCDF file */ int clobmode, /* either NCCLOB or NCNOCLOB */ int *rcode /* returned error code */ ) { int ncid = -1; #if CDF_ROUTINE_NAME cdf_routine_name = "NCCRE"; #endif if (clobmode != NC_CLOBBER && clobmode != NC_NOCLOBBER) { *rcode = NC_EINVAL; nc_advise("NCCRE", *rcode, "bad flag, did you forget to include netcdf.inc?"); } else { if (pathname == NULL) *rcode = NC_EINVAL; else { *rcode = ((ncid = nccreate (pathname, clobmode)) == -1) ? ncerr : 0; } if (*rcode != 0) { nc_advise("NCCRE", *rcode, ""); *rcode = ncerr; } } return ncid; }
int main() { char *file = "test.mnc"; int cdfid; int dim[MAX_VAR_DIMS]; cdfid=nccreate(file, NC_CLOBBER); dim[0]=ncdimdef(cdfid, MIzspace, 3L); dim[1]=ncdimdef(cdfid, MIyspace, 5L); dim[2]=ncdimdef(cdfid, MIxspace, 6L); (void) micreate_std_variable(cdfid, MIimage, NC_SHORT, 3, dim); (void) micreate_std_variable(cdfid, MIimagemax, NC_DOUBLE, 1, dim); (void) micreate_std_variable(cdfid, MIimagemin, NC_DOUBLE, 1, dim); (void) micreate_std_variable(cdfid, MIzspace, NC_DOUBLE, 1, NULL); (void) micreate_std_variable(cdfid, MIzspace_width, NC_DOUBLE, 1, &dim[0]); (void) micreate_group_variable(cdfid, MIpatient); (void) micreate_group_variable(cdfid, MIstudy); (void) micreate_group_variable(cdfid, MIacquisition); (void) ncclose(cdfid); return 0; }
/* * Create a new netCDF file, returning a netCDF ID. New netCDF * file is placed in define mode. */ static int c_nccre( const char *pathname, /* file name of new netCDF file */ int clobmode, /* either NCCLOB or NCNOCLOB */ int *rcode /* returned error code */ ) { int ncid = -1; /* Include NC_LOCK in check, in case NC_LOCK is ever implemented */ if (clobmode < 0 || clobmode > NC_NOCLOBBER + NC_64BIT_OFFSET + NC_SHARE + NC_CLASSIC_MODEL + NC_LOCK) { *rcode = NC_EINVAL; nc_advise("NCCRE", *rcode, "bad flag, did you forget to include netcdf.inc?"); } else { if (pathname == NULL) *rcode = NC_EINVAL; else { *rcode = ((ncid = nccreate (pathname, clobmode)) == -1) ? ncerr : 0; } if (*rcode != 0) { nc_advise("NCCRE", *rcode, ""); *rcode = ncerr; } } return ncid; }
int main(int argc, char **argv) { /*nc_set_log_level(3);*/ printf("\n*** Testing netcdf-4 v2 API functions.\n"); printf("*** testing simple opens and creates..."); { int ncid, varid, varid_in, dimids[2]; /* Turn off the crashing whenever there is a problem. */ ncopts = NC_VERBOSE; /* Create an empty file. */ if ((ncid = nccreate(FILE_NAME, NC_CLOBBER)) == -1) ERR; if (ncclose(ncid) == -1) ERR; /* Open the file, go into redef, and add some dims and vars. */ if ((ncid = ncopen(FILE_NAME, NC_WRITE)) == -1) ERR; if (ncredef(ncid) == -1) ERR; if ((dimids[0] = ncdimdef(ncid, DIM1_NAME, DIM1_SIZE)) == -1) ERR; if ((dimids[1] = ncdimdef(ncid, DIM2_NAME, DIM2_SIZE)) == -1) ERR; if ((varid = ncvardef(ncid, VAR1_NAME, NC_DOUBLE, NDIMS, dimids)) == -1) ERR; if ((varid_in = ncvarid(ncid, VAR1_NAME)) == -1) ERR; if (varid_in != varid) ERR; if ((varid = ncvardef(ncid, VAR2_NAME, NC_INT, NDIMS, dimids)) == -1) ERR; if ((varid_in = ncvarid(ncid, VAR2_NAME)) == -1) ERR; if (varid_in != varid) ERR; if ((varid = ncvardef(ncid, VAR3_NAME, NC_SHORT, NDIMS, dimids)) == -1) ERR; if ((varid_in = ncvarid(ncid, VAR3_NAME)) == -1) ERR; if (varid_in != varid) ERR; if (ncclose(ncid) == -1) ERR; } SUMMARIZE_ERR; FINAL_RESULTS; }
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) { int ncid, dimids[NUM_DIMS]; int varid; int nvars_in, varids_in[NUM_DIMS]; signed char fill_value = 42, fill_value_in; nc_type xtype_in; size_t len_in; char name_in[NC_MAX_NAME + 1]; int attnum_in; int cnum; #ifdef USE_PARALLEL MPI_Init(&argc, &argv); #endif printf("\n*** Testing netcdf-4 variable functions, even more.\n"); for (cnum = 0; cnum < MAX_CNUM; cnum++) { int cmode; switch(cnum) { case 0: printf("*** Testing with classic format:\n"); cmode = 0; break; case 1: printf("*** Testing with 64-bit offset format:\n"); cmode = NC_64BIT_OFFSET; break; case 2: printf("*** Testing with HDF5:\n"); cmode = NC_NETCDF4|NC_CLOBBER; break; case 3: printf("*** Testing with HDF5, netCDF Classic Model:\n"); cmode = NC_CLASSIC_MODEL | NC_NETCDF4; } printf("**** testing simple fill value attribute creation..."); { /* Create a netcdf-4 file with one scalar var. Add fill * value. */ if (nc_create(FILE_NAME, cmode, &ncid)) ERR; if (nc_def_var(ncid, VAR_NAME, NC_BYTE, 0, NULL, &varid)) ERR; if (nc_enddef(ncid)) ERR; if (nc_redef(ncid)) ERR; if (nc_put_att_schar(ncid, varid, _FillValue, NC_BYTE, 1, &fill_value)) ERR; if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR; if (nvars_in != 1 || varids_in[0] != 0) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (strcmp(name_in, VAR_NAME)) ERR; if (nc_inq_att(ncid, varid, _FillValue, &xtype_in, &len_in)) ERR; if (xtype_in != NC_BYTE || len_in != 1) ERR; if (nc_get_att(ncid, varid, _FillValue, &fill_value_in)) ERR; if (fill_value_in != fill_value) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing simple fill value with data read..."); { size_t start[NUM_DIMS], count[NUM_DIMS]; signed char data = 99, data_in; /* Create a netcdf-4 file with one unlimited dim and one * var. Add fill value. */ if (nc_create(FILE_NAME, cmode, &ncid)) ERR; if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR; if (nc_def_var(ncid, VAR_NAME, NC_BYTE, NUM_DIMS, dimids, &varid)) ERR; if (nc_enddef(ncid)) ERR; if (nc_redef(ncid)) ERR; if (nc_put_att_schar(ncid, varid, _FillValue, NC_BYTE, 1, &fill_value)) ERR; if (nc_enddef(ncid)) ERR; /* Write the second record. */ start[0] = 1; count[0] = 1; if (nc_put_vara_schar(ncid, varid, start, count, &data)) ERR; /* Read the first record, it should be the fill value. */ start[0] = 0; if (nc_get_vara_schar(ncid, varid, start, count, &data_in)) ERR; if (data_in != fill_value) ERR; /* Read the second record, it should be the value we just wrote * there. */ start[0] = 1; if (nc_get_vara_schar(ncid, varid, start, count, &data_in)) ERR; if (data_in != data) ERR; /* Close up. */ if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; /* Check metadata. */ if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR; if (nvars_in != 1 || varids_in[0] != 0) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (strcmp(name_in, VAR_NAME)) ERR; /* Check fill value att. */ if (nc_inq_att(ncid, varid, _FillValue, &xtype_in, &len_in)) ERR; if (xtype_in != NC_BYTE || len_in != 1) ERR; if (nc_get_att(ncid, varid, _FillValue, &fill_value_in)) ERR; if (fill_value_in != fill_value) ERR; /* Read the first record, it should be the fill value. */ start[0] = 0; if (nc_get_vara_schar(ncid, varid, start, count, &data_in)) ERR; if (data_in != fill_value) ERR; /* Read the second record, it should be the value we just wrote * there. */ start[0] = 1; if (nc_get_vara_schar(ncid, varid, start, count, &data_in)) ERR; if (data_in != data) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing fill value with one other attribute..."); { int losses_value = 192, losses_value_in; /* Create a netcdf-4 file with one dim and one var. Add another * attribute, then fill value. */ if (nc_create(FILE_NAME, cmode, &ncid)) ERR; if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR; if (nc_def_var(ncid, VAR_NAME, NC_BYTE, NUM_DIMS, dimids, &varid)) ERR; if (nc_put_att_int(ncid, varid, LOSSES_NAME, NC_INT, 1, &losses_value)) ERR; if (nc_put_att_schar(ncid, varid, _FillValue, NC_BYTE, 1, &fill_value)) ERR; if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq_att(ncid, 0, LOSSES_NAME, &xtype_in, &len_in)) ERR; if (xtype_in != NC_INT || len_in != 1) ERR; if (nc_get_att(ncid, 0, LOSSES_NAME, &losses_value_in)) ERR; if (losses_value_in != losses_value) ERR; if (nc_inq_att(ncid, 0, _FillValue, &xtype_in, &len_in)) ERR; if (xtype_in != NC_BYTE || len_in != 1) ERR; if (nc_get_att(ncid, 0, _FillValue, &fill_value_in)) ERR; if (fill_value_in != fill_value) ERR; if (nc_inq_attid(ncid, 0, LOSSES_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, _FillValue, &attnum_in)) ERR; if (attnum_in != 1) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing fill value with three other attributes..."); { #define NUM_LEADERS 3 char leader[NUM_LEADERS][NC_MAX_NAME + 1] = {"hair_length_of_strategoi", "hair_length_of_Miltiades", "hair_length_of_Darius_I"}; short hair_length[NUM_LEADERS] = {3, 11, 4}; short short_in; int a; /* Create a netcdf file with one dim and one var. Add 3 * attributes, then fill value. */ if (nc_create(FILE_NAME, cmode, &ncid)) ERR; if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR; if (nc_def_var(ncid, VAR_NAME, NC_BYTE, NUM_DIMS, dimids, &varid)) ERR; for (a = 0; a < NUM_LEADERS; a++) if (nc_put_att_short(ncid, varid, leader[a], NC_SHORT, 1, &hair_length[a])) ERR; if (nc_put_att_schar(ncid, varid, _FillValue, NC_BYTE, 1, &fill_value)) ERR; if (nc_close(ncid)) ERR; /* Open the file. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; /* Check our three hair-related attributes. */ for (a = 0; a < NUM_LEADERS; a++) { if (nc_inq_att(ncid, 0, leader[a], &xtype_in, &len_in)) ERR; if (xtype_in != NC_SHORT || len_in != 1) ERR; if (nc_get_att(ncid, 0, leader[a], &short_in)) ERR; if (short_in != hair_length[a]) ERR; if (nc_inq_attid(ncid, 0, leader[a], &attnum_in)) ERR; if (attnum_in != a) ERR; } /* Check our fill value attribute. */ if (nc_inq_att(ncid, 0, _FillValue, &xtype_in, &len_in)) ERR; if (xtype_in != NC_BYTE || len_in != 1) ERR; if (nc_get_att(ncid, 0, _FillValue, &fill_value_in)) ERR; if (fill_value_in != fill_value) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing fill value with simple example..."); { /* Dims stuff. */ #define NDIMS 3 #define VAR_DIMS 3 #define DIM_A "dim1" #define DIM_A_LEN 4 #define DIM_B "dim2" #define DIM_B_LEN 3 #define DIM_C "dim3" #define DIM_C_LEN NC_UNLIMITED /* Var stuff. */ #define CXX_VAR_NAME "P" /* Att stuff. */ #define NUM_ATTS 4 #define LONG_NAME "long_name" #define PRES_MAX_WIND "pressure at maximum wind" #define UNITS "units" #define HECTOPASCALS "hectopascals" int dimid[NDIMS], var_dimids[VAR_DIMS] = {2, 1, 0}; float fill_value = -9999.0f; char long_name[] = PRES_MAX_WIND; if (nc_create(FILE_NAME, cmode, &ncid)) ERR; /* Create dims. */ if (nc_def_dim(ncid, DIM_A, DIM_A_LEN, &dimid[0])) ERR; if (nc_def_dim (ncid, DIM_B, DIM_B_LEN, &dimid[1])) ERR; if (nc_def_dim(ncid, DIM_C, DIM_C_LEN, &dimid[2])) ERR; /* Create var. */ if (nc_def_var(ncid, CXX_VAR_NAME, NC_FLOAT, VAR_DIMS, var_dimids, &varid)) ERR; if (varid) ERR; if (nc_put_att(ncid, varid, LONG_NAME, NC_CHAR, strlen(long_name) + 1, long_name)) ERR; if (nc_put_att(ncid, varid, UNITS, NC_CHAR, strlen(UNITS) + 1, UNITS)) ERR; /* Check to ensure the atts have their expected attnums. */ if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; /* Now add a fill value. This will acutually cause HDF5 to * destroy the dataset and recreate it, recreating also the * three attributes that are attached to it. */ if (nc_put_att(ncid, varid, _FillValue, NC_FLOAT, 1, &fill_value)) ERR; /* Check to ensure the atts have their expected attnums. */ if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; if (nc_inq_attid(ncid, 0, _FillValue, &attnum_in)) ERR; if (attnum_in != 2) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; #ifndef NO_NETCDF_2 /* The following test is an attempt to recreate a problem occuring in the cxx tests. The file is created in c++ in nctsts.cpp. */ printf("**** testing fill value with example from cxx tests in v2 api..."); { /* Dims stuff. */ #define NDIMS_1 4 #define VAR_DIMS 3 #define LAT "lat" #define LAT_LEN 4 #define LON "lon" #define LON_LEN 3 #define FRTIMED "frtimed" #define FRTIMED_LEN NC_UNLIMITED #define TIMELEN "timelen" #define TIMELEN_LEN 20 /* Var stuff. */ #define CXX_VAR_NAME "P" /* Att stuff. */ #define NUM_ATTS 4 #define LONG_NAME "long_name" #define UNITS "units" int dimid[NDIMS_1], var_dimids[VAR_DIMS] = {2, 0, 1}; float fill_value = -9999.0f; char long_name[] = PRES_MAX_WIND; int i, attid[NUM_ATTS]; ncid = nccreate(FILE_NAME, NC_NETCDF4); /* Create dims. */ dimid[0] = ncdimdef(ncid, LAT, LAT_LEN); dimid[1] = ncdimdef(ncid, LON, LON_LEN); dimid[2] = ncdimdef(ncid, FRTIMED, FRTIMED_LEN); dimid[3] = ncdimdef(ncid, TIMELEN, TIMELEN_LEN); /* Just check our dimids to see that they are correct. */ for (i = 0; i < NDIMS_1; i++) if (dimid[i] != i) ERR; /* Create var. */ varid = ncvardef(ncid, CXX_VAR_NAME, NC_FLOAT, VAR_DIMS, var_dimids); if (varid) ERR; /* Add three atts to the var, long_name, units, and * valid_range. */ if (nc_put_att(ncid, varid, LONG_NAME, NC_CHAR, strlen(long_name) + 1, long_name)) ERR; if (nc_put_att(ncid, varid, UNITS, NC_CHAR, strlen(UNITS) + 1, UNITS)) ERR; /* Check to ensure the atts have their expected attnums. */ if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; /* Now add a fill value. This will acutually cause HDF5 to * destroy the dataset and recreate it, recreating also the * three attributes that are attached to it. */ attid[3] = ncattput(ncid, varid, _FillValue, NC_FLOAT, 1, &fill_value); /* Check to ensure the atts have their expected attnums. */ if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; ncclose(ncid); /* Open the file and check. */ ncid = ncopen(FILE_NAME, 0); if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; if (nc_inq_attid(ncid, 0, _FillValue, &attnum_in)) ERR; if (attnum_in != 2) ERR; ncclose(ncid); } SUMMARIZE_ERR; #endif /* NO_NETCDF_2 */ } printf("**** testing create order varids..."); #define UNITS "units" #define DIMNAME "x" #define VARNAME "data" { /* This test contributed by Jeff Whitaker of NOAA - Thanks Jeff! */ int ncid, dimid, varid, xvarid; char units[] = "zlotys"; if (nc_create(FILE_NAME, NC_NETCDF4|NC_CLASSIC_MODEL, &ncid)) ERR; if (nc_def_dim(ncid, DIMNAME, 1, &dimid)) ERR; if (nc_enddef(ncid)) ERR; if (nc_redef(ncid)) ERR; if (nc_def_var(ncid, DIMNAME, NC_INT, 1, &dimid, &xvarid)) ERR; if (nc_put_att_text(ncid, xvarid, UNITS, strlen(units), units)) ERR; if (nc_def_var(ncid, VARNAME, NC_INT, 1, &dimid, &varid)) ERR; if (nc_close(ncid)) ERR; if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; #define RANK_wind 1 printf("**** testing simple variable renaming..."); { /* This test contributed by Jeff Whitaker of NOAA - Thanks Jeff! */ int ncid, lat_dim, time_dim, lon_dim, wind_id; size_t lat_len = 73, time_len = 10, lon_len = 145; int cdf_goober[1]; /* if (nc_set_default_format(NC_FORMAT_NETCDF4, NULL)) ERR;*/ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; /* define dimensions */ if (nc_def_dim(ncid, "a", lon_len, &lon_dim)) ERR; if (nc_def_dim(ncid, "b", lat_len, &lat_dim)) ERR; if (nc_def_dim(ncid, "c", time_len, &time_dim)) ERR; if (nc_put_att_text(ncid, NC_GLOBAL, "a", 3, "bar")) ERR; cdf_goober[0] = 2; if (nc_put_att_int(ncid, NC_GLOBAL, "b", NC_INT, 1, cdf_goober)) ERR; /* define variables */ if (nc_def_var(ncid, "aa", NC_FLOAT, RANK_wind, &lon_dim, &wind_id)) ERR; if (nc_close(ncid)) ERR; if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_rename_var(ncid, 0, "az")) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing dimension and variable renaming..."); { /* This test contributed by Jeff Whitaker of NOAA - Thanks Jeff! */ int ncid, lat_dim, time_dim, lon_dim, wind_id; size_t lat_len = 73, time_len = 10, lon_len = 145; int wind_dims[RANK_wind], wind_slobber[1], cdf_goober[1]; if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; /* define dimensions */ if (nc_def_dim(ncid, "lon", lon_len, &lon_dim)) ERR; if (nc_def_dim(ncid, "lat", lat_len, &lat_dim)) ERR; if (nc_def_dim(ncid, "time", time_len, &time_dim)) ERR; if (nc_put_att_text(ncid, NC_GLOBAL, "foo", 3, "bar")) ERR; cdf_goober[0] = 2; if (nc_put_att_int(ncid, NC_GLOBAL, "goober", NC_INT, 1, cdf_goober)) ERR; /* define variables */ wind_dims[0] = lon_dim; if (nc_def_var(ncid, "temp", NC_FLOAT, RANK_wind, wind_dims, &wind_id)) ERR; if (nc_put_att_text(ncid, wind_id, "bar", 3, "foo")) ERR; wind_slobber[0] = 3; if (nc_put_att_int(ncid, wind_id, "slobber", NC_INT, 1, wind_slobber)) ERR; if (nc_close(ncid)) ERR; /* re-open dataset*/ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq_dimid(ncid, "lon", &lon_dim)) ERR; /* rename dimension */ if (nc_rename_dim(ncid, lon_dim, "longitude")) ERR; if (nc_inq_varid(ncid, "temp", &wind_id)) ERR; /* rename variable */ if (nc_rename_var(ncid, wind_id, "wind")) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; /* printf("*** testing 2D array of NC_CHAR..."); */ /* { */ /* int dimid[NDIMS_1], var_dimids[VAR_DIMS] = {2, 0, 1}; */ /* float fill_value = -9999.0f; */ /* char long_name[] = PRES_MAX_WIND; */ /* int i, attid[NUM_ATTS]; */ /* ncid = nccreate(FILE_NAME, NC_NETCDF4); */ /* /\* Create dims. *\/ */ /* dimid[0] = ncdimdef(ncid, LAT, LAT_LEN); */ /* dimid[1] = ncdimdef(ncid, LON, LON_LEN); */ /* /\* Create var. *\/ */ /* varid = ncvardef(ncid, CXX_VAR_NAME, NC_FLOAT, VAR_DIMS, var_dimids); */ /* if (varid) ERR; */ /* ncclose(ncid); */ /* /\* Open the file and check. *\/ */ /* ncid = ncopen(FILE_NAME, 0); */ /* ncclose(ncid); */ /* } */ /* SUMMARIZE_ERR; */ #define NDIMS 3 #define NNAMES 4 #define NLINES 13 /* printf("**** testing funny names for netCDF-4..."); */ /* { */ /* int ncid, wind_id; */ /* size_t len[NDIMS] = {7, 3, 1}; */ /* int dimids[NDIMS], dimids_in[NDIMS], ndims_in; */ /* char funny_name[NNAMES][NC_MAX_NAME] = {"\a\t", "\f\n", "\r\v", "\b"}; */ /* char name_in[NC_MAX_NAME + 1]; */ /* char *speech[NLINES] = {"who would fardels bear, ", */ /* "To grunt and sweat under a weary life, ", */ /* "But that the dread of something after death, ", */ /* "The undiscover'd country from whose bourn ", */ /* "No traveller returns, puzzles the will ", */ /* "And makes us rather bear those ills we have ", */ /* "Than fly to others that we know not of? ", */ /* "Thus conscience does make cowards of us all; ", */ /* "And thus the native hue of resolution ", */ /* "Is sicklied o'er with the pale cast of thought, ", */ /* "And enterprises of great pith and moment ", */ /* "With this regard their currents turn awry, ", */ /* "And lose the name of action."}; */ /* char *speech_in[NLINES]; */ /* int i; */ /* unsigned short nlines = NLINES; */ /* unsigned int nlines_in; */ /* if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; */ /* /\* Define dimensions. *\/ */ /* for (i = 0; i < NDIMS; i++) */ /* if (nc_def_dim(ncid, funny_name[i], len[i], &dimids[i])) ERR; */ /* /\* Write some global atts. *\/ */ /* if (nc_put_att_string(ncid, NC_GLOBAL, funny_name[0], NLINES, */ /* (const char **)speech)) ERR; */ /* if (nc_put_att_ushort(ncid, NC_GLOBAL, funny_name[1], NC_UINT, 1, &nlines)) ERR; */ /* /\* Define variables. *\/ */ /* if (nc_def_var(ncid, funny_name[3], NC_INT64, NDIMS, dimids, &wind_id)) ERR; */ /* if (nc_close(ncid)) ERR; */ /* /\* Open the file and check. *\/ */ /* if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; */ /* if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; */ /* if (ndims_in != NDIMS) ERR; */ /* for (i = 0; i < NDIMS; i++) */ /* { */ /* if (dimids_in[i] != i) ERR; */ /* if (nc_inq_dimname(ncid, i, name_in)) ERR; */ /* if (strcmp(name_in, funny_name[i])) ERR; */ /* } */ /* if (nc_get_att_string(ncid, NC_GLOBAL, funny_name[0], (char **)speech_in)) ERR; */ /* for (i = 0; i < NLINES; i++) */ /* if (strcmp(speech_in[i], speech[i])) ERR; */ /* if (nc_get_att_uint(ncid, NC_GLOBAL, funny_name[1], &nlines_in)) ERR; */ /* if (nlines_in != NLINES) ERR; */ /* if (nc_free_string(NLINES, (char **)speech_in)) ERR; */ /* if (nc_inq_varname(ncid, 0, name_in)) ERR; */ /* if (strcmp(name_in, funny_name[3])) ERR; */ /* if (nc_close(ncid)) ERR; */ /* } */ /* SUMMARIZE_ERR; */ printf("**** testing endianness..."); #define NDIMS4 1 #define DIM4_NAME "Joe" #define VAR_NAME4 "Ed" #define DIM4_LEN 10 { int dimids[NDIMS4], dimids_in[NDIMS4]; int varid; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; int data[DIM4_LEN], data_in[DIM4_LEN]; int endian_in; int i; for (i = 0; i < DIM4_LEN; i++) data[i] = i; /* Create a netcdf-4 file with one dim and one var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM4_NAME, DIM4_LEN, &dimids[0])) ERR; if (dimids[0] != 0) ERR; if (nc_def_var(ncid, VAR_NAME4, NC_INT, NDIMS4, dimids, &varid)) ERR; if (nc_def_var_endian(ncid, varid, NC_ENDIAN_BIG)) ERR; if (varid != 0) ERR; if (nc_put_var_int(ncid, varid, data)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS4 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) ERR; if (varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_endian(ncid, 0, &endian_in)) ERR; if (endian_in != NC_ENDIAN_BIG) ERR; if (nc_close(ncid)) ERR; /* Open the file and check the same stuff. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS4 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) ERR; if (varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_endian(ncid, 0, &endian_in)) ERR; if (endian_in != NC_ENDIAN_BIG) ERR; if (nc_get_var_int(ncid, varid, data_in)) ERR; for (i = 0; i < DIM4_LEN; i++) if (data[i] != data_in[i]) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing chunking..."); { #define NDIMS5 1 #define DIM5_NAME "D5" #define VAR_NAME5 "V5" #define DIM5_LEN 1000 int dimids[NDIMS5], dimids_in[NDIMS5]; int varid; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; int data[DIM5_LEN], data_in[DIM5_LEN]; int chunksize[NDIMS5] = {5}; int chunksize_in[NDIMS5]; int contiguous_in; int i, d; for (i = 0; i < DIM5_LEN; i++) data[i] = i; /* Create a netcdf-4 file with one dim and one var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM5_NAME, DIM5_LEN, &dimids[0])) ERR; if (dimids[0] != 0) ERR; if (nc_def_var(ncid, VAR_NAME5, NC_INT, NDIMS5, dimids, &varid)) ERR; if (nc_def_var_chunking(ncid, varid, 0, chunksize)) ERR; if (nc_put_var_int(ncid, varid, data)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS5 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) ERR; if (varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR_NAME5) || xtype_in != NC_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS5; d++) if (chunksize[d] != chunksize_in[d]) ERR; if (contiguous_in != 0) ERR; if (nc_get_var_int(ncid, varid, data_in)) ERR; for (i = 0; i < DIM5_LEN; i++) if (data[i] != data_in[i]) ERR_RET; if (nc_close(ncid)) ERR; /* Open the file and check the same stuff. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS5 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) ERR; if (varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR_NAME5) || xtype_in != NC_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS5; d++) if (chunksize[d] != chunksize_in[d]) ERR; if (contiguous_in != 0) ERR; if (nc_get_var_int(ncid, varid, data_in)) ERR; for (i = 0; i < DIM5_LEN; i++) if (data[i] != data_in[i]) ERR_RET; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing contiguous storage..."); { #define NDIMS6 1 #define DIM6_NAME "D5" #define VAR_NAME6 "V5" #define DIM6_LEN 100 int dimids[NDIMS6], dimids_in[NDIMS6]; int varid; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; int data[DIM6_LEN], data_in[DIM6_LEN]; int chunksize_in[NDIMS6]; int contiguous_in; int i, d; for (i = 0; i < DIM6_LEN; i++) data[i] = i; /* Create a netcdf-4 file with one dim and one var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM6_NAME, DIM6_LEN, &dimids[0])) ERR; if (dimids[0] != 0) ERR; if (nc_def_var(ncid, VAR_NAME6, NC_INT, NDIMS6, dimids, &varid)) ERR; if (nc_def_var_chunking(ncid, varid, 1, NULL)) ERR; if (nc_put_var_int(ncid, varid, data)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS6 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) ERR; if (varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR_NAME6) || xtype_in != NC_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS6; d++) if (chunksize_in[d] != 0) ERR; if (!contiguous_in) ERR; if (nc_get_var_int(ncid, varid, data_in)) ERR; for (i = 0; i < DIM6_LEN; i++) if (data_in[i] != data[i]) ERR_RET; if (nc_close(ncid)) ERR; /* Open the file and check the same stuff. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS6 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) ERR; if (varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR_NAME6) || xtype_in != NC_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS6; d++) if (chunksize_in[d] != 0) ERR; if (!contiguous_in) ERR; if (nc_get_var_int(ncid, varid, data_in)) ERR; for (i = 0; i < DIM6_LEN; i++) if (data[i] != data_in[i]) ERR_RET; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing extreme numbers dude..."); { #define VAR_NAME7 "V5" #define DIM6_LEN 100 int varid; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; /* unsigned long long data = 9223372036854775807ull, data_in;*/ unsigned long long data = 9223372036854775817ull, data_in; /* Create a netcdf-4 file with scalar var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_var(ncid, VAR_NAME7, NC_UINT64, 0, NULL, &varid)) ERR; if (nc_put_var_ulonglong(ncid, varid, &data)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != 0 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1 || varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, NULL, &natts)) ERR; if (strcmp(name_in, VAR_NAME7) || xtype_in != NC_UINT64 || ndims != 0 || natts != 0) ERR; if (nc_get_var_ulonglong(ncid, varid, &data_in)) ERR; if (data_in != data) ERR; if (nc_close(ncid)) ERR; /* Open the file and check the same stuff. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != 0 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1 || varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, NULL, &natts)) ERR; if (strcmp(name_in, VAR_NAME7) || xtype_in != NC_UINT64 || ndims != 0 || natts != 0) ERR; if (nc_get_var_ulonglong(ncid, varid, &data_in)) ERR; if (data_in != data) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing error codes for name clashes..."); { #define GENERIC_NAME "bob" int ncid, varid, numgrps, ntypes; /* Create a netcdf-4 file with one var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_var(ncid, GENERIC_NAME, NC_BYTE, 0, NULL, &varid)) ERR; /* These don'e work, becuase the name is already in use. Make * sure the correct error is returned. */ if (nc_def_grp(ncid, GENERIC_NAME, NULL) != NC_ENAMEINUSE) ERR; if (nc_def_opaque(ncid, 1, GENERIC_NAME, NULL) != NC_ENAMEINUSE) ERR; /* Close it. */ if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR; if (nvars_in != 1 || varids_in[0] != 0) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (strcmp(name_in, GENERIC_NAME)) ERR; if (nc_inq_grps(ncid, &numgrps, NULL)) ERR; if (numgrps) ERR; if (nc_inq_typeids(ncid, &ntypes, NULL)) ERR; if (ntypes) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing error codes for name clashes some more..."); { #define GENERIC_NAME "bob" int ncid, varid, numgrps, ntypes; /* Create a netcdf-4 file with one type. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_opaque(ncid, 1, GENERIC_NAME, NULL)) ERR; /* These don'e work, becuase the name is already in use. Make * sure the correct error is returned. */ if (nc_def_grp(ncid, GENERIC_NAME, NULL) != NC_ENAMEINUSE) ERR; if (nc_def_var(ncid, GENERIC_NAME, NC_BYTE, 0, NULL, &varid) != NC_ENAMEINUSE) ERR; /* Close it. */ if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR; if (nvars_in) ERR; if (nc_inq_grps(ncid, &numgrps, NULL)) ERR; if (numgrps) ERR; if (nc_inq_typeids(ncid, &ntypes, NULL)) ERR; if (ntypes != 1) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing error codes for name clashes even more..."); { #define GENERIC_NAME "bob" int ncid, varid, numgrps, ntypes; /* Create a netcdf-4 file with one group. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_grp(ncid, GENERIC_NAME, NULL)) ERR; /* These don'e work, becuase the name is already in use. Make * sure the correct error is returned. */ if (nc_def_opaque(ncid, 1, GENERIC_NAME, NULL) != NC_ENAMEINUSE) ERR; if (nc_def_var(ncid, GENERIC_NAME, NC_BYTE, 0, NULL, &varid) != NC_ENAMEINUSE) ERR; /* Close it. */ if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR; if (nvars_in) ERR; if (nc_inq_grps(ncid, &numgrps, NULL)) ERR; if (numgrps != 1) ERR; if (nc_inq_typeids(ncid, &ntypes, NULL)) ERR; if (ntypes) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing error code for too-large chunks..."); { #define NDIMS17 2 #define DIM17_NAME "personality" #define DIM17_NAME_2 "good_looks" #define VAR_NAME17 "ed" #define DIM17_LEN 2147483644 /* max dimension size - 2GB - 4. */ #define DIM17_2_LEN 1000 int dimids[NDIMS17], dimids_in[NDIMS17]; int varid; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; int chunksize[NDIMS17] = {5, 5}; int bad_chunksize[NDIMS17] = {5, DIM17_LEN}; int chunksize_in[NDIMS17]; int contiguous_in; int d; /* Create a netcdf-4 file with two dims and one var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM17_NAME, DIM17_LEN, &dimids[0])) ERR; if (nc_def_dim(ncid, DIM17_NAME_2, DIM17_2_LEN, &dimids[1])) ERR; if (dimids[0] != 0 || dimids[1] != 1) ERR; if (nc_def_var(ncid, VAR_NAME17, NC_UINT64, NDIMS17, dimids, &varid)) ERR; if (nc_def_var_chunking(ncid, varid, 0, bad_chunksize) != NC_EBADCHUNK) ERR; if (nc_def_var_chunking(ncid, varid, 0, chunksize)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS17 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) ERR; if (varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR_NAME17) || xtype_in != NC_UINT64 || ndims != 2 || natts != 0 || dimids_in[0] != 0 || dimids_in[1] != 1) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS17; d++) if (chunksize[d] != chunksize_in[d]) ERR; if (contiguous_in != 0) ERR; if (nc_close(ncid)) ERR; /* Open the file and check the same stuff. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS17 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) ERR; if (varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR_NAME17) || xtype_in != NC_UINT64 || ndims != 2 || natts != 0 || dimids_in[0] != 0 || dimids_in[1] != 1) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS17; d++) if (chunksize[d] != chunksize_in[d]) ERR; if (contiguous_in != 0) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; FINAL_RESULTS; #ifdef USE_PARALLEL MPI_Finalize(); #endif }
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; }
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 main() { /* create example.cdf */ int ncid; /* netCDF id */ /* dimension ids */ int lat_dim, lon_dim, frtime_dim, timelen_dim; /* variable ids */ int P_id, lat_id, lon_id, frtime_id, reftime_id, scalarv_id; /* variable shapes */ int dims[3]; /* containers for scalar attributes */ float float_val; double double_val; /* attribute vectors */ float P_valid_range[2]; /* enter define mode */ ncid = nccreate("example.nc", NC_CLOBBER); /* define dimensions */ lat_dim = ncdimdef(ncid, "lat", 4L); lon_dim = ncdimdef(ncid, "lon", 3L); frtime_dim = ncdimdef(ncid, "frtime", NC_UNLIMITED); timelen_dim = ncdimdef(ncid, "timelen", 20L); /* define variables and assign attributes */ dims[0] = frtime_dim; dims[1] = lat_dim; dims[2] = lon_dim; P_id = ncvardef (ncid, "P", NC_FLOAT, 3, dims); ncattput (ncid, P_id, "long_name", NC_CHAR, 24, (void *)"pressure at maximum wind"); ncattput (ncid, P_id, "units", NC_CHAR, 12, (void *)"hectopascals"); P_valid_range[0] = 0; P_valid_range[1] = 1500; ncattput (ncid, P_id, "valid_range", NC_FLOAT, 2, (void *) P_valid_range); float_val = -9999; ncattput (ncid, P_id, "_FillValue", NC_FLOAT, 1, (void *) &float_val); dims[0] = lat_dim; lat_id = ncvardef (ncid, "lat", NC_FLOAT, 1, dims); ncattput (ncid, lat_id, "long_name", NC_CHAR, 8, (void *)"latitude"); ncattput (ncid, lat_id, "units", NC_CHAR, 13, (void *)"degrees_north"); dims[0] = lon_dim; lon_id = ncvardef (ncid, "lon", NC_FLOAT, 1, dims); ncattput (ncid, lon_id, "long_name", NC_CHAR, 9, (void *)"longitude"); ncattput (ncid, lon_id, "units", NC_CHAR, 12, (void *)"degrees_east"); dims[0] = frtime_dim; frtime_id = ncvardef (ncid, "frtime", NC_LONG, 1, dims); ncattput (ncid, frtime_id, "long_name", NC_CHAR, 13, (void *)"forecast time"); ncattput (ncid, frtime_id, "units", NC_CHAR, 5, (void *)"hours"); dims[0] = timelen_dim; reftime_id = ncvardef (ncid, "reftime", NC_CHAR, 1, dims); ncattput (ncid, reftime_id, "long_name", NC_CHAR, 14, (void *)"reference time"); ncattput (ncid, reftime_id, "units", NC_CHAR, 9, (void *)"text_time"); scalarv_id = ncvardef (ncid, "scalarv", NC_LONG, 0, 0); double_val = 1; ncattput (ncid, scalarv_id, "scalar_att", NC_DOUBLE, 1, (void *) &double_val); /* Global attributes */ ncattput (ncid, NC_GLOBAL, "history", NC_CHAR, 41, (void *)"created by Unidata LDM from NPS broadcast"); ncattput (ncid, NC_GLOBAL, "title", NC_CHAR, 48, (void *)"NMC Global Product Set: Pressure at Maximum Wind"); /* leave define mode */ ncendef (ncid); { /* store lat */ static long lat_start[] = {0}; static long lat_edges[] = {4}; static float lat[] = {-90, -87.5, -85, -82.5}; ncvarput(ncid, lat_id, lat_start, lat_edges, (void *)lat); } { /* store lon */ static long lon_start[] = {0}; static long lon_edges[] = {3}; static float lon[] = {-180, -175, -170}; ncvarput(ncid, lon_id, lon_start, lon_edges, (void *)lon); } { /* store frtime */ static long frtime_start[] = {0}; static long frtime_edges[] = {1}; static long frtime[] = {12}; ncvarput(ncid, frtime_id, frtime_start, frtime_edges, (void *)frtime); } { /* store frtime */ static long frtime_start[] = {1}; static long frtime_edges[] = {1}; static long frtime[] = {18}; ncvarput(ncid, frtime_id, frtime_start, frtime_edges, (void *)frtime); } { /* store reftime */ static long reftime_start[] = {0}; static long reftime_edges[] = {20}; static char reftime[] = {"1992 03 04 12:00"}; ncvarput(ncid, reftime_id, reftime_start, reftime_edges, (void *)reftime); } { /* store P */ static long P_start[] = {0, 0, 0}; static long P_edges[] = {2, 4, 3}; static float P[2][4][3] = { {{950, 951, 952}, {953, 954, 955}, {956, 957, 958}, {959, 960, 961}}, {{962, 963, 964}, {965, 966, 967}, {968, 969, 970}, {971, 972, 973}} }; ncvarput(ncid, P_id, P_start, P_edges, (void *)&P[0][0][0]); } { /* store scalarv */ static long scalarv = {-2147483647}; ncvarput1(ncid, scalarv_id, (long *)0, (void *)&scalarv); } ncclose (ncid); return 0; }
/* ----------------------------- MNI Header ----------------------------------- @NAME : CreateBloodCDF @INPUT : @OUTPUT : @RETURNS : @DESCRIPTION: @METHOD : @GLOBALS : @CALLS : @CREATED : @MODIFIED : ---------------------------------------------------------------------------- */ int CreateBloodCDF (char name[], header *cnt_header) { int file_CDF; int dim_id[1]; int parent_id; int sample_start_id; int sample_stop_id; int sample_length_id; int count_start_id; int count_length_id; int counts_id; int empty_weight_id; int full_weight_id; int corrected_activity_id; int activity_id; file_CDF = nccreate (name, NC_CLOBBER); if (file_CDF == MI_ERROR) { return (file_CDF); } /* Create the dimension */ dim_id[0] = ncdimdef (file_CDF, "sample", (long)cnt_header->num_samples); /* Create the variables */ sample_start_id = ncvardef (file_CDF, MIsamplestart, NC_DOUBLE, 1, dim_id); sample_stop_id = ncvardef (file_CDF, MIsamplestop, NC_DOUBLE, 1, dim_id); sample_length_id = ncvardef (file_CDF, MIsamplelength, NC_DOUBLE, 1, dim_id); count_start_id = ncvardef (file_CDF, MIcountstart, NC_DOUBLE, 1, dim_id); count_length_id = ncvardef (file_CDF, MIcountlength, NC_DOUBLE, 1, dim_id); counts_id = ncvardef (file_CDF, MIcounts, NC_DOUBLE, 1, dim_id); empty_weight_id = ncvardef (file_CDF, MIemptyweight, NC_DOUBLE, 1, dim_id); full_weight_id = ncvardef (file_CDF, MIfullweight, NC_DOUBLE, 1, dim_id); corrected_activity_id = ncvardef (file_CDF, MIcorrectedactivity, NC_DOUBLE, 1, dim_id); activity_id = ncvardef (file_CDF, MIactivity, NC_DOUBLE, 1, dim_id); /* Create variable attributes */ miattputstr (file_CDF, sample_start_id, "units", "seconds"); miattputstr (file_CDF, sample_stop_id, "units", "seconds"); miattputstr (file_CDF, sample_length_id, "units", "seconds"); miattputstr (file_CDF, count_start_id, "units", "seconds"); miattputstr (file_CDF, count_length_id, "units", "seconds"); miattputstr (file_CDF, counts_id, "units", "counts"); miattputstr (file_CDF, empty_weight_id, "units", "grams"); miattputstr (file_CDF, full_weight_id, "units", "grams"); miattputstr (file_CDF, corrected_activity_id, "units", "Bq/gram"); miattputstr (file_CDF, activity_id, "units", "Bq"); /* Make a root for the blood analysis info */ parent_id = ncvardef (file_CDF, MIbloodroot, NC_LONG, 0, NULL); (void) miattputstr (file_CDF, parent_id, MIbloodname, cnt_header->patient_name); (void) ncattput (file_CDF, parent_id, MIbloodrunnumber, NC_LONG, 1, &(cnt_header->run_number)); (void) miattputstr (file_CDF, parent_id, MIbloodstarttime, cnt_header->start_time); (void) miattputstr (file_CDF, parent_id, MIblooddate, cnt_header->date); (void) miattputstr (file_CDF, parent_id, MIbloodisotope, cnt_header->isotope); (void) miattputstr (file_CDF, parent_id, MIbloodstudytype, cnt_header->study_type); (void) miattputint (file_CDF, parent_id, MIbloodbackground, cnt_header->background); (void) miattputstr (file_CDF, parent_id, MIbloodcomplete, "false"); /* Set up the hierarchy */ (void) miadd_child (file_CDF, parent_id, sample_start_id); (void) miadd_child (file_CDF, parent_id, sample_stop_id); (void) miadd_child (file_CDF, parent_id, sample_length_id); (void) miadd_child (file_CDF, parent_id, count_start_id); (void) miadd_child (file_CDF, parent_id, count_length_id); (void) miadd_child (file_CDF, parent_id, counts_id); (void) miadd_child (file_CDF, parent_id, empty_weight_id); (void) miadd_child (file_CDF, parent_id, full_weight_id); (void) miadd_child (file_CDF, parent_id, corrected_activity_id); (void) miadd_child (file_CDF, parent_id, activity_id); /* End definition mode */ ncendef (file_CDF); return (file_CDF); }
void quit_draw() { browse_draw(); nccreate(4,30, "ncdu confirm quit"); ncaddstr(2,2, "Really quit? (y/N)"); }
void help_draw() { int i, line; browse_draw(); nccreate(15, 60, "ncdu help"); ncaddstr(13, 38, "Press q to continue"); if(page == 1) attron(A_REVERSE); ncaddstr(0, 30, "1:Keys"); attroff(A_REVERSE); if(page == 2) attron(A_REVERSE); ncaddstr(0, 39, "2:Format"); attroff(A_REVERSE); if(page == 3) attron(A_REVERSE); ncaddstr(0, 50, "3:About"); attroff(A_REVERSE); switch(page) { case 1: line = 1; for(i=start*2; i<start*2+20; i+=2) { attron(A_BOLD); ncaddstr(++line, 13-strlen(keys[i]), keys[i]); attroff(A_BOLD); ncaddstr(line, 15, keys[i+1]); } if(start != KEYS-10) ncaddstr(12, 25, "-- more --"); break; case 2: attron(A_BOLD); ncaddstr(2, 3, "X [size] [graph] [file or directory]"); attroff(A_BOLD); ncaddstr(3, 4, "The X is only present in the following cases:"); attron(A_BOLD); ncaddch( 5, 4, '!'); ncaddch( 6, 4, '.'); ncaddch( 7, 4, '<'); ncaddch( 8, 4, '>'); ncaddch( 9, 4, '@'); ncaddch(10, 4, 'H'); ncaddch(11, 4, 'e'); attroff(A_BOLD); ncaddstr( 5, 7, "An error occured while reading this directory"); ncaddstr( 6, 7, "An error occured while reading a subdirectory"); ncaddstr( 7, 7, "File or directory is excluded from the statistics"); ncaddstr( 8, 7, "Directory was on an other filesystem"); ncaddstr( 9, 7, "This is not a file nor a dir (symlink, socket, ...)"); ncaddstr(10, 7, "Same file was already counted (hard link)"); ncaddstr(11, 7, "Empty directory"); break; case 3: /* Indeed, too much spare time */ attron(A_REVERSE); #define x 12 #define y 3 /* N */ ncaddstr(y+0, x+0, " "); ncaddstr(y+1, x+0, " "); ncaddstr(y+2, x+0, " "); ncaddstr(y+3, x+0, " "); ncaddstr(y+4, x+0, " "); ncaddstr(y+1, x+4, " "); ncaddstr(y+2, x+4, " "); ncaddstr(y+3, x+4, " "); ncaddstr(y+4, x+4, " "); /* C */ ncaddstr(y+0, x+8, " "); ncaddstr(y+1, x+8, " "); ncaddstr(y+2, x+8, " "); ncaddstr(y+3, x+8, " "); ncaddstr(y+4, x+8, " "); /* D */ ncaddstr(y+0, x+19, " "); ncaddstr(y+1, x+19, " "); ncaddstr(y+2, x+15, " "); ncaddstr(y+3, x+15, " "); ncaddstr(y+3, x+19, " "); ncaddstr(y+4, x+15, " "); /* U */ ncaddstr(y+0, x+23, " "); ncaddstr(y+1, x+23, " "); ncaddstr(y+2, x+23, " "); ncaddstr(y+3, x+23, " "); ncaddstr(y+0, x+27, " "); ncaddstr(y+1, x+27, " "); ncaddstr(y+2, x+27, " "); ncaddstr(y+3, x+27, " "); ncaddstr(y+4, x+23, " "); attroff(A_REVERSE); ncaddstr(y+0, x+30, "NCurses"); ncaddstr(y+1, x+30, "Disk"); ncaddstr(y+2, x+30, "Usage"); ncprint( y+4, x+30, "%s", PACKAGE_VERSION); ncaddstr( 9, 7, "Written by Yoran Heling <*****@*****.**>"); ncaddstr(10, 16, "http://dev.yorhel.nl/ncdu/"); break; } }
/* ----------------------------- MNI Header ----------------------------------- @NAME : OpenFiles @INPUT : parent_file -> The name of the minc file to create the child from, or NULL if there is no parent file. child_file -> The name of the child file to be created. tm_stamp -> A string to be prepended to the history attribute. @OUTPUT : parent_CDF -> The cdfid of the opened parent file, or -1 if no parent file was given. child_CDF -> The cdfid of the created child file. @RETURNS : TRUE if all went well FALSE if error opening parent file (but only if one was supplied) FALSE if error creating child file @DESCRIPTION: Opens the (optional) parent MINC file, and creates the (required) new MINC file. Also creates the root variable (using micreate_std_variable) in the child file. @METHOD : @GLOBALS : none @CALLS : NetCDF routines MINC routines @CREATED : May 31, 1993 by MW @MODIFIED : Aug 11, 1993, GPW - added provisions for no parent file. Oct 27, 1993, GPW - moved from micreate.c to micreateimage.c; removed copying of attributes and history update; renamed from CreateChild to OpenFiles. ---------------------------------------------------------------------------- */ Boolean OpenFiles (char parent_file[], char child_file[], int *parent_CDF, int *child_CDF) { struct stat statbuf; /* used to check that created file exists */ /* * If a filename for the parent MINC file was supplied, open the file; * else return -1 for *parent_CDF. */ if (parent_file != NULL) { *parent_CDF = ncopen (parent_file, NC_NOWRITE); if (*parent_CDF == MI_ERROR) { sprintf (ErrMsg, "Error opening input file %s: %s\n", parent_file, NCErrMsg (ncerr, errno)); return (FALSE); } } else { *parent_CDF = -1; } /* * Create the child file, bomb if any error. N.B. we call nccreate() * with a mode of NC_NOCLOBBER here because if we use NC_CLOBBER and * the file is uncreatable (eg. permission denied), then the NetCDF * code incorrectly attempts to delete the file; this results in * errno being clobbered, so we'd print out an inaccurate error * message here. */ *child_CDF = nccreate (child_file, gClobberFlag ? NC_CLOBBER : NC_NOCLOBBER); if (*child_CDF == MI_ERROR) { sprintf (ErrMsg, "Error creating file %s: %s\n", child_file, NCErrMsg (ncerr, errno)); ncclose (*parent_CDF); return (FALSE); } /* * Now just check to make sure the file exists and has non-zero size * (because NetCDF fails to report disk full!) */ if (stat (child_file, &statbuf) != 0) { sprintf (ErrMsg, "File %s was not created: disk may be full\n", child_file); ncclose (*parent_CDF); ncclose (*child_CDF); return (FALSE); } /* if (statbuf.st_size == 0) { sprintf (ErrMsg, "Error creating file %s: disk may be full\n", child_file); ncclose (*parent_CDF); ncclose (*child_CDF); return (FALSE); } */ #ifdef DEBUG printf ("OpenFiles:\n"); printf (" Parent file %s, CDF %d\n", parent_file, *parent_CDF); printf (" Child file %s, CDF %d\n\n", child_file, *child_CDF); #endif /* The parent file is now open for reading, and the child file is */ /* created and opened for definition. */ return (TRUE); } /* OpenFiles () */
void browse_draw() { struct dir *t; char fmtsize[9], *tmp; int selected = 0, i; erase(); t = dirlist_get(0); /* top line - basic info */ attron(A_REVERSE); mvhline(0, 0, ' ', wincols); mvhline(winrows-1, 0, ' ', wincols); mvprintw(0,0,"%s %s ~ Use the arrow keys to navigate, press ? for help", PACKAGE_NAME, PACKAGE_VERSION); if(dir_import_active) mvaddstr(0, wincols-10, "[imported]"); else if(read_only) mvaddstr(0, wincols-11, "[read-only]"); attroff(A_REVERSE); /* second line - the path */ mvhline(1, 0, '-', wincols); if(t) { mvaddch(1, 3, ' '); tmp = getpath(t->parent); mvaddstr(1, 4, cropstr(tmp, wincols-8)); mvaddch(1, 4+((int)strlen(tmp) > wincols-8 ? wincols-8 : (int)strlen(tmp)), ' '); } /* bottom line - stats */ attron(A_REVERSE); if(t) { strcpy(fmtsize, formatsize(t->parent->size)); mvprintw(winrows-1, 0, " Total disk usage: %s Apparent size: %s Items: %d", fmtsize, formatsize(t->parent->asize), t->parent->items); } else mvaddstr(winrows-1, 0, " No items to display."); attroff(A_REVERSE); /* nothing to display? stop here. */ if(!t) return; /* get start position */ t = dirlist_top(0); /* print the list to the screen */ for(i=0; t && i<winrows-3; t=dirlist_next(t),i++) { browse_draw_item(t, 2+i); /* save the selected row number for later */ if(t->flags & FF_BSEL) selected = i; } /* draw message window */ if(message) { nccreate(6, 60, "Message"); ncaddstr(2, 2, message); ncaddstr(4, 34, "Press any key to continue"); } /* draw information window */ t = dirlist_get(0); if(!message && info_show && t != dirlist_parent) browse_draw_info(t); /* move cursor to selected row for accessibility */ move(selected+2, 0); }