//----------------------------------------------------------------
// Open the first NETCDF file and query all the types for all the variables
static void determine_var_types()
{
assert(netcdf_file_names != 0);
assert(netcdf_var_names != 0);
struct Type type;
int plist_id,i = 0,varidp,ndimsp;
int file_id = ncmpi_open(MPI_COMM_WORLD,netcdf_file_names[0], NC_NOWRITE, MPI_INFO_NULL, &plist_id);
if (file_id != NC_NOERR)
terminate_with_error_msg("ERROR: Cannot open file %s\n", netcdf_file_names[0]);
var_types = (struct Type *)calloc(var_count, sizeof(*var_types));
nc_type xtypep;
for (i = 0; i < var_count; ++i)
{
int dataset_id = ncmpi_inq_varid (plist_id, netcdf_var_names[i], &varidp);
dataset_id = ncmpi_inq_vartype(plist_id,varidp, &xtypep);
if (dataset_id != NC_NOERR)
terminate_with_error_msg("ERROR: Cannot read the datatype of the variable %s\n", netcdf_var_names[i]);
int num_dims = ncmpi_inq_varndims(plist_id,varidp,&ndimsp);
if (ndimsp > 3 )
{
//TODO:probably we can make it more clever to handle more dimensions as they are not related to the variable itself on netcdf
type.atomic_type = INVALID; // we don't support arrays of more than 3 dimension
return;
}
else if (xtypep == NC_FLOAT || xtypep == NC_INT)
{
type.num_values = 1;
}
else // we don't support HD5_COMPOUND datatype for example
{
type.atomic_type = INVALID;
}
type.atomic_type = from_netcdf_atomic_type(xtypep);
var_types[i] = type;
if (var_types[i].atomic_type == INVALID)
terminate_with_error_msg("ERROR: The datatype of the %s variable is not supported\n", netcdf_var_names[i]);
}
ncmpi_close(plist_id);
}
int main(int argc, char **argv) {
int i, j;
int status;
int ncid1, ncid2;
int ndims, nvars, ngatts, unlimdimid;
char name[NC_MAX_NAME];
nc_type type, *vartypes;
MPI_Offset attlen, dimlen, varsize;
MPI_Offset *shape, *start;
void *valuep;
int *dimids, *varids, **vardims, *varndims, *varnatts;
params opts;
int rank;
int nprocs;
int NC_mode;
MPI_Comm comm = MPI_COMM_WORLD;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (rank == 0)
fprintf(stderr, "Testing read ... ");
parse_read_args(argc, argv, rank, &opts);
/********** START OF NETCDF ACCESS **************/
/* Read a netCDF file and write it out to another file */
/**
* Open the input dataset - ncid1:
* File name: "../data/test_int.nc"
* Dataset API: Collective
* And create the output dataset - ncid2:
* File name: "testread.nc"
* Dataset API: Collective
*/
status = ncmpi_open(comm, opts.infname, 0, MPI_INFO_NULL, &ncid1);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_inq_version(ncid1, &NC_mode);
status = ncmpi_create(comm, opts.outfname, NC_CLOBBER|NC_mode, MPI_INFO_NULL, &ncid2);
if (status != NC_NOERR) handle_error(status);
/**
* Inquire the dataset definitions of input dataset AND
* Add dataset definitions for output dataset.
*/
status = ncmpi_inq(ncid1, &ndims, &nvars, &ngatts, &unlimdimid);
if (status != NC_NOERR) handle_error(status);
/* Inquire global attributes, assume CHAR attributes. */
for (i = 0; i < ngatts; i++) {
status = ncmpi_inq_attname(ncid1, NC_GLOBAL, i, name);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_inq_att (ncid1, NC_GLOBAL, name, &type, &attlen);
if (status != NC_NOERR) handle_error(status);
switch (type) {
case NC_CHAR:
valuep = (void *)malloc(attlen * sizeof(char));
status = ncmpi_get_att_text(ncid1, NC_GLOBAL, name, (char*)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_att_text (ncid2, NC_GLOBAL, name, attlen, (char *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
case NC_SHORT:
valuep = (void *)malloc(attlen * sizeof(short));
status = ncmpi_get_att_short(ncid1, NC_GLOBAL, name, (short*)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_att_short (ncid2, NC_GLOBAL, name, type, attlen, (short *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
case NC_INT:
valuep = (void *)malloc(attlen * sizeof(int));
status = ncmpi_get_att_int(ncid1, NC_GLOBAL, name, (int*)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_att_int (ncid2, NC_GLOBAL, name, type, attlen, (int *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
case NC_FLOAT:
valuep = (void *)malloc(attlen * sizeof(float));
status = ncmpi_get_att_float(ncid1, NC_GLOBAL, name, (float*)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_att_float (ncid2, NC_GLOBAL, name, type, attlen, (float *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
case NC_DOUBLE:
valuep = (void *)malloc(attlen * sizeof(double));
status = ncmpi_get_att_double(ncid1, NC_GLOBAL, name, (double*)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_att_double (ncid2, NC_GLOBAL, name, type, attlen, (double *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
default:
;
/* handle unexpected types */
}
}
/* Inquire dimension */
dimids = (int*) malloc(ndims * sizeof(int));
for (i = 0; i < ndims; i++) {
status = ncmpi_inq_dim(ncid1, i, name, &dimlen);
if (status != NC_NOERR) handle_error(status);
if (i == unlimdimid)
dimlen = NC_UNLIMITED;
status = ncmpi_def_dim(ncid2, name, dimlen, dimids+i);
if (status != NC_NOERR) handle_error(status);
}
free(dimids);
vartypes = (nc_type*) malloc(nvars * sizeof(nc_type));
varids = (int*) malloc(nvars * sizeof(int));
varndims = (int*) malloc(nvars * sizeof(int));
varnatts = (int*) malloc(nvars * sizeof(int));
vardims = (int**) malloc(nvars * sizeof(int*));
/* Inquire variables */
for (i = 0; i < nvars; i++) {
status = ncmpi_inq_varndims(ncid1, i, varndims+i);
if (status != NC_NOERR) handle_error(status);
vardims[i] = (int*) malloc(varndims[i] * sizeof(int));
status = ncmpi_inq_var (ncid1, i, name, vartypes+i, varndims+i, vardims[i], varnatts+i);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_def_var(ncid2, name, vartypes[i], varndims[i], vardims[i], varids+i);
if (status != NC_NOERR) handle_error(status);
/* var attributes, assume CHAR attributes */
for (j = 0; j < varnatts[i]; j++) {
status = ncmpi_inq_attname(ncid1, i, j, name);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_inq_att (ncid1, i, name, &type, &attlen);
if (status != NC_NOERR) handle_error(status);
switch (type) {
case NC_CHAR:
valuep = (void *)malloc(attlen * sizeof(char));
status = ncmpi_get_att_text(ncid1, i, name, (char*)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_att_text (ncid2, varids[i], name, attlen, (char *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
case NC_SHORT:
valuep = (void *)malloc(attlen * sizeof(short));
status = ncmpi_get_att_short(ncid1, i, name, (short*)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_att_short (ncid2, varids[i], name, type, attlen, (short *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
case NC_INT:
valuep = (void *)malloc(attlen * sizeof(int));
status = ncmpi_get_att_int(ncid1, i, name, (int*)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_att_int (ncid2, varids[i], name, type, attlen, (int *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
case NC_FLOAT:
valuep = (void *)malloc(attlen * sizeof(float));
status = ncmpi_get_att_float(ncid1, i, name, (float*)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_att_float (ncid2, varids[i], name, type, attlen, (float *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
case NC_DOUBLE:
valuep = (void *)malloc(attlen * sizeof(double));
status = ncmpi_get_att_double(ncid1, i, name, (double*)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_att_double (ncid2, varids[i], name, type, attlen, (double *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
default:
;
/* handle unexpected types */
}
}
}
/**
* End Define Mode (switch to data mode) for output dataset
* Dataset API: Collective
*/
status = ncmpi_enddef(ncid2);
if (status != NC_NOERR) handle_error(status);
/**
* Read data of variables from input dataset
* (ONLY DEAL WITH: NC_INT, NC_FLOAT, NC_DOUBLE for now)
* Write the data out to the corresponding variables in the output dataset
*
* Data Partition (Assume 4 processors):
* square: 2-D, (Block, *), 25*100 from 100*100
* cube: 3-D, (Block, *, *), 25*100*100 from 100*100*100
* xytime: 3-D, (Block, *, *), 25*100*100 from 100*100*100
* time: 1-D, Block-wise, 25 from 100
*
* Data Mode API: collective
*/
for (i = 0; i < nvars; i++) {
shape = (MPI_Offset*) calloc(varndims[i] * 2, sizeof(MPI_Offset));
start = shape + varndims[i];
varsize = 1;
for (j = 0; j < varndims[i]; j++) {
status = ncmpi_inq_dim(ncid1, vardims[i][j], name, shape + j);
if (status != NC_NOERR) handle_error(status);
if (j == 0) {
shape[j] /= nprocs;
start[j] = shape[j] * rank;
}
varsize *= shape[j];
}
switch (vartypes[i]) {
case NC_CHAR:
break;
case NC_SHORT:
valuep = (void *)malloc(varsize * sizeof(short));
status = ncmpi_get_vara_short_all(ncid1, i, start, shape, (short *)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_vara_short_all(ncid2, varids[i],
start, shape, (short *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
case NC_INT:
valuep = (void *)malloc(varsize * sizeof(int));
status = ncmpi_get_vara_int_all(ncid1, i, start, shape, (int *)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_vara_int_all(ncid2, varids[i],
start, shape, (int *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
case NC_FLOAT:
valuep = (void *)malloc(varsize * sizeof(float));
status = ncmpi_get_vara_float_all(ncid1, i, start, shape, (float *)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_vara_float_all(ncid2, varids[i],
start, shape, (float *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
case NC_DOUBLE:
valuep = (void *)malloc(varsize * sizeof(double));
status = ncmpi_get_vara_double_all(ncid1, i, start, shape, (double *)valuep);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_put_vara_double_all(ncid2, varids[i],
start, shape, (double *)valuep);
if (status != NC_NOERR) handle_error(status);
free(valuep);
break;
default:
;
/* handle unexpected types */
}
free(vardims[i]);
free(shape);
}
/**
* Close the datasets
* Dataset API: collective
*/
status = ncmpi_close(ncid1);
if (status != NC_NOERR) handle_error(status);
status = ncmpi_close(ncid2);
if (status != NC_NOERR) handle_error(status);
free(vartypes);
free(varids);
free(varndims);
free(varnatts);
free(vardims);
/******************* END OF NETCDF ACCESS ****************/
if (rank == 0)
fprintf(stderr, "OK\nInput file %s copied to: %s!\n", opts.infname, opts.outfname);
MPI_Finalize();
return 0;
}
int main(int argc, char **argv) {
int i, j=0, rank, nprocs, err;
int ncfile, ndims, nvars, ngatts, unlimited, var_ndims, var_natts;;
int *dimids=NULL;
char filename[256], varname[NC_MAX_NAME+1];
MPI_Offset *dim_sizes=NULL, var_size;
nc_type type;
int *data=NULL;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if (argc > 2) {
if (rank == 0) printf("Usage: %s filename\n", argv[0]);
MPI_Finalize();
exit(-1);
}
if (argc > 1) snprintf(filename, 256, "%s", argv[1]);
else strcpy(filename, "testfile.nc");
if (rank == 0) {
err = ncmpi_open(MPI_COMM_SELF, filename,
NC_NOWRITE, MPI_INFO_NULL, &ncfile);
if (err != NC_NOERR) handle_error(err, __LINE__);
/* reader knows nothing about dataset, but we can interrogate with
* query routines: ncmpi_inq tells us how many of each kind of
* "thing" (dimension, variable, attribute) we will find in the
* file */
err = ncmpi_inq(ncfile, &ndims, &nvars, &ngatts, &unlimited);
if (err != NC_NOERR) handle_error(err, __LINE__);
/* we do not really need the name of the dimension or the variable
* for reading in this example. we could, in a different example,
* take the name of a variable on the command line and read just
* that one */
dim_sizes = (MPI_Offset*) calloc(ndims, sizeof(MPI_Offset));
/* netcdf dimension identifiers are allocated sequentially starting
* at zero; same for variable identifiers */
for(i=0; i<ndims; i++) {
err = ncmpi_inq_dimlen(ncfile, i, &(dim_sizes[i]) );
if (err != NC_NOERR) handle_error(err, __LINE__);
}
}
/* need to inform other MPI processors how many variables we will send */
err = MPI_Bcast(&nvars, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_ERR(err)
for(i=0; i<nvars; i++) {
/* rank 0 will find out the size of each variable, read it, and
* broadcast it to the rest of the processors */
if (rank == 0) {
/* obtain the number of dimensions of variable i, so we can
* allocate the dimids array */
err = ncmpi_inq_varndims(ncfile, i, &var_ndims);
if (err != NC_NOERR) handle_error(err, __LINE__);
dimids = (int*) malloc(var_ndims * sizeof(int));
err = ncmpi_inq_var(ncfile, i, varname, &type, &var_ndims, dimids,
&var_natts);
if (err != NC_NOERR) handle_error(err, __LINE__);
for (j=0, var_size=1; j<var_ndims; j++) {
var_size *= dim_sizes[dimids[j]];
}
free(dimids);
}
/* oddity: there's no predefined MPI_Offset type */
err = MPI_Bcast(&var_size, 1, MPI_OFFSET, 0, MPI_COMM_WORLD);
MPI_ERR(err)
data = (int*) calloc(var_size, sizeof(int));
if (rank == 0) {
switch(type) {
case NC_INT:
/* now we have the variable identifiers and we know how big
* they are */
/* this approach is not scalable: i/o happens from a single
* processor. This approach can be ok if the amount of
* data is quite small, but almost always the underlying
* MPI-IO library can do a better job */
err = ncmpi_get_var_int_all(ncfile, j, data);
if (err != NC_NOERR) handle_error(err, __LINE__);
break;
default:
/* we can do this for all the known netcdf types but this
* example is already getting too long */
fprintf(stderr, "unsupported NetCDF type \n");
}
}
/*and finally all processors have the data */
err = MPI_Bcast(data, var_size, MPI_INT, 0, MPI_COMM_WORLD);
MPI_ERR(err)
/* Here, every process can do computation on the local buffer, data,
or copy the contents to somewhere else */
free(data);
}
if (rank == 0) {
err = ncmpi_close(ncfile);
if (err != NC_NOERR) handle_error(err, __LINE__);
free(dim_sizes);
}
MPI_Finalize();
return 0;
}
/*----< main() >--------------------------------------------------------------*/
int main(int argc, char **argv)
{
int i, j, c, err, rank, nprocs, verbose, quiet;
int ncid1, ndims1, nvars1, natts1, unlimdimid1, *dimids1;
int ncid2, ndims2, nvars2, natts2, unlimdimid2, *dimids2;
char *name1, *name2;
MPI_Offset *shape=NULL, varsize, *start=NULL;
MPI_Offset attlen1, dimlen1, attlen2, dimlen2;
nc_type type1, type2;
MPI_Comm comm=MPI_COMM_WORLD;
int nvars, check_header, check_variable_list, check_entire_file;
long long numVarDIFF=0, numHeadDIFF=0, varDIFF, numDIFF;
struct vspec var_list;
extern char *optarg;
extern int optind;
MPI_Info info;
MPI_Init(&argc, &argv);
MPI_Comm_size(comm, &nprocs);
MPI_Comm_rank(comm, &rank);
progname = argv[0];
verbose = 0;
quiet = 0;
check_header = 0;
check_variable_list = 0;
check_entire_file = 0;
var_list.names = NULL;
var_list.nvars = 0;
while ((c = getopt(argc, argv, "bhqv:")) != -1)
switch(c) {
case 'h': /* compare header only */
check_header = 1;
break;
case 'v': /* variable names */
/* make list of names of variables specified */
get_var_names(optarg, &var_list);
check_variable_list = 1;
break;
case 'b':
verbose = 1;
break;
case 'q':
quiet = 1;
break;
case '?':
usage(rank, argv[0]);
break;
}
/* quiet overwrites verbose */
if (quiet) verbose = 0;
if (argc - optind != 2) usage(rank, argv[0]);
if (check_header == 0 && check_variable_list == 0) {
check_entire_file = 1;
check_header = 1;
}
name1 = (char*) malloc(NC_MAX_NAME);
if (!name1) OOM_ERROR
name2 = (char*) malloc(NC_MAX_NAME);
if (!name2) OOM_ERROR
/* Nov. 18, 2014 -- disable subfiling as it does not correctly handle the
* cases when nprocs < num_subfiles */
MPI_Info_create (&info);
MPI_Info_set (info, "pnetcdf_subfiling", "disable");
/* open files */
err = ncmpi_open(comm, argv[optind], NC_NOWRITE, info, &ncid1);
HANDLE_ERROR
err = ncmpi_open(comm, argv[optind+1], NC_NOWRITE, info, &ncid2);
HANDLE_ERROR
MPI_Info_free(&info);
/* check header */
if (check_header && rank == 0) { /* only root checks header */
int attnump;
err = ncmpi_inq(ncid1, &ndims1, &nvars1, &natts1, &unlimdimid1);
HANDLE_ERROR
err = ncmpi_inq(ncid2, &ndims2, &nvars2, &natts2, &unlimdimid2);
HANDLE_ERROR
if (ndims1 != ndims2) { /* check number of dimensions if equal */
if (!quiet) printf("DIFF: number of dimensions (%d) != (%d)\n",ndims1, ndims2);
numHeadDIFF++;
}
else if (verbose)
printf("SAME: number of dimensions (%d)\n",ndims1);
if (nvars1 != nvars2) { /* check number of variables if equal */
if (!quiet) printf("DIFF: number of variables (%d) != (%d)\n",nvars1, nvars2);
numHeadDIFF++;
}
else if (verbose)
printf("SAME: number of variables (%d)\n",nvars1);
if (natts1 != natts2) { /* check number of global attributes if equal */
if (!quiet) printf("DIFF: number of global attributes (%d) != (%d)\n",natts1, natts2);
numHeadDIFF++;
}
else if (verbose)
printf("SAME: number of global attributes (%d)\n",natts1);
/* Compare global attributes, assume CHAR attributes. */
for (i=0; i<natts1; i++) { /* check what's in file1 also in file2 */
err = ncmpi_inq_attname(ncid1, NC_GLOBAL, i, name1);
HANDLE_ERROR
/* find the attr with the same name from ncid2 */
err = ncmpi_inq_attid(ncid2, NC_GLOBAL, name1, &attnump);
if (err == NC_ENOTATT) {
if (!quiet) printf("DIFF: global attribute \"%s\" not found in file %s\n",
name1,argv[optind+1]);
numHeadDIFF++;
continue;
}
err = ncmpi_inq_att(ncid1, NC_GLOBAL, name1, &type1, &attlen1);
HANDLE_ERROR
err = ncmpi_inq_att(ncid2, NC_GLOBAL, name1, &type2, &attlen2);
HANDLE_ERROR
if (type1 != type2) {
if (!quiet) printf("DIFF: global attribute \"%s\" data type (%s) != (%s)\n",
name1,get_type(type1),get_type(type2));
numHeadDIFF++;
continue;
}
else if (verbose) {
printf("Global attribute \"%s\":\n",name1);
printf("\tSAME: data type (%s)\n",get_type(type1));
}
if (attlen1 != attlen2) {
if (!quiet) printf("DIFF: global attribute \"%s\" length (%lld) != (%lld)\n",
name1,attlen1,attlen2);
numHeadDIFF++;
continue;
}
else if (verbose)
printf("\tSAME: length (%lld)\n",attlen1);
switch (type1) {
case NC_CHAR: CHECK_GLOBAL_ATT_DIFF(char, ncmpi_get_att_text, NC_CHAR)
case NC_SHORT: CHECK_GLOBAL_ATT_DIFF(short, ncmpi_get_att_short, NC_SHORT)
case NC_INT: CHECK_GLOBAL_ATT_DIFF(int, ncmpi_get_att_int, NC_INT)
case NC_FLOAT: CHECK_GLOBAL_ATT_DIFF(float, ncmpi_get_att_float, NC_FLOAT)
case NC_DOUBLE: CHECK_GLOBAL_ATT_DIFF(double, ncmpi_get_att_double, NC_DOUBLE)
case NC_UBYTE: CHECK_GLOBAL_ATT_DIFF(ubyte, ncmpi_get_att_uchar, NC_UBYTE)
case NC_USHORT: CHECK_GLOBAL_ATT_DIFF(ushort, ncmpi_get_att_ushort, NC_USHORT)
case NC_UINT: CHECK_GLOBAL_ATT_DIFF(uint, ncmpi_get_att_uint, NC_UINT)
case NC_INT64: CHECK_GLOBAL_ATT_DIFF(int64, ncmpi_get_att_longlong, NC_INT64)
case NC_UINT64: CHECK_GLOBAL_ATT_DIFF(uint64, ncmpi_get_att_ulonglong, NC_UINT64)
default: ; /* TODO: handle unexpected types */
}
}
for (i=0; i<natts2; i++) { /* check attributes in file2 but not in file1 */
err = ncmpi_inq_attname(ncid2, NC_GLOBAL, i, name2);
HANDLE_ERROR
/* find the attr with the same name from ncid1 */
if (ncmpi_inq_attid(ncid1, NC_GLOBAL, name2, &attnump) == NC_ENOTATT) {
numHeadDIFF++;
if (!quiet) printf("DIFF: global attribute \"%s\" not found in file %s\n",
name1,argv[optind]);
}
}
/* Compare dimension */
if (ndims1 && verbose)
printf("Dimension:\n");
for (i=0; i<ndims1; i++) { /* check dimensions in file1 also in file2 */
int dimid;
err = ncmpi_inq_dim(ncid1, i, name1, &dimlen1);
HANDLE_ERROR
/* find the dim with the same name from ncid2 */
err = ncmpi_inq_dimid(ncid2, name1, &dimid);
if (err == NC_EBADDIM) {
if (!quiet) printf("DIFF: dimension \"%s\" not found in file %s\n",
name1,argv[optind+1]);
numHeadDIFF++;
continue;
}
err = ncmpi_inq_dimlen(ncid2, dimid, &dimlen2);
HANDLE_ERROR
if (dimlen1 != dimlen2) {
/* cast to quiet warning on 32 bit platforms */
if (!quiet) printf("DIFF: dimension \"%s\" length (%lld) != (%lld)\n",
name1,(long long int)dimlen1,(long long int)dimlen2);
numHeadDIFF++;
}
else if (verbose)
printf("\tSAME: dimension \"%s\" length (%lld)\n",
name1,(long long int)dimlen1);
}
for (i=0; i<ndims2; i++) { /* check dimensions in file2 but not in file1 */
int dimid;
err = ncmpi_inq_dim(ncid2, i, name2, &dimlen2);
HANDLE_ERROR
/* find the dim with the same name from ncid1 */
if (ncmpi_inq_dimid(ncid2, name1, &dimid) == NC_EBADDIM) {
if (!quiet) printf("DIFF: dimension \"%s\" not found in file %s\n",
name1,argv[optind]);
numHeadDIFF++;
}
}
/* Compare variables' metadata */
for (i=0; i<nvars1; i++) {
int varid;
err = ncmpi_inq_varndims(ncid1, i, &ndims1); HANDLE_ERROR
dimids1 = (int*) malloc((size_t)ndims1 * SIZEOF_INT);
if (!dimids1) OOM_ERROR
err = ncmpi_inq_var(ncid1, i, name1, &type1, &ndims1, dimids1, &natts1);
HANDLE_ERROR
/* find the variable with the same name from ncid2 */
err = ncmpi_inq_varid(ncid2, name1, &varid);
if (err == NC_ENOTVAR) {
if (!quiet) printf("DIFF: variable \"%s\" not found in file %s\n",
name1,argv[optind+1]);
numHeadDIFF++;
numVarDIFF++;
continue;
}
err = ncmpi_inq_varndims(ncid2, varid, &ndims2); HANDLE_ERROR
dimids2 = (int*) malloc((size_t)ndims2 * SIZEOF_INT);
if (!dimids2) OOM_ERROR
err = ncmpi_inq_var(ncid2, varid, name2, &type2, &ndims2, dimids2, &natts2);
HANDLE_ERROR
if (type1 != type2) {
if (!quiet) printf("DIFF: variable \"%s\" data type (%s) != (%s)\n",
name1,get_type(type1),get_type(type2));
numHeadDIFF++;
}
else if (verbose) {
printf("Variable \"%s\":\n",name1);
printf("\tSAME: data type (%s)\n",get_type(type1));
}
if (ndims1 != ndims2) {
if (!quiet) printf("DIFF: variable \"%s\" number of dimensions (%d) != (%d)\n",
name1,ndims1,ndims2);
numHeadDIFF++;
}
else {
if (verbose)
printf("\tSAME: number of dimensions (%d)\n",ndims1);
for (j=0; j<ndims1; j++) { /* check variable's dimensionality */
char dimname1[NC_MAX_NAME], dimname2[NC_MAX_NAME];
/* get dim name for each dim ID */
err = ncmpi_inq_dim(ncid1, dimids1[j], dimname1, &dimlen1);
HANDLE_ERROR
err = ncmpi_inq_dim(ncid1, dimids2[j], dimname2, &dimlen2);
HANDLE_ERROR
if (verbose)
printf("\tdimension %d:\n",j);
if (strcmp(dimname1, dimname2) != 0) {
if (!quiet) printf("DIFF: variable \"%s\" of type \"%s\" dimension %d's name (%s) != (%s)\n",
name1,get_type(type1),j,dimname1,dimname2);
numHeadDIFF++;
}
else if (verbose)
printf("\t\tSAME: name (%s)\n",dimname1);
if (dimlen1 != dimlen2) {
if (!quiet) printf("DIFF: variable \"%s\" of type \"%s\" dimension %d's length (%lld) != (%lld)\n",
name1,get_type(type1),j,(long long int)dimlen1,(long long int)dimlen2);
numHeadDIFF++;
}
else if (verbose)
printf("\t\tSAME: length (%lld)\n",(long long int)dimlen1);
}
}
if (natts1 != natts2) {
if (!quiet) printf("DIFF: variable \"%s\" number of attributes (%d) != (%d)\n",
name1,natts1,natts2);
numHeadDIFF++;
}
else if (verbose)
printf("\tSAME: number of attributes (%d)\n",natts1);
/* var attributes, assume CHAR attributes */
for (j=0; j<natts1; j++) {
char attrname[NC_MAX_NAME];
err = ncmpi_inq_attname(ncid1, i, j, attrname);
HANDLE_ERROR
err = ncmpi_inq_att(ncid1, i, attrname, &type1, &attlen1);
HANDLE_ERROR
/* find the variable attr with the same name from ncid2 */
err = ncmpi_inq_att(ncid2, varid, attrname, &type2, &attlen2);
if (err == NC_ENOTATT) {
if (!quiet) printf("DIFF: variable \"%s\" attribute \"%s\" not found in file %s\n",
name1,attrname,argv[optind+1]);
numHeadDIFF++;
continue;
}
if (verbose)
printf("\tattribute \"%s\":\n",attrname);
if (type1 != type2) {
if (!quiet) printf("DIFF: variable \"%s\" attribute \"%s\" data type (%s) != (%s)\n",
name1,attrname,get_type(type1),get_type(type2));
numHeadDIFF++;
continue; /* skip this attribute */
}
else if (verbose)
printf("\t\tSAME: data type (%s)\n",get_type(type1));
if (attlen1 != attlen2) {
if (!quiet) printf("DIFF: variable \"%s\" attribute \"%s\" length (%lld) != (%lld)\n",
name1,attrname,(long long int)attlen1,(long long int)attlen2);
numHeadDIFF++;
continue; /* skip this attribute */
}
else if (verbose)
printf("\t\tSAME: length (%lld)\n",(long long int)attlen1);
switch (type1) {
case NC_CHAR: CHECK_VAR_ATT_DIFF(char, ncmpi_get_att_text, NC_CHAR)
case NC_SHORT: CHECK_VAR_ATT_DIFF(short, ncmpi_get_att_short, NC_SHORT)
case NC_INT: CHECK_VAR_ATT_DIFF(int, ncmpi_get_att_int, NC_INT)
case NC_FLOAT: CHECK_VAR_ATT_DIFF(float, ncmpi_get_att_float, NC_FLOAT)
case NC_DOUBLE: CHECK_VAR_ATT_DIFF(double, ncmpi_get_att_double, NC_DOUBLE)
case NC_UBYTE: CHECK_VAR_ATT_DIFF(ubyte, ncmpi_get_att_uchar, NC_UBYTE)
case NC_USHORT: CHECK_VAR_ATT_DIFF(ushort, ncmpi_get_att_ushort, NC_USHORT)
case NC_UINT: CHECK_VAR_ATT_DIFF(uint, ncmpi_get_att_uint, NC_UINT)
case NC_INT64: CHECK_VAR_ATT_DIFF(int64, ncmpi_get_att_longlong, NC_INT64)
case NC_UINT64: CHECK_VAR_ATT_DIFF(uint64, ncmpi_get_att_ulonglong, NC_UINT64)
default: ; /* TODO: handle unexpected types */
}
}
for (j=0; j<natts2; j++) {
char attrname[NC_MAX_NAME];
err = ncmpi_inq_attname(ncid2, varid, j, attrname);
HANDLE_ERROR
/* find the variable attr with the same name from ncid1 */
err = ncmpi_inq_att(ncid1, i, attrname, &type1, &attlen1);
if (err == NC_ENOTATT) {
if (!quiet) printf("DIFF: variable \"%s\" attribute \"%s\" not found in file %s\n",
name1,attrname,argv[optind]);
numHeadDIFF++;
}
}
free(dimids1);
free(dimids2);
}
for (i=0; i<nvars2; i++) { /* check variables in file2 but not in file1 */
int varid;
err = ncmpi_inq_varname(ncid2, i, name2);
HANDLE_ERROR
/* find the variable with the same name from ncid1 */
err = ncmpi_inq_varid(ncid1, name2, &varid);
if (err == NC_ENOTVAR) {
if (!quiet) printf("DIFF: variable \"%s\" not found in file %s\n",
name2,argv[optind]);
numHeadDIFF++;
numVarDIFF++;
}
}
}
