/***************************************************************************** * * ex_get_num_props - get number of properties * *****************************************************************************/ int ex_get_num_props(int exoid, ex_entity_type obj_type) { int cntr, varid; char *var_name; char errmsg[MAX_ERR_LENGTH]; cntr = 0; /* loop until there is not a property variable defined; the name of */ /* the variables begin with an increment of 1 ("xx_prop1") so use cntr+1 */ while (EX_TRUE) { switch (obj_type) { case EX_ELEM_BLOCK: var_name = VAR_EB_PROP(cntr + 1); break; case EX_EDGE_BLOCK: var_name = VAR_ED_PROP(cntr + 1); break; case EX_FACE_BLOCK: var_name = VAR_FA_PROP(cntr + 1); break; case EX_NODE_SET: var_name = VAR_NS_PROP(cntr + 1); break; case EX_EDGE_SET: var_name = VAR_ES_PROP(cntr + 1); break; case EX_FACE_SET: var_name = VAR_FS_PROP(cntr + 1); break; case EX_SIDE_SET: var_name = VAR_SS_PROP(cntr + 1); break; case EX_ELEM_SET: var_name = VAR_ELS_PROP(cntr + 1); break; case EX_ELEM_MAP: var_name = VAR_EM_PROP(cntr + 1); break; case EX_FACE_MAP: var_name = VAR_FAM_PROP(cntr + 1); break; case EX_EDGE_MAP: var_name = VAR_EDM_PROP(cntr + 1); break; case EX_NODE_MAP: var_name = VAR_NM_PROP(cntr + 1); break; default: exerrval = EX_BADPARAM; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type, exoid); ex_err("ex_get_prop_names", errmsg, exerrval); return (EX_FATAL); } if (nc_inq_varid(exoid, var_name, &varid) != NC_NOERR) { /* no variable with this name; return cntr which is now the number of */ /* properties for this type of entity */ return (cntr); } cntr++; } }
int ex_get_prop_array(int exoid, ex_entity_type obj_type, const char *prop_name, void_int *values) { int num_props, i, propid, status; int found = EX_FALSE; char *name; char tmpstr[MAX_STR_LENGTH + 1]; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ /* open appropriate variable, depending on obj_type and prop_name */ num_props = ex_get_num_props(exoid, obj_type); for (i = 1; i <= num_props; i++) { switch (obj_type) { case EX_ELEM_BLOCK: name = VAR_EB_PROP(i); break; case EX_EDGE_BLOCK: name = VAR_ED_PROP(i); break; case EX_FACE_BLOCK: name = VAR_FA_PROP(i); break; case EX_NODE_SET: name = VAR_NS_PROP(i); break; case EX_EDGE_SET: name = VAR_ES_PROP(i); break; case EX_FACE_SET: name = VAR_FS_PROP(i); break; case EX_ELEM_SET: name = VAR_ELS_PROP(i); break; case EX_SIDE_SET: name = VAR_SS_PROP(i); break; case EX_ELEM_MAP: name = VAR_EM_PROP(i); break; case EX_FACE_MAP: name = VAR_FAM_PROP(i); break; case EX_EDGE_MAP: name = VAR_EDM_PROP(i); break; case EX_NODE_MAP: name = VAR_NM_PROP(i); break; default: exerrval = EX_BADPARAM; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type, exoid); ex_err("ex_get_prop_array", errmsg, exerrval); return (EX_FATAL); } if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate property array %s in file id %d", name, exoid); ex_err("ex_get_prop_array", errmsg, exerrval); return (EX_FATAL); } /* compare stored attribute name with passed property name */ memset(tmpstr, 0, MAX_STR_LENGTH + 1); if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property name in file id %d", exoid); ex_err("ex_get_prop_array", errmsg, exerrval); return (EX_FATAL); } if (strcmp(tmpstr, prop_name) == 0) { found = EX_TRUE; break; } } /* if property is not found, return warning */ if (!found) { exerrval = EX_BADPARAM; snprintf(errmsg, MAX_ERR_LENGTH, "Warning: object type %d, property %s not defined in file id %d", obj_type, prop_name, exoid); ex_err("ex_get_prop_array", errmsg, exerrval); return (EX_WARN); } /* read num_obj values from property variable */ if (ex_int64_status(exoid) & EX_IDS_INT64_API) { status = nc_get_var_longlong(exoid, propid, values); } else { status = nc_get_var_int(exoid, propid, values); } if (status != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to read values in %s property array in file id %d", ex_name_of_object(obj_type), exoid); ex_err("ex_get_prop_array", errmsg, exerrval); return (EX_FATAL); } return (EX_NOERR); }
int ex_id_lkup(int exoid, ex_entity_type id_type, ex_entity_id num) { char * id_table; char * id_dim; char * stat_table; int varid, dimid; size_t dim_len, i; int64_t *id_vals = NULL; int * stat_vals = NULL; static int filled = EX_FALSE; struct obj_stats *tmp_stats; int status; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ switch (id_type) { case EX_NODAL: return 0; case EX_GLOBAL: return 0; case EX_ELEM_BLOCK: id_table = VAR_ID_EL_BLK; /* id array name */ id_dim = DIM_NUM_EL_BLK; /* id array dimension name*/ stat_table = VAR_STAT_EL_BLK; /* id status array name */ tmp_stats = ex_get_stat_ptr(exoid, &exoII_eb); break; case EX_NODE_SET: id_table = VAR_NS_IDS; id_dim = DIM_NUM_NS; stat_table = VAR_NS_STAT; tmp_stats = ex_get_stat_ptr(exoid, &exoII_ns); break; case EX_SIDE_SET: id_table = VAR_SS_IDS; id_dim = DIM_NUM_SS; stat_table = VAR_SS_STAT; tmp_stats = ex_get_stat_ptr(exoid, &exoII_ss); break; case EX_EDGE_BLOCK: id_table = VAR_ID_ED_BLK; id_dim = DIM_NUM_ED_BLK; stat_table = VAR_STAT_ED_BLK; tmp_stats = ex_get_stat_ptr(exoid, &exoII_ed); break; case EX_FACE_BLOCK: id_table = VAR_ID_FA_BLK; id_dim = DIM_NUM_FA_BLK; stat_table = VAR_STAT_FA_BLK; tmp_stats = ex_get_stat_ptr(exoid, &exoII_fa); break; case EX_EDGE_SET: id_table = VAR_ES_IDS; id_dim = DIM_NUM_ES; stat_table = VAR_ES_STAT; tmp_stats = ex_get_stat_ptr(exoid, &exoII_es); break; case EX_FACE_SET: id_table = VAR_FS_IDS; id_dim = DIM_NUM_FS; stat_table = VAR_FS_STAT; tmp_stats = ex_get_stat_ptr(exoid, &exoII_fs); break; case EX_ELEM_SET: id_table = VAR_ELS_IDS; id_dim = DIM_NUM_ELS; stat_table = VAR_ELS_STAT; tmp_stats = ex_get_stat_ptr(exoid, &exoII_els); break; case EX_NODE_MAP: id_table = VAR_NM_PROP(1); id_dim = DIM_NUM_NM; stat_table = ""; tmp_stats = ex_get_stat_ptr(exoid, &exoII_nm); break; case EX_EDGE_MAP: id_table = VAR_EDM_PROP(1); id_dim = DIM_NUM_EDM; stat_table = ""; tmp_stats = ex_get_stat_ptr(exoid, &exoII_edm); break; case EX_FACE_MAP: id_table = VAR_FAM_PROP(1); id_dim = DIM_NUM_FAM; stat_table = ""; tmp_stats = ex_get_stat_ptr(exoid, &exoII_fam); break; case EX_ELEM_MAP: id_table = VAR_EM_PROP(1); id_dim = DIM_NUM_EM; stat_table = ""; tmp_stats = ex_get_stat_ptr(exoid, &exoII_em); break; default: exerrval = EX_BADPARAM; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unsupported id array type %d for file id %d", id_type, exoid); ex_err("ex_id_lkup", errmsg, exerrval); return (EX_FATAL); } if ((tmp_stats->id_vals == NULL) || (!(tmp_stats->valid_ids))) { /* first time thru or id arrays haven't been completely filled yet */ /* get size of id array */ /* First get dimension id of id array */ if ((status = nc_inq_dimid(exoid, id_dim, &dimid)) != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate id array dimension in file id %d", exoid); ex_err("ex_id_lkup", errmsg, exerrval); return (EX_FATAL); } /* Next get value of dimension */ if ((status = nc_inq_dimlen(exoid, dimid, &dim_len)) != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %s array length in file id %d", id_table, exoid); ex_err("ex_id_lkup", errmsg, exerrval); return (EX_FATAL); } /* get variable id of id array */ if ((status = nc_inq_varid(exoid, id_table, &varid)) != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %s array in file id %d", id_table, exoid); ex_err("ex_id_lkup", errmsg, exerrval); return (EX_FATAL); } /* allocate space for id array and initialize to zero to ensure that the higher bits don't contain garbage while copy from ints */ if (!(id_vals = calloc(dim_len, sizeof(int64_t)))) { exerrval = EX_MEMFAIL; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate memory for %s array for file id %d", id_table, exoid); ex_err("ex_id_lkup", errmsg, exerrval); return (EX_FATAL); } if (ex_int64_status(exoid) & EX_IDS_INT64_API) { status = nc_get_var_longlong(exoid, varid, (long long *)id_vals); } else { int *id_vals_int; if (!(id_vals_int = malloc(dim_len * sizeof(int)))) { exerrval = EX_MEMFAIL; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate memory for temporary array " "id_vals_int for file id %d", exoid); ex_err("ex_id_lkup", errmsg, exerrval); free(id_vals); return (EX_FATAL); } status = nc_get_var_int(exoid, varid, (int *)id_vals_int); if (status == NC_NOERR) { for (i = 0; i < dim_len; i++) { id_vals[i] = (int64_t)id_vals_int[i]; } } free(id_vals_int); } if (status != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s array from file id %d", id_table, exoid); ex_err("ex_id_lkup", errmsg, exerrval); free(id_vals); return (EX_FATAL); } /* check if values in stored arrays are filled with non-zeroes */ filled = EX_TRUE; for (i = 0; i < dim_len; i++) { if (id_vals[i] == EX_INVALID_ID || id_vals[i] == NC_FILL_INT) { filled = EX_FALSE; break; /* id array hasn't been completely filled with valid ids yet */ } } if (filled) { tmp_stats->valid_ids = EX_TRUE; tmp_stats->num = dim_len; tmp_stats->id_vals = id_vals; } } else { id_vals = tmp_stats->id_vals; dim_len = tmp_stats->num; } /* Do a linear search through the id array to find the array value corresponding to the passed index number */ for (i = 0; i < dim_len; i++) { if (id_vals[i] == num) { break; /* found the id requested */ } } if (i >= dim_len) /* failed to find id number */ { if (!(tmp_stats->valid_ids)) { free(id_vals); } exerrval = EX_LOOKUPFAIL; return (EX_LOOKUPFAIL); /*if we got here, the id array value doesn't exist */ } /* Now check status array to see if object is null */ /* get variable id of status array */ if (nc_inq_varid(exoid, stat_table, &varid) == NC_NOERR) { /* if status array exists, use it, otherwise assume object exists to be backward compatible */ if ((tmp_stats->stat_vals == NULL) || (!(tmp_stats->valid_stat))) { /* first time thru or status arrays haven't been filled yet */ /* allocate space for new status array */ if (!(stat_vals = malloc(dim_len * sizeof(int)))) { exerrval = EX_MEMFAIL; free(id_vals); snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate memory for %s array for file id %d", id_table, exoid); ex_err("ex_id_lkup", errmsg, exerrval); return (EX_FATAL); } if ((status = nc_get_var_int(exoid, varid, stat_vals)) != NC_NOERR) { exerrval = status; free(id_vals); free(stat_vals); snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s array from file id %d", stat_table, exoid); ex_err("ex_id_lkup", errmsg, exerrval); return (EX_FATAL); } if (tmp_stats->valid_ids) { /* status array is valid only if ids are valid */ tmp_stats->valid_stat = EX_TRUE; tmp_stats->stat_vals = stat_vals; } } else { stat_vals = tmp_stats->stat_vals; } if (stat_vals[i] == 0) /* is this object null? */ { exerrval = EX_NULLENTITY; if (!(tmp_stats->valid_stat)) { free(stat_vals); } if (!(tmp_stats->valid_ids)) { free(id_vals); } return (-((int)i + 1)); /* return index into id array (1-based) */ } } if (!(tmp_stats->valid_ids)) { free(id_vals); free(stat_vals); } return (i + 1); /* return index into id array (1-based) */ }
int ex_put_num_map ( int exoid, ex_entity_type map_type, int map_id, const int *map ) { int dimid, varid; size_t start[1]; int ldum; int num_maps; size_t num_entries; int cur_num_maps; char errmsg[MAX_ERR_LENGTH]; const char* dnumentries; const char* dnummaps; const char* vmapids; const char* vmap; int status; exerrval = 0; /* clear error code */ switch ( map_type ) { case EX_NODE_MAP: dnumentries = DIM_NUM_NODES; dnummaps = DIM_NUM_NM; vmapids = VAR_NM_PROP(1); break; case EX_EDGE_MAP: dnumentries = DIM_NUM_EDGE; dnummaps = DIM_NUM_EDM; vmapids = VAR_EDM_PROP(1); break; case EX_FACE_MAP: dnumentries = DIM_NUM_FACE; dnummaps = DIM_NUM_FAM; vmapids = VAR_FAM_PROP(1); break; case EX_ELEM_MAP: dnumentries = DIM_NUM_ELEM; dnummaps = DIM_NUM_EM; vmapids = VAR_EM_PROP(1); 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 (nc_inq_dimid (exoid, dnumentries, &dimid) != NC_NOERR ) { return (EX_NOERR); } /* first check if any maps are specified */ if ((status = nc_inq_dimid (exoid, dnummaps, &dimid)) != NC_NOERR ) { exerrval = status; sprintf(errmsg, "Error: no %ss specified in file id %d", ex_name_of_object(map_type),exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } /* Check for duplicate map id entry */ ex_id_lkup(exoid,map_type,map_id); if (exerrval != EX_LOOKUPFAIL) /* found the map id */ { sprintf(errmsg, "Error: %s %d already defined in file id %d", ex_name_of_object(map_type),map_id,exoid); ex_err("ex_put_num_map",errmsg,exerrval); return(EX_FATAL); } /* Get number of maps initialized for this file */ if ((status = nc_inq_dimlen(exoid,dimid,&num_entries)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get number of %ss in file id %d", ex_name_of_object(map_type),exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } num_maps = num_entries; /* 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, ex_get_counter_list(map_type)); if (cur_num_maps >= num_maps) { exerrval = EX_FATAL; sprintf(errmsg, "Error: exceeded number of %ss (%d) specified in file id %d", ex_name_of_object(map_type),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, ex_get_counter_list(map_type)); /* write out information to previously defined variable */ /* first get id of variable */ if ((status = nc_inq_varid (exoid, vmapids, &varid)) == -1) { exerrval = status; sprintf(errmsg, "Error: failed to locate %s ids in file id %d", ex_name_of_object(map_type),exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } /* then, write out map id */ start[0] = cur_num_maps; ldum = (int)map_id; if ((status = nc_put_var1_int(exoid, varid, start, &ldum)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to store %s id %d in file id %d", ex_name_of_object(map_type),map_id,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; default: exerrval = 1005; sprintf(errmsg, "Internal Error: unrecognized map type in switch: %d in file id %d", map_type,exoid); ex_err("ex_putt_n_one_attr",errmsg,EX_MSG); return (EX_FATAL); } /* locate variable array in which to store the map */ if ((status = nc_inq_varid(exoid,vmap,&varid)) != NC_NOERR) { int dims[2]; /* determine number of entries */ if ((status = nc_inq_dimid (exoid, dnumentries, &dimid)) == -1 ) { exerrval = status; sprintf(errmsg, "Error: couldn't determine number of %s entries in file id %d", ex_name_of_object(map_type),exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } status = 0; if ((status = nc_redef( exoid )) != NC_NOERR ) { exerrval = status; 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 ((status = nc_def_var( exoid, vmap, NC_INT, 1, dims, &varid )) == -1 ) { exerrval = status; sprintf(errmsg, "Error: failed to define map %s in file id %d", vmap, exoid); ex_err("ex_put_num_map",errmsg,exerrval); } if ((status = nc_enddef(exoid)) != NC_NOERR ) { /* 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 */ if ((status = nc_put_var_int(exoid, varid, map)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to store %s in file id %d", ex_name_of_object(map_type),exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } return (EX_NOERR); }
int ex_put_prop_names(int exoid, ex_entity_type obj_type, int num_props, char **prop_names) { int status; int oldfill, temp; int i, propid, dimid, dims[1]; size_t name_length, prop_name_len; char * name; long long vals[1]; int max_name_len = 0; int int_type = NC_INT; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ if (ex_int64_status(exoid) & EX_IDS_INT64_DB) { int_type = NC_INT64; } /* Get the name string length */ name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_ALLOWED_NAME_LENGTH) + 1; /* inquire id of previously defined dimension (number of objects) */ if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(obj_type), &dimid)) != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate number of %s in file id %d", ex_name_of_object(obj_type), exoid); ex_err("ex_put_prop_names", errmsg, exerrval); return (EX_FATAL); } nc_set_fill(exoid, NC_FILL, &oldfill); /* fill with zeros per routine spec */ /* put netcdf file into define mode */ if ((status = nc_redef(exoid)) != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "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: name = VAR_EB_PROP(i + 2); break; case EX_FACE_BLOCK: name = VAR_FA_PROP(i + 2); break; case EX_EDGE_BLOCK: name = VAR_ED_PROP(i + 2); break; case EX_NODE_SET: name = VAR_NS_PROP(i + 2); break; case EX_SIDE_SET: name = VAR_SS_PROP(i + 2); break; case EX_EDGE_SET: name = VAR_ES_PROP(i + 2); break; case EX_FACE_SET: name = VAR_FS_PROP(i + 2); break; case EX_ELEM_SET: name = VAR_ELS_PROP(i + 2); break; case EX_ELEM_MAP: name = VAR_EM_PROP(i + 2); break; case EX_FACE_MAP: name = VAR_FAM_PROP(i + 2); break; case EX_EDGE_MAP: name = VAR_EDM_PROP(i + 2); break; case EX_NODE_MAP: name = VAR_NM_PROP(i + 2); break; default: exerrval = EX_BADPARAM; snprintf(errmsg, MAX_ERR_LENGTH, "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 ((status = nc_def_var(exoid, name, int_type, 1, dims, &propid)) != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "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 ((status = nc_put_att_longlong(exoid, propid, _FillValue, int_type, 1, vals)) != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "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 */ } /* Check that the property name length is less than MAX_NAME_LENGTH */ prop_name_len = strlen(prop_names[i]) + 1; if (prop_name_len > name_length) { fprintf(stderr, "Warning: The property name '%s' is too long.\n\tIt will " "be truncated from %d to %d characters\n", prop_names[i], (int)prop_name_len - 1, (int)name_length - 1); prop_name_len = name_length; } if (prop_name_len > max_name_len) { max_name_len = prop_name_len; } /* store property name as attribute of property array variable */ if ((status = nc_put_att_text(exoid, propid, ATT_PROP_NAME, prop_name_len, prop_names[i])) != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "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 ((status = nc_enddef(exoid)) != NC_NOERR) { exerrval = status; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to leave define mode in file id %d", exoid); ex_err("ex_put_prop_names", errmsg, exerrval); return (EX_FATAL); } /* Update the maximum_name_length attribute on the file. */ ex_update_max_name_length(exoid, max_name_len - 1); nc_set_fill(exoid, oldfill, &temp); /* default: turn off fill */ return (EX_NOERR); /* Fatal error: exit definition mode and return */ error_ret: if (nc_enddef(exoid) != NC_NOERR) { /* exit define mode */ snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition for file id %d", exoid); ex_err("ex_put_prop_names", errmsg, exerrval); } return (EX_FATAL); }
int ex_put_prop (int exoid, ex_entity_type obj_type, ex_entity_id obj_id, const char *prop_name, ex_entity_id value) { int status; int oldfill = 0; int temp; int found = FALSE; int num_props, i, dimid, propid, dims[1]; int int_type; size_t start[1]; size_t prop_name_len, name_length; char name[MAX_VAR_NAME_LENGTH+1]; char tmpstr[MAX_STR_LENGTH+1]; char dim_name[MAX_VAR_NAME_LENGTH+1]; long long vals[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); 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_EDGE_BLOCK: strcpy (name, VAR_ED_PROP(i)); break; case EX_FACE_BLOCK: strcpy (name, VAR_FA_PROP(i)); break; case EX_NODE_SET: strcpy (name, VAR_NS_PROP(i)); break; case EX_EDGE_SET: strcpy (name, VAR_ES_PROP(i)); break; case EX_FACE_SET: strcpy (name, VAR_FS_PROP(i)); break; case EX_ELEM_SET: strcpy (name, VAR_ELS_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_FACE_MAP: strcpy (name, VAR_FAM_PROP(i)); break; case EX_EDGE_MAP: strcpy (name, VAR_EDM_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 ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) { exerrval = status; 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 */ memset(tmpstr, 0, MAX_STR_LENGTH+1); if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) { exerrval = status; 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) { name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_ALLOWED_NAME_LENGTH)+1; /* put netcdf file into define mode */ if ((status = nc_redef (exoid)) != NC_NOERR) { exerrval = status; 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_FACE_BLOCK: strcpy (name, VAR_FA_PROP(num_props+1)); strcpy (dim_name, DIM_NUM_FA_BLK); break; case EX_EDGE_BLOCK: strcpy (name, VAR_ED_PROP(num_props+1)); strcpy (dim_name, DIM_NUM_ED_BLK); break; case EX_NODE_SET: strcpy (name, VAR_NS_PROP(num_props+1)); strcpy (dim_name, DIM_NUM_NS); break; case EX_EDGE_SET: strcpy (name, VAR_ES_PROP(num_props+1)); strcpy (dim_name, DIM_NUM_ES); break; case EX_FACE_SET: strcpy (name, VAR_FS_PROP(num_props+1)); strcpy (dim_name, DIM_NUM_FS); break; case EX_ELEM_SET: strcpy (name, VAR_ELS_PROP(num_props+1)); strcpy (dim_name, DIM_NUM_ELS); 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_FACE_MAP: strcpy (name, VAR_FAM_PROP(num_props+1)); strcpy (dim_name, DIM_NUM_FAM); break; case EX_EDGE_MAP: strcpy (name, VAR_EDM_PROP(num_props+1)); strcpy (dim_name, DIM_NUM_EDM); 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 ((status = nc_inq_dimid(exoid, dim_name, &dimid)) != NC_NOERR) { exerrval = status; 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; nc_set_fill(exoid, NC_FILL, &oldfill); /* fill with zeros per routine spec */ int_type = NC_INT; if (ex_int64_status(exoid) & EX_IDS_INT64_DB) { int_type = NC_INT64; } if ((status = nc_def_var(exoid, name, int_type, 1, dims, &propid)) != NC_NOERR) { exerrval = status; 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 */ } vals[0] = 0; /* fill value */ /* create attribute to cause variable to fill with zeros per routine spec */ if ((status = nc_put_att_longlong(exoid, propid, _FillValue, int_type, 1, vals)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to create property name fill attribute in file id %d", exoid); ex_err("ex_put_prop",errmsg,exerrval); goto error_ret; /* Exit define mode and return */ } /* Check that the property name length is less than MAX_NAME_LENGTH */ prop_name_len = strlen(prop_name)+1; if (prop_name_len > name_length) { fprintf(stderr, "Warning: The property name '%s' is too long.\n\tIt will be truncated from %d to %d characters\n", prop_name, (int)prop_name_len-1, (int)name_length-1); prop_name_len = name_length; } /* store property name as attribute of property array variable */ if ((status = nc_put_att_text(exoid, propid, ATT_PROP_NAME, prop_name_len, (void*)prop_name)) != NC_NOERR) { exerrval = status; 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 */ } ex_update_max_name_length(exoid, prop_name_len-1); /* leave define mode */ if ((status = nc_enddef (exoid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to leave define mode in file id %d", exoid); ex_err("ex_put_prop",errmsg,exerrval); return (EX_FATAL); } nc_set_fill(exoid, oldfill, &temp); /* default: nofill */ } /* 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_type, value); if (exerrval != EX_LOOKUPFAIL) /* found the id */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Warning: attempt to assign duplicate %s ID %"PRId64" in file id %d", ex_name_of_object(obj_type), value, exoid); ex_err("ex_put_prop",errmsg,exerrval); return (EX_WARN); } } start[0] = ex_id_lkup (exoid, obj_type, obj_id); if (exerrval != 0) { if (exerrval == EX_NULLENTITY) { sprintf(errmsg, "Warning: no properties allowed for NULL %s id %"PRId64" in file id %d", ex_name_of_object(obj_type), obj_id,exoid); ex_err("ex_put_prop",errmsg,EX_MSG); return (EX_WARN); } else { sprintf(errmsg, "Error: failed to find value %"PRId64" in %s property array in file id %d", obj_id, ex_name_of_object(obj_type), exoid); ex_err("ex_put_prop",errmsg,exerrval); return (EX_FATAL); } } start[0] = start[0] - 1; /* value is of type 'ex_entity_id' which is a typedef to int64_t or long long */ status = nc_put_var1_longlong(exoid, propid, start, (long long*)&value); if (status != NC_NOERR) { exerrval = status; 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: nc_set_fill(exoid, oldfill, &temp); /* default: nofill */ if (nc_enddef (exoid) != NC_NOERR) { /* 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_prop_array(int exoid, ex_entity_type obj_type, const char *prop_name, const void_int *values) { int oldfill = 0; int temp; int num_props, i, propid, dimid, dims[1], status; int found = EX_FALSE; int int_type; size_t num_obj; char * name; char tmpstr[MAX_STR_LENGTH + 1]; char errmsg[MAX_ERR_LENGTH]; EX_FUNC_ENTER(); ex_check_valid_file_id(exoid, __func__); /* check if property has already been created */ num_props = ex_get_num_props(exoid, obj_type); /* inquire id of previously defined dimension (number of objects) */ status = ex_get_dimension(exoid, ex_dim_num_objects(obj_type), ex_name_of_object(obj_type), &num_obj, &dimid, __func__); if (status != NC_NOERR) { EX_FUNC_LEAVE(status); } for (i = 1; i <= num_props; i++) { switch (obj_type) { case EX_ELEM_BLOCK: name = VAR_EB_PROP(i); break; case EX_FACE_BLOCK: name = VAR_FA_PROP(i); break; case EX_EDGE_BLOCK: name = VAR_ED_PROP(i); break; case EX_NODE_SET: name = VAR_NS_PROP(i); break; case EX_EDGE_SET: name = VAR_ES_PROP(i); break; case EX_FACE_SET: name = VAR_FS_PROP(i); break; case EX_ELEM_SET: name = VAR_ELS_PROP(i); break; case EX_SIDE_SET: name = VAR_SS_PROP(i); break; case EX_ELEM_MAP: name = VAR_EM_PROP(i); break; case EX_FACE_MAP: name = VAR_FAM_PROP(i); break; case EX_EDGE_MAP: name = VAR_EDM_PROP(i); break; case EX_NODE_MAP: name = VAR_NM_PROP(i); break; default: snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type, exoid); ex_err(__func__, errmsg, EX_BADPARAM); EX_FUNC_LEAVE(EX_FATAL); } if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property array id in file id %d", exoid); ex_err(__func__, errmsg, status); EX_FUNC_LEAVE(EX_FATAL); } /* compare stored attribute name with passed property name */ memset(tmpstr, 0, MAX_STR_LENGTH + 1); if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property name in file id %d", exoid); ex_err(__func__, errmsg, status); EX_FUNC_LEAVE(EX_FATAL); } if (strcmp(tmpstr, prop_name) == 0) { found = EX_TRUE; break; } } /* if property array has not been created, create it */ if (!found) { /* put netcdf file into define mode */ if ((status = nc_redef(exoid)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to place file id %d into define mode", exoid); ex_err(__func__, errmsg, status); EX_FUNC_LEAVE(EX_FATAL); } /* create a variable with a name xx_prop#, where # is the new number */ /* of properties */ switch (obj_type) { case EX_ELEM_BLOCK: name = VAR_EB_PROP(num_props + 1); break; case EX_FACE_BLOCK: name = VAR_FA_PROP(num_props + 1); break; case EX_EDGE_BLOCK: name = VAR_ED_PROP(num_props + 1); break; case EX_NODE_SET: name = VAR_NS_PROP(num_props + 1); break; case EX_EDGE_SET: name = VAR_ES_PROP(num_props + 1); break; case EX_FACE_SET: name = VAR_FS_PROP(num_props + 1); break; case EX_ELEM_SET: name = VAR_ELS_PROP(num_props + 1); break; case EX_SIDE_SET: name = VAR_SS_PROP(num_props + 1); break; case EX_ELEM_MAP: name = VAR_EM_PROP(num_props + 1); break; case EX_FACE_MAP: name = VAR_FAM_PROP(num_props + 1); break; case EX_EDGE_MAP: name = VAR_EDM_PROP(num_props + 1); break; case EX_NODE_MAP: name = VAR_NM_PROP(num_props + 1); break; default: snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type, exoid); ex_err(__func__, errmsg, EX_BADPARAM); goto error_ret; /* Exit define mode and return */ } dims[0] = dimid; nc_set_fill(exoid, NC_FILL, &oldfill); /* fill with zeros per routine spec */ int_type = NC_INT; if (ex_int64_status(exoid) & EX_IDS_INT64_DB) { int_type = NC_INT64; } if ((status = nc_def_var(exoid, name, int_type, 1, dims, &propid)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to create property array variable in file id %d", exoid); ex_err(__func__, errmsg, status); goto error_ret; /* Exit define mode and return */ } nc_set_fill(exoid, oldfill, &temp); /* default: nofill */ /* store property name as attribute of property array variable */ if ((status = nc_put_att_text(exoid, propid, ATT_PROP_NAME, strlen(prop_name) + 1, prop_name)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store property name %s in file id %d", prop_name, exoid); ex_err(__func__, errmsg, status); goto error_ret; /* Exit define mode and return */ } /* leave define mode */ if ((status = nc_enddef(exoid)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to leave define mode in file id %d", exoid); ex_err(__func__, errmsg, status); EX_FUNC_LEAVE(EX_FATAL); } } /* put num_obj values in property array */ if (ex_int64_status(exoid) & EX_IDS_INT64_API) { status = nc_put_var_longlong(exoid, propid, values); } else { status = nc_put_var_int(exoid, propid, values); } if (status != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store property values in file id %d", exoid); ex_err(__func__, errmsg, status); EX_FUNC_LEAVE(EX_FATAL); } EX_FUNC_LEAVE(EX_NOERR); /* Fatal error: exit definition mode and return */ error_ret: nc_set_fill(exoid, oldfill, &temp); /* default: nofill */ if ((status = nc_enddef(exoid)) != NC_NOERR) { /* exit define mode */ snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition for file id %d", exoid); ex_err(__func__, errmsg, status); } EX_FUNC_LEAVE(EX_FATAL); }
int ex_get_prop (int exoid, ex_entity_type obj_type, ex_entity_id obj_id, const char *prop_name, void_int *value) { int status; int num_props, i, propid; int found = EX_FALSE; size_t start[1]; char name[MAX_VAR_NAME_LENGTH+1]; char tmpstr[MAX_STR_LENGTH+1]; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ /* open appropriate variable, depending on obj_type and prop_name */ num_props = ex_get_num_props(exoid,obj_type); for (i=1; i<=num_props; i++) { switch (obj_type){ case EX_ELEM_BLOCK: strcpy (name, VAR_EB_PROP(i)); break; case EX_EDGE_BLOCK: strcpy (name, VAR_ED_PROP(i)); break; case EX_FACE_BLOCK: strcpy (name, VAR_FA_PROP(i)); break; case EX_NODE_SET: strcpy (name, VAR_NS_PROP(i)); break; case EX_EDGE_SET: strcpy (name, VAR_ES_PROP(i)); break; case EX_FACE_SET: strcpy (name, VAR_FS_PROP(i)); break; case EX_ELEM_SET: strcpy (name, VAR_ELS_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_FACE_MAP: strcpy (name, VAR_FAM_PROP(i)); break; case EX_EDGE_MAP: strcpy (name, VAR_EDM_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_get_prop",errmsg,exerrval); return(EX_FATAL); } if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate property array %s in file id %d", name, exoid); ex_err("ex_get_prop",errmsg,exerrval); return (EX_FATAL); } /* compare stored attribute name with passed property name */ memset(tmpstr, 0, MAX_STR_LENGTH+1); if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get property name in file id %d", exoid); ex_err("ex_get_prop",errmsg,exerrval); return (EX_FATAL); } if (strcmp(tmpstr, prop_name) == 0) { found = EX_TRUE; break; } } /* if property is not found, return warning */ if (!found) { exerrval = EX_BADPARAM; sprintf(errmsg, "Warning: %s property %s not defined in file id %d", ex_name_of_object(obj_type), prop_name, exoid); ex_err("ex_get_prop",errmsg,exerrval); return (EX_WARN); } /* find index into property array using obj_id; read value from property */ /* array at proper index; ex_id_lkup returns an index that is 1-based, */ /* but netcdf expects 0-based arrays so subtract 1 */ start[0] = ex_id_lkup (exoid, obj_type, obj_id); if (exerrval != 0) { if (exerrval == EX_NULLENTITY) { sprintf(errmsg, "Warning: %s id %"PRId64" is NULL in file id %d", ex_name_of_object(obj_type), obj_id, exoid); ex_err("ex_get_prop",errmsg,EX_NULLENTITY); return (EX_WARN); } else { exerrval = status; sprintf(errmsg, "Error: failed to locate id %"PRId64" in %s property array in file id %d", obj_id, ex_name_of_object(obj_type), exoid); ex_err("ex_get_prop",errmsg,exerrval); return (EX_FATAL); } } start[0] = start[0] - 1; if (ex_int64_status(exoid) & EX_IDS_INT64_API) { long long l_val; status = nc_get_var1_longlong (exoid, propid, start, &l_val); if (status == NC_NOERR) { int64_t *val = (int64_t*)value; *val = l_val; } } else { int i_val; status = nc_get_var1_int (exoid, propid, start, &i_val); if (status == NC_NOERR) { int *val = (int*)value; *val = i_val; } } if (status != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to read value in %s property array in file id %d", ex_name_of_object(obj_type), exoid); ex_err("ex_get_prop",errmsg,exerrval); return (EX_FATAL); } return (EX_NOERR); }
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_init_ext (int exoid, const ex_init_params *model) { int numdimdim, numnoddim, elblkdim, edblkdim, fablkdim, esetdim, fsetdim, elsetdim, nsetdim, ssetdim, dim_str_name, dim[2], temp; int nmapdim,edmapdim,famapdim,emapdim,timedim; int status; int title_len; #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]; int rootid = exoid & EX_FILE_ID_MASK; exerrval = 0; /* clear error code */ if (rootid == exoid && nc_inq_dimid (exoid, DIM_NUM_DIM, &temp) == NC_NOERR) { exerrval = EX_MSG; sprintf(errmsg, "Error: initialization already done for file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); return (EX_FATAL); } /* put file into define mode */ if ((status = nc_redef (exoid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to put file id %d into define mode", exoid); ex_err("ex_put_init_ext",errmsg,exerrval); return (EX_FATAL); } /* define some attributes... */ title_len = strlen(model->title) < MAX_LINE_LENGTH ? strlen(model->title) : MAX_LINE_LENGTH; if ((status = nc_put_att_text(rootid, NC_GLOBAL, (const char*)ATT_TITLE, title_len+1, model->title)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define model->title attribute to file id %d", rootid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* ...and some dimensions... */ /* create name string length dimension */ if (nc_inq_dimid (rootid, DIM_STR_NAME, &dim_str_name) != NC_NOERR) { int max_name = ex_inquire_int(exoid, EX_INQ_MAX_READ_NAME_LENGTH); if (max_name < ex_default_max_name_length) { max_name = ex_default_max_name_length; } if ((status=nc_def_dim (rootid, DIM_STR_NAME, max_name+1, &dim_str_name)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define name string length in file id %d",rootid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; } } if ((status = nc_def_dim(exoid, DIM_TIME, NC_UNLIMITED, &timedim)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define time dimension in file id %d", exoid); ex_err("ex_create",errmsg,exerrval); return (EX_FATAL); } dim[0] = timedim; if ((status = nc_def_var(exoid, VAR_WHOLE_TIME, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define whole time step variable in file id %d", exoid); ex_err("ex_create",errmsg,exerrval); return (EX_FATAL); } ex_compress_variable(exoid, temp, 2); if ((status = nc_def_dim(exoid, DIM_NUM_DIM, model->num_dim, &numdimdim)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define number of dimensions in file id %d",exoid); ex_err("ex_put_init_ext",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 model->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 (model->num_nodes > 0) { if ((status = nc_def_dim(exoid, DIM_NUM_NODES, model->num_nodes, &numnoddim)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define number of nodes in file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } if (model->num_elem > 0) { if (model->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_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } if ((status = nc_def_dim(exoid, DIM_NUM_ELEM, model->num_elem, &temp)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define number of elements in file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } if (model->num_edge > 0) { if (model->num_nodes <= 0) { exerrval = EX_MSG; sprintf(errmsg, "Error: Cannot have non-zero edge count if node count is zero.in file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } if ((status = nc_def_dim(exoid, DIM_NUM_EDGE, model->num_edge, &temp)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define number of edges in file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } if (model->num_face > 0) { if (model->num_nodes <= 0) { exerrval = EX_MSG; sprintf(errmsg, "Error: Cannot have non-zero face count if node count is zero.in file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } if ((status = nc_def_dim(exoid, DIM_NUM_FACE, model->num_face, &temp)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define number of faces in file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } if (ex_write_object_params(exoid, "element block", DIM_NUM_EL_BLK, VAR_STAT_EL_BLK, VAR_ID_EL_BLK, model->num_elem_blk, &elblkdim)) { goto error_ret; } if (ex_write_object_params(exoid, "edge block", DIM_NUM_ED_BLK, VAR_STAT_ED_BLK, VAR_ID_ED_BLK, model->num_edge_blk, &edblkdim)) { goto error_ret; } if (ex_write_object_params(exoid, "face block", DIM_NUM_FA_BLK, VAR_STAT_FA_BLK, VAR_ID_FA_BLK, model->num_face_blk, &fablkdim)) { goto error_ret; } if (ex_write_object_params(exoid, "node set", DIM_NUM_NS, VAR_NS_STAT, VAR_NS_IDS, model->num_node_sets, &nsetdim)) { goto error_ret; } if (ex_write_object_params(exoid, "edge set", DIM_NUM_ES, VAR_ES_STAT, VAR_ES_IDS, model->num_edge_sets, &esetdim)) { goto error_ret; } if (ex_write_object_params(exoid, "face set", DIM_NUM_FS, VAR_FS_STAT, VAR_FS_IDS, model->num_face_sets, &fsetdim)) { goto error_ret; } if (ex_write_object_params(exoid, "side set", DIM_NUM_SS, VAR_SS_STAT, VAR_SS_IDS, model->num_side_sets, &ssetdim)) { goto error_ret; } if (ex_write_object_params(exoid, "elem set", DIM_NUM_ELS, VAR_ELS_STAT, VAR_ELS_IDS, model->num_elem_sets, &elsetdim)) { goto error_ret; } if (ex_write_map_params(exoid, "node map", DIM_NUM_NM, VAR_NM_PROP(1), model->num_node_maps, &nmapdim) != NC_NOERR) { goto error_ret; } if (ex_write_map_params(exoid, "edge map", DIM_NUM_EDM, VAR_EDM_PROP(1), model->num_edge_maps, &edmapdim) != NC_NOERR) { goto error_ret; } if (ex_write_map_params(exoid, "face map", DIM_NUM_FAM, VAR_FAM_PROP(1), model->num_face_maps, &famapdim) != NC_NOERR) { goto error_ret; } if (ex_write_map_params(exoid, "element map", DIM_NUM_EM, VAR_EM_PROP(1), model->num_elem_maps, &emapdim) != NC_NOERR) { goto error_ret; } /* * 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 (model->num_nodes > 0) { if (ex_large_model(exoid) == 1) { /* node coordinate arrays -- separate storage... */ dim[0] = numnoddim; if (model->num_dim > 0) { if ((status = nc_def_var (exoid, VAR_COORD_X, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define node x coordinate array in file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } ex_compress_variable(exoid, temp, 2); } if (model->num_dim > 1) { if ((status = nc_def_var(exoid, VAR_COORD_Y, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define node y coordinate array in file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } ex_compress_variable(exoid, temp, 2); } if (model->num_dim > 2) { if ((status = nc_def_var(exoid, VAR_COORD_Z, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define node z coordinate array in file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } ex_compress_variable(exoid, temp, 2); } } else { /* node coordinate arrays: -- all stored together (old method) */ dim[0] = numdimdim; dim[1] = numnoddim; if ((status = nc_def_var(exoid, VAR_COORD, nc_flt_code(exoid), 2, dim, &temp)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to define node coordinate array in file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } } } if (ex_write_object_names(exoid, "element block",VAR_NAME_EL_BLK,elblkdim, dim_str_name, model->num_elem_blk) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "edge block", VAR_NAME_ED_BLK,edblkdim, dim_str_name, model->num_edge_blk) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "face block", VAR_NAME_FA_BLK,fablkdim, dim_str_name, model->num_face_blk) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "node set", VAR_NAME_NS, nsetdim, dim_str_name, model->num_node_sets) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "edge set", VAR_NAME_ES, esetdim, dim_str_name, model->num_edge_sets) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "face set", VAR_NAME_FS, fsetdim, dim_str_name, model->num_face_sets) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "side set", VAR_NAME_SS, ssetdim, dim_str_name, model->num_side_sets) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "element set", VAR_NAME_ELS, elsetdim, dim_str_name, model->num_elem_sets) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "node map", VAR_NAME_NM, nmapdim, dim_str_name, model->num_node_maps) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "edge map", VAR_NAME_EDM, edmapdim, dim_str_name, model->num_edge_maps) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "face map", VAR_NAME_FAM, famapdim, dim_str_name, model->num_face_maps) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "element map", VAR_NAME_EM, emapdim, dim_str_name, model->num_elem_maps) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "coordinate", VAR_NAME_COOR, numdimdim,dim_str_name, model->num_dim) != NC_NOERR) { goto error_ret; } /* leave define mode */ if ((status = nc_enddef (exoid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to complete variable definitions in file id %d",exoid); ex_err("ex_put_init_ext",errmsg,exerrval); return (EX_FATAL); } /* Fill the id and status arrays with EX_INVALID_ID */ { int *invalid_ids = NULL; int maxset = model->num_elem_blk; if (maxset < model->num_edge_blk) { maxset = model->num_edge_blk; } if (maxset < model->num_face_blk) { maxset = model->num_face_blk; } if (maxset < model->num_node_sets) { maxset = model->num_node_sets; } if (maxset < model->num_edge_sets) { maxset = model->num_edge_sets; } if (maxset < model->num_face_sets) { maxset = model->num_face_sets; } if (maxset < model->num_side_sets) { maxset = model->num_side_sets; } if (maxset < model->num_elem_sets) { maxset = model->num_elem_sets; } if (maxset < model->num_node_maps) { maxset = model->num_node_maps; } if (maxset < model->num_edge_maps) { maxset = model->num_edge_maps; } if (maxset < model->num_face_maps) { maxset = model->num_face_maps; } if (maxset < model->num_elem_maps) { maxset = model->num_elem_maps; } /* allocate space for id/status array */ if (!(invalid_ids = malloc(maxset*sizeof(int)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate memory for id/status array for file id %d", exoid); ex_err("ex_put_init_ext",errmsg,exerrval); return (EX_FATAL); } invalidate_id_status(exoid, VAR_STAT_EL_BLK, VAR_ID_EL_BLK, model->num_elem_blk, invalid_ids); invalidate_id_status(exoid, VAR_STAT_ED_BLK, VAR_ID_ED_BLK, model->num_edge_blk, invalid_ids); invalidate_id_status(exoid, VAR_STAT_FA_BLK, VAR_ID_FA_BLK, model->num_face_blk, invalid_ids); invalidate_id_status(exoid, VAR_NS_STAT, VAR_NS_IDS, model->num_node_sets, invalid_ids); invalidate_id_status(exoid, VAR_ES_STAT, VAR_ES_IDS, model->num_edge_sets, invalid_ids); invalidate_id_status(exoid, VAR_FS_STAT, VAR_FS_IDS, model->num_face_sets, invalid_ids); invalidate_id_status(exoid, VAR_SS_STAT, VAR_SS_IDS, model->num_side_sets, invalid_ids); invalidate_id_status(exoid, VAR_ELS_STAT, VAR_ELS_IDS, model->num_elem_sets, invalid_ids); invalidate_id_status(exoid, 0, VAR_NM_PROP(1), model->num_node_maps, invalid_ids); invalidate_id_status(exoid, 0, VAR_EDM_PROP(1), model->num_edge_maps, invalid_ids); invalidate_id_status(exoid, 0, VAR_FAM_PROP(1), model->num_face_maps, invalid_ids); invalidate_id_status(exoid, 0, VAR_EM_PROP(1), model->num_elem_maps, invalid_ids); if (invalid_ids != NULL) { free(invalid_ids); invalid_ids = NULL; } } /* Write dummy values to the names arrays to avoid corruption issues on some platforms */ if (model->num_elem_blk > 0) { write_dummy_names(exoid, EX_ELEM_BLOCK); } if (model->num_edge_blk > 0) { write_dummy_names(exoid, EX_EDGE_BLOCK); } if (model->num_face_blk > 0) { write_dummy_names(exoid, EX_FACE_BLOCK); } if (model->num_node_sets> 0) { write_dummy_names(exoid, EX_NODE_SET); } if (model->num_edge_sets> 0) { write_dummy_names(exoid, EX_EDGE_SET); } if (model->num_face_sets> 0) { write_dummy_names(exoid, EX_FACE_SET); } if (model->num_side_sets> 0) { write_dummy_names(exoid, EX_SIDE_SET); } if (model->num_elem_sets> 0) { write_dummy_names(exoid, EX_ELEM_SET); } if (model->num_node_maps> 0) { write_dummy_names(exoid, EX_NODE_MAP); } if (model->num_edge_maps> 0) { write_dummy_names(exoid, EX_EDGE_MAP); } if (model->num_face_maps> 0) { write_dummy_names(exoid, EX_FACE_MAP); } if (model->num_elem_maps> 0) { write_dummy_names(exoid, EX_ELEM_MAP); } return (EX_NOERR); /* Fatal error: exit definition mode and return */ error_ret: if (nc_enddef (exoid) != NC_NOERR) /* exit define mode */ { sprintf(errmsg, "Error: failed to complete definition for file id %d", exoid); ex_err("ex_put_init_ext",errmsg,exerrval); } return (EX_FATAL); }
/*! * writes a map; this is a vector of integers of length number of mesh * objects of that type (element, node, face, edge) */ int ex_put_partial_num_map (int exoid, ex_entity_type map_type, ex_entity_id map_id, int64_t ent_start, int64_t ent_count, const void_int *map) { int status; int dimid, varid, map_ndx, map_exists; size_t start[1]; size_t num_maps, num_mobj, count[1]; int cur_num_maps; char errmsg[MAX_ERR_LENGTH]; const char* dnumentries; const char* dnummaps; const char* vmapids; const char* vmap; exerrval = 0; /* clear error code */ switch ( map_type ) { case EX_NODE_MAP: dnumentries = DIM_NUM_NODES; dnummaps = DIM_NUM_NM; vmapids = VAR_NM_PROP(1); break; case EX_EDGE_MAP: dnumentries = DIM_NUM_EDGE; dnummaps = DIM_NUM_EDM; vmapids = VAR_EDM_PROP(1); break; case EX_FACE_MAP: dnumentries = DIM_NUM_FACE; dnummaps = DIM_NUM_FAM; vmapids = VAR_FAM_PROP(1); break; case EX_ELEM_MAP: dnumentries = DIM_NUM_ELEM; dnummaps = DIM_NUM_EM; vmapids = VAR_EM_PROP(1); 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 (nc_inq_dimid (exoid, dnumentries, &dimid) != NC_NOERR ) { return (EX_NOERR); } /* first check if any maps are specified */ if ((status = nc_inq_dimid (exoid, dnummaps, &dimid)) != NC_NOERR ) { exerrval = status; sprintf(errmsg, "Error: no %ss specified in file id %d", ex_name_of_object(map_type),exoid); ex_err("ex_put_partial_num_map",errmsg,exerrval); return (EX_FATAL); } /* Check for duplicate map id entry */ ex_id_lkup(exoid,map_type,map_id); if (exerrval == EX_LOOKUPFAIL) { /* did not find the map id */ map_exists = 0; /* Map is being defined */ } else { map_exists = 1; /* A portion of this map has already been written */ } /* Check for duplicate map id entry */ if (!map_exists) { /* Get number of maps initialized for this file */ if ((status = nc_inq_dimlen(exoid,dimid,&num_maps)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get number of %ss in file id %d", ex_name_of_object(map_type),exoid); ex_err("ex_put_partial_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 element maps for a specific file and returns that value. */ cur_num_maps = ex_get_file_item(exoid, ex_get_counter_list(map_type)); if (cur_num_maps >= (int)num_maps) { exerrval = EX_FATAL; sprintf(errmsg, "Error: exceeded number of %ss (%"ST_ZU") specified in file id %d", ex_name_of_object(map_type),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 element maps for a specific file and returns that value incremented. */ cur_num_maps = ex_inc_file_item(exoid, ex_get_counter_list(map_type)); } else { map_ndx = ex_id_lkup(exoid,map_type,map_id); cur_num_maps = map_ndx-1; } /* determine number of elements */ if ((status = nc_inq_dimid(exoid, dnumentries, &dimid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: couldn't determine number of mesh objects in file id %d", exoid); ex_err("ex_put_partial_num_map",errmsg,exerrval); return (EX_FATAL); } if ((status = nc_inq_dimlen(exoid, dimid, &num_mobj)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get number of mesh objects in file id %d", exoid); ex_err("ex_put_partial_num_map",errmsg,exerrval); return (EX_FATAL); } /* Check input parameters for a valid range of numbers */ if (ent_start <= 0 || ent_start > num_mobj) { exerrval = EX_FATAL; sprintf(errmsg, "Error: start count is invalid in file id %d", exoid); ex_err("ex_put_partial_num_map",errmsg,exerrval); return (EX_FATAL); } if (ent_count < 0) { exerrval = EX_FATAL; sprintf(errmsg, "Error: Invalid count value in file id %d", exoid); ex_err("ex_put_partial_num_map",errmsg,exerrval); return (EX_FATAL); } if (ent_start+ent_count-1 > num_mobj) { exerrval = EX_FATAL; sprintf(errmsg, "Error: start+count-1 is larger than mesh object count in file id %d", exoid); ex_err("ex_put_partial_num_map",errmsg,exerrval); return (EX_FATAL); } /* write out information to previously defined variable */ /* first get id of variable */ if ((status = nc_inq_varid (exoid, vmapids, &varid)) == -1) { exerrval = status; sprintf(errmsg, "Error: failed to locate %s ids in file id %d", ex_name_of_object(map_type),exoid); ex_err("ex_put_num_map",errmsg,exerrval); return (EX_FATAL); } /* then, write out map id */ if (!map_exists) { start[0] = cur_num_maps; { if ((status = nc_put_var1_longlong(exoid, varid, start, (long long*)&map_id)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to store %s id %"PRId64" in file id %d", ex_name_of_object(map_type),map_id,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; default: exerrval = 1005; sprintf(errmsg, "Internal Error: unrecognized map type in switch: %d in file id %d", map_type,exoid); ex_err("ex_putt_partial_one_attr",errmsg,EX_MSG); return (EX_FATAL); } /* locate variable array in which to store the map */ if ((status = nc_inq_varid(exoid,vmap, &varid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate %s %"PRId64" in file id %d", ex_name_of_object(map_type),map_id,exoid); ex_err("ex_put_partial_num_map",errmsg,exerrval); return (EX_FATAL); } /* write out the map */ start[0] = ent_start-1; count[0] = ent_count; if (count[0] == 0) start[0] = 0; if (ex_int64_status(exoid) & EX_MAPS_INT64_API) { status = nc_put_vara_longlong(exoid, varid, start, count, map); } else { status = nc_put_vara_int(exoid, varid, start, count, map); } if (status != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to store %s in file id %d", ex_name_of_object(map_type),exoid); ex_err("ex_put_partial_num_map",errmsg,exerrval); return (EX_FATAL); } return (EX_NOERR); }
int ex_id_lkup( int exoid, ex_entity_type id_type, int num) { char id_table[MAX_VAR_NAME_LENGTH+1]; char id_dim[MAX_VAR_NAME_LENGTH+1]; char stat_table[MAX_VAR_NAME_LENGTH+1]; int varid, dimid; size_t dim_len, i; int *id_vals=NULL, *stat_vals=NULL; static int filled=FALSE; struct obj_stats *tmp_stats; int status; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ switch(id_type) { case EX_NODAL: return 0; case EX_GLOBAL: return 0; case EX_ELEM_BLOCK: strcpy(id_table, VAR_ID_EL_BLK); /* id array name */ strcpy(id_dim, DIM_NUM_EL_BLK); /* id array dimension name*/ strcpy(stat_table, VAR_STAT_EL_BLK); /* id status array name */ tmp_stats = ex_get_stat_ptr (exoid, &exoII_eb); break; case EX_NODE_SET: strcpy(id_table, VAR_NS_IDS); strcpy(id_dim, DIM_NUM_NS); strcpy(stat_table, VAR_NS_STAT); tmp_stats = ex_get_stat_ptr (exoid, &exoII_ns); break; case EX_SIDE_SET: strcpy(id_table, VAR_SS_IDS); strcpy(id_dim, DIM_NUM_SS); strcpy(stat_table, VAR_SS_STAT); tmp_stats = ex_get_stat_ptr (exoid, &exoII_ss); break; case EX_ELEM_MAP: strcpy(id_table, VAR_EM_PROP(1)); strcpy(id_dim, DIM_NUM_EM); strcpy(stat_table, ""); tmp_stats = ex_get_stat_ptr (exoid, &exoII_em); break; case EX_NODE_MAP: strcpy(id_table, VAR_NM_PROP(1)); strcpy(id_dim, DIM_NUM_NM); strcpy(stat_table, ""); tmp_stats = ex_get_stat_ptr (exoid, &exoII_nm); break; case EX_EDGE_BLOCK: strcpy(id_table, VAR_ID_ED_BLK); strcpy(id_dim, DIM_NUM_ED_BLK); strcpy(stat_table, VAR_STAT_ED_BLK); tmp_stats = ex_get_stat_ptr (exoid, &exoII_ed); break; case EX_FACE_BLOCK: strcpy(id_table, VAR_ID_FA_BLK); strcpy(id_dim, DIM_NUM_FA_BLK); strcpy(stat_table, VAR_STAT_FA_BLK); tmp_stats = ex_get_stat_ptr (exoid, &exoII_fa); break; case EX_EDGE_SET: strcpy(id_table, VAR_ES_IDS); strcpy(id_dim, DIM_NUM_ES); strcpy(stat_table, VAR_ES_STAT); tmp_stats = ex_get_stat_ptr (exoid, &exoII_es); break; case EX_FACE_SET: strcpy(id_table, VAR_FS_IDS); strcpy(id_dim, DIM_NUM_FS); strcpy(stat_table, VAR_FS_STAT); tmp_stats = ex_get_stat_ptr (exoid, &exoII_fs); break; case EX_ELEM_SET: strcpy(id_table, VAR_ELS_IDS); strcpy(id_dim, DIM_NUM_ELS); strcpy(stat_table, VAR_ELS_STAT); tmp_stats = ex_get_stat_ptr (exoid, &exoII_els); break; case EX_EDGE_MAP: strcpy(id_table, VAR_EDM_PROP(1)); strcpy(id_dim, DIM_NUM_EDM); strcpy(stat_table, ""); tmp_stats = ex_get_stat_ptr (exoid, &exoII_edm); break; case EX_FACE_MAP: strcpy(id_table, VAR_FAM_PROP(1)); strcpy(id_dim, DIM_NUM_FAM); strcpy(stat_table, ""); tmp_stats = ex_get_stat_ptr (exoid, &exoII_fam); break; default: exerrval = EX_BADPARAM; sprintf(errmsg, "Error: unsupported id array type %d for file id %d", id_type, exoid); ex_err("ex_id_lkup",errmsg,exerrval); return (EX_FATAL); } if ( (tmp_stats->id_vals == NULL) || (!(tmp_stats->valid_ids)) ) { /* first time thru or id arrays haven't been completely filled yet */ /* get size of id array */ /* First get dimension id of id array */ if ((status = nc_inq_dimid(exoid,id_dim,&dimid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate id array dimension in file id %d", exoid); ex_err("ex_id_lkup",errmsg,exerrval); return (EX_FATAL); } /* Next get value of dimension */ if ((status = nc_inq_dimlen(exoid,dimid,&dim_len)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate %s array length in file id %d", id_table,exoid); ex_err("ex_id_lkup",errmsg,exerrval); return (EX_FATAL); } /* get variable id of id array */ if ((status = nc_inq_varid (exoid, id_table, &varid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate %s array in file id %d", id_table, exoid); ex_err("ex_id_lkup",errmsg,exerrval); return (EX_FATAL); } /* allocate space for id array */ if (!(id_vals = malloc((int)dim_len*sizeof(int)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate memory for %s array for file id %d", id_table,exoid); ex_err("ex_id_lkup",errmsg,exerrval); return (EX_FATAL); } if ((status = nc_get_var_int (exoid, varid, id_vals)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get %s array from file id %d", id_table,exoid); ex_err("ex_id_lkup",errmsg,exerrval); free(id_vals); return (EX_FATAL); } /* check if values in stored arrays are filled with non-zeroes */ filled = TRUE; for (i=0;i<dim_len;i++) { if (id_vals[i] == 0 || id_vals[i] == NC_FILL_INT) { filled = FALSE; break; /* id array hasn't been completely filled with valid ids yet */ } } if (filled) { tmp_stats->valid_ids = TRUE; tmp_stats->num = (long)dim_len; tmp_stats->id_vals = id_vals; } } else { id_vals = tmp_stats->id_vals; dim_len = tmp_stats->num; } /* Do a linear search through the id array to find the array value corresponding to the passed index number */ for (i=0;i<dim_len;i++) { if (id_vals[i] == num) break; /* found the id requested */ } if (i >= dim_len) /* failed to find id number */ { if ( !(tmp_stats->valid_ids) ) { free (id_vals); } exerrval = EX_LOOKUPFAIL; return(EX_LOOKUPFAIL); /*if we got here, the id array value doesn't exist */ } /* Now check status array to see if object is null */ /* get variable id of status array */ if (nc_inq_varid (exoid, stat_table, &varid) == NC_NOERR) { /* if status array exists, use it, otherwise assume object exists to be backward compatible */ if ( (tmp_stats->stat_vals == NULL) || (!(tmp_stats->valid_stat)) ) { /* first time thru or status arrays haven't been filled yet */ /* allocate space for new status array */ if (!(stat_vals = malloc((int)dim_len*sizeof(int)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate memory for %s array for file id %d", id_table,exoid); ex_err("ex_id_lkup",errmsg,exerrval); return (EX_FATAL); } if ((status = nc_get_var_int (exoid, varid, stat_vals)) != NC_NOERR) { exerrval = status; free(stat_vals); sprintf(errmsg, "Error: failed to get %s array from file id %d", stat_table,exoid); ex_err("ex_id_lkup",errmsg,exerrval); return (EX_FATAL); } if (tmp_stats->valid_ids) { /* status array is valid only if ids are valid */ tmp_stats->valid_stat = TRUE; tmp_stats->stat_vals = stat_vals; } } else { stat_vals = tmp_stats->stat_vals; } if (stat_vals[i] == 0) /* is this object null? */ { exerrval = EX_NULLENTITY; if ( !(tmp_stats->valid_stat) ) { free (stat_vals); } if ( !(tmp_stats->valid_ids) ) { if (id_vals) free (id_vals); } return(-(((int)i)+1)); /* return index into id array (1-based) */ } } if ( !(tmp_stats->valid_ids) ) { if (id_vals) free (id_vals); if (stat_vals) free (stat_vals); } return(((int)i)+1); /* return index into id array (1-based) */ }
int ex_put_init_ext(int exoid, const ex_init_params *model) { int numdimdim, numnoddim, elblkdim, edblkdim, fablkdim, esetdim, fsetdim, elsetdim, nsetdim, ssetdim, dim_str_name, dim[2], temp; int nmapdim, edmapdim, famapdim, emapdim, timedim; int status; int title_len; #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]; EX_FUNC_ENTER(); int rootid = exoid & EX_FILE_ID_MASK; ex_check_valid_file_id(exoid, __func__); if (rootid == exoid && nc_inq_dimid(exoid, DIM_NUM_DIM, &temp) == NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: initialization already done for file id %d", exoid); ex_err(__func__, errmsg, EX_MSG); EX_FUNC_LEAVE(EX_FATAL); } /* put file into define mode */ if ((status = nc_redef(exoid)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to put file id %d into define mode", exoid); ex_err(__func__, errmsg, status); EX_FUNC_LEAVE(EX_FATAL); } /* define some attributes... */ title_len = strlen(model->title) < MAX_LINE_LENGTH ? strlen(model->title) : MAX_LINE_LENGTH; if ((status = nc_put_att_text(rootid, NC_GLOBAL, (const char *)ATT_TITLE, title_len + 1, model->title)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define model->title attribute to file id %d", rootid); ex_err(__func__, errmsg, status); goto error_ret; /* exit define mode and return */ } /* ...and some dimensions... */ /* create name string length dimension */ if (nc_inq_dimid(rootid, DIM_STR_NAME, &dim_str_name) != NC_NOERR) { if ((status = nc_def_dim(rootid, DIM_STR_NAME, NC_MAX_NAME, &dim_str_name)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define name string length in file id %d", rootid); ex_err(__func__, errmsg, status); goto error_ret; } } if ((status = nc_def_dim(exoid, DIM_TIME, NC_UNLIMITED, &timedim)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define time dimension in file id %d", exoid); ex_err(__func__, errmsg, status); goto error_ret; } dim[0] = timedim; if ((status = nc_def_var(exoid, VAR_WHOLE_TIME, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define whole time step variable in file id %d", exoid); ex_err(__func__, errmsg, status); goto error_ret; } { struct ex_file_item *file = ex_find_file_item(exoid); file->time_varid = temp; } ex_compress_variable(exoid, temp, 2); if ((status = nc_def_dim(exoid, DIM_NUM_DIM, model->num_dim, &numdimdim)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define number of dimensions in file id %d", exoid); ex_err(__func__, errmsg, status); 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 model->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 (model->num_nodes > 0) { if ((status = nc_def_dim(exoid, DIM_NUM_NODES, model->num_nodes, &numnoddim)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define number of nodes in file id %d", exoid); ex_err(__func__, errmsg, status); goto error_ret; /* exit define mode and return */ } } if (model->num_elem > 0) { if (model->num_nodes <= 0) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Cannot have non-zero element count if node count " "is zero.in file id %d", exoid); ex_err(__func__, errmsg, EX_BADPARAM); goto error_ret; /* exit define mode and return */ } if ((status = nc_def_dim(exoid, DIM_NUM_ELEM, model->num_elem, &temp)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define number of elements in file id %d", exoid); ex_err(__func__, errmsg, status); goto error_ret; /* exit define mode and return */ } } if (model->num_edge > 0) { if (model->num_nodes <= 0) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Cannot have non-zero edge count if node count is " "zero.in file id %d", exoid); ex_err(__func__, errmsg, EX_BADPARAM); goto error_ret; /* exit define mode and return */ } if ((status = nc_def_dim(exoid, DIM_NUM_EDGE, model->num_edge, &temp)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define number of edges in file id %d", exoid); ex_err(__func__, errmsg, status); goto error_ret; /* exit define mode and return */ } } if (model->num_face > 0) { if (model->num_nodes <= 0) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Cannot have non-zero face count if node count is " "zero.in file id %d", exoid); ex_err(__func__, errmsg, EX_BADPARAM); goto error_ret; /* exit define mode and return */ } if ((status = nc_def_dim(exoid, DIM_NUM_FACE, model->num_face, &temp)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define number of faces in file id %d", exoid); ex_err(__func__, errmsg, status); goto error_ret; /* exit define mode and return */ } } if (ex_write_object_params(exoid, "element block", DIM_NUM_EL_BLK, VAR_STAT_EL_BLK, VAR_ID_EL_BLK, model->num_elem_blk, &elblkdim)) { goto error_ret; } if (ex_write_object_params(exoid, "edge block", DIM_NUM_ED_BLK, VAR_STAT_ED_BLK, VAR_ID_ED_BLK, model->num_edge_blk, &edblkdim)) { goto error_ret; } if (ex_write_object_params(exoid, "face block", DIM_NUM_FA_BLK, VAR_STAT_FA_BLK, VAR_ID_FA_BLK, model->num_face_blk, &fablkdim)) { goto error_ret; } if (ex_write_object_params(exoid, "node set", DIM_NUM_NS, VAR_NS_STAT, VAR_NS_IDS, model->num_node_sets, &nsetdim)) { goto error_ret; } if (ex_write_object_params(exoid, "edge set", DIM_NUM_ES, VAR_ES_STAT, VAR_ES_IDS, model->num_edge_sets, &esetdim)) { goto error_ret; } if (ex_write_object_params(exoid, "face set", DIM_NUM_FS, VAR_FS_STAT, VAR_FS_IDS, model->num_face_sets, &fsetdim)) { goto error_ret; } if (ex_write_object_params(exoid, "side set", DIM_NUM_SS, VAR_SS_STAT, VAR_SS_IDS, model->num_side_sets, &ssetdim)) { goto error_ret; } if (ex_write_object_params(exoid, "elem set", DIM_NUM_ELS, VAR_ELS_STAT, VAR_ELS_IDS, model->num_elem_sets, &elsetdim)) { goto error_ret; } if (ex_write_map_params(exoid, "node map", DIM_NUM_NM, VAR_NM_PROP(1), model->num_node_maps, &nmapdim) != NC_NOERR) { goto error_ret; } if (ex_write_map_params(exoid, "edge map", DIM_NUM_EDM, VAR_EDM_PROP(1), model->num_edge_maps, &edmapdim) != NC_NOERR) { goto error_ret; } if (ex_write_map_params(exoid, "face map", DIM_NUM_FAM, VAR_FAM_PROP(1), model->num_face_maps, &famapdim) != NC_NOERR) { goto error_ret; } if (ex_write_map_params(exoid, "element map", DIM_NUM_EM, VAR_EM_PROP(1), model->num_elem_maps, &emapdim) != NC_NOERR) { goto error_ret; } if (model->num_nodes > 0) { dim[0] = numnoddim; if (model->num_dim > 0) { if ((status = nc_def_var(exoid, VAR_COORD_X, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define node x coordinate array in file id %d", exoid); ex_err(__func__, errmsg, status); goto error_ret; /* exit define mode and return */ } ex_compress_variable(exoid, temp, 2); } if (model->num_dim > 1) { if ((status = nc_def_var(exoid, VAR_COORD_Y, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define node y coordinate array in file id %d", exoid); ex_err(__func__, errmsg, status); goto error_ret; /* exit define mode and return */ } ex_compress_variable(exoid, temp, 2); } if (model->num_dim > 2) { if ((status = nc_def_var(exoid, VAR_COORD_Z, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define node z coordinate array in file id %d", exoid); ex_err(__func__, errmsg, status); goto error_ret; /* exit define mode and return */ } ex_compress_variable(exoid, temp, 2); } } if (ex_write_object_names(exoid, "element block", VAR_NAME_EL_BLK, elblkdim, dim_str_name, model->num_elem_blk) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "edge block", VAR_NAME_ED_BLK, edblkdim, dim_str_name, model->num_edge_blk) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "face block", VAR_NAME_FA_BLK, fablkdim, dim_str_name, model->num_face_blk) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "node set", VAR_NAME_NS, nsetdim, dim_str_name, model->num_node_sets) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "edge set", VAR_NAME_ES, esetdim, dim_str_name, model->num_edge_sets) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "face set", VAR_NAME_FS, fsetdim, dim_str_name, model->num_face_sets) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "side set", VAR_NAME_SS, ssetdim, dim_str_name, model->num_side_sets) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "element set", VAR_NAME_ELS, elsetdim, dim_str_name, model->num_elem_sets) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "node map", VAR_NAME_NM, nmapdim, dim_str_name, model->num_node_maps) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "edge map", VAR_NAME_EDM, edmapdim, dim_str_name, model->num_edge_maps) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "face map", VAR_NAME_FAM, famapdim, dim_str_name, model->num_face_maps) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "element map", VAR_NAME_EM, emapdim, dim_str_name, model->num_elem_maps) != NC_NOERR) { goto error_ret; } if (ex_write_object_names(exoid, "coordinate", VAR_NAME_COOR, numdimdim, dim_str_name, model->num_dim) != NC_NOERR) { goto error_ret; } /* leave define mode */ if ((status = nc_enddef(exoid)) != NC_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete variable definitions in file id %d", exoid); ex_err(__func__, errmsg, status); EX_FUNC_LEAVE(EX_FATAL); } /* Fill the id and status arrays with EX_INVALID_ID */ { int *invalid_ids = NULL; int maxset = model->num_elem_blk; if (maxset < model->num_edge_blk) { maxset = model->num_edge_blk; } if (maxset < model->num_face_blk) { maxset = model->num_face_blk; } if (maxset < model->num_node_sets) { maxset = model->num_node_sets; } if (maxset < model->num_edge_sets) { maxset = model->num_edge_sets; } if (maxset < model->num_face_sets) { maxset = model->num_face_sets; } if (maxset < model->num_side_sets) { maxset = model->num_side_sets; } if (maxset < model->num_elem_sets) { maxset = model->num_elem_sets; } if (maxset < model->num_node_maps) { maxset = model->num_node_maps; } if (maxset < model->num_edge_maps) { maxset = model->num_edge_maps; } if (maxset < model->num_face_maps) { maxset = model->num_face_maps; } if (maxset < model->num_elem_maps) { maxset = model->num_elem_maps; } /* allocate space for id/status array */ if (!(invalid_ids = malloc(maxset * sizeof(int)))) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate memory for id/status array for file id %d", exoid); ex_err(__func__, errmsg, EX_MEMFAIL); EX_FUNC_LEAVE(EX_FATAL); } invalidate_id_status(exoid, VAR_STAT_EL_BLK, VAR_ID_EL_BLK, model->num_elem_blk, invalid_ids); invalidate_id_status(exoid, VAR_STAT_ED_BLK, VAR_ID_ED_BLK, model->num_edge_blk, invalid_ids); invalidate_id_status(exoid, VAR_STAT_FA_BLK, VAR_ID_FA_BLK, model->num_face_blk, invalid_ids); invalidate_id_status(exoid, VAR_NS_STAT, VAR_NS_IDS, model->num_node_sets, invalid_ids); invalidate_id_status(exoid, VAR_ES_STAT, VAR_ES_IDS, model->num_edge_sets, invalid_ids); invalidate_id_status(exoid, VAR_FS_STAT, VAR_FS_IDS, model->num_face_sets, invalid_ids); invalidate_id_status(exoid, VAR_SS_STAT, VAR_SS_IDS, model->num_side_sets, invalid_ids); invalidate_id_status(exoid, VAR_ELS_STAT, VAR_ELS_IDS, model->num_elem_sets, invalid_ids); invalidate_id_status(exoid, 0, VAR_NM_PROP(1), model->num_node_maps, invalid_ids); invalidate_id_status(exoid, 0, VAR_EDM_PROP(1), model->num_edge_maps, invalid_ids); invalidate_id_status(exoid, 0, VAR_FAM_PROP(1), model->num_face_maps, invalid_ids); invalidate_id_status(exoid, 0, VAR_EM_PROP(1), model->num_elem_maps, invalid_ids); if (invalid_ids != NULL) { free(invalid_ids); invalid_ids = NULL; } } /* Write dummy values to the names arrays to avoid corruption issues on some * platforms */ write_dummy_names(exoid, EX_ELEM_BLOCK, model->num_elem_blk); write_dummy_names(exoid, EX_EDGE_BLOCK, model->num_edge_blk); write_dummy_names(exoid, EX_FACE_BLOCK, model->num_face_blk); write_dummy_names(exoid, EX_NODE_SET, model->num_node_sets); write_dummy_names(exoid, EX_EDGE_SET, model->num_edge_sets); write_dummy_names(exoid, EX_FACE_SET, model->num_face_sets); write_dummy_names(exoid, EX_SIDE_SET, model->num_side_sets); write_dummy_names(exoid, EX_ELEM_SET, model->num_elem_sets); write_dummy_names(exoid, EX_NODE_MAP, model->num_node_maps); write_dummy_names(exoid, EX_EDGE_MAP, model->num_edge_maps); write_dummy_names(exoid, EX_FACE_MAP, model->num_face_maps); write_dummy_names(exoid, EX_ELEM_MAP, model->num_elem_maps); EX_FUNC_LEAVE(EX_NOERR); /* Fatal error: exit definition mode and return */ error_ret: if ((status = nc_enddef(exoid)) != NC_NOERR) /* exit define mode */ { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition for file id %d", exoid); ex_err(__func__, errmsg, status); } EX_FUNC_LEAVE(EX_FATAL); }
int ex_get_prop_names (int exoid, ex_entity_type obj_type, char **prop_names) { int status; int i, num_props, propid; char var_name[12]; size_t att_len; nc_type att_type; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* determine which type of object property names are desired for */ num_props = ex_get_num_props (exoid, obj_type); for (i=0; i<num_props; i++) { switch (obj_type) { case EX_ELEM_BLOCK: strcpy (var_name, VAR_EB_PROP(i+1)); break; case EX_FACE_BLOCK: strcpy (var_name, VAR_FA_PROP(i+1)); break; case EX_EDGE_BLOCK: strcpy (var_name, VAR_ED_PROP(i+1)); break; case EX_NODE_SET: strcpy (var_name, VAR_NS_PROP(i+1)); break; case EX_SIDE_SET: strcpy (var_name, VAR_SS_PROP(i+1)); break; case EX_EDGE_SET: strcpy (var_name, VAR_ES_PROP(i+1)); break; case EX_FACE_SET: strcpy (var_name, VAR_FS_PROP(i+1)); break; case EX_ELEM_SET: strcpy (var_name, VAR_ELS_PROP(i+1)); break; case EX_ELEM_MAP: strcpy (var_name, VAR_EM_PROP(i+1)); break; case EX_FACE_MAP: strcpy (var_name, VAR_FAM_PROP(i+1)); break; case EX_EDGE_MAP: strcpy (var_name, VAR_EDM_PROP(i+1)); break; case EX_NODE_MAP: strcpy (var_name, VAR_NM_PROP(i+1)); break; default: exerrval = EX_BADPARAM; sprintf(errmsg, "Error: object type %d not supported; file id %d", obj_type, exoid); ex_err("ex_get_prop_names",errmsg,EX_BADPARAM); return(EX_FATAL); } if ((status = nc_inq_varid(exoid, var_name, &propid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate property array %s in file id %d", var_name, exoid); ex_err("ex_get_prop_names",errmsg,exerrval); return (EX_FATAL); } /* for each property, read the "name" attribute of property array variable */ if ((status = nc_inq_att(exoid, propid, ATT_PROP_NAME, &att_type, &att_len)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get property attributes (type, len) in file id %d", exoid); ex_err("ex_get_prop_names",errmsg,exerrval); return (EX_FATAL); } if (att_len-1 <= ex_max_name_length) { /* Client has large enough char string to hold text... */ if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, prop_names[i])) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get property name in file id %d", exoid); ex_err("ex_get_prop_names",errmsg,exerrval); return (EX_FATAL); } } else { /* FIXME */ exerrval = NC_ESTS; sprintf(errmsg, "Error: property name length exceeds space available to store it in file id %d", exoid); ex_err("ex_get_prop_names",errmsg,exerrval); return (EX_FATAL); } } return (EX_NOERR); }
int ex_put_prop_names (int exoid, ex_entity_type obj_type, int num_props, char **prop_names) { int status; int oldfill, temp; int i, propid, dimid, dims[1]; char name[MAX_VAR_NAME_LENGTH+1]; int vals[1]; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ /* inquire id of previously defined dimension (number of objects) */ if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(obj_type), &dimid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate number of %s in file id %d", ex_name_of_object(obj_type), exoid); ex_err("ex_put_prop_names",errmsg, exerrval); return(EX_FATAL); } nc_set_fill(exoid, NC_FILL, &oldfill); /* fill with zeros per routine spec */ /* put netcdf file into define mode */ if ((status = nc_redef (exoid)) != NC_NOERR) { exerrval = status; 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_FACE_BLOCK: strcpy (name, VAR_FA_PROP(i+2)); break; case EX_EDGE_BLOCK: strcpy (name, VAR_ED_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_EDGE_SET: strcpy (name, VAR_ES_PROP(i+2)); break; case EX_FACE_SET: strcpy (name, VAR_FS_PROP(i+2)); break; case EX_ELEM_SET: strcpy (name, VAR_ELS_PROP(i+2)); break; case EX_ELEM_MAP: strcpy (name, VAR_EM_PROP(i+2)); break; case EX_FACE_MAP: strcpy (name, VAR_FAM_PROP(i+2)); break; case EX_EDGE_MAP: strcpy (name, VAR_EDM_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 ((status = nc_def_var(exoid, name, NC_INT, 1, dims, &propid)) != NC_NOERR) { exerrval = status; 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 ((status = nc_put_att_int(exoid, propid, _FillValue, NC_INT, 1, vals)) != NC_NOERR) { exerrval = status; 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 ((status = nc_put_att_text(exoid, propid, ATT_PROP_NAME, strlen(prop_names[i])+1, prop_names[i])) != NC_NOERR) { exerrval = status; 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 ((status = nc_enddef(exoid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to leave define mode in file id %d", exoid); ex_err("ex_put_prop_names",errmsg,exerrval); return (EX_FATAL); } nc_set_fill(exoid, oldfill, &temp); /* default: turn off fill */ return (EX_NOERR); /* Fatal error: exit definition mode and return */ error_ret: if (nc_enddef (exoid) != NC_NOERR) { /* 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_get_ids (int exoid, ex_entity_type obj_type, void_int *ids) { int varid, status; char errmsg[MAX_ERR_LENGTH]; const char* varidobj; exerrval = 0; /* clear error code */ switch (obj_type) { case EX_EDGE_BLOCK: varidobj = VAR_ID_ED_BLK; break; case EX_FACE_BLOCK: varidobj = VAR_ID_FA_BLK; break; case EX_ELEM_BLOCK: varidobj = VAR_ID_EL_BLK; break; case EX_NODE_SET: varidobj = VAR_NS_IDS; break; case EX_EDGE_SET: varidobj = VAR_ES_IDS; break; case EX_FACE_SET: varidobj = VAR_FS_IDS; break; case EX_SIDE_SET: varidobj = VAR_SS_IDS; break; case EX_ELEM_SET: varidobj = VAR_ELS_IDS; break; case EX_NODE_MAP: varidobj = VAR_NM_PROP(1); break; case EX_EDGE_MAP: varidobj = VAR_EDM_PROP(1); break; case EX_FACE_MAP: varidobj = VAR_FAM_PROP(1); break; case EX_ELEM_MAP: varidobj = VAR_EM_PROP(1); break; default:/* invalid variable type */ exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid type specified in file id %d", exoid); ex_err("ex_get_ids",errmsg,exerrval); return(EX_FATAL); } /* Determine if there are any 'obj-type' objects */ if ((status = nc_inq_dimid (exoid, ex_dim_num_objects(obj_type), &varid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Warning: no %s defined in file id %d", ex_name_of_object(obj_type), exoid); ex_err("ex_get_ids",errmsg,exerrval); return (EX_WARN); } /* inquire id's of previously defined dimensions and variables */ if ((status = nc_inq_varid(exoid, varidobj, &varid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate %s ids variable in file id %d", ex_name_of_object(obj_type),exoid); ex_err("ex_get_ids",errmsg,exerrval); return (EX_FATAL); } /* read in the element block ids */ if (ex_int64_status(exoid) & EX_IDS_INT64_API) { status = nc_get_var_longlong(exoid, varid, ids); } else { status = nc_get_var_int(exoid, varid, ids); } if (status != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to return %s ids in file id %d", ex_name_of_object(obj_type),exoid); ex_err("ex_get_ids",errmsg,exerrval); return (EX_FATAL); } return(EX_NOERR); }