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_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) */
}
