int main() { int cdf, cdf2; int img; int dim[MAX_VAR_DIMS]; int dim2[MAX_VAR_DIMS]; long start[MAX_VAR_DIMS]; long count[MAX_VAR_DIMS]; double image[256*256]; int i, j, k, ioff; char filename[256]; char filename2[256]; set_ncopts(NC_VERBOSE|NC_FATAL); snprintf(filename, sizeof(filename), "test_minc-%d.mnc", getpid()); snprintf(filename2, sizeof(filename2), "test_minc2-%d.mnc", getpid()); cdf=micreate(filename, NC_CLOBBER); count[2]=5; count[1]=3; count[0]=7; dim[2]=ncdimdef(cdf, MIzspace, count[2]); dim[1]=ncdimdef(cdf, MIxspace, count[1]); dim[0]=ncdimdef(cdf, MIyspace, count[0]); dim2[0]=ncdimdef(cdf, MItime, NC_UNLIMITED); dim2[1]=dim[0]; dim2[2]=dim[1]; img=ncvardef(cdf, MIimage, NC_SHORT, 3, dim); (void) ncvardef(cdf, "testvar", NC_FLOAT, 2, dim2); (void) miattputstr(cdf, img, MIsigntype, MI_SIGNED); for (j=0; j<count[0]; j++) { for (i=0; i<count[1]; i++) { ioff=(j*count[1]+i)*count[2]; for (k=0; k<count[2]; k++) image[ioff+k]=ioff+k+10; } } cdf2=micreate(filename2,NC_CLOBBER); (void) ncdimdef(cdf2, "junkdim", NC_UNLIMITED); (void) micopy_all_var_defs(cdf, cdf2, 1, &img); (void) ncendef(cdf2); (void) ncendef(cdf); (void) miset_coords(3,0L,start); (void) mivarput(cdf, img, start, count, NC_DOUBLE, NULL, image); (void) micopy_all_var_values(cdf, cdf2, 1, &img); (void) miclose(cdf2); (void) miclose(cdf); unlink(filename); unlink(filename2); return(0); }
int define_variable_name_variable(int exoid, const char *VARIABLE, long dimension, const char *label) { char errmsg[MAX_ERR_LENGTH]; int dims[2]; int variable; dims[0] = dimension; dims[1] = ncdimid(exoid, DIM_STR); /* Checked earlier, so known to exist */ if ((variable = ncvardef (exoid, VARIABLE, NC_CHAR, 2, dims)) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: %s variable names are already defined in file id %d", label, exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to define %s variable names in file id %d", label, exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); } } return variable; }
MNCAPI int MI2vardef(int fd, const char *varnm, nc_type vartype, int ndims, const int *dimids) { if (MI2_ISH5OBJ(fd)) { return (hdf_vardef(fd, varnm, vartype, ndims, dimids)); } else { return (ncvardef(fd, varnm, vartype, ndims, dimids)); } }
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 main(int argc, char *argv[]) { char *pname; char *filename, *tempfile, *newfile; char string[1024]; char *variable_name, *attribute_name; int created_tempfile; int done_redef; int iatt; int mincid, varid; int variable_exists, attribute_exists; nc_type attribute_type, new_type; int attribute_length, new_length; void *new_value; int total_length, alloc_length, ival; char *zeros; int old_ncopts; /* Parse the command line */ pname=argv[0]; if (ParseArgv(&argc, argv, argTable, 0) || (argc != 2)) { (void) fprintf(stderr, "\nUsage: %s [<options>] <file.mnc>\n", pname); (void) fprintf(stderr, " %s [-help]\n\n", pname); exit(EXIT_FAILURE); } filename = argv[1]; /* Create temp file name. First try looking for minc extension, then a compression extension. Chop off the unwanted extension. */ (void) strncpy(string, filename, sizeof(string)-1); tempfile = strstr(string, MINC_EXTENSION); if (tempfile != NULL) { tempfile += strlen(MINC_EXTENSION); if (*tempfile == '\0') tempfile = NULL; } else { tempfile = strstr(string, GZIP_EXTENSION); if (tempfile == NULL) tempfile = strstr(string, BZIP_EXTENSION); if (tempfile == NULL) tempfile = strstr(string, BZIP2_EXTENSION); if (tempfile == NULL) tempfile = strstr(string, COMPRESS_EXTENSION); if (tempfile == NULL) tempfile = strstr(string, PACK_EXTENSION); if (tempfile == NULL) tempfile = strstr(string, ZIP_EXTENSION); } if (tempfile != NULL) { *tempfile = '\0'; tempfile = string; } /* If tempfile == NULL, then either we have a minc file or we don't know how to edit the file in place. Check that it is a minc file. */ if (tempfile == NULL) { newfile = miexpand_file(filename, tempfile, TRUE, &created_tempfile); if (created_tempfile) { if (newfile != NULL) { (void) remove(newfile); free(newfile); } (void) fprintf(stderr, "Cannot edit file \"%s\" in place.\n", filename); exit(EXIT_FAILURE); } } /* Expand the file. */ newfile = miexpand_file(filename, tempfile, FALSE, &created_tempfile); if (newfile == NULL) { (void) fprintf(stderr, "Error decompressing file \"%s\"\n", filename); exit(EXIT_FAILURE); } /* If a new file was created, get rid of the old one */ if (created_tempfile) { (void) remove(filename); } /* Open the file */ mincid = miopen(newfile, NC_WRITE); /* Loop through attribute list, modifying values */ done_redef = FALSE; ncopts = NC_VERBOSE; zeros = NULL; alloc_length = 0; for (iatt=0; iatt < attribute_list_size; iatt++) { /* Get variable and attribute name */ variable_name = attribute_list[iatt].variable; attribute_name = attribute_list[iatt].attribute; /* Check for attribute existence */ if (strlen(variable_name) == 0) { varid = NC_GLOBAL; variable_exists = TRUE; } else { old_ncopts = ncopts; ncopts = 0; varid = ncvarid(mincid, variable_name); ncopts = old_ncopts; variable_exists = (varid != MI_ERROR); } attribute_type = NC_CHAR; attribute_length = 0; if (variable_exists) { old_ncopts = ncopts; ncopts = 0; attribute_exists = (ncattinq(mincid, varid, attribute_name, &attribute_type, &attribute_length) != MI_ERROR); ncopts = old_ncopts; } else attribute_exists = FALSE; /* Are we inserting or deleting? */ switch (attribute_list[iatt].action) { case Insert_attribute: case Append_attribute: if (attribute_list[iatt].value != NULL) { new_type = NC_CHAR; new_length = strlen(attribute_list[iatt].value)+1; new_value = (void *) attribute_list[iatt].value; } else { new_type = NC_DOUBLE; new_length = attribute_list[iatt].num_doubles; new_value = (void *) attribute_list[iatt].double_values; } /* For append we have to copy the entire attribute, if it * already exists. */ if (attribute_list[iatt].action == Append_attribute && attribute_exists) { char *tmp_value; /* Verify that the existing type matches the newly * requested type. Don't allow a -dappend on a * string attribute, for example. */ if (new_type != attribute_type) { fprintf(stderr, "Can't append %s data to %s attribute %s:%s.\n", (new_type == NC_DOUBLE) ? "double" : "string", (attribute_type == NC_DOUBLE) ? "double" : "string", variable_name, attribute_name); exit(EXIT_FAILURE); } new_type = attribute_type; tmp_value = malloc((attribute_length + new_length) * nctypelen(new_type)); ncattget(mincid, varid, attribute_name, tmp_value); /* For string attributes, remove any trailing null * character before appending. */ if (new_type == NC_CHAR && tmp_value[attribute_length-1] == 0) { attribute_length--; } memcpy(tmp_value + attribute_length * nctypelen(new_type), new_value, new_length * nctypelen(new_type)); new_length += attribute_length; new_value = (void *) tmp_value; } total_length = attribute_length*nctypelen(attribute_type); if (!attribute_exists || (total_length < new_length*nctypelen(new_type))) { if (! done_redef) { done_redef = TRUE; (void) ncredef(mincid); } } else if (!done_redef && attribute_exists && (total_length > 0)) { if (total_length > alloc_length) { if (zeros != NULL) free(zeros); zeros = malloc(total_length); alloc_length = total_length; for (ival=0; ival < alloc_length; ival++) zeros[ival] = '\0'; } (void) ncattput(mincid, varid, attribute_name, NC_CHAR, total_length, zeros); (void) ncsync(mincid); } if (!variable_exists) { old_ncopts = ncopts; ncopts = 0; varid = micreate_group_variable(mincid, variable_name); ncopts = old_ncopts; if (varid == MI_ERROR) { varid = ncvardef(mincid, variable_name, NC_INT, 0, NULL); } variable_exists = (varid != MI_ERROR); } if (variable_exists) { (void) ncattput(mincid, varid, attribute_name, new_type, new_length, new_value); } break; case Delete_attribute: if (attribute_exists) { if (! done_redef) { done_redef = TRUE; (void) ncredef(mincid); } (void) ncattdel(mincid, varid, attribute_name); } break; default: (void) fprintf(stderr, "Program error: unknown action %d\n", (int) attribute_list[iatt].action); exit(EXIT_FAILURE); } } ncopts = NC_VERBOSE | NC_FATAL; /* Close the file */ (void) miclose(mincid); /* Free stuff */ free(newfile); if (zeros != NULL) free(zeros); exit(EXIT_SUCCESS); }
int cpy_var_def(int in_id,int out_id,int rec_dim_id,char *var_nm) /* int in_id: input netCDF input-file ID int out_id: input netCDF output-file ID int rec_dim_id: input input-file record dimension ID char *var_nm: input variable name int cpy_var_def(): output output-file variable ID */ { /* Routine to copy the variable metadata from an input netCDF file * to an output netCDF file. */ int *dim_in_id; int *dim_out_id; int idx; int nbr_dim; int var_in_id; int var_out_id; int temp; extern int ncopts; nc_type var_type; /* See if the requested variable is already in the output file. */ temp = ncopts; ncopts=0; var_out_id=ncvarid(out_id,var_nm); ncopts = temp; if(var_out_id != -1) return var_out_id; /* See if the requested variable is in the input file. */ var_in_id=ncvarid(in_id,var_nm); /* Get the type of the variable and the number of dimensions. */ ncvarinq(in_id,var_in_id,(char *)NULL,&var_type,&nbr_dim, (int *)NULL,(int *)NULL); /* Recall: 1. The dimensions must be defined before the variable. 2. The variable must be defined before the attributes. */ /* Allocate space to hold the dimension IDs */ dim_in_id=malloc(nbr_dim*sizeof(int)); dim_out_id=malloc(nbr_dim*sizeof(int)); /* Get the dimension IDs */ ncvarinq(in_id,var_in_id,(char *)NULL,(nc_type *)NULL, (int *)NULL,dim_in_id,(int *)NULL); /* Get the dimension sizes and names */ for(idx=0;idx<nbr_dim;idx++){ char dim_nm[MAX_NC_NAME]; long dim_sz; ncdiminq(in_id,dim_in_id[idx],dim_nm,&dim_sz); /* See if the dimension has already been defined */ temp = ncopts; ncopts = 0; dim_out_id[idx]=ncdimid(out_id,dim_nm); ncopts = temp; /* If the dimension hasn't been defined, copy it */ if(dim_out_id[idx] == -1){ if(dim_in_id[idx] != rec_dim_id){ dim_out_id[idx]=ncdimdef(out_id,dim_nm,dim_sz); }else{ dim_out_id[idx]=ncdimdef(out_id,dim_nm,NC_UNLIMITED); } /* end else */ } /* end if */ } /* end loop over dim */ /* Define the variable in the output file */ /* If variable is float or double, define it according to the EXODUS file's IO_word_size */ if ((var_type == NC_FLOAT) || (var_type == NC_DOUBLE)) { var_out_id=ncvardef(out_id,var_nm,nc_flt_code(out_id), nbr_dim,dim_out_id); } else { var_out_id=ncvardef(out_id,var_nm,var_type,nbr_dim,dim_out_id); } /* Free the space holding the dimension IDs */ (void)free(dim_in_id); (void)free(dim_out_id); return var_out_id; } /* end cpy_var_def() */
int ex_put_elem_block (int exoid, int elem_blk_id, const char *elem_type, int num_elem_this_blk, int num_nodes_per_elem, int num_attr) { int varid, dimid, dims[2], elem_blk_id_ndx, elem_blk_stat, strdim; long start[2], num_elem_blk; nclong ldum; int cur_num_elem_blk, nelnoddim, numelbdim, numattrdim, connid; char *cdum; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ cdum = 0; /* first check if any element blocks are specified */ if ((dimid = (ncdimid (exoid, DIM_NUM_EL_BLK))) == -1 ) { exerrval = ncerr; sprintf(errmsg, "Error: no element blocks defined in file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* Get number of element blocks defined for this file */ if ((ncdiminq (exoid,dimid,cdum,&num_elem_blk)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of element blocks in file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* Next: Make sure that this is not a duplicate element block id by searching the VAR_ID_EL_BLK array. WARNING: This must be done outside of define mode because id_lkup accesses the database to determine the position */ if ((varid = ncvarid (exoid, VAR_ID_EL_BLK)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate element block ids in file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); } elem_blk_id_ndx = ex_id_lkup(exoid,VAR_ID_EL_BLK,elem_blk_id); if (exerrval != EX_LOOKUPFAIL) /* found the element block id */ { exerrval = EX_FATAL; sprintf(errmsg, "Error: element block id %d already exists in file id %d", elem_blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* Keep track of the total number of element blocks defined using a counter stored in a linked list keyed by exoid. NOTE: ex_get_file_item is a function that finds the number of element blocks for a specific file and returns that value incremented. */ cur_num_elem_blk=ex_get_file_item(exoid, &eb_ctr_list); if (cur_num_elem_blk >= num_elem_blk) { exerrval = EX_FATAL; sprintf(errmsg, "Error: exceeded number of element blocks (%ld) defined in file id %d", num_elem_blk,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* NOTE: ex_get_file_item is a function that finds the number of element blocks for a specific file and returns that value incremented. */ cur_num_elem_blk=ex_inc_file_item(exoid, &eb_ctr_list); start[0] = (long)cur_num_elem_blk; /* write out element block id to previously defined id array variable*/ ldum = (nclong)elem_blk_id; if (ncvarput1 (exoid, varid, start, &ldum) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store element block id to file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } elem_blk_id_ndx = start[0]+1; /* element id index into VAR_ID_EL_BLK array*/ if (num_elem_this_blk == 0) /* Is this a NULL element block? */ elem_blk_stat = 0; /* change element block status to NULL */ else elem_blk_stat = 1; /* change element block status to TRUE */ if ((varid = ncvarid (exoid, VAR_STAT_EL_BLK)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate element block status in file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } ldum = (nclong)elem_blk_stat; if (ncvarput1 (exoid, varid, start, &ldum) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store element id %d status to file id %d", elem_blk_id, exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } if (num_elem_this_blk == 0) /* Is this a NULL element block? */ { return(EX_NOERR); } /* * Check that storage required for connectivity array is less * than 2GB which is maximum size permitted by netcdf * (in large file mode). 1<<29 == max number of integer items. */ if (num_elem_this_blk * num_nodes_per_elem > (1<<29)) { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Size to store connectivity for element block %d exceeds 2GB in file id %d", elem_blk_id, exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* 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_elem_block",errmsg,exerrval); return (EX_FATAL); } /* define some dimensions and variables*/ if ((numelbdim = ncdimdef (exoid, DIM_NUM_EL_IN_BLK(elem_blk_id_ndx), (long)num_elem_this_blk)) == -1) { if (ncerr == NC_ENAMEINUSE) /* duplicate entry */ { exerrval = ncerr; sprintf(errmsg, "Error: element block %d already defined in file id %d", elem_blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of elements/block for block %d file id %d", elem_blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } if ((nelnoddim = ncdimdef (exoid, DIM_NUM_NOD_PER_EL(elem_blk_id_ndx), (long)num_nodes_per_elem)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of nodes/element for block %d in file id %d", elem_blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* element attribute array */ if (num_attr > 0) { if ((numattrdim = ncdimdef (exoid, DIM_NUM_ATT_IN_BLK(elem_blk_id_ndx), (long)num_attr)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of attributes in block %d in file id %d", elem_blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } dims[0] = numelbdim; dims[1] = numattrdim; if ((ncvardef (exoid, VAR_ATTRIB(elem_blk_id_ndx), nc_flt_code(exoid), 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define attributes for element block %d in file id %d", elem_blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* inquire previously defined dimensions */ if ((strdim = ncdimid (exoid, DIM_STR)) < 0) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get string length in file id %d",exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* Attribute names... */ dims[0] = numattrdim; dims[1] = strdim; if (ncvardef (exoid, VAR_NAME_ATTRIB(elem_blk_id_ndx), NC_CHAR, 2, dims) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define element attribute name array in file id %d",exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } /* element connectivity array */ dims[0] = numelbdim; dims[1] = nelnoddim; if ((connid = ncvardef (exoid, VAR_CONN(elem_blk_id_ndx), NC_LONG, 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to create connectivity array for block %d in file id %d", elem_blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* store element type as attribute of connectivity variable */ if ((ncattput (exoid, connid, ATT_NAME_ELB, NC_CHAR, strlen(elem_type)+1, (void*) elem_type)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store element type name %s in file id %d", elem_type,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* leave define mode */ if (ncendef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to complete element block definition in file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } 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_elem_block",errmsg,exerrval); } return (EX_FATAL); }
/* -------------------- end of local defines -------------------- */ int ex_put_coordinate_frames( int exoid, int nframes, const int cf_ids[], void* pt_coordinates, const char* tags) { int dim, dim9; /* dimension id for nframes, nframes*9 */ char errmsg[MAX_ERR_LENGTH]; /* buffer for error messages */ int exerrval; /* returned error value */ int varcoords; /* variable id for the coordinates */ int varids; /* variable id for the frame ids */ int vartags; /* variable id for the frame tags */ long int start=0; /* start value for varputs */ long int count=nframes; /* number vars to put in varput */ long int count9=nframes*9; /* ditto, but for coordinates */ int i; /* general indices */ void* pt_c=0; /* pointer to size converted array */ if ( exoid < 0 ) return exoid; if ( nframes == 0 ) /* write nothing */ return (EX_NOERR); if ( nframes<0 ) return 1; assert( cf_ids!=0 ); assert( pt_coordinates !=0 ); assert( tags != 0 ); /* make the definitions */ /* go into define mode. define num_frames, num_frames9 */ if (ncredef (exoid) == -1){ exerrval = ncerr; sprintf(errmsg,"Error: failed to place file id %d into define mode", exoid); ex_err(PROCNAME,errmsg,exerrval); return (EX_FATAL); } if ( (dim=ncdimdef (exoid, NUM_CFRAMES, nframes)) == -1 || (dim9=ncdimdef (exoid, NUM_CFRAME9, nframes*9))== -1 ){ exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of coordinate frames in file id %d", exoid); ex_err(PROCNAME,errmsg,exerrval); goto error_ret; } /* define the variables. coordinates, tags and ids */ if ((varcoords=ncvardef (exoid, FRAME_COORDS, nc_flt_code(exoid), 1, &dim9)) == -1 || (varids=ncvardef (exoid, FRAME_IDS,NC_INT, 1, &dim)) == -1 || (vartags=ncvardef(exoid, FRAME_TAGS,NC_CHAR,1,&dim)) == -1 ) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define coordinate frames in file id %d", exoid); ex_err(PROCNAME,errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* leave define mode */ if (ncendef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to complete coordinate frame definition in file id %d", exoid); ex_err(PROCNAME,errmsg,exerrval); return (EX_FATAL); } /* check variables consistency */ exerrval = EX_NOERR; for (i=0;i<nframes;i++) if ( strchr("RrCcSs",tags[i])==0 ){ sprintf(errmsg,"Warning: Unrecognized coordinate frame tag: '%c'.", tags[i]); exerrval=2; ex_err(PROCNAME,errmsg,exerrval); } /* could also check vectors. Leave this up to the application */ /* put the variables into the file */ pt_c = ex_conv_array(exoid,RTN_ADDRESS,pt_coordinates,count9); if ( ncvarput (exoid, vartags, &start, &count, tags) == -1 || ncvarput (exoid, varids, &start, &count, cf_ids) == -1 || ncvarput (exoid, varcoords, &start, &count9, pt_c )==-1 ){ exerrval = ncerr; sprintf(errmsg, "Error: failed writing frame data in file id %d",exoid); ex_err(PROCNAME,errmsg,exerrval); return (EX_FATAL); } return (EX_NOERR); error_ret: if (ncendef (exoid) == -1) /* exit define mode */ { sprintf(errmsg, "Error: failed to complete frame definition for file id %d", exoid); ex_err(PROCNAME,errmsg,exerrval); } return (EX_FATAL); }
int ex_put_num_map ( int exoid, int map_type, int map_id, const int *map ) { int dimid, varid, iresult; long start[1]; nclong ldum, *lptr; long num_maps, num_entries, count[1]; int cur_num_maps; char *cdum; char errmsg[MAX_ERR_LENGTH]; const char* tname; const char* dnumentries; const char* dnummaps; const char* vmapids; const char* vmap = 0; struct list_item** map_ctr_list; exerrval = 0; /* clear error code */ cdum = 0; switch ( map_type ) { case EX_NODE_MAP: tname = "node"; dnumentries = DIM_NUM_NODES; dnummaps = DIM_NUM_NM; vmapids = VAR_NM_PROP(1); map_ctr_list = &nm_ctr_list; break; case EX_EDGE_MAP: tname = "edge"; dnumentries = DIM_NUM_EDGE; dnummaps = DIM_NUM_EDM; vmapids = VAR_EDM_PROP(1); map_ctr_list = &edm_ctr_list; break; case EX_FACE_MAP: tname = "face"; dnumentries = DIM_NUM_FACE; dnummaps = DIM_NUM_FAM; vmapids = VAR_FAM_PROP(1); map_ctr_list = &fam_ctr_list; break; case EX_ELEM_MAP: tname = "element"; dnumentries = DIM_NUM_ELEM; dnummaps = DIM_NUM_EM; vmapids = VAR_EM_PROP(1); map_ctr_list = &em_ctr_list; break; default: exerrval = EX_BADPARAM; sprintf( errmsg, "Error: Bad map type (%d) specified for file id %d", map_type, exoid ); ex_err( "ex_put_num_map", errmsg, exerrval ); return (EX_FATAL); } /* Make sure the file contains entries */ if ((dimid = (ncdimid (exoid, dnumentries))) == -1 ) { return (EX_NOERR); } /* first check if any maps are specified */ if ((dimid = (ncdimid (exoid, dnummaps))) == -1 ) { exerrval = ncerr; sprintf(errmsg, "Error: no %s maps specified in file id %d", tname,exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } /* Check for duplicate map id entry */ ex_id_lkup(exoid,vmapids,map_id); if (exerrval != EX_LOOKUPFAIL) /* found the map id */ { exerrval = ncerr; sprintf(errmsg, "Error: %s map %d already defined in file id %d", tname,map_id,exoid); ex_err("ex_put_num_map",errmsg,exerrval); return(EX_FATAL); } /* Get number of maps initialized for this file */ if ((ncdiminq (exoid,dimid,cdum,&num_maps)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of %s maps in file id %d", tname,exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } /* Keep track of the total number of maps defined using a counter stored in a linked list keyed by exoid. NOTE: ex_get_file_item is used to find the number of maps for a specific file and returns that value. */ cur_num_maps = ex_get_file_item(exoid, map_ctr_list ); if (cur_num_maps >= num_maps) { exerrval = EX_FATAL; sprintf(errmsg, "Error: exceeded number of %s maps (%ld) specified in file id %d", tname,num_maps,exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } /* NOTE: ex_inc_file_item is used to find the number of maps for a specific file and returns that value incremented. */ cur_num_maps = ex_inc_file_item(exoid, map_ctr_list ); /* write out information to previously defined variable */ /* first get id of variable */ if ((varid = ncvarid (exoid, vmapids)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate %s map ids in file id %d", tname,exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } /* then, write out map id */ start[0] = cur_num_maps; ldum = (nclong)map_id; if (ncvarput1 (exoid, varid, start, &ldum) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store %s map id %d in file id %d", tname,map_id,exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } /* determine number of entries */ if ((dimid = (ncdimid (exoid, dnumentries))) == -1 ) { exerrval = ncerr; sprintf(errmsg, "Error: couldn't determine number of %s entries in file id %d", tname,exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } if (ncdiminq (exoid, dimid, (char *) 0, &num_entries) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of %s entries in file id %d", tname,exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } switch ( map_type ) { case EX_NODE_MAP: vmap = VAR_NODE_MAP(cur_num_maps+1); break; case EX_EDGE_MAP: vmap = VAR_EDGE_MAP(cur_num_maps+1); break; case EX_FACE_MAP: vmap = VAR_FACE_MAP(cur_num_maps+1); break; case EX_ELEM_MAP: vmap = VAR_ELEM_MAP(cur_num_maps+1); break; } /* locate variable array in which to store the map */ if ((varid = ncvarid(exoid,vmap)) == -1) { #if 0 exerrval = ncerr; sprintf(errmsg, "Error: failed to locate %s map %d in file id %d", vmap,map_id,exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); #endif int dims[2]; ncerr = 0; if ( ncredef( exoid ) == -1 ) { exerrval = ncerr; sprintf(errmsg, "Error: failed to place file id %d into define mode", exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } dims[0] = dimid; if ( (varid = ncvardef( exoid, vmap, NC_LONG, 1, dims )) == -1 ) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define map %s in file id %d", vmap, exoid); ex_err("ex_put_num_map",errmsg,exerrval); } if ( ncendef( exoid ) == -1 ) { /* exit define mode */ sprintf( errmsg, "Error: failed to complete definition for file id %d", exoid ); ex_err( "ex_put_num_map", errmsg, exerrval ); varid = -1; /* force early exit */ } if ( varid == -1 ) /* we couldn't define variable and have prepared error message. */ return (EX_FATAL); } /* write out the map */ /* 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_entries; if (sizeof(int) == sizeof(nclong)) { iresult = ncvarput (exoid, varid, start, count, map); } else { lptr = itol (map, (int)num_entries); iresult = ncvarput (exoid, varid, start, count, lptr); free(lptr); } if (iresult == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store %s map in file id %d", tname,exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } return (EX_NOERR); }
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_sset_var (int exoid, int time_step, int sset_var_index, int sset_id, int num_faces_this_sset, const void *sset_var_vals) { int varid, dimid,time_dim, numelbdim, dims[2], sset_id_ndx; long num_ssets, num_sset_var, start[2], count[2]; nclong *sset_var_tab; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ /* Determine index of sset_id in VAR_SS_ID array */ sset_id_ndx = ex_id_lkup(exoid,VAR_SS_IDS,sset_id); if (exerrval != 0) { if (exerrval == EX_NULLENTITY) { sprintf(errmsg, "Warning: no variables allowed for NULL sideset %d in file id %d", sset_id,exoid); ex_err("ex_put_sset_var",errmsg,EX_MSG); return (EX_WARN); } else { sprintf(errmsg, "Error: failed to locate sideset id %d in %s array in file id %d", sset_id, VAR_SS_IDS, exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } } if ((varid = ncvarid (exoid, VAR_SS_VAR(sset_var_index,sset_id_ndx))) == -1) { if (ncerr == NC_ENOTVAR) /* variable doesn't exist, create it! */ { /* inquire previously defined dimensions */ /* check for the existance of an sideset variable truth table */ if ((varid = ncvarid (exoid, VAR_SSET_TAB)) != -1) { /* find out number of sidesets and sideset variables */ if ((dimid = ncdimid (exoid, DIM_NUM_SS)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate number of sidesets in file id %d", exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } if (ncdiminq (exoid, dimid, (char *) 0, &num_ssets) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of sidesets in file id %d", exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } if ((dimid = ncdimid (exoid, DIM_NUM_SSET_VAR)) == -1) { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: no sideset variables stored in file id %d", exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } if (ncdiminq (exoid, dimid, (char *) 0, &num_sset_var) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of sideset variables in file id %d", exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } if (!(sset_var_tab = malloc(num_ssets*num_sset_var*sizeof(nclong)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate memory for sideset variable truth table in file id %d", exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } /* read in the sideset variable truth table */ start[0] = 0; start[1] = 0; count[0] = num_ssets; count[1] = num_sset_var; if (ncvarget (exoid, varid, start, count, sset_var_tab) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get truth table from file id %d", exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } if(sset_var_tab[num_sset_var*(sset_id_ndx-1)+sset_var_index-1] == 0L) { free(sset_var_tab); exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid sideset variable %d, sideset %d in file id %d", sset_var_index, sset_id, exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } free(sset_var_tab); } if ((time_dim = ncdimid (exoid, DIM_TIME)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate time dimension in file id %d", exoid); ex_err("ex_put_sset_var",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } if ((numelbdim=ncdimid(exoid, DIM_NUM_SIDE_SS(sset_id_ndx))) == -1) { if (ncerr == NC_EBADDIM) { exerrval = ncerr; sprintf(errmsg, "Error: number of faces in sideset %d not defined in file id %d", sset_id, exoid); ex_err("ex_put_sset_var",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate number of sides in sideset %d in file id %d", sset_id, exoid); ex_err("ex_put_sset_var",errmsg,exerrval); } goto error_ret; } /* variable doesn't exist so put file into define mode */ if (ncredef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to put file id %d into define mode", exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } /* define netCDF variable to store sideset variable values */ dims[0] = time_dim; dims[1] = numelbdim; if ((varid = ncvardef(exoid,VAR_SS_VAR(sset_var_index,sset_id_ndx), nc_flt_code(exoid), 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define sideset variable %d in file id %d", sset_var_index,exoid); ex_err("ex_put_sset_var",errmsg,exerrval); goto error_ret; } /* leave define mode */ if (ncendef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to complete sideset variable %s definition to file id %d", VAR_SS_VAR(sset_var_index,sset_id_ndx), exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate sideset variable %s in file id %d", VAR_SS_VAR(sset_var_index,sset_id_ndx),exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } } /* store sideset variable values */ start[0] = --time_step; start[1] = 0; count[0] = 1; count[1] = num_faces_this_sset; if (ncvarput (exoid, varid, start, count, ex_conv_array(exoid,WRITE_CONVERT,sset_var_vals, num_faces_this_sset)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store sideset variable %d in file id %d", sset_var_index,exoid); ex_err("ex_put_sset_var",errmsg,exerrval); return (EX_FATAL); } 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_sset_var",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); }
int ex_put_init (int exoid, const char *title, int num_dim, int num_nodes, int num_elem, int num_elem_blk, int num_node_sets, int num_side_sets) { int numdimdim, numnoddim, elblkdim, nsetdim, ssetdim, strdim, dim[2], varid; #if 0 /* used for header size calculations which are turned off for now */ int header_size, fixed_var_size, iows; #endif char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ if ((ncdimid (exoid, DIM_NUM_DIM)) != -1) { exerrval = EX_MSG; sprintf(errmsg, "Error: initialization already done for file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); return (EX_FATAL); } /* put file into define mode */ if (ncredef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to put file id %d into define mode", exoid); ex_err("ex_put_init",errmsg,exerrval); return (EX_FATAL); } /* define some attributes... */ if (ncattput (exoid, NC_GLOBAL, (const char*) ATT_TITLE, NC_CHAR, strlen(title)+1, (void *)title) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define title attribute to file id %d", exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* ...and some dimensions... */ if ((numdimdim = ncdimdef (exoid, DIM_NUM_DIM, (long)num_dim)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of dimensions in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* * Need to handle "empty file" that may be the result of a strange * load balance or some other strange run. Note that if num_node * == 0, then num_elem must be zero since you cannot have elements * with no nodes. It *is* permissible to have zero elements with * non-zero node count. */ if (num_nodes > 0) { if ((numnoddim = ncdimdef (exoid, DIM_NUM_NODES, (long)num_nodes)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of nodes in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } if (num_elem > 0) { if (num_nodes <= 0) { exerrval = EX_MSG; sprintf(errmsg, "Error: Cannot have non-zero element count if node count is zero.in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } if ((ncdimdef (exoid, DIM_NUM_ELEM, (long)num_elem)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of elements in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } /* Can have nonzero num_elem_blk even if num_elem == 0 */ if (num_elem_blk > 0) { if ((elblkdim = ncdimdef (exoid, DIM_NUM_EL_BLK, (long)num_elem_blk)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of element blocks in file id %d", exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* ...and some variables */ /* element block id status array */ dim[0] = elblkdim; if ((varid = ncvardef (exoid, VAR_STAT_EL_BLK, NC_LONG, 1, dim)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define element block status array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } #if 0 /* store property name as attribute of property array variable */ if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 7, "STATUS")) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store element block property name %s in file id %d", "STATUS",exoid); ex_err("ex_put_init",errmsg,exerrval); return (EX_FATAL); } #endif /* element block id array */ if ((varid = ncvardef (exoid, VAR_ID_EL_BLK, NC_LONG, 1, dim)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define element block id array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* store property name as attribute of property array variable */ if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 3, "ID")) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store element block property name %s in file id %d", "ID",exoid); ex_err("ex_put_init",errmsg,exerrval); return (EX_FATAL); } } /* node set id array: */ nsetdim = 0; if (num_node_sets > 0) { if ((nsetdim = ncdimdef (exoid, DIM_NUM_NS, (long)num_node_sets)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of node sets in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* node set id status array: */ dim[0] = nsetdim; if ((varid = ncvardef (exoid, VAR_NS_STAT, NC_LONG, 1, dim)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to create node sets status array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } #if 0 /* store property name as attribute of property array variable */ if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 7, "STATUS")) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store node set property name %s in file id %d", "ID",exoid); ex_err("ex_put_init",errmsg,exerrval); return (EX_FATAL); } #endif /* node set id array: */ dim[0] = nsetdim; if ((varid = ncvardef (exoid, VAR_NS_IDS, NC_LONG, 1, dim)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to create node sets property array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* store property name as attribute of property array variable */ if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 3, "ID")) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store node set property name %s in file id %d", "ID",exoid); ex_err("ex_put_init",errmsg,exerrval); return (EX_FATAL); } } /* side set id array: */ ssetdim = 0; if (num_side_sets > 0) { if ((ssetdim = ncdimdef (exoid, DIM_NUM_SS, (long)num_side_sets)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of side sets in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* side set id status array: */ dim[0] = ssetdim; if ((varid = ncvardef (exoid, VAR_SS_STAT, NC_LONG, 1, dim)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define side set status in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } #if 0 /* store property name as attribute of property array variable */ if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 7, "STATUS")) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store side set property name %s in file id %d", "ID",exoid); ex_err("ex_put_init",errmsg,exerrval); return (EX_FATAL); } #endif /* side set id array: */ if ((varid = ncvardef (exoid, VAR_SS_IDS, NC_LONG, 1, dim)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define side set property in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* store property name as attribute of property array variable */ if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 3, "ID")) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store side set property name %s in file id %d", "ID",exoid); ex_err("ex_put_init",errmsg,exerrval); return (EX_FATAL); } } /* * To reduce the maximum dataset sizes, the storage of the nodal * coordinates and the nodal variables was changed from a single * dataset to a dataset per component or variable. However, we * want to maintain some form of compatability with the old * exodusII version. It is easy to do this on read; however, we * also want to be able to store in the old format using the new * library. * * The mode is set in the ex_create call. The setting can be checked * via the ATT_FILESIZE attribute in the file (1=large, * 0=normal). Also handle old files that do not contain this * attribute. */ if (num_nodes > 0) { if (ex_large_model(exoid) == 1) { /* node coordinate arrays -- separate storage... */ /* * Check that storage required for coordinates is less * than 2GB which is maximum size permitted by netcdf * (in large file mode). 1<<29 == max number of integer items. */ int shift = nc_flt_code(exoid) == NC_DOUBLE ? 28 : 29; if (num_nodes > (1<<shift)) { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Size to store nodal coordinates exceeds 2GB in file id %d", exoid); ex_err("ex_put_init",errmsg,exerrval); return (EX_FATAL); } dim[0] = numnoddim; if (num_dim > 0) { if (ncvardef (exoid, VAR_COORD_X, nc_flt_code(exoid), 1, dim) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define node x coordinate array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } if (num_dim > 1) { if (ncvardef (exoid, VAR_COORD_Y, nc_flt_code(exoid), 1, dim) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define node y coordinate array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } if (num_dim > 2) { if (ncvardef (exoid, VAR_COORD_Z, nc_flt_code(exoid), 1, dim) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define node z coordinate array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } } else { /* node coordinate arrays: -- all stored together (old method) */ dim[0] = numdimdim; dim[1] = numnoddim; if (ncvardef (exoid, VAR_COORD, nc_flt_code(exoid), 2, dim) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define node coordinate array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } } /* inquire previously defined dimensions */ if ((strdim = ncdimid (exoid, DIM_STR)) < 0) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get string length in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* coordinate names array */ dim[0] = numdimdim; dim[1] = strdim; if (ncvardef (exoid, VAR_NAME_COOR, NC_CHAR, 2, dim) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define coordinate name array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* Element block names... */ if (num_elem_blk > 0) { dim[0] = elblkdim; dim[1] = strdim; if (ncvardef (exoid, VAR_NAME_EL_BLK, NC_CHAR, 2, dim) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define element block name array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } /* Nodeset names... */ if (num_node_sets > 0) { dim[0] = nsetdim; dim[1] = strdim; if (ncvardef (exoid, VAR_NAME_NS, NC_CHAR, 2, dim) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define nodeset name array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } /* Sideset names... */ if (num_side_sets > 0) { dim[0] = ssetdim; dim[1] = strdim; if (ncvardef (exoid, VAR_NAME_SS, NC_CHAR, 2, dim) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define sideset name array in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } /* leave define mode */ #if 1 if (ncendef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to complete variable definitions in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); return (EX_FATAL); } #else /* estimate (guess) size of header of netCDF file */ header_size = 1200 + num_elem_blk * 800 + num_node_sets * 220 + num_side_sets * 300; if (header_size > MAX_HEADER_SIZE) header_size = MAX_HEADER_SIZE; /* estimate (guess) size of fixed size variable section of netCDF file */ if (nc_flt_code(exoid) == NC_DOUBLE) iows = 8; else iows = 4; fixed_var_size = num_dim * num_nodes * iows + num_nodes * sizeof(int) + num_elem * 16 * sizeof(int) + num_elem_blk * sizeof(int) + num_node_sets * num_nodes/100 * sizeof(int) + num_node_sets * num_nodes/100 * iows + num_node_sets * sizeof(int) + num_side_sets * num_elem/100 * 2 * sizeof(int) + num_side_sets * num_elem/100 * iows + num_side_sets * sizeof(int); /* With netcdf-3.4, this produces very large files on the * SGI. Also with netcdf-3.5beta3 */ /* * This is also causing other problems on other systems .. disable for now */ if (nc__enddef (exoid, header_size, NC_ALIGN_CHUNK, fixed_var_size, NC_ALIGN_CHUNK) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to complete variable definitions in file id %d",exoid); ex_err("ex_put_init",errmsg,exerrval); return (EX_FATAL); } #endif 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_init",errmsg,exerrval); } return (EX_FATAL); }
int ex_put_all_var_param (int exoid, int num_g, int num_n, int num_e, int *elem_var_tab, int num_m, int *nset_var_tab, int num_s, int *sset_var_tab) { int in_define = 0; int time_dim, num_nod_dim, dimid, iresult; long num_elem_blk, num_nset, num_sset; int numelblkdim, numelvardim, numnsetdim, nsetvardim, numssetdim, ssetvardim; int i; int eblk_varid, nset_varid, sset_varid; int *eblk_ids = 0; int *nset_ids = 0; int *sset_ids = 0; nclong *eblk_stat = 0; nclong *nset_stat = 0; nclong *sset_stat = 0; int dims[3]; char errmsg[MAX_ERR_LENGTH]; const char* routine = "ex_put_all_var_param"; exerrval = 0; /* clear error code */ /* inquire previously defined dimensions */ if ((time_dim = ncdimid (exoid, DIM_TIME)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate time dimension in file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; } if ((num_nod_dim = ncdimid (exoid, DIM_NUM_NODES)) == -1) { if (num_n > 0) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate number of nodes in file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; } } /* Check this now so we can use it later without checking for errors */ if (ncdimid (exoid, DIM_STR) < 0) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get string length in file id %d",exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; } if (num_e > 0) { numelblkdim = ex_get_dimension(exoid, DIM_NUM_EL_BLK, "element blocks", &num_elem_blk, routine); if (numelblkdim == -1) goto error_ret; /* get element block IDs */ if (!(eblk_ids = static_cast<int*>(malloc(num_elem_blk*sizeof(int))))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate memory for element block id array for file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; } ex_get_elem_blk_ids (exoid, eblk_ids); /* Get element block status array for later use (allocates memory) */ eblk_stat = get_status_array(exoid, num_elem_blk, VAR_STAT_EL_BLK, "element block"); if (eblk_stat == NULL) { goto error_ret; } } if (num_m > 0) { numnsetdim = ex_get_dimension(exoid, DIM_NUM_NS, "nodesets", &num_nset, routine); if (numnsetdim == -1) goto error_ret; /* get nodeset IDs */ if (!(nset_ids = static_cast<int*>(malloc(num_nset*sizeof(int))))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate memory for nodeset id array for file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; } ex_get_node_set_ids (exoid, nset_ids); /* Get nodeset status array for later use (allocates memory) */ nset_stat = get_status_array(exoid, num_nset, VAR_NS_STAT, "nodeset"); if (nset_stat == NULL) { goto error_ret; } } if (num_s > 0) { numssetdim = ex_get_dimension(exoid, DIM_NUM_SS, "sidesets", &num_sset, routine); if (numssetdim == -1) goto error_ret; /* get sideset IDs */ if (!(sset_ids = static_cast<int*>(malloc(num_sset*sizeof(int))))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate memory for sideset id array for file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; } ex_get_side_set_ids (exoid, sset_ids); /* Get sideset status array for later use (allocates memory) */ sset_stat = get_status_array(exoid, num_sset, VAR_SS_STAT, "sideset"); if (sset_stat == NULL) { goto error_ret; } } /* put file into define mode */ if (ncredef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to put file id %d into define mode", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; } in_define = 1; /* define dimensions and variables */ if (num_g > 0) { dimid = define_dimension(exoid, DIM_NUM_GLO_VAR, num_g, "global"); if (dimid == -1) goto error_ret; dims[0] = time_dim; dims[1] = dimid; if ((ncvardef (exoid, VAR_GLO_VAR, nc_flt_code(exoid), 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define global variables in file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* Now define global variable name variable */ if (define_variable_name_variable(exoid, VAR_NAME_GLO_VAR, dimid, "global") == -1) goto error_ret; } if (num_n > 0) { /* * There are two ways to store the nodal variables. The old way * * was a blob (#times,#vars,#nodes), but that was exceeding the * netcdf maximum dataset size for large models. The new way is * to store #vars separate datasets each of size (#times,#nodes) * * We want this routine to be capable of storing both formats * based on some external flag. Since the storage format of the * coordinates have also been changed, we key off of their * storage type to decide which method to use for nodal * variables. If the variable 'coord' is defined, then store old * way; otherwise store new. */ dimid = define_dimension(exoid, DIM_NUM_NOD_VAR, num_n, "nodal"); if (dimid == -1) goto error_ret; if (ex_large_model(exoid) == 0) { /* Old way */ dims[0] = time_dim; dims[1] = dimid; dims[2] = num_nod_dim; if ((ncvardef (exoid, VAR_NOD_VAR, nc_flt_code(exoid), 3, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define nodal variables in file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } else { /* Store new way */ for (i = 1; i <= num_n; i++) { dims[0] = time_dim; dims[1] = num_nod_dim; if ((ncvardef (exoid, VAR_NOD_VAR_NEW(i), nc_flt_code(exoid), 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define nodal variable %d in file id %d", i, exoid); ex_err("ex_put_var_param",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } } /* Now define nodal variable name variable */ if (define_variable_name_variable(exoid, VAR_NAME_NOD_VAR, dimid, "nodal") == -1) goto error_ret; } if (num_e > 0) { numelvardim = define_dimension(exoid, DIM_NUM_ELE_VAR, num_e, "element"); if (numelvardim == -1) goto error_ret; /* Now define element variable name variable */ if (define_variable_name_variable(exoid, VAR_NAME_ELE_VAR, numelvardim, "element") == -1) goto error_ret; if (define_truth_table('e', exoid, num_elem_blk, num_e, elem_var_tab, eblk_stat, eblk_ids, "element block") == -1) goto error_ret; eblk_stat = static_cast<nclong*>(safe_free (eblk_stat)); eblk_ids = static_cast<int*>( safe_free (eblk_ids)); /* create a variable array in which to store the element variable truth * table */ dims[0] = numelblkdim; dims[1] = numelvardim; if ((eblk_varid = ncvardef (exoid, VAR_ELEM_TAB, NC_LONG, 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define element variable truth table in file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } if (num_m > 0) { nsetvardim = define_dimension(exoid, DIM_NUM_NSET_VAR, num_m, "nodeset"); if (nsetvardim == -1) goto error_ret; /* Now define nodeset variable name variable */ if (define_variable_name_variable(exoid, VAR_NAME_NSET_VAR, nsetvardim, "nodeset") == -1) goto error_ret; if (define_truth_table('m', exoid, num_nset, num_m, nset_var_tab, nset_stat, nset_ids, "nodeset") == -1) goto error_ret; nset_stat = static_cast<nclong*>(safe_free (nset_stat)); nset_ids = static_cast<int*>(safe_free (nset_ids)); /* create a variable array in which to store the truth table */ dims[0] = numnsetdim; dims[1] = nsetvardim; if ((nset_varid = ncvardef (exoid, VAR_NSET_TAB, NC_LONG, 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define nodeset variable truth table in file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } if (num_s > 0) { ssetvardim = define_dimension(exoid, DIM_NUM_SSET_VAR, num_s, "sideset"); if (ssetvardim == -1) goto error_ret; /* Now define sideset variable name variable */ if (define_variable_name_variable(exoid, VAR_NAME_SSET_VAR, ssetvardim, "sideset") == -1) goto error_ret; if (define_truth_table('s', exoid, num_sset, num_s, sset_var_tab, sset_stat, sset_ids, "sideset") == -1) goto error_ret; sset_stat = static_cast<nclong*>(safe_free (sset_stat)); sset_ids = static_cast<int*>(safe_free (sset_ids)); /* create a variable array in which to store the truth table */ dims[0] = numssetdim; dims[1] = ssetvardim; if ((sset_varid = ncvardef (exoid, VAR_SSET_TAB, NC_LONG, 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define sideset variable truth table in file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } /* leave define mode */ in_define = 0; if (ncendef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to complete definition in file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); goto error_ret; } /* write out the variable truth tables */ if (num_e > 0) { iresult = put_truth_table(exoid, num_elem_blk, num_e, eblk_varid, elem_var_tab, "element"); if (iresult == -1) goto error_ret; } if (num_m > 0) { iresult = put_truth_table(exoid, num_nset, num_m, nset_varid, nset_var_tab, "nodeset"); if (iresult == -1) goto error_ret; } if (num_s > 0) { iresult = put_truth_table(exoid, num_sset, num_s, sset_varid, sset_var_tab, "sideset"); if (iresult == -1) goto error_ret; } return(EX_NOERR); /* Fatal error: exit definition mode and return */ error_ret: if (in_define == 1) { if (ncendef (exoid) == -1) /* exit define mode */ { sprintf(errmsg, "Error: failed to complete definition for file id %d", exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); } } safe_free(eblk_ids); safe_free(nset_ids); safe_free(sset_ids); safe_free(eblk_stat); safe_free(nset_stat); safe_free(sset_stat); return(EX_FATAL); }
int define_truth_table(char type, int exoid, int num_ent, int num_var, int *var_tab, int *status, int *ids, const char *label) { char errmsg[MAX_ERR_LENGTH]; int k = 0; int i, j; int time_dim; int dims[2]; int varid; time_dim = ncdimid (exoid, DIM_TIME); if (var_tab == NULL) { exerrval = EX_NULLENTITY; sprintf(errmsg, "Error: %s variable truth table is NULL in file id %d", label, exoid); ex_err("ex_put_all_var_param",errmsg, exerrval); return -1; } for (i=0; i<num_ent; i++) { for (j=1; j<=num_var; j++) { /* check if variables are to be put out for this block */ if (var_tab[k] != 0) { if (status[i] == 0) {/* check for NULL entity */ var_tab[k] = 0; #if 0 exerrval = EX_NULLENTITY; sprintf(errmsg, "Warning: %s variable truth table specifies invalid entry for NULL %s %d, variable %d in file id %d", label, label, ids[i], j, exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); #endif } else { dims[0] = time_dim; /* Determine number of entities in entity */ /* Need way to make this more generic... */ if (type == 'e') dims[1] = ncdimid (exoid, DIM_NUM_EL_IN_BLK(i+1)); else if (type == 'm') dims[1] = ncdimid (exoid, DIM_NUM_NOD_NS(i+1)); else if (type == 's') dims[1] = ncdimid (exoid, DIM_NUM_SIDE_SS(i+1)); if (dims[1] == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate number of entities in %s %d in file id %d", label, ids[i], exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); return -1; } /* define netCDF variable to store variable values; * the j index cycles from 1 through the number of variables so * that the index of the EXODUS II variable (which is part of * the name of the netCDF variable) will begin at 1 instead of 0 */ if (type == 'e') varid = ncvardef(exoid, VAR_ELEM_VAR(j,i+1), nc_flt_code(exoid), 2, dims); else if (type == 'm') varid = ncvardef(exoid, VAR_NS_VAR(j,i+1), nc_flt_code(exoid), 2, dims); else if (type == 's') varid = ncvardef(exoid, VAR_SS_VAR(j,i+1), nc_flt_code(exoid), 2, dims); if (varid == -1) { if (ncerr != NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define %s variable for %s %d in file id %d", label, label, ids[i], exoid); ex_err("ex_put_all_var_param",errmsg,exerrval); return -1; } } } } /* if */ k++; /* increment truth table pointer */ } /* for j */ } /* for i */ return 0; }
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); }
static void define_variable(const int netcdf_unit, const char *name_string, const nc_type netcdf_type, const int num_dimensions, const int dimension_id_1, const int dimension_id_2, const int dimension_val_1, const int dimension_val_2, int *identifier) { int err; char err_msg[MAX_CHAR_ERR_MSG]; #ifdef NETCDF_3 int dim[NC_MAX_VAR_DIMS]; #endif #ifdef NETCDF_2 int tim[NC_MAX_VAR_DIMS]; /* This is ludicrous... */ long dim[NC_MAX_VAR_DIMS]; #endif if ( num_dimensions < 0 ) { EH(-1, "Bad dimension specified."); } if ( num_dimensions > 0 ) { if ( dimension_id_1 < 0 ) { return; /* Do not even create a variable. */ /* sprintf(err_msg, "Bad 1st netCDF dimension ID %d for %s\n", dimension_id_1, name_string); EH(-1, err_msg); */ } if ( dimension_val_1 < 1 ) { return; } } if ( num_dimensions > 1 ) { if ( dimension_id_2 < 0 ) { sprintf(err_msg, "Bad 2nd netCDF dimension ID %d for %s\n", dimension_id_1, name_string); EH(-1, err_msg); } if ( dimension_val_2 < 1 ) { return; } } dim[0] = MAX(dimension_id_1, 1); dim[1] = MAX(dimension_id_2, 1); #ifdef NETCDF_3 err = nc_def_var(netcdf_unit, name_string, netcdf_type, num_dimensions, dim, identifier); if ( err != NC_NOERR ) { sprintf(err_msg, "nc_def_var on %s (%d-D) id=%d", name_string, num_dimensions, *identifier); EH(-1, err_msg); } #endif #ifdef NETCDF_2 for ( i=0; i<num_dimensions; i++ ) { tim[i] = dim[i]; } err = ncvardef(netcdf_unit, name_string, netcdf_type, num_dimensions, tim); sprintf(err_msg, "ncvardef on %s (%d-D) id=%d", name_string, num_dimensions, err); EH(err, err_msg); *identifier = err; #endif return; }
/* ----------------------------- 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); }
int ex_put_block( int exoid, int blk_type, int blk_id, const char* entry_descrip, int num_entries_this_blk, int num_nodes_per_entry, int num_edges_per_entry, int num_faces_per_entry, int num_attr_per_entry ) { int varid, dimid, dims[2], blk_id_ndx, blk_stat, strdim; long start[2], num_blk; nclong ldum; int cur_num_blk, numblkdim, numattrdim; int nnodperentdim, nedgperentdim = -1, nfacperentdim = -1; int connid, econnid, fconnid; char *cdum; char errmsg[MAX_ERR_LENGTH]; const char* tname; const char* dnumblk; const char* vblkids; const char* vblksta; const char* vnodcon = 0; const char* vedgcon = 0; const char* vfaccon = 0; const char* vattnam = 0; const char* vblkatt = 0; const char* dneblk = 0; const char* dnape = 0; const char* dnnpe = 0; const char* dnepe = 0; const char* dnfpe = 0; struct list_item** ctr_list; exerrval = 0; /* clear error code */ cdum = 0; switch (blk_type) { case EX_EDGE_BLOCK: tname = "edge"; dnumblk = DIM_NUM_ED_BLK; vblkids = VAR_ID_ED_BLK; vblksta = VAR_STAT_ED_BLK; ctr_list = &ed_ctr_list; break; case EX_FACE_BLOCK: tname = "face"; dnumblk = DIM_NUM_FA_BLK; vblkids = VAR_ID_FA_BLK; vblksta = VAR_STAT_FA_BLK; ctr_list = &fa_ctr_list; break; case EX_ELEM_BLOCK: tname = "element"; dnumblk = DIM_NUM_EL_BLK; vblkids = VAR_ID_EL_BLK; vblksta = VAR_STAT_EL_BLK; ctr_list = &eb_ctr_list; break; default: exerrval = EX_BADPARAM; sprintf( errmsg, "Error: Bad block type (%d) specified for file id %d", blk_type, exoid ); ex_err( "ex_put_block", errmsg, exerrval ); return (EX_FATAL); } /* first check if any element blocks are specified */ if ((dimid = (ncdimid (exoid, dnumblk))) == -1 ) { exerrval = ncerr; sprintf(errmsg, "Error: no element blocks defined in file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* Get number of element blocks defined for this file */ if ((ncdiminq (exoid,dimid,cdum,&num_blk)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of element blocks in file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* Next: Make sure that this is not a duplicate element block id by searching the vblkids array. WARNING: This must be done outside of define mode because id_lkup accesses the database to determine the position */ if ((varid = ncvarid (exoid, vblkids)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate element block ids in file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); } blk_id_ndx = ex_id_lkup(exoid,vblkids,blk_id); if (exerrval != EX_LOOKUPFAIL) /* found the element block id */ { exerrval = EX_FATAL; sprintf(errmsg, "Error: element block id %d already exists in file id %d", blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* Keep track of the total number of element blocks defined using a counter stored in a linked list keyed by exoid. NOTE: ex_get_file_item is a function that finds the number of element blocks for a specific file and returns that value incremented. */ cur_num_blk=ex_get_file_item(exoid, ctr_list); if (cur_num_blk >= num_blk) { exerrval = EX_FATAL; sprintf(errmsg, "Error: exceeded number of element blocks (%ld) defined in file id %d", num_blk,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* NOTE: ex_get_file_item is a function that finds the number of element blocks for a specific file and returns that value incremented. */ cur_num_blk=ex_inc_file_item(exoid, ctr_list); start[0] = (long)cur_num_blk; /* write out element block id to previously defined id array variable*/ ldum = (nclong)blk_id; if (ncvarput1 (exoid, varid, start, &ldum) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store element block id to file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } blk_id_ndx = start[0]+1; /* element id index into vblkids array*/ if (num_entries_this_blk == 0) /* Is this a NULL element block? */ blk_stat = 0; /* change element block status to NULL */ else blk_stat = 1; /* change element block status to TRUE */ if ((varid = ncvarid (exoid, vblksta)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate element block status in file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } ldum = (nclong)blk_stat; if (ncvarput1 (exoid, varid, start, &ldum) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store element id %d status to file id %d", blk_id, exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } if (num_entries_this_blk == 0) /* Is this a NULL element block? */ { return(EX_NOERR); } /* * Check that storage required for connectivity array is less * than 2GB which is maximum size permitted by netcdf * (in large file mode). 1<<29 == max number of integer items. */ if (num_entries_this_blk * num_nodes_per_entry > (1<<29)) { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Size to store connectivity for element block %d exceeds 2GB in file id %d", blk_id, exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* 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_elem_block",errmsg,exerrval); return (EX_FATAL); } switch (blk_type) { case EX_EDGE_BLOCK: dneblk = DIM_NUM_ED_IN_EBLK(blk_id_ndx); dnnpe = DIM_NUM_NOD_PER_ED(blk_id_ndx); dnepe = 0; dnfpe = 0; dnape = DIM_NUM_ATT_IN_EBLK(blk_id_ndx); vblkatt = VAR_EATTRIB(blk_id_ndx); vattnam = VAR_NAME_EATTRIB(blk_id_ndx); vnodcon = VAR_EBCONN(blk_id_ndx); vedgcon = 0; vfaccon = 0; break; case EX_FACE_BLOCK: dneblk = DIM_NUM_FA_IN_FBLK(blk_id_ndx); dnnpe = DIM_NUM_NOD_PER_FA(blk_id_ndx); dnepe = 0; dnfpe = 0; dnape = DIM_NUM_ATT_IN_FBLK(blk_id_ndx); vblkatt = VAR_FATTRIB(blk_id_ndx); vattnam = VAR_NAME_FATTRIB(blk_id_ndx); vnodcon = VAR_FBCONN(blk_id_ndx); vedgcon = 0; vfaccon = 0; break; case EX_ELEM_BLOCK: dneblk = DIM_NUM_EL_IN_BLK(blk_id_ndx); dnnpe = DIM_NUM_NOD_PER_EL(blk_id_ndx); dnepe = DIM_NUM_EDG_PER_EL(blk_id_ndx); dnfpe = DIM_NUM_FAC_PER_EL(blk_id_ndx); dnape = DIM_NUM_ATT_IN_BLK(blk_id_ndx); vblkatt = VAR_ATTRIB(blk_id_ndx); vattnam = VAR_NAME_ATTRIB(blk_id_ndx); vnodcon = VAR_CONN(blk_id_ndx); vedgcon = VAR_ECONN(blk_id_ndx); vfaccon = VAR_FCONN(blk_id_ndx); break; } /* define some dimensions and variables*/ if ((numblkdim = ncdimdef (exoid,dneblk,(long)num_entries_this_blk)) == -1) { if (ncerr == NC_ENAMEINUSE) /* duplicate entry */ { exerrval = ncerr; sprintf(errmsg, "Error: element block %d already defined in file id %d", blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of elements/block for block %d file id %d", blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } if ((nnodperentdim = ncdimdef (exoid,dnnpe,(long)num_nodes_per_entry)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of nodes/element for block %d in file id %d", blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } if ( dnepe && num_edges_per_entry > 0 ) { if ((nedgperentdim = ncdimdef (exoid,dnepe,(long)num_edges_per_entry)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of edges/element for block %d in file id %d", blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } if ( dnfpe && num_faces_per_entry > 0 ) { if ((nfacperentdim = ncdimdef (exoid,dnfpe,(long)num_faces_per_entry)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of faces/element for block %d in file id %d", blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } /* element attribute array */ if (num_attr_per_entry > 0) { if ((numattrdim = ncdimdef (exoid, dnape, (long)num_attr_per_entry)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of attributes in block %d in file id %d", blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } dims[0] = numblkdim; dims[1] = numattrdim; if ((ncvardef (exoid, vblkatt, nc_flt_code(exoid), 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define attributes for element block %d in file id %d", blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* inquire previously defined dimensions */ if ((strdim = ncdimid (exoid, DIM_STR)) < 0) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get string length in file id %d",exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } /* Attribute names... */ dims[0] = numattrdim; dims[1] = strdim; if (ncvardef (exoid, vattnam, NC_CHAR, 2, dims) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to define element attribute name array in file id %d",exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } /* element connectivity array */ dims[0] = numblkdim; dims[1] = nnodperentdim; if ((connid = ncvardef (exoid, vnodcon, NC_LONG, 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to create connectivity array for block %d in file id %d", blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* store element type as attribute of connectivity variable */ if ((ncattput (exoid, connid, ATT_NAME_ELB, NC_CHAR, strlen(entry_descrip)+1, (void*) entry_descrip)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store element type name %s in file id %d", entry_descrip,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } if ( vedgcon && num_edges_per_entry ) { dims[0] = numblkdim; dims[1] = nedgperentdim; if ((econnid = ncvardef (exoid, vedgcon, NC_LONG, 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to create edge connectivity array for block %d in file id %d", blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } if ( vfaccon && num_faces_per_entry ) { dims[0] = numblkdim; dims[1] = nfacperentdim; if ((fconnid = ncvardef (exoid, vfaccon, NC_LONG, 2, dims)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to create face connectivity array for block %d in file id %d", blk_id,exoid); ex_err("ex_put_elem_block",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } /* leave define mode */ if (ncendef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to complete element block definition in file id %d", exoid); ex_err("ex_put_elem_block",errmsg,exerrval); return (EX_FATAL); } 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_elem_block",errmsg,exerrval); } return (EX_FATAL); }
/* Test case 1 - file creation & definition. */ static int test1(struct testinfo *ip, struct dimdef *dims, int ndims) { int varid; int stat; int i; /* Test case #1 - file creation */ ip->name = micreate_tempfile(); if (ip->name == NULL) { FUNC_ERROR("micreate_tempfile\n"); } ip->fd = micreate(ip->name, NC_CLOBBER); if (ip->fd < 0) { FUNC_ERROR("micreate"); } /* Have to use ncdimdef() here since there is no MINC equivalent. Sigh. */ for (i = 0; i < ndims; i++) { /* Define the dimension */ ip->dim[i] = ncdimdef(ip->fd, dims[i].name, dims[i].length); if (ip->dim[i] < 0) { FUNC_ERROR("ncdimdef"); } /* Create the dimension variable. */ varid = micreate_std_variable(ip->fd, dims[i].name, NC_DOUBLE, 0, &ip->dim[i]); if (varid < 0) { FUNC_ERROR("micreate_std_variable"); } stat = miattputdbl(ip->fd, varid, MIstep, 0.8); if (stat < 0) { FUNC_ERROR("miattputdbl"); } stat = miattputdbl(ip->fd, varid, MIstart, 22.0); if (stat < 0) { FUNC_ERROR("miattputdbl"); } } /* Create the image-max variable. */ ip->maxid = micreate_std_variable(ip->fd, MIimagemax, NC_FLOAT, 0, NULL); if (ip->maxid < 0) { FUNC_ERROR("micreate_std_variable"); } /* Create the image-min variable. */ ip->minid = micreate_std_variable(ip->fd, MIimagemin, NC_FLOAT, 0, NULL); if (ip->minid < 0) { FUNC_ERROR("micreate_std_variable"); } ip->imgid = micreate_std_variable(ip->fd, MIimage, NC_INT, ndims, ip->dim); if (ip->imgid < 0) { FUNC_ERROR("micreate_std_variable"); } ip->test_group = ncvardef(ip->fd,(char*)"test",NC_INT,0,0);/* micreate_group_variable(ip->fd,(char*)"test");*/ if(ip->test_group<0) { FUNC_ERROR("micreate_group_variable"); } ip->large_attribute=calloc(ip->attribute_size,sizeof(char)); memset(ip->large_attribute,'X',ip->attribute_size-1); ip->test_attribute = ncattput(ip->fd, ip->test_group, "test", NC_CHAR, ip->attribute_size, ip->large_attribute); return (0); }
int ex_put_node_set_param (int exoid, int node_set_id, int num_nodes_in_set, int num_dist_in_set) { int dimid, varid, dims[1]; long start[1]; nclong ldum; long num_node_sets; int cur_num_node_sets, node_set_stat; char *cdum; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ cdum = 0; /* first check if any node sets are specified */ if ((dimid = (ncdimid (exoid, DIM_NUM_NS))) == -1 ) { exerrval = ncerr; sprintf(errmsg, "Error: no node sets specified in file id %d", exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); return (EX_FATAL); } /* Check for duplicate node set id entry */ ex_id_lkup(exoid,VAR_NS_IDS,node_set_id); if (exerrval != EX_LOOKUPFAIL) /* found the node set id */ { exerrval = ncerr; sprintf(errmsg, "Error: node set %d already defined in file id %d", node_set_id,exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); return(EX_FATAL); } /* Get number of node sets initialized for this file */ if ((ncdiminq (exoid,dimid,cdum,&num_node_sets)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of node sets in file id %d", exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); return (EX_FATAL); } /* Keep track of the total number of node sets defined using a counter stored in a linked list keyed by exoid. NOTE: ex_get_file_item is used to find the number of node sets for a specific file and returns that value. */ cur_num_node_sets=ex_get_file_item(exoid, &ns_ctr_list ); if (cur_num_node_sets >= num_node_sets) { exerrval = EX_FATAL; sprintf(errmsg, "Error: exceeded number of node sets (%ld) specified in file id %d", num_node_sets,exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); return (EX_FATAL); } /* NOTE: ex_inc_file_item is used to find the number of node sets for a specific file and returns that value incremented. */ cur_num_node_sets=ex_inc_file_item(exoid, &ns_ctr_list ); /* write out information to previously defined variable */ /* first get id of variable */ if ((varid = ncvarid (exoid, VAR_NS_IDS)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate node set ids in file id %d", exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); return (EX_FATAL); } /* then, write out node set id */ start[0] = cur_num_node_sets; ldum = (nclong)node_set_id; if (ncvarput1 (exoid, varid, start, &ldum) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store node set id %d in file id %d", node_set_id,exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); return (EX_FATAL); } if (num_nodes_in_set == 0) /* Is this a NULL side set? */ node_set_stat = 0; /* change node set status to NULL */ else node_set_stat = 1; /* change node set status to TRUE */ if ((varid = ncvarid (exoid, VAR_NS_STAT)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate node set status in file id %d", exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); return (EX_FATAL); } ldum = (nclong)node_set_stat; if (ncvarput1 (exoid, varid, start, &ldum) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store node set %d status to file id %d", node_set_id, exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); return (EX_FATAL); } if (num_nodes_in_set == 0) /* Is this a NULL side set? */ { return(EX_NOERR); } /* put netcdf file into define mode */ if (ncredef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to put file id %d into define mode", exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); return (EX_FATAL); } if ((dimid = ncdimdef (exoid, DIM_NUM_NOD_NS(cur_num_node_sets+1), (long)num_nodes_in_set)) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: node set %d size already defined in file id %d", node_set_id,exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of nodes for set %d in file id %d", node_set_id,exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); } goto error_ret; } /* create variable array in which to store the node set node list */ dims[0] = dimid; if (ncvardef(exoid, VAR_NODE_NS(cur_num_node_sets+1), NC_LONG,1,dims) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: node set %d node list already defined in file id %d", node_set_id,exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to create node set %d node list in file id %d", node_set_id,exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } /* Create distribution factors variable if required */ if (num_dist_in_set > 0) { /* num_dist_in_set should equal num_nodes_in_set */ if (num_dist_in_set != num_nodes_in_set) { exerrval = EX_FATAL; sprintf(errmsg, "Error: # dist fact (%d) not equal to # nodes (%d) in node set %d file id %d", num_dist_in_set, num_nodes_in_set, node_set_id,exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } else { /* create variable for distribution factors */ if (ncvardef (exoid, VAR_FACT_NS(cur_num_node_sets+1), nc_flt_code(exoid), 1, dims) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: node set %d dist factors already exist in file id %d", node_set_id,exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to create node set %d dist factors in file id %d", node_set_id,exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } } } /* leave define mode */ if (ncendef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to complete definition in file id %d", exoid); ex_err("ex_put_node_set_param",errmsg,exerrval); return (EX_FATAL); } 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_node_set_param",errmsg,exerrval); } return (EX_FATAL); }
int ex_put_concat_side_sets (int exoid, const int *side_set_ids, const int *num_elem_per_set, const int *num_dist_per_set, const int *side_sets_elem_index, const int *side_sets_dist_index, const int *side_sets_elem_list, const int *side_sets_side_list, const void *side_sets_dist_fact) { char *cdum; int i, num_side_sets, cur_num_side_sets, dimid, varid, dims[1], *ss_stat; int iresult; long start[1], count[1]; nclong *lptr; float fdum; const float *flt_dist_fact; const double *dbl_dist_fact; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ cdum = 0; /* initialize even though it is not used */ /* first check if any side sets are specified */ if (ncdimid (exoid, DIM_NUM_SS) == -1) { if (ncerr == NC_EBADDIM) { exerrval = ncerr; sprintf(errmsg, "Error: no side sets defined for file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate side sets defined in file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } return (EX_FATAL); } /* inquire how many side sets are to be stored */ if (ex_inquire(exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum) == -1) { sprintf(errmsg, "Error: failed to get number of side sets defined for file id %d", exoid); /* use error val from inquire */ ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } /* fill out side set status array */ /* First, allocate space for the side set status list */ if (!(ss_stat= malloc(num_side_sets*sizeof(int)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set status array in file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } for (i=0;i<num_side_sets;i++) { if (num_elem_per_set[i] == 0) /* Is this a NULL side set? */ ss_stat[i] = 0; /* change side set status to NULL */ else ss_stat[i] = 1; /* change side set status to TRUE */ } /* Next, get variable id of status array */ if ((varid = ncvarid (exoid, VAR_SS_STAT)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate side set status in file id %d", exoid); ex_err("ex_put_concat_node_set",errmsg,exerrval); return (EX_FATAL); } /* 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_side_sets; if (sizeof(int) == sizeof(nclong)) { iresult = ncvarput (exoid, varid, start, count, ss_stat); } else { lptr = itol (ss_stat, num_side_sets); iresult = ncvarput (exoid, varid, start, count, lptr); free(lptr); } if (iresult == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store side set status array to file id %d", exoid); ex_err("ex_put_concat_side_set",errmsg,exerrval); return (EX_FATAL); } free(ss_stat); /* put netcdf file into define mode */ if (ncredef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to put file id %d into define mode", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } /* create side set definitions */ for (i=0; i<num_side_sets; i++) { /* Keep track of the total number of side sets defined using a counter stored in a linked list keyed by exoid. NOTE: ex_get_file_item is used to find the number of side sets for a specific file and returns that value. */ cur_num_side_sets=ex_get_file_item(exoid, &ss_ctr_list ); if (cur_num_side_sets >= num_side_sets) { exerrval = EX_FATAL; sprintf(errmsg, "Error: exceeded number of side sets (%d) defined in file id %d", num_side_sets,exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); goto error_ret; } /* NOTE: ex_inc_file_item is used to find the number of side sets for a specific file and returns that value incremented. */ cur_num_side_sets=ex_inc_file_item(exoid, &ss_ctr_list ); /* define dimension for number of sides/elements per side set */ if (num_elem_per_set[i] == 0) /* Is this a NULL side set? */ continue; /* Do not create anything for NULL side sets! */ if ((dimid = ncdimdef (exoid, DIM_NUM_SIDE_SS(cur_num_side_sets+1), (long)num_elem_per_set[i])) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: side set side count %d already defined in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of sides for set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } goto error_ret; } /* create element list variable for side set */ dims[0] = dimid; if (ncvardef (exoid,VAR_ELEM_SS(cur_num_side_sets+1),NC_LONG,1,dims) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: element list already exists for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to create element list for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } /* create side list variable for side set */ if (ncvardef (exoid,VAR_SIDE_SS(cur_num_side_sets+1),NC_LONG,1,dims) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: side list already exists for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to create side list for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } /* define dimension for number of dist factors/nodes per side set */ /* NOTE: only define df count if the dist factors exist! */ if (num_dist_per_set[i] > 0) { if ((dimid = ncdimdef (exoid, DIM_NUM_DF_SS(cur_num_side_sets+1), (long)num_dist_per_set[i])) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: side set df count %d already defined in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to define side set df count for set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } goto error_ret; } /* create distribution factor list variable for side set */ dims[0] = dimid; if (ncvardef (exoid, VAR_FACT_SS(cur_num_side_sets+1), nc_flt_code(exoid), 1, dims) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: dist factor list already exists for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to create dist factor list for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } } /* end define dist factors */ } /* leave define mode */ if (ncendef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to complete definition in file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } /* Next, fill out side set ids array */ /* first get id of side set ids array variable */ if ((varid = ncvarid (exoid, VAR_SS_IDS)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate side set ids array in file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } /* then, write out side set id list */ /* 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_side_sets; if (sizeof(int) == sizeof(nclong)) { iresult = ncvarput (exoid, varid, start, count, side_set_ids); } else { lptr = itol (side_set_ids, num_side_sets); iresult = ncvarput (exoid, varid, start, count, lptr); free(lptr); } if (iresult == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store side set id array in file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } /* If the side_sets_elem_index is passed in as a NULL pointer, then * the user only wants us to define the sidesets and not populate * the data structures. */ if (side_sets_elem_index == 0) return(EX_NOERR); /* Now, use ExodusII call to store side sets */ for (i=0; i<num_side_sets; i++) { if (num_elem_per_set[i] == 0) /* Is this a NULL side set? */ continue; /* Do not create anything for NULL side sets! */ if (ex_comp_ws(exoid) == sizeof(float)) { flt_dist_fact = side_sets_dist_fact; if (ex_put_side_set(exoid, side_set_ids[i], &(side_sets_elem_list[side_sets_elem_index[i]]), &(side_sets_side_list[side_sets_elem_index[i]])) == -1) return(EX_FATAL); /* error will be reported by subroutine */ if (num_dist_per_set[i] > 0) /* store dist factors if required */ { if (ex_put_side_set_dist_fact(exoid, side_set_ids[i], &(flt_dist_fact[side_sets_dist_index[i]])) == -1) { sprintf(errmsg, "Error: failed to store side set %d dist factors for file id %d", side_set_ids[i],exoid); /* use error val from exodusII routine */ ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } } } else if (ex_comp_ws(exoid) == sizeof(double)) { dbl_dist_fact = side_sets_dist_fact; if (ex_put_side_set(exoid, side_set_ids[i], &(side_sets_elem_list[side_sets_elem_index[i]]), &(side_sets_side_list[side_sets_elem_index[i]])) == -1) return(EX_FATAL); /* error will be reported by subroutine */ if (num_dist_per_set[i] > 0) /* only store if they exist */ { if (ex_put_side_set_dist_fact(exoid, side_set_ids[i], &(dbl_dist_fact[side_sets_dist_index[i]])) == -1) { sprintf(errmsg, "Error: failed to store side set %d dist factors for file id %d", side_set_ids[i],exoid); /* use error val from exodusII routine */ ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } } } else { /* unknown floating point word size */ exerrval = EX_BADPARAM; sprintf(errmsg, "Error: unsupported floating point word size %d for file id %d", ex_comp_ws(exoid), exoid); ex_err("ex_put_concat_side_sets", errmsg, exerrval); return (EX_FATAL); } } 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_concat_side_sets",errmsg,exerrval); } return (EX_FATAL); }
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 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; }
int main(int argc, char **argv) { int cdf; int img, img2; int dim[MAX_VAR_DIMS]; long start[MAX_VAR_DIMS]; long count[MAX_VAR_DIMS]; double image[256*256]; int i, itype, jtype; int cflag = 0; char filename[256]; #if MINC2 if (argc == 2 && !strcmp(argv[1], "-2")) { cflag = MI2_CREATE_V2; } #endif /* MINC2 */ snprintf(filename, sizeof(filename), "test_minc_types-%d.mnc", getpid()); ncopts=NC_VERBOSE|NC_FATAL; for (itype=0; itype<ntypes; itype++) { for (jtype=0; jtype<ntypes; jtype++) { cdf=micreate(filename, NC_CLOBBER | cflag); count[2]=256; count[1]=20; count[0]=7; dim[2]=ncdimdef(cdf, MIzspace, count[2]); dim[1]=ncdimdef(cdf, MIxspace, count[1]); dim[0]=ncdimdef(cdf, MIyspace, count[0]); img=ncvardef(cdf, MIimage, types[itype].type, 1, dim); (void) miattputstr(cdf, img, MIsigntype, types[itype].sign); img2=ncvardef(cdf, "image2", types[jtype].type, 1, dim); (void) miattputstr(cdf, img2, MIsigntype, types[jtype].sign); image[0]=10.0; image[1]=2.0*(-FLT_MAX); image[2]=2.0*FLT_MAX; image[3]=3.2; image[4]=3.7; image[5]=(-3.2); image[6]=(-3.7); #if 0 for (j=0; j<count[0]; j++) { for (i=0; i<count[1]; i++) { ioff=(j*count[1]+i)*count[2]; for (k=0; k<count[2]; k++) image[ioff+k]=ioff+k+10; } } #endif (void) ncendef(cdf); (void) miset_coords(3,0L,start); (void) mivarput(cdf, img, start, count, NC_DOUBLE, NULL, image); (void) mivarget(cdf, img, start, count, types[jtype].type, types[jtype].sign, image); (void) mivarput(cdf, img2, start, count, types[jtype].type, types[jtype].sign, image); (void) mivarget(cdf, img2, start, count, NC_DOUBLE, NULL, image); (void) printf("Image 1 : %s %s\n",types[itype].sign, types[itype].ctype); (void) printf("Image 2 : %s %s\n",types[jtype].sign, types[jtype].ctype); for (i=0;i<count[0];i++) (void) printf(" image[%d] = %g\n",(int) i, image[i]); (void) miclose(cdf); } } unlink(filename); return(0); }
MNCAPI int minc_save_start(char *path, /* Path to the file */ int filetype, /* Date type as stored in the file */ long ct, /* Total length of time axis, in voxels */ long cz, /* Total length of Z axis, in voxels */ long cy, /* Total length of Y axis, in voxels */ long cx, /* Total length of X axis, in voxels */ double dt, /* Sample width along time axis, in seconds */ double dz, /* Sample width along Z axis, in mm */ double dy, /* Sample width along Y axis, in mm */ double dx, /* Sample width along X axis, in mm */ void *infoptr, /* Opaque file structure information */ const char *history) /* New history information */ { int fd; /* MINC file descriptor */ int dim_id[MI_S_NDIMS]; /* netCDF dimension ID array */ int var_ndims; /* Number of dimensions per variable */ int var_dims[MI_S_NDIMS]; /* Dimension ID's per variable */ int i, j; /* Generic loop counters */ int old_ncopts; /* For supressing fatal error messages */ struct file_info *p_file; /* For accessing the file structure */ struct var_info *p_var; struct att_info *p_att; int var_id; /* netCDF ID for variable */ char *signstr; nc_type nctype; old_ncopts =get_ncopts(); set_ncopts(0); fd = micreate(path, NC_CLOBBER); set_ncopts(old_ncopts); if (fd < 0) { return (MINC_STATUS_ERROR); } if (ct > 0) { dim_id[MI_S_T] = ncdimdef(fd, MItime, ct); micreate_std_variable(fd, MItime, NC_INT, 0, NULL); if (dt > 0.0) { miattputdbl(fd, ncvarid(fd, MItime), MIstep, dt); } } else { dim_id[MI_S_T] = -1; } if (cz > 0) { dim_id[MI_S_Z] = ncdimdef(fd, MIzspace, cz); micreate_std_variable(fd, MIzspace, NC_INT, 0, NULL); if (dz > 0.0) { miattputdbl(fd, ncvarid(fd, MIzspace), MIstep, dz); } } else { dim_id[MI_S_Z] = -1; } if (cy > 0) { dim_id[MI_S_Y] = ncdimdef(fd, MIyspace, cy); micreate_std_variable(fd, MIyspace, NC_INT, 0, NULL); if (dy > 0.0) { miattputdbl(fd, ncvarid(fd, MIyspace), MIstep, dy); } } else { return (MINC_STATUS_ERROR); /* Must define Y */ } if (cx > 0) { dim_id[MI_S_X] = ncdimdef(fd, MIxspace, cx); micreate_std_variable(fd, MIxspace, NC_INT, 0, NULL); if (dx > 0.0) { miattputdbl(fd, ncvarid(fd, MIxspace), MIstep, dx); } } else { return (MINC_STATUS_ERROR); /* Must define X */ } /* The var_dims[] array is the array of actual dimension ID's to * be used in defining the image variables. Here I set it up by * copying all valid dimension ID's from the dim_id[] array. */ var_ndims = 0; for (i = 0; i < MI_S_NDIMS; i++) { if (dim_id[i] >= 0) { var_dims[var_ndims] = dim_id[i]; var_ndims++; } } minc_simple_to_nc_type(filetype, &nctype, &signstr); /* Create the image variable with the standard * dimension order, and the same type as the template * file. */ micreate_std_variable(fd, MIimage, nctype, var_ndims, var_dims); micreate_std_variable(fd, MIimagemin, NC_DOUBLE, 1, var_dims); micreate_std_variable(fd, MIimagemax, NC_DOUBLE, 1, var_dims); /* Copy information from the infoptr to the output. */ if ((p_file = infoptr) != NULL) { old_ncopts =get_ncopts(); set_ncopts(0); for (i = 0; i < p_file->file_natts; i++) { p_att = &p_file->file_atts[i]; if (strcmp(p_att->att_name, "ident") != 0) { ncattput(fd, NC_GLOBAL, p_att->att_name, p_att->att_type, p_att->att_len, p_att->att_val); } } for (i = 0; i < p_file->file_nvars; i++) { p_var = &p_file->file_vars[i]; if ((var_id = ncvarid(fd, p_var->var_name)) < 0) { var_id = ncvardef(fd, p_var->var_name, p_var->var_type, p_var->var_ndims, p_var->var_dims); } for (j = 0; j < p_var->var_natts; j++) { p_att = &p_var->var_atts[j]; ncattput(fd, var_id, p_att->att_name, p_att->att_type, p_att->att_len, p_att->att_val); } } set_ncopts(old_ncopts); } miattputstr(fd, ncvarid(fd, MIimage), MIcomplete, MI_FALSE); miattputstr(fd, ncvarid(fd, MIimage), MIsigntype, signstr); miappend_history(fd, history); ncendef(fd); return fd; }
int cpy_coord_def(int in_id,int out_id,int rec_dim_id,char *var_nm, int in_large, int out_large) /* int in_id: input netCDF input-file ID int out_id: input netCDF output-file ID int rec_dim_id: input input-file record dimension ID char *var_nm: input variable name int in_large: large file setting for input file int out_large: large file setting for output file int cpy_var_def(): output output-file variable ID */ { const char *routine = NULL; long spatial_dim; int nbr_dim; int temp; int dim_out_id[2]; int var_out_id = -1; /* Handle easiest situation first: in_large matches out_large */ if (in_large == out_large) { return cpy_var_def(in_id, out_id, rec_dim_id, var_nm); } /* At this point, know that in_large != out_large, so some change to the coord variable definition is needed. Also will need the spatial dimension, so get that now.*/ ex_get_dimension(in_id, DIM_NUM_DIM, "dimension", &spatial_dim, routine); if (in_large == 0 && out_large == 1) { /* output file will have coordx, coordy, coordz (if 3d). See if they are already defined in output file. Assume either all or none are defined. */ temp = ncopts; ncopts=0; { int var_out_idx = ncvarid(out_id, VAR_COORD_X); int var_out_idy = ncvarid(out_id, VAR_COORD_Y); int var_out_idz = ncvarid(out_id, VAR_COORD_Z); ncopts = temp; if (var_out_idx != -1 && var_out_idy != -1 && (spatial_dim == 2 || var_out_idz != -1)) { return var_out_idx; } } /* Get dimid of the num_nodes dimension in output file... */ dim_out_id[0]=ncdimid(out_id,DIM_NUM_NODES); /* Define the variables in the output file */ /* Define according to the EXODUS file's IO_word_size */ nbr_dim = 1; var_out_id=ncvardef(out_id,VAR_COORD_X,nc_flt_code(out_id), nbr_dim, dim_out_id); var_out_id=ncvardef(out_id,VAR_COORD_Y,nc_flt_code(out_id), nbr_dim, dim_out_id); if (spatial_dim == 3) var_out_id=ncvardef(out_id,VAR_COORD_Z,nc_flt_code(out_id), nbr_dim, dim_out_id); } if (in_large == 1 && out_large == 0) { /* input file has coordx, coordy, coordz (if 3d); output will only have "coord". See if is already defined in output file. */ temp = ncopts; ncopts=0; var_out_id = ncvarid(out_id, VAR_COORD); ncopts = temp; if (var_out_id != -1) return var_out_id; /* Get dimid of the spatial dimension and num_nodes dimensions in output file... */ dim_out_id[0]=ncdimid(out_id,DIM_NUM_DIM); dim_out_id[1]=ncdimid(out_id,DIM_NUM_NODES); /* Define the variable in the output file */ /* Define according to the EXODUS file's IO_word_size */ nbr_dim = 2; var_out_id=ncvardef(out_id,VAR_COORD,nc_flt_code(out_id), nbr_dim, dim_out_id); } return var_out_id; }
/* Open an input netCDF file and get some information about it */ int process_ncinfile(char *ncname, unsigned char appendnc, int outncfid, char *outncname, int *nfiles, unsigned char verbose) { struct fileinfo ncinfile; /* Information about an input netCDF file */ int nfiles2; /* Number of files in the decomposed domain */ int d, v, n; /* Loop variables */ int dimid; /* ID of a dimension */ int decomp[4]; /* "domain_decomposition" information */ char attname[MAX_NC_NAME]; /* Name of a global or variable attribute */ unsigned char ncinfileerror=0; /* Were there any file errors? */ /* Open an input netCDF file; return if not openable - possibly IEEE */ if ((ncinfile.ncfid=ncopen(ncname,NC_NOWRITE))==(-1)) return(2); /* Determine the number of files in the decomposed domain */ if (ncattget(ncinfile.ncfid,NC_GLOBAL,"NumFilesInSet", (void *)&nfiles2)==(-1)) { if (*nfiles==1) { fprintf(stderr,"Error: missing the \"NumFilesInSet\" global attribute!\n"); return(1); } else if (*nfiles==(-1)) { fprintf(stderr,"Warning: missing the \"NumFilesInSet\" global attribute.\n"); } } *nfiles=nfiles2; /* Get some general information about the input netCDF file */ if (ncinquire(ncinfile.ncfid,&(ncinfile.ndims),&(ncinfile.nvars), &(ncinfile.ngatts),&(ncinfile.recdim))==(-1)) { fprintf(stderr,"Error: cannot read the file's metadata!\n"); ncclose(ncinfile.ncfid); return(1); } /* Get some information about the dimensions */ for (d=0; d < ncinfile.ndims; d++) { if ((ncdiminq(ncinfile.ncfid,d,ncinfile.dimname[d], &(ncinfile.dimsize[d])))==(-1)) { fprintf(stderr,"Error: cannot read dimension #%d's metadata!\n",d); ncclose(ncinfile.ncfid); return(1); } ncinfile.dimfullsize[d]=ncinfile.dimsize[d]; ncinfile.dimstart[d]=1; ncinfile.dimend[d]=(-1); } /* Get some information about the variables */ for (v=0; v < ncinfile.nvars; v++) { if ((ncvarinq(ncinfile.ncfid,v,ncinfile.varname[v], &(ncinfile.datatype[v]),&(ncinfile.varndims[v]), ncinfile.vardim[v],&(ncinfile.natts[v])))==(-1)) { fprintf(stderr,"Error: cannot read variable #%d's metadata!\n",v); ncclose(ncinfile.ncfid); return(1); } /* If the variable is also a dimension then get decomposition info */ if ((dimid=ncdimid(ncinfile.ncfid,ncinfile.varname[v]))!=(-1)) { if (ncattget(ncinfile.ncfid,v,"domain_decomposition", (void *)decomp)!=(-1)) { ncinfile.dimfullsize[dimid]=decomp[1]-decomp[0]+1; ncinfile.dimstart[dimid]=decomp[2]-(decomp[0]-1); ncinfile.dimend[dimid]=decomp[3]-(decomp[0]-1); } else { ncinfile.dimfullsize[dimid]=ncinfile.dimsize[dimid]; ncinfile.dimstart[dimid]=1; ncinfile.dimend[dimid]=(-1); } } } #if DEBUG==1 print_debug(&ncinfile,verbose); #endif /* If the output netCDF file was just created then define its structure */ if (!appendnc) { #if DEBUG==1 printf("Creating output netCDF file... \"%s\"\n",outncname); #endif /* Define the dimensions */ for (d=0; d < ncinfile.ndims; d++) { if (d==ncinfile.recdim) ncdimdef(outncfid,ncinfile.dimname[d],NC_UNLIMITED); else ncdimdef(outncfid,ncinfile.dimname[d],ncinfile.dimfullsize[d]); } /* Define the variables and copy their attributes */ for (v=0; v < ncinfile.nvars; v++) { ncvardef(outncfid,ncinfile.varname[v],ncinfile.datatype[v], ncinfile.varndims[v],ncinfile.vardim[v]); for (n=0; n < ncinfile.natts[v]; n++) { ncattname(ncinfile.ncfid,v,n,attname); if (!strcmp(attname,"domain_decomposition")) continue; else { if (ncattcopy(ncinfile.ncfid,v,attname,outncfid,v)==(-1)) { fprintf(stderr,"Error: cannot copy variable \"%s\"'s attributes!\n", ncinfile.varname[v]); return(1); } } } } /* Copy the global attributes */ for (n=0; n < ncinfile.ngatts; n++) { ncattname(ncinfile.ncfid,NC_GLOBAL,n,attname); if (!strcmp(attname,"NumFilesInSet")) continue; else if (!strcmp(attname,"filename")) ncattput(outncfid,NC_GLOBAL,attname,NC_CHAR,strlen(outncname), (void *)outncname); else { if (ncattcopy(ncinfile.ncfid,NC_GLOBAL,attname,outncfid, NC_GLOBAL)==(-1)) { fprintf(stderr,"Error: cannot copy the file's global attributes!\n"); return(1); } } } /* Definitions done */ ncendef(outncfid); } /* Copy all the data values of the dimensions and variables */ ncinfileerror=copy_nc_data(&ncinfile,outncfid,appendnc,verbose); /* Done */ ncclose(ncinfile.ncfid); return(ncinfileerror); }
int ex_put_elem_num_map (int exoid, const int *elem_map) { int numelemdim, dims[1], mapid, iresult; long num_elem, start[1], count[1]; nclong *lptr; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ /* inquire id's of previously defined dimensions */ /* determine number of elements. Return if zero... */ if ((numelemdim = ncdimid (exoid, DIM_NUM_ELEM)) == -1) { return (EX_NOERR); } if (ncdiminq (exoid, numelemdim, (char *) 0, &num_elem) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of elements in file id %d", exoid); ex_err("ex_put_elem_num_map",errmsg,exerrval); return (EX_FATAL); } /* put netcdf file into define mode */ if ((mapid = ncvarid (exoid, VAR_ELEM_NUM_MAP)) == -1) { if (ncredef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to put file id %d into define mode", exoid); ex_err("ex_put_elem_num_map",errmsg,exerrval); return (EX_FATAL); } /* create a variable array in which to store the element numbering map */ dims[0] = numelemdim; if ((mapid = ncvardef (exoid, VAR_ELEM_NUM_MAP, NC_LONG, 1, dims)) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: element numbering map already exists in file id %d", exoid); ex_err("ex_put_elem_num_map",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to create element numbering map in file id %d", exoid); ex_err("ex_put_elem_num_map",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } /* leave define mode */ if (ncendef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to complete definition in file id %d", exoid); ex_err("ex_put_elem_num_map",errmsg,exerrval); return (EX_FATAL); } } /* write out the element numbering map */ /* 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_elem; if (sizeof(int) == sizeof(nclong)) { iresult = ncvarput (exoid, mapid, start, count, elem_map); } else { lptr = itol (elem_map, (int)num_elem); iresult = ncvarput (exoid, mapid, start, count, lptr); free(lptr); } if (iresult == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store element numbering map in file id %d", exoid); ex_err("ex_put_elem_num_map",errmsg,exerrval); return (EX_FATAL); } 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_elem_num_map",errmsg,exerrval); } return (EX_FATAL); }
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 }