/*! \internal */
int
cpy_var_val(int in_id,int out_id,char *var_nm)
/*
int in_id: input netCDF input-file ID
int out_id: input netCDF output-file ID
char *var_nm: input variable name
*/
{
/* Routine to copy the variable data from an input netCDF file
* to an output netCDF file.
*/
int *dim_id;
int idx;
int nbr_dim;
int var_in_id;
int var_out_id;
size_t *dim_cnt;
size_t *dim_sz;
size_t *dim_srt;
size_t var_sz=1L;
nc_type var_type_in, var_type_out;
void *void_ptr = NULL;
/* Get the var_id for the requested variable from both files. */
(void)nc_inq_varid(in_id, var_nm, &var_in_id);
(void)nc_inq_varid(out_id,var_nm, &var_out_id);
/* Get the number of dimensions for the variable. */
(void)nc_inq_vartype( out_id, var_out_id, &var_type_out);
(void)nc_inq_varndims(out_id, var_out_id, &nbr_dim);
(void)nc_inq_vartype( in_id, var_in_id, &var_type_in);
(void)nc_inq_varndims(in_id, var_in_id, &nbr_dim);
/* Allocate space to hold the dimension IDs */
dim_cnt = malloc(nbr_dim*sizeof(size_t));
dim_id=malloc(nbr_dim*sizeof(int));
dim_sz=malloc(nbr_dim*sizeof(size_t));
dim_srt=malloc(nbr_dim*sizeof(size_t));
/* Get the dimension IDs from the input file */
(void)nc_inq_vardimid(in_id, var_in_id, dim_id);
/* Get the dimension sizes and names from the input file */
for(idx=0;idx<nbr_dim;idx++){
/* NB: For the unlimited dimension, ncdiminq() returns the maximum
value used so far in writing data for that dimension.
Thus if you read the dimension sizes from the output file, then
the ncdiminq() returns dim_sz=0 for the unlimited dimension
until a variable has been written with that dimension. This is
the reason for always reading the input file for the dimension
sizes. */
(void)nc_inq_dimlen(in_id,dim_id[idx],dim_cnt+idx);
/* Initialize the indicial offset and stride arrays */
dim_srt[idx]=0L;
var_sz*=dim_cnt[idx];
} /* end loop over dim */
/* Allocate enough space to hold the variable */
if (var_sz > 0)
void_ptr=malloc(var_sz * type_size(var_type_in));
/* Get the variable */
/* if variable is float or double, convert if necessary */
if(nbr_dim==0){ /* variable is a scalar */
if (var_type_in == NC_INT && var_type_out == NC_INT) {
nc_get_var1_int(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_int(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_INT64 && var_type_out == NC_INT64) {
nc_get_var1_longlong(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_longlong(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_FLOAT) {
nc_get_var1_float(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_float(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_DOUBLE) {
nc_get_var1_double(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_double(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_CHAR) {
nc_get_var1_text(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_text(out_id, var_out_id, 0L, void_ptr);
}
else {
assert(1==0);
}
} else { /* variable is a vector */
if (var_type_in == NC_INT && var_type_out == NC_INT) {
(void)nc_get_var_int(in_id, var_in_id, void_ptr);
(void)nc_put_var_int(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_INT64 && var_type_out == NC_INT64) {
(void)nc_get_var_longlong(in_id, var_in_id, void_ptr);
(void)nc_put_var_longlong(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_FLOAT) {
(void)nc_get_var_float(in_id, var_in_id, void_ptr);
(void)nc_put_var_float(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_DOUBLE) {
(void)nc_get_var_double(in_id, var_in_id, void_ptr);
(void)nc_put_var_double(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_CHAR) {
(void)nc_get_var_text(in_id, var_in_id, void_ptr);
(void)nc_put_var_text(out_id, var_out_id, void_ptr);
}
else {
assert(1==0);
}
} /* end if variable is an array */
/* Free the space that held the dimension IDs */
(void)free(dim_cnt);
(void)free(dim_id);
(void)free(dim_sz);
(void)free(dim_srt);
/* Free the space that held the variable */
(void)free(void_ptr);
return(EX_NOERR);
} /* end cpy_var_val() */
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
main(int argc, char **argv)
{
printf("\n*** Testing netcdf-4 group functions.\n");
printf("*** testing use of unlimited dim in parent group...");
{
#define NDIMS_IN_VAR 1
#define NDIMS_IN_FILE 2
#define BABE_LIMIT 3
#define DIM_NAME1 "Influence"
#define DIM_NAME2 "Babe_Factor"
#define VAR_NAME1 "Court_of_Star_Chamber"
#define VAR_NAME2 "Justice_of_the_Peace"
#define VAR_NAME3 "Bosworth_Field"
int ncid, dimid1, dimid2, varid1, varid2, varid3, henry_vii_id;
int grpid_in, varid_in1, varid_in2, varid_in3;
nc_type xtype_in;
int ndims_in, dimids_in[NDIMS_IN_FILE], dimid1_in, natts;
char name_in[NC_MAX_NAME + 1];
size_t len_in, index[NDIMS_IN_VAR] = {0};
long long value = NC_FILL_INT64 + 1, value_in;
/* Create a file with an unlimited dim and a limited, used by
* variables in child groups. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_NAME1, NC_UNLIMITED, &dimid1)) ERR;
if (nc_def_dim(ncid, DIM_NAME2, BABE_LIMIT, &dimid2)) ERR;
if (nc_def_grp(ncid, HENRY_VII, &henry_vii_id)) ERR;
if (nc_def_var(henry_vii_id, VAR_NAME1, NC_INT64, NDIMS_IN_VAR, &dimid1, &varid1)) ERR;
if (nc_def_var(henry_vii_id, VAR_NAME2, NC_INT64, NDIMS_IN_VAR, &dimid1, &varid2)) ERR;
if (nc_def_var(henry_vii_id, VAR_NAME3, NC_INT64, NDIMS_IN_VAR, &dimid2, &varid3)) ERR;
/* Check it out. Find the group by name. */
if (nc_inq_ncid(ncid, HENRY_VII, &grpid_in)) ERR;
/* Ensure that dimensions in parent are visible and correct. */
if (nc_inq_dimids(grpid_in, &ndims_in, dimids_in, 1)) ERR;
if (ndims_in != NDIMS_IN_FILE || dimids_in[0] != dimid1 || dimids_in[1] != dimid2) ERR;
if (nc_inq_dim(grpid_in, dimids_in[0], name_in, &len_in)) ERR;
if (strcmp(name_in, DIM_NAME1) || len_in != 0) ERR;
if (nc_inq_dim(grpid_in, dimids_in[1], name_in, &len_in)) ERR;
if (strcmp(name_in, DIM_NAME2) || len_in != BABE_LIMIT) ERR;
/* Check the vars in the group. */
if (nc_inq_varid(grpid_in, VAR_NAME1, &varid_in1)) ERR;
if (nc_inq_varid(grpid_in, VAR_NAME2, &varid_in2)) ERR;
if (nc_inq_varid(grpid_in, VAR_NAME3, &varid_in3)) ERR;
if (varid_in1 != varid1 || varid_in2 != varid2 || varid_in3 != varid3) ERR;
if (nc_inq_var(grpid_in, varid1, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME1) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid1 || natts != 0) ERR;
if (nc_inq_var(grpid_in, varid2, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME2) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid1 || natts != 0) ERR;
if (nc_inq_var(grpid_in, varid3, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME3) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid2 || natts != 0) ERR;
/* Write one value to one variable. */
if (nc_put_var1_longlong(grpid_in, varid_in1, index, &value)) ERR;
/* Read one value from the second unlim dim variable. It should
* be the fill value. */
if (nc_get_var1_longlong(grpid_in, varid_in2, index, &value_in)) ERR;
if (value_in != NC_FILL_INT64) ERR;
/* Read one value from the variable with limited dim. It should
* be the fill value. */
if (nc_get_var1_longlong(grpid_in, varid_in3, index, &value_in)) ERR;
if (value_in != NC_FILL_INT64) ERR;
/* Attempt to read beyond end of dimensions to generate error. */
index[0] = BABE_LIMIT;
if (nc_get_var1_longlong(grpid_in, varid_in1, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_get_var1_longlong(grpid_in, varid_in2, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_get_var1_longlong(grpid_in, varid_in3, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_close(ncid)) ERR;
/* Check it out again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Find the group by name. */
if (nc_inq_ncid(ncid, HENRY_VII, &grpid_in)) ERR;
/* Ensure that dimensions in parent are visible and correct. */
if (nc_inq_dimids(grpid_in, &ndims_in, dimids_in, 1)) ERR;
if (ndims_in != NDIMS_IN_FILE || dimids_in[0] != dimid1 || dimids_in[1] != dimid2) ERR;
if (nc_inq_dim(grpid_in, dimids_in[0], name_in, &len_in)) ERR;
if (strcmp(name_in, DIM_NAME1) || len_in != 1) ERR;
if (nc_inq_dim(grpid_in, dimids_in[1], name_in, &len_in)) ERR;
if (strcmp(name_in, DIM_NAME2) || len_in != BABE_LIMIT) ERR;
/* Check the vars in the group. */
if (nc_inq_varid(grpid_in, VAR_NAME1, &varid_in1)) ERR;
if (nc_inq_varid(grpid_in, VAR_NAME2, &varid_in2)) ERR;
if (nc_inq_varid(grpid_in, VAR_NAME3, &varid_in3)) ERR;
if (varid_in1 != varid1 || varid_in2 != varid2 || varid_in3 != varid3) ERR;
if (nc_inq_var(grpid_in, varid1, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME1) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid1 || natts != 0) ERR;
if (nc_inq_var(grpid_in, varid2, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME2) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid1 || natts != 0) ERR;
if (nc_inq_var(grpid_in, varid3, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME3) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid2 || natts != 0) ERR;
/* Read one value from the second unlim dim variable. It should
* be the fill value. */
index[0] = 0;
if (nc_get_var1_longlong(grpid_in, varid_in2, index, &value_in)) ERR;
if (value_in != NC_FILL_INT64) ERR;
/* Read one value from the variable with limited dim. It should
* be the fill value. */
if (nc_get_var1_longlong(grpid_in, varid_in3, index, &value_in)) ERR;
if (value_in != NC_FILL_INT64) ERR;
/* Attempt to read beyond end of dimensions to generate error. */
index[0] = BABE_LIMIT;
if (nc_get_var1_longlong(grpid_in, varid_in1, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_get_var1_longlong(grpid_in, varid_in2, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_get_var1_longlong(grpid_in, varid_in3, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing groups and unlimited dimensions...");
{
int ncid;
int henry_vii_id;
int tudor_id;
int dimids_in[MAX_SIBLING_GROUPS], ndims_in;
int num_grps;
int dimid, dynasty, varid;
size_t len_in;
int natts_in;
int grpids_in[10];
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
int data_out[DIM1_LEN] = {0, 2, 6}, data_in[DIM1_LEN];
size_t start[1] = {0}, count[1] = {3};
int j;
/* Create one group, with one var, which has one dimension, which is unlimited. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_grp(ncid, DYNASTY, &tudor_id)) ERR;
if (nc_def_dim(tudor_id, DIM1_NAME, NC_UNLIMITED, &dimid)) ERR;
if (nc_def_grp(tudor_id, HENRY_VII, &henry_vii_id)) ERR;
if (nc_def_var(henry_vii_id, VAR1_NAME, NC_INT, 1, &dimid, &varid)) ERR;
if (nc_put_vara_int(henry_vii_id, varid, start, count, data_out)) ERR;
if (nc_close(ncid)) ERR;
/* Now check the file to see if the dimension and variable are
* there. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_grps(ncid, &num_grps, &dynasty)) ERR;
if (num_grps != 1) ERR;
if (nc_inq_grps(dynasty, &num_grps, grpids_in)) ERR;
if (num_grps != 1) ERR;
if (nc_inq_dim(grpids_in[0], 0, name_in, &len_in)) ERR;
if (strcmp(name_in, DIM1_NAME) || len_in != DIM1_LEN) ERR;
if (nc_inq_var(grpids_in[0], 0, name_in, &xtype_in, &ndims_in, dimids_in,
&natts_in)) ERR;
if (strcmp(name_in, VAR1_NAME) || xtype_in != NC_INT || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
if (nc_get_vara_int(grpids_in[0], 0, start, count, data_in)) ERR;
for (j=0; j<DIM1_LEN; j++)
if (data_in[j] != data_out[j]) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
}
int ne_id_lkup(int exoid, const char *ne_var_name, int64_t *idx, ex_entity_id ne_var_id)
{
const char *func_name="ne_id_lkup";
int status;
int varid, ndims, dimid[1], ret=-1;
nc_type var_type;
size_t length, start[1];
int64_t my_index, begin, end;
long long id_val;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
if ((status = nc_inq_varid(exoid, ne_var_name, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
ne_var_name, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* check if I need the length for this varible */
if (idx[1] == -1) {
/* Get the dimension IDs for this variable */
if ((status = nc_inq_var(exoid, varid, (char *) 0, &var_type, &ndims,
dimid, (int *) 0)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find dimension ID for variable \"%s\" in file ID %d",
ne_var_name, exoid);
ex_err(func_name, errmsg, exerrval);
return -1;
}
/* Get the length of this variable */
if ((status = nc_inq_dimlen(exoid, dimid[0], &length)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find dimension for variable \"%s\" in file ID %d",
ne_var_name, exoid);
ex_err(func_name, errmsg, exerrval);
return -1;
}
idx[1] = length;
} /* End "if (idx[1] == -1)" */
begin = idx[0];
end = idx[1];
/* Find the index by looping over each entry */
for(my_index=begin; my_index < end; my_index++) {
start[0] = my_index;
status = nc_get_var1_longlong(exoid, varid, start, &id_val);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable \"%s\" in file ID %d",
ne_var_name, exoid);
ex_err(func_name, errmsg, exerrval);
return -1;
}
if (id_val == ne_var_id) {
ret = (int) my_index;
break;
}
}
return ret;
}
