int main(int argc, char **argv) { printf("\n*** Testing netcdf-4 dimensions.\n"); printf("*** Checking that netcdf-4 dimids inq works on netcdf-3 file..."); { int ncid, dimid; int ndims_in, dimids_in[MAX_DIMS]; /* Create a netcdf-3 file with one dim. */ if (nc_create(FILE_NAME, 0, &ncid)) ERR; if (nc_def_dim(ncid, LAT_NAME, LAT_LEN, &dimid)) ERR; if (nc_close(ncid)) ERR; /* Open the file and make sure nc_inq_dimids yeilds correct * result. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR; if (ndims_in != 0) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Checking that netcdf-4 dimids inq works on more complex netcdf-3 file..."); { int ncid, dimid; int lon_dimid; int ndims_in, dimids_in[MAX_DIMS]; /* Create a netcdf-3 file with three dim. */ if (nc_create(FILE_NAME, 0, &ncid)) ERR; if (nc_def_dim(ncid, LEVEL_NAME, NC_UNLIMITED, &dimid)) ERR; if (nc_def_dim(ncid, LAT_NAME, LAT_LEN, &dimid)) ERR; if (nc_def_dim(ncid, LON_NAME, LON_LEN, &lon_dimid)) ERR; if (nc_close(ncid)) ERR; /* Open the file and make sure nc_inq_dimids yeilds correct * result. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 3 || dimids_in[0] != 0 || dimids_in[1] != 1 || dimids_in[2] != 2) ERR; if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Testing file with just one dimension..."); { int ncid, dimid; int ndims_in, dimids_in[MAX_DIMS]; size_t len_in; char name_in[NC_MAX_NAME + 1]; int varid_in; /* Create a file with one dim and nothing else. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, LAT_NAME, LAT_LEN, &dimid)) ERR; /* Check out what we've got. */ if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != LAT_LEN || strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1) ERR; if (nc_inq_dimid(ncid, LAT_NAME, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_dimname(ncid, 0, name_in)) ERR; if (strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dimlen(ncid, 0, &len_in)) ERR; if (len_in != LAT_LEN) ERR; if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR; if (ndims_in != 0) ERR; if (nc_close(ncid)) ERR; /* Reopen and check it out again. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != LAT_LEN || strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1) ERR; if (nc_inq_dimid(ncid, LAT_NAME, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_dimname(ncid, 0, name_in)) ERR; if (strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dimlen(ncid, 0, &len_in)) ERR; if (len_in != LAT_LEN) ERR; if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR; if (ndims_in != 0) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Testing renaming of one dimension..."); { int ncid, dimid, varid_in; char name_in[NC_MAX_NAME + 1]; size_t len_in; int ndims_in, dimids_in[MAX_DIMS]; /* Reopen the file with one dim, and change the name of the dim. */ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_rename_dim(ncid, 0, BUBBA)) ERR; /* Check out what we've got. */ dimid = 0; if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != LAT_LEN || strcmp(name_in, BUBBA)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1) ERR; if (dimids_in[0] != 0) ERR; if (nc_inq_dimid(ncid, BUBBA, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_dimname(ncid, 0, name_in)) ERR; if (strcmp(name_in, BUBBA)) ERR; if (nc_inq_dimlen(ncid, 0, &len_in)) ERR; if (len_in != LAT_LEN) ERR; if (nc_close(ncid)) ERR; /* Reopen and check out what we've got again. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != LAT_LEN || strcmp(name_in, BUBBA)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_dimid(ncid, BUBBA, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_dimname(ncid, 0, name_in)) ERR; if (strcmp(name_in, BUBBA)) ERR; if (nc_inq_dimlen(ncid, 0, &len_in)) ERR; if (len_in != LAT_LEN) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Testing file with just one unlimited dimension..."); { int ncid, dimid; int ndims_in, dimids_in[MAX_DIMS]; size_t len_in; char name_in[NC_MAX_NAME + 1]; int unlimdimid_in; int nunlimdims_in; /* Create a file with one unlimied dim and nothing else. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, LEVEL_NAME, NC_UNLIMITED, &dimid)) ERR; /* Check it out before the enddef. */ if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != NC_UNLIMITED || strcmp(name_in, LEVEL_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_unlimdim(ncid, &unlimdimid_in)) ERR; if (unlimdimid_in != 0) ERR; if (nc_inq_unlimdims(ncid, &nunlimdims_in, &unlimdimid_in)) ERR; if (nunlimdims_in != 1 || unlimdimid_in != 0) ERR; /* Automatically enddef and close. */ if (nc_close(ncid)) ERR; /* Reopen and check it out. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != NC_UNLIMITED || strcmp(name_in, LEVEL_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_unlimdim(ncid, &unlimdimid_in)) ERR; if (unlimdimid_in != 0) ERR; if (nc_inq_unlimdims(ncid, &nunlimdims_in, &unlimdimid_in)) ERR; if (nunlimdims_in != 1 || unlimdimid_in != 0) ERR; if (unlimdimid_in != 0) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; #define ROMULUS "Romulus" #define REMUS "Remus" #define DIMS2 2 printf("*** Testing file with two unlimited dimensions..."); { int ncid, dimid[DIMS2]; int ndims_in, dimids_in[DIMS2]; size_t len_in; char name_in[NC_MAX_NAME + 1]; int unlimdimid_in[DIMS2]; int nunlimdims_in; /* Create a file with one unlimied dim and nothing else. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, REMUS, NC_UNLIMITED, &dimid[0])) ERR; if (nc_def_dim(ncid, ROMULUS, NC_UNLIMITED, &dimid[1])) ERR; /* Check it out before the enddef. */ if (nc_inq_dim(ncid, dimid[0], name_in, &len_in)) ERR; if (len_in != NC_UNLIMITED || strcmp(name_in, REMUS)) ERR; if (nc_inq_dim(ncid, dimid[1], name_in, &len_in)) ERR; if (len_in != NC_UNLIMITED || strcmp(name_in, ROMULUS)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 2 || dimids_in[0] != 0 || dimids_in[1] != 1) ERR; if (nc_inq_unlimdim(ncid, &unlimdimid_in[0])) ERR; if (unlimdimid_in[0] != 1) ERR; if (nc_inq_unlimdims(ncid, &nunlimdims_in, unlimdimid_in)) ERR; if (nunlimdims_in != 2 || unlimdimid_in[0] != 1 || unlimdimid_in[1] != 0) ERR; /* Automatically enddef and close. */ if (nc_close(ncid)) ERR; /* Reopen and check it out. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Testing ordering of dimensions..."); { #define A_NAME "a" #define B_NAME "b" #define A_LEN 50 #define B_LEN 92 #define A_DIMID 1 #define B_DIMID 0 int ncid; int ndims_in, dimids_in[MAX_DIMS]; size_t len_in; char name_in[NC_MAX_NAME + 1]; int dimid_a, dimid_b; /* Create a file with two dims and nothing else. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, B_NAME, B_LEN, &dimid_b)) ERR; if (nc_def_dim(ncid, A_NAME, A_LEN, &dimid_a)) ERR; if (dimid_b != B_DIMID || dimid_a != A_DIMID) ERR; /* Check out what we've got. */ if (nc_inq_dim(ncid, dimid_a, name_in, &len_in)) ERR; if (len_in != A_LEN || strcmp(name_in, A_NAME)) ERR; if (nc_inq_dim(ncid, dimid_b, name_in, &len_in)) ERR; if (len_in != B_LEN || strcmp(name_in, B_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 2 || dimids_in[0] != 0 || dimids_in[1] != 1) ERR; if (nc_close(ncid)) ERR; /* Reopen and check it out again. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq_dim(ncid, B_DIMID, name_in, &len_in)) ERR; if (len_in != B_LEN || strcmp(name_in, B_NAME)) ERR; if (nc_inq_dim(ncid, A_DIMID, name_in, &len_in)) ERR; if (len_in != A_LEN || strcmp(name_in, A_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 2 || dimids_in[0] != 0 || dimids_in[1] != 1) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Testing file with just one unlimited dimension and one var..."); { int ncid, dimid, dimids[MAX_DIMS]; int level_varid; int natts_in, ndims_in, dimids_in[MAX_DIMS]; nc_type xtype_in; size_t len_in; char name_in[NC_MAX_NAME + 1]; int unlimdimid_in; size_t start[MAX_DIMS], count[MAX_DIMS]; int varid_in, nvars_in, nunlimdims_in; unsigned long long uint64_data[1] = {42}; /* Create a file with one unlimied dim and nothing else. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, LEVEL_NAME, NC_UNLIMITED, &dimid)) ERR; if (dimid != 0) ERR; dimids[0] = dimid; if (nc_def_var(ncid, LEVEL_NAME, NC_UINT64, 1, dimids, &level_varid)) ERR; if (level_varid != 0) ERR; /* Check it out before enddef. */ if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != 0 || strcmp(name_in, LEVEL_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_unlimdim(ncid, &unlimdimid_in)) ERR; if (unlimdimid_in != 0) ERR; if (nc_inq_unlimdims(ncid, &nunlimdims_in, &unlimdimid_in)) ERR; if (nunlimdims_in != 1 || unlimdimid_in != 0) ERR; if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 || unlimdimid_in != 0) ERR; if (nc_inq_varid(ncid, LEVEL_NAME, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, LEVEL_NAME) || xtype_in != NC_UINT64 || ndims_in != 1 || dimids_in[0] != 0 || natts_in != 0) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (strcmp(name_in, LEVEL_NAME)) ERR; /* Now write one record of data to the var. */ start[0] = 0; count[0] = 1; if (nc_put_vara_ulonglong(ncid, 0, start, count, uint64_data)) ERR; /* Check dimension informaiton again. Now the length of this * dimension should be one. */ if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != 1 || strcmp(name_in, LEVEL_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_dimlen(ncid, 0, &len_in)) ERR; if (len_in != 1) ERR; if (nc_inq_unlimdim(ncid, &unlimdimid_in)) ERR; if (unlimdimid_in != 0) ERR; if (nc_inq_unlimdims(ncid, &nunlimdims_in, &unlimdimid_in)) ERR; if (nunlimdims_in != 1 || unlimdimid_in != 0) ERR; if (unlimdimid_in != 0) ERR; if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 || unlimdimid_in != 0) ERR; if (nc_inq_varid(ncid, LEVEL_NAME, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, LEVEL_NAME) || xtype_in != NC_UINT64 || ndims_in != 1 || dimids_in[0] != 0 || natts_in != 0) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (strcmp(name_in, LEVEL_NAME)) ERR; /* Close the file. */ if (nc_close(ncid)) ERR; /* Check it out. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != 1 || strcmp(name_in, LEVEL_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_unlimdim(ncid, &unlimdimid_in)) ERR; if (unlimdimid_in != 0) ERR; if (nc_inq_unlimdims(ncid, &nunlimdims_in, &unlimdimid_in)) ERR; if (nunlimdims_in != 1 || unlimdimid_in != 0) ERR; if (unlimdimid_in != 0) ERR; if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 || unlimdimid_in != 0) ERR; if (nc_inq_varid(ncid, LEVEL_NAME, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, LEVEL_NAME) || xtype_in != NC_UINT64 || ndims_in != 1 || dimids_in[0] != 0 || natts_in != 0) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (strcmp(name_in, LEVEL_NAME)) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Testing adding a coordinate var to file with dimension..."); { int ncid, dimid, dimids[MAX_DIMS]; int natts_in, ndims_in, dimids_in[MAX_DIMS]; nc_type xtype_in; size_t len_in; char name_in[NC_MAX_NAME + 1]; int unlimdimid_in; int nvars_in, dim5_varid; /* Create a file with one dim and nothing else. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM5_NAME, DIM5_LEN, &dimid)) ERR; /* Check out what we've got. */ if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != 1 || nvars_in != 0 || natts_in != 0 || unlimdimid_in != -1) ERR; if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != DIM5_LEN || strcmp(name_in, DIM5_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_close(ncid)) ERR; /* Reopen and check it out again. */ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != 1 || nvars_in != 0 || natts_in != 0 || unlimdimid_in != -1) ERR; if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR; if (len_in != DIM5_LEN || strcmp(name_in, DIM5_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; /* Add a coordinate var for this dimension. */ dimids[0] = 0; if (nc_def_var(ncid, DIM5_NAME, NC_FLOAT, 1, dimids, &dim5_varid)) ERR; /* Check it out. */ if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 || unlimdimid_in != -1) ERR; if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR; if (len_in != DIM5_LEN || strcmp(name_in, DIM5_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, DIM5_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimids_in[0] != 0 || natts_in != 0) ERR; if (nc_close(ncid)) ERR; /* Reopen and check it out again. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 || unlimdimid_in != -1) ERR; if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR; if (len_in != DIM5_LEN || strcmp(name_in, DIM5_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, DIM5_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimids_in[0] != 0 || natts_in != 0) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Testing adding a coordinate var to file with unlimited dimension..."); { int ncid, dimid, dimids[MAX_DIMS]; int natts_in, ndims_in, dimids_in[MAX_DIMS]; nc_type xtype_in; size_t len_in; char name_in[NC_MAX_NAME + 1]; int unlimdimid_in; size_t start[MAX_DIMS], count[MAX_DIMS], index[MAX_DIMS]; unsigned short data[2] = {42, 24}, data_in[2]; int nvars_in, hp_varid, dim5_varid; /* Create a file with one dim and one var. This time make * it an unlimited dim. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM5_NAME, NC_UNLIMITED, &dimid)) ERR; if (dimid != 0) ERR; dimids[0] = dimid; if (nc_def_var(ncid, HP_NAME, NC_USHORT, 1, dimids, &hp_varid)) ERR; if (hp_varid != 0) ERR; /* Check out what we've got. */ if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 || unlimdimid_in != 0) ERR; if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR; if (len_in != 0 || strcmp(name_in, DIM5_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, HP_NAME) || xtype_in != NC_USHORT || ndims_in != 1 || dimids_in[0] != 0 || natts_in != 0) ERR; /* Add a record to the HP variable. */ start[0] = 0; count[0] = 1; if (nc_put_vara(ncid, hp_varid, start, count, data)) ERR; /* Check to ensure dimension grew. */ if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR; if (len_in != 1 || strcmp(name_in, DIM5_NAME)) ERR; /* Reread the value just written. */ index[0] = 0; if (nc_get_var1_ushort(ncid, hp_varid, index, data_in)) ERR; if (data_in[0] != data[0]) ERR; if (nc_close(ncid)) ERR; /* Reopen and check it out again. */ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 || unlimdimid_in != 0) ERR; if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR; if (len_in != 1 || strcmp(name_in, DIM5_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; /* Add a coordinate var for this dimension. */ dimids[0] = 0; if (nc_def_var(ncid, DIM5_NAME, NC_FLOAT, 1, dimids, &dim5_varid)) ERR; /* Check it out. */ if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != 1 || nvars_in != 2 || natts_in != 0 || unlimdimid_in != 0) ERR; if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR; if (len_in != 1 || strcmp(name_in, DIM5_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_var(ncid, dim5_varid, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, DIM5_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimids_in[0] != 0 || natts_in != 0) ERR; if (nc_close(ncid)) ERR; /* Reopen and check it out again. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != 1 || nvars_in != 2 || natts_in != 0 || unlimdimid_in != 0) ERR; if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR; if (len_in != 1 || strcmp(name_in, DIM5_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1 || dimids_in[0] != 0) ERR; if (nc_inq_var(ncid, dim5_varid, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, DIM5_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimids_in[0] != 0 || natts_in != 0) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Creating file with 1 data var, 2 dims, and 2 coord. vars..."); { int ncid, dimids[MAX_DIMS]; int lat_dimid, lon_dimid, lat_varid, lon_varid; int pres_varid; char name_in[NC_MAX_NAME + 1]; int natts_in, ndims_in, dimids_in[MAX_DIMS]; nc_type xtype_in; size_t len_in; float lat[LAT_LEN], lon[LON_LEN]; float lat_in[LAT_LEN], lon_in[LON_LEN]; double pres[LAT_LEN][LON_LEN], pres_in[LAT_LEN][LON_LEN]; int i, j; /* Lats and lons suitable for some South American data. */ for (lat[0] = 40.0, i = 1; i < LAT_LEN; i++) lat[i] = lat[i - 1] + .5; for (lon[0] = 20.0, i = 1; i < LON_LEN; i++) lon[i] = lon[i - 1] + 1.5; /* Some phoney 2D pressure data. */ for (i = 0; i < LAT_LEN; i++) for (j = 0; j < LON_LEN; j++) pres[i][j] = 1013.1 + j; /* Create a file. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; /* Define lat and lon dimensions, with associated variables. */ if (nc_def_dim(ncid, LAT_NAME, LAT_LEN, &lat_dimid)) ERR; dimids[0] = lat_dimid; if (nc_def_var(ncid, LAT_NAME, NC_FLOAT, 1, dimids, &lat_varid)) ERR; if (nc_def_dim(ncid, LON_NAME, LON_LEN, &lon_dimid)) ERR; dimids[0] = lon_dimid; if (nc_def_var(ncid, LON_NAME, NC_FLOAT, 1, dimids, &lon_varid)) ERR; /* Define a 2D variable called pressure, with NC_DOUBLE on a lat * lon grid. */ dimids[0] = lat_dimid; dimids[1] = lon_dimid; if (nc_def_var(ncid, PRES_NAME, NC_DOUBLE, 2, dimids, &pres_varid)) ERR; /* Check our dimensions. */ if (nc_inq_dim(ncid, lat_dimid, name_in, &len_in)) ERR; if (len_in != LAT_LEN || strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dim(ncid, lon_dimid, name_in, &len_in)) ERR; if (len_in != LON_LEN || strcmp(name_in, LON_NAME)) ERR; if (nc_inq_var(ncid, lat_varid, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, LAT_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimids_in[0] != lat_dimid || natts_in != 0) ERR; if (nc_inq_var(ncid, lon_varid, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, LON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimids_in[0] != lon_dimid || natts_in != 0) ERR; /* Check our data variable. */ if (nc_inq_var(ncid, pres_varid, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, PRES_NAME) || xtype_in != NC_DOUBLE || ndims_in != 2 || dimids_in[0] != lat_dimid || dimids_in[1] != lon_dimid || natts_in != 0) ERR; /* Write our latitude and longitude values. This writes all * metadata to disk too. */ if (nc_put_var_float(ncid, lat_varid, lat)) ERR; if (nc_put_var_float(ncid, lon_varid, lon)) ERR; /* Write our 2D pressure values. */ if (nc_put_var_double(ncid, pres_varid, (double *)pres)) ERR; /* Check our latitude and longitude values. */ if (nc_get_var(ncid, lat_varid, lat_in)) ERR; for (i = 0; i < LAT_LEN; i++) if (lat[i] != lat_in[i]) ERR; if (nc_get_var_float(ncid, lon_varid, lon_in)) ERR; for (i = 0; i < LON_LEN; i++) if (lon[i] != lon_in[i]) ERR; /* Check our pressure values. */ if (nc_get_var_double(ncid, pres_varid, (double *)pres_in)) ERR; for (i = 0; i < LAT_LEN; i++) for (j = 0; j < LON_LEN; j++) if (pres[i][j] != pres_in[i][j]) ERR; /* Close the file. */ if (nc_close(ncid)) ERR; /* Reopen the file and check it out again. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; /* Check our dimensions. */ if (nc_inq_dim(ncid, lat_dimid, name_in, &len_in)) ERR; if (len_in != LAT_LEN || strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dim(ncid, lon_dimid, name_in, &len_in)) ERR; if (len_in != LON_LEN || strcmp(name_in, LON_NAME)) ERR; if (nc_inq_var(ncid, lat_varid, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, LAT_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimids_in[0] != lat_dimid || natts_in != 0) ERR; if (nc_inq_var(ncid, lon_varid, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, LON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimids_in[0] != lon_dimid || natts_in != 0) ERR; /* Check our data variable. */ if (nc_inq_var(ncid, pres_varid, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, PRES_NAME) || xtype_in != NC_DOUBLE || ndims_in != 2 || dimids_in[0] != lat_dimid || dimids_in[1] != lon_dimid || natts_in != 0) ERR; /* Check our latitude and longitude values. */ if (nc_get_var(ncid, lat_varid, lat_in)) ERR; for (i = 0; i < LAT_LEN; i++) if (lat[i] != lat_in[i]) ERR; if (nc_get_var_float(ncid, lon_varid, lon_in)) ERR; for (i = 0; i < LON_LEN; i++) if (lon[i] != lon_in[i]) ERR; /* Check our pressure values. */ if (nc_get_var_double(ncid, pres_varid, (double *)pres_in)) ERR; for (i = 0; i < LAT_LEN; i++) for (j = 0; j < LON_LEN; j++) if (pres[i][j] != pres_in[i][j]) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Creating file with 3 data vars, 4 dims, and 2 coord. vars..."); { int ncid, lat_dimid, dimids[MAX_DIMS]; int level_dimid, time_dimid, elev_varid; int lat_varid, lon_dimid, lon_varid, pres_varid, hp_varid; double pres[LAT_LEN][LON_LEN][LEVEL_LEN][TIME_LEN]; double pres_in[LAT_LEN][LON_LEN][LEVEL_LEN][TIME_LEN]; unsigned short hp[LAT_LEN][LON_LEN][TIME_LEN]; unsigned short hp_in[LAT_LEN][LON_LEN][TIME_LEN]; unsigned long long elev[LAT_LEN][LON_LEN], elev_in[LAT_LEN][LON_LEN]; size_t start[4], count[4]; int nvars, ndims, natts, unlimdimid; int natts_in, ndims_in, dimids_in[MAX_DIMS]; nc_type xtype_in; size_t len_in; char name_in[NC_MAX_NAME + 1]; float lat[LAT_LEN], lon[LON_LEN]; float lat_in[LAT_LEN], lon_in[LON_LEN]; int i, j, k, l; /* Some phony 4D pressure data. */ for (i = 0; i < LAT_LEN; i++) for (j = 0; j < LON_LEN; j++) for (k = 0; k < LEVEL_LEN; k++) for (l = 0; l <TIME_LEN; l++) pres[i][j][k][l] = 1013.1 + j; /* Some phony 3D hp data. */ for (i = 0; i < LAT_LEN; i++) for (j = 0; j < LON_LEN; j++) for (l = 0; l <TIME_LEN; l++) hp[i][j][l] = 100 + l; /* Some phony 2D elevaton data. */ for (i = 0; i < LAT_LEN; i++) for (j = 0; j < LON_LEN; j++) elev[i][j] = 1010101022223333ULL + i + j; /* Some phony 1D lats and lons. */ for (i = 0; i < LAT_LEN; i++) lat[i] = i * 5.; for (i = 0; i < LON_LEN; i++) lon[i] = i * 5.; if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; /* Define lat, lon, level, and timestep dimensions, with * associated coordinate variables for lat and lon only. Time is * an unlimited dimension. */ if (nc_def_dim(ncid, LAT_NAME, LAT_LEN, &lat_dimid)) ERR; if (lat_dimid != LAT_DIMID) ERR; dimids[0] = lat_dimid; if (nc_def_var(ncid, LAT_NAME, NC_FLOAT, 1, dimids, &lat_varid)) ERR; if (lat_varid != LAT_VARID) ERR; if (nc_def_dim(ncid, LON_NAME, LON_LEN, &lon_dimid)) ERR; if (lon_dimid != LON_DIMID) ERR; dimids[0] = lon_dimid; if (nc_def_var(ncid, LON_NAME, NC_FLOAT, 1, dimids, &lon_varid)) ERR; if (lon_varid != LON_VARID) ERR; if (nc_def_dim(ncid, LEVEL_NAME, LEVEL_LEN, &level_dimid)) ERR; if (level_dimid != LEVEL_DIMID) ERR; if (nc_def_dim(ncid, TIME_NAME, NC_UNLIMITED, &time_dimid)) ERR; if (time_dimid != TIME_DIMID) ERR; /* Define a 4D NC_DOUBLE variable called pressure. */ dimids[0] = lat_dimid; dimids[1] = lon_dimid; dimids[2] = level_dimid; dimids[3] = time_dimid; if (nc_def_var(ncid, PRES_NAME, NC_DOUBLE, 4, dimids, &pres_varid)) ERR; if (pres_varid != PRES_VARID) ERR; /* Define a 2D variable for surface elevation. Use NC_INT64 * because our units for this is Angstroms from Earth's * Center. */ if (nc_def_var(ncid, ELEV_NAME, NC_INT64, 2, dimids, &elev_varid)) ERR; if (elev_varid != ELEV_VARID) ERR; /* Define a 3D NC_USHORT variable to store the number of Harry * Potter books in this grid square at this time (ignore HP * books in airplanes, dirigibles, hot air balloons, space * capsules, hang-gliders, parachutes, and flying on brooms). */ dimids[2] = time_dimid; if (nc_def_var(ncid, HP_NAME, NC_USHORT, 3, dimids, &hp_varid)) ERR; if (hp_varid != HP_VARID) ERR; /* Did all our stuff make it into the internal metadata model * intact? */ /* Check our dimensions. */ if (nc_inq_dim(ncid, LAT_DIMID, name_in, &len_in)) ERR; if (len_in != LAT_LEN || strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dim(ncid, LON_DIMID, name_in, &len_in)) ERR; if (len_in != LON_LEN || strcmp(name_in, LON_NAME)) ERR; if (nc_inq_dim(ncid, LEVEL_DIMID, name_in, &len_in)) ERR; if (len_in != LEVEL_LEN || strcmp(name_in, LEVEL_NAME)) ERR; if (nc_inq_dim(ncid, TIME_DIMID, name_in, &len_in)) ERR; if (len_in != 0 || strcmp(name_in, TIME_NAME)) ERR; /* Check our coordinate variables. */ if (nc_inq_var(ncid, LAT_VARID, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, LAT_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimids_in[0] != LAT_DIMID || natts_in != 0) ERR; if (nc_inq_var(ncid, LON_VARID, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, LON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimids_in[0] != LON_DIMID || natts_in != 0) ERR; /* Check our data variables. */ if (nc_inq_var(ncid, PRES_VARID, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, PRES_NAME) || xtype_in != NC_DOUBLE || ndims_in != 4 || dimids_in[0] != LAT_DIMID || dimids_in[1] != LON_DIMID || dimids_in[2] != LEVEL_DIMID || dimids_in[3] != TIME_DIMID || natts_in != 0) ERR; if (nc_inq_var(ncid, ELEV_VARID, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, ELEV_NAME) || xtype_in != NC_INT64 || ndims_in != 2 || dimids_in[0] != LAT_DIMID || dimids_in[1] != LON_DIMID || natts_in != 0) ERR; if (nc_inq_var(ncid, HP_VARID, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, HP_NAME) || xtype_in != NC_USHORT || ndims_in != 3 || dimids_in[0] != LAT_DIMID || dimids_in[1] != LON_DIMID || dimids_in[2] != TIME_DIMID || natts_in != 0) ERR; /* Write our latitude and longitude values. This writes all * metadata to disk too. */ if (nc_put_var_float(ncid, lat_varid, lat)) ERR; if (nc_put_var_float(ncid, lon_varid, lon)) ERR; /* Write our 4D pressure, elevation, and hp data. But this * should do nothing for pressure and hp, because these are * record vars, and nc_put_var_* doesn't do anything to record * vars, because it doesn't know how big the var is supposed to * be. */ if (nc_put_var_double(ncid, pres_varid, (double *)pres)) ERR; if (nc_put_var_ulonglong(ncid, elev_varid, (unsigned long long *)elev)) ERR; if (nc_put_var_ushort(ncid, hp_varid, (unsigned short *)hp)) ERR; /* Check our latitude and longitude values. */ if (nc_get_var(ncid, lat_varid, lat_in)) ERR; for (i = 0; i < LAT_LEN; i++) if (lat[i] != lat_in[i]) ERR; if (nc_get_var_float(ncid, lon_varid, lon_in)) ERR; for (i = 0; i < LON_LEN; i++) if (lon[i] != lon_in[i]) ERR; /* Make sure our pressure and hp variables are still * empty. get_var calls will return no error, but fetch no * data. */ if (nc_inq_var(ncid, pres_varid, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (nc_inq_dim(ncid, dimids_in[3], NULL, &len_in)) ERR; if (len_in != 0) ERR; if (nc_get_var_double(ncid, pres_varid, (double *)pres_in) != NC_EINVALCOORDS) ERR; if (nc_inq_var(ncid, hp_varid, NULL, NULL, &ndims_in, dimids_in, NULL)) ERR; if (nc_inq_dim(ncid, dimids_in[2], NULL, &len_in)) ERR; if (len_in != 0) ERR; if (nc_get_var_ushort(ncid, hp_varid, (unsigned short *)hp_in) != NC_EINVALCOORDS) ERR; /* Now use nc_put_vara to really write pressure and hp * data. Write TIME_LEN (4) records of each. */ start[0] = start[1] = start[2] = start[3] = 0; count[0] = LAT_LEN; count[1] = LON_LEN; count[2] = LEVEL_LEN; count[3] = TIME_LEN; if (nc_put_vara(ncid, pres_varid, start, count, (double *)pres)) ERR; count[2] = TIME_LEN; if (nc_put_vara(ncid, hp_varid, start, count, (double *)hp)) ERR; /* Check our pressure values. */ if (nc_get_var_double(ncid, pres_varid, (double *)pres_in)) ERR; for (i = 0; i < LAT_LEN; i++) for (j = 0; j < LON_LEN; j++) for (k = 0; k < LEVEL_LEN; k++) for (l = 0; l <TIME_LEN; l++) if (pres[i][j][k][l] != pres_in[i][j][k][l]) ERR; /* Check our elevation values. */ if (nc_get_var_ulonglong(ncid, elev_varid, (unsigned long long *)elev_in)) ERR; for (i = 0; i < LAT_LEN; i++) for (j = 0; j < LON_LEN; j++) if (elev[i][j] != elev_in[i][j]) ERR; /* Check our hp values. */ if (nc_get_var_ushort(ncid, hp_varid, (unsigned short *)hp_in)) ERR; for (i = 0; i < LAT_LEN; i++) for (j = 0; j < LON_LEN; j++) for (l = 0; l <TIME_LEN; l++) if (hp[i][j][l] != hp_in[i][j][l]) ERR; /* Close the file. */ if (nc_close(ncid)) ERR; /* Reopen the file and check it out again. At the moment, we * can't count on the varids and dimids being the same. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != 4 || nvars != 5 || natts != 0) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Checking file with dims and only some coordinate vars..."); #define NDIMS_EX 4 #define NLAT 6 #define NLON 12 #define LAT_NAME_EX "latitude" #define LON_NAME_EX "longitude" #define NREC 2 #define REC_NAME "time" #define LVL_NAME "level" #define NLVL 2 /* Names of things. */ #define PRES_NAME "pressure" #define TEMP_NAME "temperature" #define UNITS "units" #define DEGREES_EAST "degrees_east" #define DEGREES_NORTH "degrees_north" /* There are 4 vars, two for data, two for coordinate data. */ #define NVARS_EX 4 /* These are used to construct some example data. */ #define SAMPLE_PRESSURE 900 #define SAMPLE_TEMP 9.0 #define START_LAT 25.0 #define START_LON -125.0 /* For the units attributes. */ #define UNITS "units" #define PRES_UNITS "hPa" #define TEMP_UNITS "celsius" #define LAT_UNITS "degrees_north" #define LON_UNITS "degrees_east" #define MAX_ATT_LEN 80 { /* IDs for the netCDF file, dimensions, and variables. */ int ncid, lon_dimid, lat_dimid; int lon_varid; int ndims_in; int dimid[NDIMS_EX]; char dim_name_in[NDIMS_EX][NC_MAX_NAME]; int i; /* Create the file. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; /* Define the dimensions. */ if (nc_def_dim(ncid, LAT_NAME_EX, NLAT, &lat_dimid)) ERR; if (nc_def_dim(ncid, LON_NAME_EX, NLON, &lon_dimid)) ERR; /* Define a coordinate var. */ if (nc_def_var(ncid, LON_NAME_EX, NC_FLOAT, 1, &lon_dimid, &lon_varid)) ERR; /* Close the file. */ if (nc_close(ncid)) ERR; if (nc_open(FILE_NAME, 0, &ncid)) ERR; /* Check dimensions. */ ndims_in = 0; if (nc_inq_dimids(ncid, &ndims_in, dimid, 0)) ERR; if (ndims_in != 2) ERR; for (i = 0; i < 2; i++) { if (dimid[i] != i) ERR; if (nc_inq_dimname(ncid, i, dim_name_in[i])) ERR; } if (strcmp(dim_name_in[0], LAT_NAME_EX) || strcmp(dim_name_in[1], LON_NAME_EX)) ERR; /* Close the file. */ if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** Testing file with just one very long dimension..."); { #define VERY_LONG_LEN (size_t)4500000000LL int ncid, dimid; int ndims_in, dimids_in[MAX_DIMS]; size_t len_in; char name_in[NC_MAX_NAME + 1]; int varid_in; if (SIZEOF_SIZE_T == 8) { /* Create a file with one dim and nothing else. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, LAT_NAME, VERY_LONG_LEN, &dimid)) ERR; /* Check it out. */ if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != ((SIZEOF_SIZE_T == 8) ? VERY_LONG_LEN : NC_MAX_UINT) || strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1) ERR; if (nc_inq_dimid(ncid, LAT_NAME, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_dimname(ncid, 0, name_in)) ERR; if (strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dimlen(ncid, 0, &len_in)) ERR; if (len_in != ((SIZEOF_SIZE_T == 8) ? VERY_LONG_LEN : NC_MAX_UINT)) ERR; if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR; if (ndims_in != 0) ERR; if (nc_close(ncid)) ERR; /* Reopen and check it out again. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; /* Check it out. */ if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR; if (len_in != ((SIZEOF_SIZE_T == 8) ? VERY_LONG_LEN : NC_MAX_UINT) || strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1) ERR; if (nc_inq_dimid(ncid, LAT_NAME, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_dimname(ncid, 0, name_in)) ERR; if (strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dimlen(ncid, 0, &len_in)) ERR; if (len_in != ((SIZEOF_SIZE_T == 8) ? VERY_LONG_LEN : NC_MAX_UINT)) ERR; if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR; if (ndims_in != 0) ERR; if (nc_close(ncid)) ERR; } } SUMMARIZE_ERR; printf("*** Testing reference file with just one very long dimension..."); { #define REF_FILE_NAME "ref_tst_dims.nc" int ncid, dimid = 0; int ndims_in, dimids_in[MAX_DIMS]; size_t len_in; char name_in[NC_MAX_NAME + 1]; int varid_in; char file_in[NC_MAX_NAME + 1]; int ret; strcpy(file_in, ""); if (getenv("srcdir")) { strcat(file_in, getenv("srcdir")); strcat(file_in, "/"); } strcat(file_in, REF_FILE_NAME); /* Reopen and check it out again. */ if (nc_open(file_in, NC_NOWRITE, &ncid)) ERR; /* Check it out. */ ret = nc_inq_dim(ncid, dimid, name_in, &len_in); if ((SIZEOF_SIZE_T >= 8 && ret) || (SIZEOF_SIZE_T < 8 && ret != NC_EDIMSIZE)) ERR; if (SIZEOF_SIZE_T < 8) { if (len_in != NC_MAX_UINT) ERR; } else { if (len_in != VERY_LONG_LEN) ERR; } if (strcmp(name_in, LAT_NAME)) ERR; if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; if (ndims_in != 1) ERR; if (nc_inq_dimid(ncid, LAT_NAME, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR; if (ndims_in != 0) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; FINAL_RESULTS; }
int main() {/* create tst_diskless2.nc */ int stat; /* return status */ int ncid; /* netCDF id */ /* group ids */ int root_grp; int g_grp; int h_grp; /* type ids */ int enum_t_typ; int opaque_t_typ; int vlen_t_typ; int g_cmpd_t_typ; /* dimension ids */ int lat_dim; int lon_dim; int time_dim; /* dimension lengths */ size_t lat_len = 10; size_t lon_len = 5; size_t time_len = NC_UNLIMITED; /* variable ids */ int lat_id; int lon_id; int time_id; int Z_id; int t_id; int p_id; int rh_id; int country_id; int tag_id; int h_compoundvar_id; /* rank (number of dimensions) for each variable */ # define RANK_lat 1 # define RANK_lon 1 # define RANK_time 1 # define RANK_Z 3 # define RANK_t 3 # define RANK_p 3 # define RANK_rh 3 # define RANK_country 3 # define RANK_tag 0 # define RANK_h_compoundvar 0 /* variable shapes */ int lat_dims[RANK_lat]; int lon_dims[RANK_lon]; int time_dims[RANK_time]; int Z_dims[RANK_Z]; int t_dims[RANK_t]; int p_dims[RANK_p]; int rh_dims[RANK_rh]; int country_dims[RANK_country]; /* enter define mode */ stat = nc_create("tst_diskless2.nc", NC_DISKLESS|NC_WRITE|NC_CLOBBER|NC_NETCDF4, &ncid); check_err(stat,__LINE__,__FILE__); root_grp = ncid; stat = nc_def_grp(root_grp, "g", &g_grp); check_err(stat,__LINE__,__FILE__); stat = nc_def_grp(root_grp, "h", &h_grp); check_err(stat,__LINE__,__FILE__); { unsigned char econst; stat = nc_def_enum(root_grp, NC_UBYTE, "enum_t", &enum_t_typ); check_err(stat,__LINE__,__FILE__); econst = 0; stat = nc_insert_enum(root_grp, enum_t_typ, "Clear", &econst); check_err(stat,__LINE__,__FILE__); econst = 1; stat = nc_insert_enum(root_grp, enum_t_typ, "Cumulonimbus", &econst); check_err(stat,__LINE__,__FILE__); econst = 2; stat = nc_insert_enum(root_grp, enum_t_typ, "Stratus", &econst); check_err(stat,__LINE__,__FILE__); } stat = nc_def_opaque(root_grp, 11, "opaque_t", &opaque_t_typ); check_err(stat,__LINE__,__FILE__); stat = nc_def_vlen(root_grp, "vlen_t", NC_INT, &vlen_t_typ); check_err(stat,__LINE__,__FILE__); stat = nc_def_compound(g_grp, sizeof(g_cmpd_t), "cmpd_t", &g_cmpd_t_typ); check_err(stat,__LINE__,__FILE__); { stat = nc_insert_compound(g_grp, g_cmpd_t_typ, "f1", NC_COMPOUND_OFFSET(g_cmpd_t,f1), vlen_t_typ); check_err(stat,__LINE__,__FILE__); stat = nc_insert_compound(g_grp, g_cmpd_t_typ, "f2", NC_COMPOUND_OFFSET(g_cmpd_t,f2), enum_t_typ); check_err(stat,__LINE__,__FILE__); } /* define dimensions */ stat = nc_def_dim(root_grp, "lat", lat_len, &lat_dim); check_err(stat,__LINE__,__FILE__); stat = nc_def_dim(root_grp, "lon", lon_len, &lon_dim); check_err(stat,__LINE__,__FILE__); stat = nc_def_dim(root_grp, "time", time_len, &time_dim); check_err(stat,__LINE__,__FILE__); /* define variables */ lat_dims[0] = lat_dim; stat = nc_def_var(root_grp, "lat", NC_INT, RANK_lat, lat_dims, &lat_id); check_err(stat,__LINE__,__FILE__); lon_dims[0] = lon_dim; stat = nc_def_var(root_grp, "lon", NC_INT, RANK_lon, lon_dims, &lon_id); check_err(stat,__LINE__,__FILE__); time_dims[0] = time_dim; stat = nc_def_var(root_grp, "time", NC_INT, RANK_time, time_dims, &time_id); check_err(stat,__LINE__,__FILE__); Z_dims[0] = time_dim; Z_dims[1] = lat_dim; Z_dims[2] = lon_dim; stat = nc_def_var(root_grp, "Z", NC_FLOAT, RANK_Z, Z_dims, &Z_id); check_err(stat,__LINE__,__FILE__); t_dims[0] = time_dim; t_dims[1] = lat_dim; t_dims[2] = lon_dim; stat = nc_def_var(root_grp, "t", NC_FLOAT, RANK_t, t_dims, &t_id); check_err(stat,__LINE__,__FILE__); p_dims[0] = time_dim; p_dims[1] = lat_dim; p_dims[2] = lon_dim; stat = nc_def_var(root_grp, "p", NC_DOUBLE, RANK_p, p_dims, &p_id); check_err(stat,__LINE__,__FILE__); rh_dims[0] = time_dim; rh_dims[1] = lat_dim; rh_dims[2] = lon_dim; stat = nc_def_var(root_grp, "rh", NC_INT, RANK_rh, rh_dims, &rh_id); check_err(stat,__LINE__,__FILE__); country_dims[0] = time_dim; country_dims[1] = lat_dim; country_dims[2] = lon_dim; stat = nc_def_var(root_grp, "country", NC_STRING, RANK_country, country_dims, &country_id); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(root_grp, "tag", NC_UBYTE, RANK_tag, 0, &tag_id); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(h_grp, "compoundvar", g_cmpd_t_typ, RANK_h_compoundvar, 0, &h_compoundvar_id); check_err(stat,__LINE__,__FILE__); /* assign global attributes */ { static const int vlen_2[] = {17, 18, 19} ; static const vlen_t globalatt_att[1] = {{3, (void*)vlen_2}} ; stat = nc_put_att(root_grp, NC_GLOBAL, "globalatt", vlen_t_typ, 1, globalatt_att); check_err(stat,__LINE__,__FILE__); } /* assign per-variable attributes */ { stat = nc_put_att_text(root_grp, lat_id, "long_name", 8, "latitude"); check_err(stat,__LINE__,__FILE__); } { stat = nc_put_att_text(root_grp, lat_id, "units", 13, "degrees_north"); check_err(stat,__LINE__,__FILE__); } { stat = nc_put_att_text(root_grp, lon_id, "long_name", 9, "longitude"); check_err(stat,__LINE__,__FILE__); } { stat = nc_put_att_text(root_grp, lon_id, "units", 12, "degrees_east"); check_err(stat,__LINE__,__FILE__); } { stat = nc_put_att_text(root_grp, time_id, "units", 31, "seconds since 1992-1-1 00:00:00"); check_err(stat,__LINE__,__FILE__); } { static const char* Z_units_att[1] = {"geopotential meters"} ; stat = nc_put_att_string(root_grp, Z_id, "units", 1, Z_units_att); check_err(stat,__LINE__,__FILE__); } { static const float Z_valid_range_att[2] = {((float)0), ((float)5000)} ; stat = nc_put_att_float(root_grp, Z_id, "valid_range", NC_FLOAT, 2, Z_valid_range_att); check_err(stat,__LINE__,__FILE__); } { static const double p_FillValue_att[1] = {((double)-9999)} ; stat = nc_put_att_double(root_grp, p_id, "_FillValue", NC_DOUBLE, 1, p_FillValue_att); check_err(stat,__LINE__,__FILE__); } { static const int rh_FillValue_att[1] = {-1} ; stat = nc_put_att_int(root_grp, rh_id, "_FillValue", NC_INT, 1, rh_FillValue_att); check_err(stat,__LINE__,__FILE__); } /* leave define mode */ stat = nc_enddef (root_grp); check_err(stat,__LINE__,__FILE__); /* assign variable data */ { int lat_data[10] = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90} ; size_t lat_startset[1] = {0} ; size_t lat_countset[1] = {10}; stat = nc_put_vara(root_grp, lat_id, lat_startset, lat_countset, lat_data); check_err(stat,__LINE__,__FILE__); } { int lon_data[5] = {-140, -118, -96, -84, -52} ; size_t lon_startset[1] = {0} ; size_t lon_countset[1] = {5}; stat = nc_put_vara(root_grp, lon_id, lon_startset, lon_countset, lon_data); check_err(stat,__LINE__,__FILE__); } { static const int vlen_10[] = {3, 4, 5} ; size_t zero = 0; static g_cmpd_t h_compoundvar_data[1] = {{{3, (void*)vlen_10}, 2}}; stat = nc_put_var1(h_grp, h_compoundvar_id, &zero, h_compoundvar_data); check_err(stat,__LINE__,__FILE__); } stat = nc_close(root_grp); check_err(stat,__LINE__,__FILE__); return 0; }
/* compare contiguous, chunked, and compressed performance */ int main(int argc, char *argv[]) { int stat; /* return status */ int ncid; /* netCDF id */ int i, j, k; int dim1id, dim2id, dim3id; int varid_g; /* varid for contiguous */ int varid_k; /* varid for chunked */ int varid_x; /* varid for compressed */ float *varxy, *varxz, *varyz; /* 2D memory slabs used for I/O */ int mm; size_t dims[] = {256, 256, 256}; /* default dim lengths */ size_t chunks[] = {32, 32, 32}; /* default chunk sizes */ size_t start[3], count[3]; float contig_time, chunked_time, compressed_time, ratio; int deflate_level = 1; /* default compression level, 9 is * better and slower. If negative, * turn on shuffle filter also. */ int shuffle = NC_NOSHUFFLE; size_t cache_size_def; size_t cache_hash_def; float cache_pre_def; size_t cache_size = 0; /* use library default */ size_t cache_hash = 0; /* use library default */ float cache_pre = -1.0f; /* use library default */ /* rank (number of dimensions) for each variable */ # define RANK_var1 3 /* variable shapes */ int var_dims[RANK_var1]; TIMING_DECLS(TMsec) ; /* From args, get parameters for timing, including variable and chunk sizes. Negative deflate level means also use shuffle filter. */ parse_args(argc, argv, &deflate_level, &shuffle, dims, chunks, &cache_size, &cache_hash, &cache_pre); /* get cache defaults, then set cache parameters that are not default */ if((stat = nc_get_chunk_cache(&cache_size_def, &cache_hash_def, &cache_pre_def))) ERR1(stat); if(cache_size == 0) cache_size = cache_size_def; if(cache_hash == 0) cache_hash = cache_hash_def; if(cache_pre == -1.0f) cache_pre = cache_pre_def; if((stat = nc_set_chunk_cache(cache_size, cache_hash, cache_pre))) ERR1(stat); printf("cache: %3.2f MBytes %ld objs %3.2f preempt, ", cache_size/1.e6, cache_hash, cache_pre); if(deflate_level == 0) { printf("uncompressed "); } else { printf("compression level %d", deflate_level); } if(shuffle == 1) { printf(", shuffled"); } printf("\n\n"); /* initialize 2D slabs for writing along each axis with phony data */ varyz = (float *) emalloc(sizeof(float) * 1 * dims[1] * dims[2]); varxz = (float *) emalloc(sizeof(float) * dims[0] * 1 * dims[2]); varxy = (float *) emalloc(sizeof(float) * dims[0] * dims[1] * 1); mm = 0; for(j = 0; j < dims[1]; j++) { for(k = 0; k < dims[2]; k++) { varyz[mm++] = k + dims[2]*j; } } mm = 0; for(i = 0; i < dims[0]; i++) { for(k = 0; k < dims[2]; k++) { varxz[mm++] = k + dims[2]*i; } } mm = 0; for(i = 0; i < dims[0]; i++) { for(j = 0; j < dims[1]; j++) { varxy[mm++] = j + dims[1]*i; } } if((stat = nc_create(FILENAME, NC_NETCDF4 | NC_CLASSIC_MODEL, &ncid))) ERR1(stat); /* define dimensions */ if((stat = nc_def_dim(ncid, "dim1", dims[0], &dim1id))) ERR1(stat); if((stat = nc_def_dim(ncid, "dim2", dims[1], &dim2id))) ERR1(stat); if((stat = nc_def_dim(ncid, "dim3", dims[2], &dim3id))) ERR1(stat); /* define variables */ var_dims[0] = dim1id; var_dims[1] = dim2id; var_dims[2] = dim3id; if((stat = nc_def_var(ncid, "var_contiguous", NC_FLOAT, RANK_var1, var_dims, &varid_g))) ERR1(stat); if((stat = nc_def_var(ncid, "var_chunked", NC_FLOAT, RANK_var1, var_dims, &varid_k))) ERR1(stat); if((stat = nc_def_var(ncid, "var_compressed", NC_FLOAT, RANK_var1, var_dims, &varid_x))) ERR1(stat); if((stat = nc_def_var_chunking(ncid, varid_g, NC_CONTIGUOUS, 0))) ERR1(stat); if((stat = nc_def_var_chunking(ncid, varid_k, NC_CHUNKED, chunks))) ERR1(stat); if((stat = nc_def_var_chunking(ncid, varid_x, NC_CHUNKED, chunks))) ERR1(stat); if (deflate_level != 0) { if((stat = nc_def_var_deflate(ncid, varid_x, shuffle, NC_COMPRESSED, deflate_level))) ERR1(stat); } /* leave define mode */ if((stat = nc_enddef (ncid))) ERR1(stat); /* write each variable one yz slab at a time */ start[0] = 0; start[1] = 0; start[2] = 0; count[0] = 1; count[1] = dims[1]; count[2] = dims[2]; sprintf(time_mess," contiguous write %3ld %3ld %3ld", 1, dims[1], dims[2]); TIMING_START ; for(i = 0; i < dims[0]; i++) { start[0] = i; if((stat = nc_put_vara(ncid, varid_g, start, count, &varyz[0]))) ERR1(stat); } TIMING_END(TMsec) ; printf("\n"); contig_time = TMsec; sprintf(time_mess," chunked write %3ld %3ld %3ld %3ld %3ld %3ld", 1, dims[1], dims[2], chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[0]; i++) { start[0] = i; if((stat = nc_put_vara(ncid, varid_k, start, count, &varyz[0]))) ERR1(stat); } TIMING_END(TMsec) ; chunked_time = TMsec; ratio = contig_time/chunked_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); sprintf(time_mess," compressed write %3ld %3ld %3ld %3ld %3ld %3ld", 1, dims[1], dims[2], chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[0]; i++) { start[0] = i; if((stat = nc_put_vara(ncid, varid_x, start, count, &varyz[0]))) ERR1(stat); } TIMING_END(TMsec) ; compressed_time = TMsec; ratio = contig_time/compressed_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); printf("\n"); /* write each variable one xz slab at a time */ start[0] = 0; start[1] = 0; start[2] = 0; count[0] = dims[0]; count[1] = 1; count[2] = dims[2]; sprintf(time_mess," contiguous write %3ld %3ld %3ld", dims[0], 1, dims[2]); TIMING_START ; for(i = 0; i < dims[1]; i++) { start[1] = i; if((stat = nc_put_vara(ncid, varid_g, start, count, &varxz[0]))) ERR1(stat); } TIMING_END(TMsec) ; printf("\n"); contig_time = TMsec; sprintf(time_mess," chunked write %3ld %3ld %3ld %3ld %3ld %3ld", dims[0], 1, dims[2], chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[1]; i++) { start[1] = i; if((stat = nc_put_vara(ncid, varid_k, start, count, &varxz[0]))) ERR1(stat); } TIMING_END(TMsec) ; chunked_time = TMsec; ratio = contig_time/chunked_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); sprintf(time_mess," compressed write %3ld %3ld %3ld %3ld %3ld %3ld", dims[0], 1, dims[2], chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[1]; i++) { start[1] = i; if((stat = nc_put_vara(ncid, varid_x, start, count, &varxz[0]))) ERR1(stat); } TIMING_END(TMsec) ; compressed_time = TMsec; ratio = contig_time/compressed_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); printf("\n"); /* write each variable one xy slab at a time */ start[0] = 0; start[1] = 0; start[2] = 0; count[0] = dims[0]; count[1] = dims[1]; count[2] = 1; sprintf(time_mess," contiguous write %3ld %3ld %3ld", dims[0], dims[1], 1); TIMING_START ; for(i = 0; i < dims[2]; i++) { start[2] = i; if((stat = nc_put_vara(ncid, varid_g, start, count, &varxy[0]))) ERR1(stat); } TIMING_END(TMsec) ; printf("\n"); contig_time = TMsec; sprintf(time_mess," chunked write %3ld %3ld %3ld %3ld %3ld %3ld", dims[0], dims[1], 1, chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[2]; i++) { start[2] = i; if((stat = nc_put_vara(ncid, varid_k, start, count, &varxy[0]))) ERR1(stat); } TIMING_END(TMsec) ; chunked_time = TMsec; ratio = contig_time/chunked_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); sprintf(time_mess," compressed write %3ld %3ld %3ld %3ld %3ld %3ld", dims[0], dims[1], 1, chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[2]; i++) { start[2] = i; if((stat = nc_put_vara(ncid, varid_x, start, count, &varxy[0]))) ERR1(stat); } TIMING_END(TMsec) ; compressed_time = TMsec; ratio = contig_time/compressed_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); printf("\n"); /* read each variable one yz slab at a time */ start[0] = 0; start[1] = 0; start[2] = 0; count[0] = 1; count[1] = dims[1]; count[2] = dims[2]; sprintf(time_mess," contiguous read %3ld %3ld %3ld", 1, dims[1], dims[2]); TIMING_START ; for(i = 0; i < dims[0]; i++) { start[0] = i; if((stat = nc_get_vara(ncid, varid_g, start, count, &varyz[0]))) ERR1(stat); } TIMING_END(TMsec) ; printf("\n"); contig_time = TMsec; sprintf(time_mess," chunked read %3ld %3ld %3ld %3ld %3ld %3ld", 1, dims[1], dims[2] , chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[0]; i++) { start[0] = i; if((stat = nc_get_vara(ncid, varid_k, start, count, &varyz[0]))) ERR1(stat); } TIMING_END(TMsec) ; chunked_time = TMsec; ratio = contig_time/chunked_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); sprintf(time_mess," compressed read %3ld %3ld %3ld %3ld %3ld %3ld", 1, dims[1], dims[2] , chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[0]; i++) { start[0] = i; if((stat = nc_get_vara(ncid, varid_x, start, count, &varyz[0]))) ERR1(stat); } TIMING_END(TMsec) ; compressed_time = TMsec; ratio = contig_time/compressed_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); printf("\n"); /* read each variable one xz slab at a time */ start[0] = 0; start[1] = 0; start[2] = 0; count[0] = dims[0]; count[1] = 1; count[2] = dims[2]; sprintf(time_mess," contiguous read %3ld %3ld %3ld", dims[0], 1, dims[2]); TIMING_START ; for(i = 0; i < dims[1]; i++) { start[1] = i; if((stat = nc_get_vara(ncid, varid_g, start, count, &varxz[0]))) ERR1(stat); } TIMING_END(TMsec) ; printf("\n"); contig_time = TMsec; sprintf(time_mess," chunked read %3ld %3ld %3ld %3ld %3ld %3ld", dims[0], 1, dims[2], chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[1]; i++) { start[1] = i; if((stat = nc_get_vara(ncid, varid_k, start, count, &varxz[0]))) ERR1(stat); } TIMING_END(TMsec) ; chunked_time = TMsec; ratio = contig_time/chunked_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); sprintf(time_mess," compressed read %3ld %3ld %3ld %3ld %3ld %3ld", dims[0], 1, dims[2], chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[1]; i++) { start[1] = i; if((stat = nc_get_vara(ncid, varid_x, start, count, &varxz[0]))) ERR1(stat); } TIMING_END(TMsec) ; compressed_time = TMsec; ratio = contig_time/compressed_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); printf("\n"); /* read variable one xy slab at a time */ start[0] = 0; start[1] = 0; start[2] = 0; count[0] = dims[0]; count[1] = dims[1]; count[2] = 1; sprintf(time_mess," contiguous read %3ld %3ld %3ld", dims[0], dims[1], 1); TIMING_START ; for(i = 0; i < dims[2]; i++) { start[2] = i; if((stat = nc_get_vara(ncid, varid_g, start, count, &varxy[0]))) ERR1(stat); } TIMING_END(TMsec) ; printf("\n"); contig_time = TMsec; sprintf(time_mess," chunked read %3ld %3ld %3ld %3ld %3ld %3ld", dims[0], dims[1], 1, chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[2]; i++) { start[2] = i; if((stat = nc_get_vara(ncid, varid_k, start, count, &varxy[0]))) ERR1(stat); } TIMING_END(TMsec) ; chunked_time = TMsec; ratio = contig_time/chunked_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); sprintf(time_mess," compressed read %3ld %3ld %3ld %3ld %3ld %3ld", dims[0], dims[1], 1, chunks[0], chunks[1], chunks[2]); TIMING_START ; for(i = 0; i < dims[2]; i++) { start[2] = i; if((stat = nc_get_vara(ncid, varid_x, start, count, &varxy[0]))) ERR1(stat); } TIMING_END(TMsec) ; compressed_time = TMsec; ratio = contig_time/compressed_time; if(ratio >= 1.0) printf(" %5.2g x faster\n", ratio); else printf(" %5.2g x slower\n", 1.0/ratio); if((stat = nc_close(ncid))) ERR1(stat); return 0; }
int main() {/* create ctest0_64.nc */ int stat; /* return status */ int ncid; /* netCDF id */ /* dimension ids */ int Dr_dim; int D1_dim; int D2_dim; int D3_dim; int dim_MINUS_name_MINUS_dashes_dim; int dim_PERIOD_name_PERIOD_dots_dim; int dim_PLUS_name_PLUS_plusses_dim; int dim_ATSIGN_name_ATSIGN_ats_dim; /* dimension lengths */ size_t Dr_len = NC_UNLIMITED; size_t D1_len = 1; size_t D2_len = 2; size_t D3_len = 3; size_t dim_MINUS_name_MINUS_dashes_len = 4; size_t dim_PERIOD_name_PERIOD_dots_len = 5; size_t dim_PLUS_name_PLUS_plusses_len = 6; size_t dim_ATSIGN_name_ATSIGN_ats_len = 7; /* variable ids */ int c_id; int b_id; int s_id; int i_id; int f_id; int d_id; int cr_id; int br_id; int sr_id; int ir_id; int fr_id; int dr_id; int c1_id; int b1_id; int s1_id; int i1_id; int f1_id; int d1_id; int c2_id; int b2_id; int s2_id; int i2_id; int f2_id; int d2_id; int c3_id; int b3_id; int s3_id; int i3_id; int f3_id; int d3_id; int cr1_id; int br2_id; int sr3_id; int f11_id; int d12_id; int c13_id; int s21_id; int i22_id; int f23_id; int c31_id; int b32_id; int s33_id; int sr11_id; int ir12_id; int fr13_id; int cr21_id; int br22_id; int sr23_id; int fr31_id; int dr32_id; int cr33_id; int c111_id; int b112_id; int s113_id; int f121_id; int d122_id; int c123_id; int s131_id; int i132_id; int f133_id; int f211_id; int d212_id; int c213_id; int s221_id; int i222_id; int f223_id; int c231_id; int b232_id; int s233_id; int s311_id; int i312_id; int f313_id; int var_MINUS_name_MINUS_dashes_id; int var_PERIOD_name_PERIOD_dots_id; int var_PLUS_name_PLUS_plusses_id; int var_ATSIGN_name_ATSIGN_ats_id; /* rank (number of dimensions) for each variable */ # define RANK_c 0 # define RANK_b 0 # define RANK_s 0 # define RANK_i 0 # define RANK_f 0 # define RANK_d 0 # define RANK_cr 1 # define RANK_br 1 # define RANK_sr 1 # define RANK_ir 1 # define RANK_fr 1 # define RANK_dr 1 # define RANK_c1 1 # define RANK_b1 1 # define RANK_s1 1 # define RANK_i1 1 # define RANK_f1 1 # define RANK_d1 1 # define RANK_c2 1 # define RANK_b2 1 # define RANK_s2 1 # define RANK_i2 1 # define RANK_f2 1 # define RANK_d2 1 # define RANK_c3 1 # define RANK_b3 1 # define RANK_s3 1 # define RANK_i3 1 # define RANK_f3 1 # define RANK_d3 1 # define RANK_cr1 2 # define RANK_br2 2 # define RANK_sr3 2 # define RANK_f11 2 # define RANK_d12 2 # define RANK_c13 2 # define RANK_s21 2 # define RANK_i22 2 # define RANK_f23 2 # define RANK_c31 2 # define RANK_b32 2 # define RANK_s33 2 # define RANK_sr11 3 # define RANK_ir12 3 # define RANK_fr13 3 # define RANK_cr21 3 # define RANK_br22 3 # define RANK_sr23 3 # define RANK_fr31 3 # define RANK_dr32 3 # define RANK_cr33 3 # define RANK_c111 3 # define RANK_b112 3 # define RANK_s113 3 # define RANK_f121 3 # define RANK_d122 3 # define RANK_c123 3 # define RANK_s131 3 # define RANK_i132 3 # define RANK_f133 3 # define RANK_f211 3 # define RANK_d212 3 # define RANK_c213 3 # define RANK_s221 3 # define RANK_i222 3 # define RANK_f223 3 # define RANK_c231 3 # define RANK_b232 3 # define RANK_s233 3 # define RANK_s311 3 # define RANK_i312 3 # define RANK_f313 3 # define RANK_var_MINUS_name_MINUS_dashes 0 # define RANK_var_PERIOD_name_PERIOD_dots 0 # define RANK_var_PLUS_name_PLUS_plusses 0 # define RANK_var_ATSIGN_name_ATSIGN_ats 0 /* variable shapes */ int cr_dims[RANK_cr]; int br_dims[RANK_br]; int sr_dims[RANK_sr]; int ir_dims[RANK_ir]; int fr_dims[RANK_fr]; int dr_dims[RANK_dr]; int c1_dims[RANK_c1]; int b1_dims[RANK_b1]; int s1_dims[RANK_s1]; int i1_dims[RANK_i1]; int f1_dims[RANK_f1]; int d1_dims[RANK_d1]; int c2_dims[RANK_c2]; int b2_dims[RANK_b2]; int s2_dims[RANK_s2]; int i2_dims[RANK_i2]; int f2_dims[RANK_f2]; int d2_dims[RANK_d2]; int c3_dims[RANK_c3]; int b3_dims[RANK_b3]; int s3_dims[RANK_s3]; int i3_dims[RANK_i3]; int f3_dims[RANK_f3]; int d3_dims[RANK_d3]; int cr1_dims[RANK_cr1]; int br2_dims[RANK_br2]; int sr3_dims[RANK_sr3]; int f11_dims[RANK_f11]; int d12_dims[RANK_d12]; int c13_dims[RANK_c13]; int s21_dims[RANK_s21]; int i22_dims[RANK_i22]; int f23_dims[RANK_f23]; int c31_dims[RANK_c31]; int b32_dims[RANK_b32]; int s33_dims[RANK_s33]; int sr11_dims[RANK_sr11]; int ir12_dims[RANK_ir12]; int fr13_dims[RANK_fr13]; int cr21_dims[RANK_cr21]; int br22_dims[RANK_br22]; int sr23_dims[RANK_sr23]; int fr31_dims[RANK_fr31]; int dr32_dims[RANK_dr32]; int cr33_dims[RANK_cr33]; int c111_dims[RANK_c111]; int b112_dims[RANK_b112]; int s113_dims[RANK_s113]; int f121_dims[RANK_f121]; int d122_dims[RANK_d122]; int c123_dims[RANK_c123]; int s131_dims[RANK_s131]; int i132_dims[RANK_i132]; int f133_dims[RANK_f133]; int f211_dims[RANK_f211]; int d212_dims[RANK_d212]; int c213_dims[RANK_c213]; int s221_dims[RANK_s221]; int i222_dims[RANK_i222]; int f223_dims[RANK_f223]; int c231_dims[RANK_c231]; int b232_dims[RANK_b232]; int s233_dims[RANK_s233]; int s311_dims[RANK_s311]; int i312_dims[RANK_i312]; int f313_dims[RANK_f313]; /* enter define mode */ stat = nc_create("ctest0_64.nc", NC_CLOBBER|NC_64BIT_OFFSET, &ncid); check_err(stat,__LINE__,__FILE__); /* define dimensions */ stat = nc_def_dim(ncid, "Dr", Dr_len, &Dr_dim); check_err(stat,__LINE__,__FILE__); stat = nc_def_dim(ncid, "D1", D1_len, &D1_dim); check_err(stat,__LINE__,__FILE__); stat = nc_def_dim(ncid, "D2", D2_len, &D2_dim); check_err(stat,__LINE__,__FILE__); stat = nc_def_dim(ncid, "D3", D3_len, &D3_dim); check_err(stat,__LINE__,__FILE__); stat = nc_def_dim(ncid, "dim-name-dashes", dim_MINUS_name_MINUS_dashes_len, &dim_MINUS_name_MINUS_dashes_dim); check_err(stat,__LINE__,__FILE__); stat = nc_def_dim(ncid, "dim.name.dots", dim_PERIOD_name_PERIOD_dots_len, &dim_PERIOD_name_PERIOD_dots_dim); check_err(stat,__LINE__,__FILE__); stat = nc_def_dim(ncid, "dim+name+plusses", dim_PLUS_name_PLUS_plusses_len, &dim_PLUS_name_PLUS_plusses_dim); check_err(stat,__LINE__,__FILE__); stat = nc_def_dim(ncid, "dim@name@ats", dim_ATSIGN_name_ATSIGN_ats_len, &dim_ATSIGN_name_ATSIGN_ats_dim); check_err(stat,__LINE__,__FILE__); /* define variables */ stat = nc_def_var(ncid, "c", NC_CHAR, RANK_c, 0, &c_id); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(ncid, "b", NC_BYTE, RANK_b, 0, &b_id); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(ncid, "s", NC_SHORT, RANK_s, 0, &s_id); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(ncid, "i", NC_INT, RANK_i, 0, &i_id); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(ncid, "f", NC_FLOAT, RANK_f, 0, &f_id); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(ncid, "d", NC_DOUBLE, RANK_d, 0, &d_id); check_err(stat,__LINE__,__FILE__); cr_dims[0] = Dr_dim; stat = nc_def_var(ncid, "cr", NC_CHAR, RANK_cr, cr_dims, &cr_id); check_err(stat,__LINE__,__FILE__); br_dims[0] = Dr_dim; stat = nc_def_var(ncid, "br", NC_BYTE, RANK_br, br_dims, &br_id); check_err(stat,__LINE__,__FILE__); sr_dims[0] = Dr_dim; stat = nc_def_var(ncid, "sr", NC_SHORT, RANK_sr, sr_dims, &sr_id); check_err(stat,__LINE__,__FILE__); ir_dims[0] = Dr_dim; stat = nc_def_var(ncid, "ir", NC_INT, RANK_ir, ir_dims, &ir_id); check_err(stat,__LINE__,__FILE__); fr_dims[0] = Dr_dim; stat = nc_def_var(ncid, "fr", NC_FLOAT, RANK_fr, fr_dims, &fr_id); check_err(stat,__LINE__,__FILE__); dr_dims[0] = Dr_dim; stat = nc_def_var(ncid, "dr", NC_DOUBLE, RANK_dr, dr_dims, &dr_id); check_err(stat,__LINE__,__FILE__); c1_dims[0] = D1_dim; stat = nc_def_var(ncid, "c1", NC_CHAR, RANK_c1, c1_dims, &c1_id); check_err(stat,__LINE__,__FILE__); b1_dims[0] = D1_dim; stat = nc_def_var(ncid, "b1", NC_BYTE, RANK_b1, b1_dims, &b1_id); check_err(stat,__LINE__,__FILE__); s1_dims[0] = D1_dim; stat = nc_def_var(ncid, "s1", NC_SHORT, RANK_s1, s1_dims, &s1_id); check_err(stat,__LINE__,__FILE__); i1_dims[0] = D1_dim; stat = nc_def_var(ncid, "i1", NC_INT, RANK_i1, i1_dims, &i1_id); check_err(stat,__LINE__,__FILE__); f1_dims[0] = D1_dim; stat = nc_def_var(ncid, "f1", NC_FLOAT, RANK_f1, f1_dims, &f1_id); check_err(stat,__LINE__,__FILE__); d1_dims[0] = D1_dim; stat = nc_def_var(ncid, "d1", NC_DOUBLE, RANK_d1, d1_dims, &d1_id); check_err(stat,__LINE__,__FILE__); c2_dims[0] = D2_dim; stat = nc_def_var(ncid, "c2", NC_CHAR, RANK_c2, c2_dims, &c2_id); check_err(stat,__LINE__,__FILE__); b2_dims[0] = D2_dim; stat = nc_def_var(ncid, "b2", NC_BYTE, RANK_b2, b2_dims, &b2_id); check_err(stat,__LINE__,__FILE__); s2_dims[0] = D2_dim; stat = nc_def_var(ncid, "s2", NC_SHORT, RANK_s2, s2_dims, &s2_id); check_err(stat,__LINE__,__FILE__); i2_dims[0] = D2_dim; stat = nc_def_var(ncid, "i2", NC_INT, RANK_i2, i2_dims, &i2_id); check_err(stat,__LINE__,__FILE__); f2_dims[0] = D2_dim; stat = nc_def_var(ncid, "f2", NC_FLOAT, RANK_f2, f2_dims, &f2_id); check_err(stat,__LINE__,__FILE__); d2_dims[0] = D2_dim; stat = nc_def_var(ncid, "d2", NC_DOUBLE, RANK_d2, d2_dims, &d2_id); check_err(stat,__LINE__,__FILE__); c3_dims[0] = D3_dim; stat = nc_def_var(ncid, "c3", NC_CHAR, RANK_c3, c3_dims, &c3_id); check_err(stat,__LINE__,__FILE__); b3_dims[0] = D3_dim; stat = nc_def_var(ncid, "b3", NC_BYTE, RANK_b3, b3_dims, &b3_id); check_err(stat,__LINE__,__FILE__); s3_dims[0] = D3_dim; stat = nc_def_var(ncid, "s3", NC_SHORT, RANK_s3, s3_dims, &s3_id); check_err(stat,__LINE__,__FILE__); i3_dims[0] = D3_dim; stat = nc_def_var(ncid, "i3", NC_INT, RANK_i3, i3_dims, &i3_id); check_err(stat,__LINE__,__FILE__); f3_dims[0] = D3_dim; stat = nc_def_var(ncid, "f3", NC_FLOAT, RANK_f3, f3_dims, &f3_id); check_err(stat,__LINE__,__FILE__); d3_dims[0] = D3_dim; stat = nc_def_var(ncid, "d3", NC_DOUBLE, RANK_d3, d3_dims, &d3_id); check_err(stat,__LINE__,__FILE__); cr1_dims[0] = Dr_dim; cr1_dims[1] = D1_dim; stat = nc_def_var(ncid, "cr1", NC_CHAR, RANK_cr1, cr1_dims, &cr1_id); check_err(stat,__LINE__,__FILE__); br2_dims[0] = Dr_dim; br2_dims[1] = D2_dim; stat = nc_def_var(ncid, "br2", NC_BYTE, RANK_br2, br2_dims, &br2_id); check_err(stat,__LINE__,__FILE__); sr3_dims[0] = Dr_dim; sr3_dims[1] = D3_dim; stat = nc_def_var(ncid, "sr3", NC_SHORT, RANK_sr3, sr3_dims, &sr3_id); check_err(stat,__LINE__,__FILE__); f11_dims[0] = D1_dim; f11_dims[1] = D1_dim; stat = nc_def_var(ncid, "f11", NC_FLOAT, RANK_f11, f11_dims, &f11_id); check_err(stat,__LINE__,__FILE__); d12_dims[0] = D1_dim; d12_dims[1] = D2_dim; stat = nc_def_var(ncid, "d12", NC_DOUBLE, RANK_d12, d12_dims, &d12_id); check_err(stat,__LINE__,__FILE__); c13_dims[0] = D1_dim; c13_dims[1] = D3_dim; stat = nc_def_var(ncid, "c13", NC_CHAR, RANK_c13, c13_dims, &c13_id); check_err(stat,__LINE__,__FILE__); s21_dims[0] = D2_dim; s21_dims[1] = D1_dim; stat = nc_def_var(ncid, "s21", NC_SHORT, RANK_s21, s21_dims, &s21_id); check_err(stat,__LINE__,__FILE__); i22_dims[0] = D2_dim; i22_dims[1] = D2_dim; stat = nc_def_var(ncid, "i22", NC_INT, RANK_i22, i22_dims, &i22_id); check_err(stat,__LINE__,__FILE__); f23_dims[0] = D2_dim; f23_dims[1] = D3_dim; stat = nc_def_var(ncid, "f23", NC_FLOAT, RANK_f23, f23_dims, &f23_id); check_err(stat,__LINE__,__FILE__); c31_dims[0] = D3_dim; c31_dims[1] = D1_dim; stat = nc_def_var(ncid, "c31", NC_CHAR, RANK_c31, c31_dims, &c31_id); check_err(stat,__LINE__,__FILE__); b32_dims[0] = D3_dim; b32_dims[1] = D2_dim; stat = nc_def_var(ncid, "b32", NC_BYTE, RANK_b32, b32_dims, &b32_id); check_err(stat,__LINE__,__FILE__); s33_dims[0] = D3_dim; s33_dims[1] = D3_dim; stat = nc_def_var(ncid, "s33", NC_SHORT, RANK_s33, s33_dims, &s33_id); check_err(stat,__LINE__,__FILE__); sr11_dims[0] = Dr_dim; sr11_dims[1] = D1_dim; sr11_dims[2] = D1_dim; stat = nc_def_var(ncid, "sr11", NC_SHORT, RANK_sr11, sr11_dims, &sr11_id); check_err(stat,__LINE__,__FILE__); ir12_dims[0] = Dr_dim; ir12_dims[1] = D1_dim; ir12_dims[2] = D2_dim; stat = nc_def_var(ncid, "ir12", NC_INT, RANK_ir12, ir12_dims, &ir12_id); check_err(stat,__LINE__,__FILE__); fr13_dims[0] = Dr_dim; fr13_dims[1] = D1_dim; fr13_dims[2] = D3_dim; stat = nc_def_var(ncid, "fr13", NC_FLOAT, RANK_fr13, fr13_dims, &fr13_id); check_err(stat,__LINE__,__FILE__); cr21_dims[0] = Dr_dim; cr21_dims[1] = D2_dim; cr21_dims[2] = D1_dim; stat = nc_def_var(ncid, "cr21", NC_CHAR, RANK_cr21, cr21_dims, &cr21_id); check_err(stat,__LINE__,__FILE__); br22_dims[0] = Dr_dim; br22_dims[1] = D2_dim; br22_dims[2] = D2_dim; stat = nc_def_var(ncid, "br22", NC_BYTE, RANK_br22, br22_dims, &br22_id); check_err(stat,__LINE__,__FILE__); sr23_dims[0] = Dr_dim; sr23_dims[1] = D2_dim; sr23_dims[2] = D3_dim; stat = nc_def_var(ncid, "sr23", NC_SHORT, RANK_sr23, sr23_dims, &sr23_id); check_err(stat,__LINE__,__FILE__); fr31_dims[0] = Dr_dim; fr31_dims[1] = D3_dim; fr31_dims[2] = D1_dim; stat = nc_def_var(ncid, "fr31", NC_FLOAT, RANK_fr31, fr31_dims, &fr31_id); check_err(stat,__LINE__,__FILE__); dr32_dims[0] = Dr_dim; dr32_dims[1] = D3_dim; dr32_dims[2] = D2_dim; stat = nc_def_var(ncid, "dr32", NC_DOUBLE, RANK_dr32, dr32_dims, &dr32_id); check_err(stat,__LINE__,__FILE__); cr33_dims[0] = Dr_dim; cr33_dims[1] = D3_dim; cr33_dims[2] = D3_dim; stat = nc_def_var(ncid, "cr33", NC_CHAR, RANK_cr33, cr33_dims, &cr33_id); check_err(stat,__LINE__,__FILE__); c111_dims[0] = D1_dim; c111_dims[1] = D1_dim; c111_dims[2] = D1_dim; stat = nc_def_var(ncid, "c111", NC_CHAR, RANK_c111, c111_dims, &c111_id); check_err(stat,__LINE__,__FILE__); b112_dims[0] = D1_dim; b112_dims[1] = D1_dim; b112_dims[2] = D2_dim; stat = nc_def_var(ncid, "b112", NC_BYTE, RANK_b112, b112_dims, &b112_id); check_err(stat,__LINE__,__FILE__); s113_dims[0] = D1_dim; s113_dims[1] = D1_dim; s113_dims[2] = D3_dim; stat = nc_def_var(ncid, "s113", NC_SHORT, RANK_s113, s113_dims, &s113_id); check_err(stat,__LINE__,__FILE__); f121_dims[0] = D1_dim; f121_dims[1] = D2_dim; f121_dims[2] = D1_dim; stat = nc_def_var(ncid, "f121", NC_FLOAT, RANK_f121, f121_dims, &f121_id); check_err(stat,__LINE__,__FILE__); d122_dims[0] = D1_dim; d122_dims[1] = D2_dim; d122_dims[2] = D2_dim; stat = nc_def_var(ncid, "d122", NC_DOUBLE, RANK_d122, d122_dims, &d122_id); check_err(stat,__LINE__,__FILE__); c123_dims[0] = D1_dim; c123_dims[1] = D2_dim; c123_dims[2] = D3_dim; stat = nc_def_var(ncid, "c123", NC_CHAR, RANK_c123, c123_dims, &c123_id); check_err(stat,__LINE__,__FILE__); s131_dims[0] = D1_dim; s131_dims[1] = D3_dim; s131_dims[2] = D1_dim; stat = nc_def_var(ncid, "s131", NC_SHORT, RANK_s131, s131_dims, &s131_id); check_err(stat,__LINE__,__FILE__); i132_dims[0] = D1_dim; i132_dims[1] = D3_dim; i132_dims[2] = D2_dim; stat = nc_def_var(ncid, "i132", NC_INT, RANK_i132, i132_dims, &i132_id); check_err(stat,__LINE__,__FILE__); f133_dims[0] = D1_dim; f133_dims[1] = D3_dim; f133_dims[2] = D3_dim; stat = nc_def_var(ncid, "f133", NC_FLOAT, RANK_f133, f133_dims, &f133_id); check_err(stat,__LINE__,__FILE__); f211_dims[0] = D2_dim; f211_dims[1] = D1_dim; f211_dims[2] = D1_dim; stat = nc_def_var(ncid, "f211", NC_FLOAT, RANK_f211, f211_dims, &f211_id); check_err(stat,__LINE__,__FILE__); d212_dims[0] = D2_dim; d212_dims[1] = D1_dim; d212_dims[2] = D2_dim; stat = nc_def_var(ncid, "d212", NC_DOUBLE, RANK_d212, d212_dims, &d212_id); check_err(stat,__LINE__,__FILE__); c213_dims[0] = D2_dim; c213_dims[1] = D1_dim; c213_dims[2] = D3_dim; stat = nc_def_var(ncid, "c213", NC_CHAR, RANK_c213, c213_dims, &c213_id); check_err(stat,__LINE__,__FILE__); s221_dims[0] = D2_dim; s221_dims[1] = D2_dim; s221_dims[2] = D1_dim; stat = nc_def_var(ncid, "s221", NC_SHORT, RANK_s221, s221_dims, &s221_id); check_err(stat,__LINE__,__FILE__); i222_dims[0] = D2_dim; i222_dims[1] = D2_dim; i222_dims[2] = D2_dim; stat = nc_def_var(ncid, "i222", NC_INT, RANK_i222, i222_dims, &i222_id); check_err(stat,__LINE__,__FILE__); f223_dims[0] = D2_dim; f223_dims[1] = D2_dim; f223_dims[2] = D3_dim; stat = nc_def_var(ncid, "f223", NC_FLOAT, RANK_f223, f223_dims, &f223_id); check_err(stat,__LINE__,__FILE__); c231_dims[0] = D2_dim; c231_dims[1] = D3_dim; c231_dims[2] = D1_dim; stat = nc_def_var(ncid, "c231", NC_CHAR, RANK_c231, c231_dims, &c231_id); check_err(stat,__LINE__,__FILE__); b232_dims[0] = D2_dim; b232_dims[1] = D3_dim; b232_dims[2] = D2_dim; stat = nc_def_var(ncid, "b232", NC_BYTE, RANK_b232, b232_dims, &b232_id); check_err(stat,__LINE__,__FILE__); s233_dims[0] = D2_dim; s233_dims[1] = D3_dim; s233_dims[2] = D3_dim; stat = nc_def_var(ncid, "s233", NC_SHORT, RANK_s233, s233_dims, &s233_id); check_err(stat,__LINE__,__FILE__); s311_dims[0] = D3_dim; s311_dims[1] = D1_dim; s311_dims[2] = D1_dim; stat = nc_def_var(ncid, "s311", NC_SHORT, RANK_s311, s311_dims, &s311_id); check_err(stat,__LINE__,__FILE__); i312_dims[0] = D3_dim; i312_dims[1] = D1_dim; i312_dims[2] = D2_dim; stat = nc_def_var(ncid, "i312", NC_INT, RANK_i312, i312_dims, &i312_id); check_err(stat,__LINE__,__FILE__); f313_dims[0] = D3_dim; f313_dims[1] = D1_dim; f313_dims[2] = D3_dim; stat = nc_def_var(ncid, "f313", NC_FLOAT, RANK_f313, f313_dims, &f313_id); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(ncid, "var-name-dashes", NC_DOUBLE, RANK_var_MINUS_name_MINUS_dashes, 0, &var_MINUS_name_MINUS_dashes_id); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(ncid, "var.name.dots", NC_DOUBLE, RANK_var_PERIOD_name_PERIOD_dots, 0, &var_PERIOD_name_PERIOD_dots_id); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(ncid, "var+name+plusses", NC_DOUBLE, RANK_var_PLUS_name_PLUS_plusses, 0, &var_PLUS_name_PLUS_plusses_id); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(ncid, "var@name@ats", NC_DOUBLE, RANK_var_ATSIGN_name_ATSIGN_ats, 0, &var_ATSIGN_name_ATSIGN_ats_id); check_err(stat,__LINE__,__FILE__); /* assign global attributes */ { /* Gc */ stat = nc_put_att_text(ncid, NC_GLOBAL, "Gc", 0, ""); check_err(stat,__LINE__,__FILE__); } { /* Gb */ static const signed char Gb_att[2] = {-128, 127} ; stat = nc_put_att_schar(ncid, NC_GLOBAL, "Gb", NC_BYTE, 2, Gb_att); check_err(stat,__LINE__,__FILE__); } { /* Gs */ static const short Gs_att[3] = {-32768, 0, 32767} ; stat = nc_put_att_short(ncid, NC_GLOBAL, "Gs", NC_SHORT, 3, Gs_att); check_err(stat,__LINE__,__FILE__); } { /* Gi */ static const int Gi_att[3] = {-2147483647, 0, 2147483647} ; stat = nc_put_att_int(ncid, NC_GLOBAL, "Gi", NC_INT, 3, Gi_att); check_err(stat,__LINE__,__FILE__); } { /* Gf */ static const float Gf_att[3] = {-9.9999996e+35, 0, 9.9999996e+35} ; stat = nc_put_att_float(ncid, NC_GLOBAL, "Gf", NC_FLOAT, 3, Gf_att); check_err(stat,__LINE__,__FILE__); } { /* Gd */ static const double Gd_att[3] = {-1e+308, 0, 1e+308} ; stat = nc_put_att_double(ncid, NC_GLOBAL, "Gd", NC_DOUBLE, 3, Gd_att); check_err(stat,__LINE__,__FILE__); } { /* Gatt-name-dashes */ static const int Gatt_MINUS_name_MINUS_dashes_att[1] = {-1} ; stat = nc_put_att_int(ncid, NC_GLOBAL, "Gatt-name-dashes", NC_INT, 1, Gatt_MINUS_name_MINUS_dashes_att); check_err(stat,__LINE__,__FILE__); } { /* Gatt.name.dots */ static const int Gatt_PERIOD_name_PERIOD_dots_att[1] = {-2} ; stat = nc_put_att_int(ncid, NC_GLOBAL, "Gatt.name.dots", NC_INT, 1, Gatt_PERIOD_name_PERIOD_dots_att); check_err(stat,__LINE__,__FILE__); } { /* Gatt+name+plusses */ static const int Gatt_PLUS_name_PLUS_plusses_att[1] = {-3} ; stat = nc_put_att_int(ncid, NC_GLOBAL, "Gatt+name+plusses", NC_INT, 1, Gatt_PLUS_name_PLUS_plusses_att); check_err(stat,__LINE__,__FILE__); } { /* Gatt@name@ats */ static const int Gatt_ATSIGN_name_ATSIGN_ats_att[1] = {-4} ; stat = nc_put_att_int(ncid, NC_GLOBAL, "Gatt@name@ats", NC_INT, 1, Gatt_ATSIGN_name_ATSIGN_ats_att); check_err(stat,__LINE__,__FILE__); } /* assign per-variable attributes */ { /* att-name-dashes */ static const int c_att_MINUS_name_MINUS_dashes_att[1] = {4} ; stat = nc_put_att_int(ncid, c_id, "att-name-dashes", NC_INT, 1, c_att_MINUS_name_MINUS_dashes_att); check_err(stat,__LINE__,__FILE__); } { /* att.name.dots */ static const int c_att_PERIOD_name_PERIOD_dots_att[1] = {5} ; stat = nc_put_att_int(ncid, c_id, "att.name.dots", NC_INT, 1, c_att_PERIOD_name_PERIOD_dots_att); check_err(stat,__LINE__,__FILE__); } { /* att+name+plusses */ static const int c_att_PLUS_name_PLUS_plusses_att[1] = {6} ; stat = nc_put_att_int(ncid, c_id, "att+name+plusses", NC_INT, 1, c_att_PLUS_name_PLUS_plusses_att); check_err(stat,__LINE__,__FILE__); } { /* att@name@ats */ static const int c_att_ATSIGN_name_ATSIGN_ats_att[1] = {7} ; stat = nc_put_att_int(ncid, c_id, "att@name@ats", NC_INT, 1, c_att_ATSIGN_name_ATSIGN_ats_att); check_err(stat,__LINE__,__FILE__); } { /* c */ stat = nc_put_att_text(ncid, b_id, "c", 0, ""); check_err(stat,__LINE__,__FILE__); } { /* b */ static const signed char s_b_att[4] = {0, 127, -128, -1} ; stat = nc_put_att_schar(ncid, s_id, "b", NC_BYTE, 4, s_b_att); check_err(stat,__LINE__,__FILE__); } { /* s */ static const short s_s_att[3] = {-32768, 0, 32767} ; stat = nc_put_att_short(ncid, s_id, "s", NC_SHORT, 3, s_s_att); check_err(stat,__LINE__,__FILE__); } { /* i */ static const int i_i_att[3] = {-2147483647, 0, 2147483647} ; stat = nc_put_att_int(ncid, i_id, "i", NC_INT, 3, i_i_att); check_err(stat,__LINE__,__FILE__); } { /* f */ static const float i_f_att[3] = {-9.9999996e+35, 0, 9.9999996e+35} ; stat = nc_put_att_float(ncid, i_id, "f", NC_FLOAT, 3, i_f_att); check_err(stat,__LINE__,__FILE__); } { /* d */ static const double i_d_att[3] = {-1e+308, 0, 1e+308} ; stat = nc_put_att_double(ncid, i_id, "d", NC_DOUBLE, 3, i_d_att); check_err(stat,__LINE__,__FILE__); } { /* c */ stat = nc_put_att_text(ncid, f_id, "c", 1, "x"); check_err(stat,__LINE__,__FILE__); } { /* c */ stat = nc_put_att_text(ncid, d_id, "c", 8, "abcd\tZ$&"); check_err(stat,__LINE__,__FILE__); } /* leave define mode */ stat = nc_enddef (ncid); check_err(stat,__LINE__,__FILE__); /* assign variable data */ { size_t zero = 0; static char c_data[1] = {'2'}; stat = nc_put_var1(ncid, c_id, &zero, c_data); check_err(stat,__LINE__,__FILE__); } { size_t zero = 0; static signed char b_data[1] = {-2}; stat = nc_put_var1(ncid, b_id, &zero, b_data); check_err(stat,__LINE__,__FILE__); } { size_t zero = 0; static short s_data[1] = {-5}; stat = nc_put_var1(ncid, s_id, &zero, s_data); check_err(stat,__LINE__,__FILE__); } { size_t zero = 0; static int i_data[1] = {-20}; stat = nc_put_var1(ncid, i_id, &zero, i_data); check_err(stat,__LINE__,__FILE__); } { size_t zero = 0; static float f_data[1] = {-9}; stat = nc_put_var1(ncid, f_id, &zero, f_data); check_err(stat,__LINE__,__FILE__); } { size_t zero = 0; static double d_data[1] = {-10}; stat = nc_put_var1(ncid, d_id, &zero, d_data); check_err(stat,__LINE__,__FILE__); } { char cr_data[2] = "ab" ; size_t cr_startset[1] = {0} ; size_t cr_countset[1] = {2} ; stat = nc_put_vara(ncid, cr_id, cr_startset, cr_countset, cr_data); check_err(stat,__LINE__,__FILE__); } { signed char br_data[2] = {-128, 127} ; size_t br_startset[1] = {0} ; size_t br_countset[1] = {2} ; stat = nc_put_vara(ncid, br_id, br_startset, br_countset, br_data); check_err(stat,__LINE__,__FILE__); } { short sr_data[2] = {-32768, 32767} ; size_t sr_startset[1] = {0} ; size_t sr_countset[1] = {2} ; stat = nc_put_vara(ncid, sr_id, sr_startset, sr_countset, sr_data); check_err(stat,__LINE__,__FILE__); } { int ir_data[2] = {-2147483646, 2147483647} ; size_t ir_startset[1] = {0} ; size_t ir_countset[1] = {2} ; stat = nc_put_vara(ncid, ir_id, ir_startset, ir_countset, ir_data); check_err(stat,__LINE__,__FILE__); } { float fr_data[2] = {-9.9999996e+35, 9.9999996e+35} ; size_t fr_startset[1] = {0} ; size_t fr_countset[1] = {2} ; stat = nc_put_vara(ncid, fr_id, fr_startset, fr_countset, fr_data); check_err(stat,__LINE__,__FILE__); } { double dr_data[2] = {-1e+308, 1e+308} ; size_t dr_startset[1] = {0} ; size_t dr_countset[1] = {2} ; stat = nc_put_vara(ncid, dr_id, dr_startset, dr_countset, dr_data); check_err(stat,__LINE__,__FILE__); } { char c1_data[1] = "\000" ; size_t c1_startset[1] = {0} ; size_t c1_countset[1] = {1} ; stat = nc_put_vara(ncid, c1_id, c1_startset, c1_countset, c1_data); check_err(stat,__LINE__,__FILE__); } { signed char b1_data[1] = {-128} ; size_t b1_startset[1] = {0} ; size_t b1_countset[1] = {1} ; stat = nc_put_vara(ncid, b1_id, b1_startset, b1_countset, b1_data); check_err(stat,__LINE__,__FILE__); } { short s1_data[1] = {-32768} ; size_t s1_startset[1] = {0} ; size_t s1_countset[1] = {1} ; stat = nc_put_vara(ncid, s1_id, s1_startset, s1_countset, s1_data); check_err(stat,__LINE__,__FILE__); } { int i1_data[1] = {-2147483646} ; size_t i1_startset[1] = {0} ; size_t i1_countset[1] = {1} ; stat = nc_put_vara(ncid, i1_id, i1_startset, i1_countset, i1_data); check_err(stat,__LINE__,__FILE__); } { float f1_data[1] = {-9.9999996e+35} ; size_t f1_startset[1] = {0} ; size_t f1_countset[1] = {1} ; stat = nc_put_vara(ncid, f1_id, f1_startset, f1_countset, f1_data); check_err(stat,__LINE__,__FILE__); } { double d1_data[1] = {-1e+308} ; size_t d1_startset[1] = {0} ; size_t d1_countset[1] = {1} ; stat = nc_put_vara(ncid, d1_id, d1_startset, d1_countset, d1_data); check_err(stat,__LINE__,__FILE__); } { char c2_data[2] = "ab" ; size_t c2_startset[1] = {0} ; size_t c2_countset[1] = {2} ; stat = nc_put_vara(ncid, c2_id, c2_startset, c2_countset, c2_data); check_err(stat,__LINE__,__FILE__); } { signed char b2_data[2] = {-128, 127} ; size_t b2_startset[1] = {0} ; size_t b2_countset[1] = {2} ; stat = nc_put_vara(ncid, b2_id, b2_startset, b2_countset, b2_data); check_err(stat,__LINE__,__FILE__); } { short s2_data[2] = {-32768, 32767} ; size_t s2_startset[1] = {0} ; size_t s2_countset[1] = {2} ; stat = nc_put_vara(ncid, s2_id, s2_startset, s2_countset, s2_data); check_err(stat,__LINE__,__FILE__); } { int i2_data[2] = {-2147483646, 2147483647} ; size_t i2_startset[1] = {0} ; size_t i2_countset[1] = {2} ; stat = nc_put_vara(ncid, i2_id, i2_startset, i2_countset, i2_data); check_err(stat,__LINE__,__FILE__); } { float f2_data[2] = {-9.9999996e+35, 9.9999996e+35} ; size_t f2_startset[1] = {0} ; size_t f2_countset[1] = {2} ; stat = nc_put_vara(ncid, f2_id, f2_startset, f2_countset, f2_data); check_err(stat,__LINE__,__FILE__); } { double d2_data[2] = {-1e+308, 1e+308} ; size_t d2_startset[1] = {0} ; size_t d2_countset[1] = {2} ; stat = nc_put_vara(ncid, d2_id, d2_startset, d2_countset, d2_data); check_err(stat,__LINE__,__FILE__); } { char c3_data[3] = "\001À." ; size_t c3_startset[1] = {0} ; size_t c3_countset[1] = {3} ; stat = nc_put_vara(ncid, c3_id, c3_startset, c3_countset, c3_data); check_err(stat,__LINE__,__FILE__); } { signed char b3_data[3] = {-128, 127, -1} ; size_t b3_startset[1] = {0} ; size_t b3_countset[1] = {3} ; stat = nc_put_vara(ncid, b3_id, b3_startset, b3_countset, b3_data); check_err(stat,__LINE__,__FILE__); } { short s3_data[3] = {-32768, 0, 32767} ; size_t s3_startset[1] = {0} ; size_t s3_countset[1] = {3} ; stat = nc_put_vara(ncid, s3_id, s3_startset, s3_countset, s3_data); check_err(stat,__LINE__,__FILE__); } { int i3_data[3] = {-2147483646, 0, 2147483647} ; size_t i3_startset[1] = {0} ; size_t i3_countset[1] = {3} ; stat = nc_put_vara(ncid, i3_id, i3_startset, i3_countset, i3_data); check_err(stat,__LINE__,__FILE__); } { float f3_data[3] = {-9.9999996e+35, 0, 9.9999996e+35} ; size_t f3_startset[1] = {0} ; size_t f3_countset[1] = {3} ; stat = nc_put_vara(ncid, f3_id, f3_startset, f3_countset, f3_data); check_err(stat,__LINE__,__FILE__); } { double d3_data[3] = {-1e+308, 0, 1e+308} ; size_t d3_startset[1] = {0} ; size_t d3_countset[1] = {3} ; stat = nc_put_vara(ncid, d3_id, d3_startset, d3_countset, d3_data); check_err(stat,__LINE__,__FILE__); } { char cr1_data[2] = "xy" ; size_t cr1_startset[2] = {0, 0} ; size_t cr1_countset[2] = {2, 1} ; stat = nc_put_vara(ncid, cr1_id, cr1_startset, cr1_countset, cr1_data); check_err(stat,__LINE__,__FILE__); } { signed char br2_data[4] = {-24, -26, -20, -22} ; size_t br2_startset[2] = {0, 0} ; size_t br2_countset[2] = {2, 2} ; stat = nc_put_vara(ncid, br2_id, br2_startset, br2_countset, br2_data); check_err(stat,__LINE__,__FILE__); } { short sr3_data[6] = {-375, -380, -385, -350, -355, -360} ; size_t sr3_startset[2] = {0, 0} ; size_t sr3_countset[2] = {2, 3} ; stat = nc_put_vara(ncid, sr3_id, sr3_startset, sr3_countset, sr3_data); check_err(stat,__LINE__,__FILE__); } { float f11_data[1] = {-2187} ; size_t f11_startset[2] = {0, 0} ; size_t f11_countset[2] = {1, 1} ; stat = nc_put_vara(ncid, f11_id, f11_startset, f11_countset, f11_data); check_err(stat,__LINE__,__FILE__); } { double d12_data[2] = {-3000, -3010} ; size_t d12_startset[2] = {0, 0} ; size_t d12_countset[2] = {1, 2} ; stat = nc_put_vara(ncid, d12_id, d12_startset, d12_countset, d12_data); check_err(stat,__LINE__,__FILE__); } { char c13_data[3] = "\tb\177" ; size_t c13_startset[2] = {0, 0} ; size_t c13_countset[2] = {1, 3} ; stat = nc_put_vara(ncid, c13_id, c13_startset, c13_countset, c13_data); check_err(stat,__LINE__,__FILE__); } { short s21_data[2] = {-375, -350} ; size_t s21_startset[2] = {0, 0} ; size_t s21_countset[2] = {2, 1} ; stat = nc_put_vara(ncid, s21_id, s21_startset, s21_countset, s21_data); check_err(stat,__LINE__,__FILE__); } { int i22_data[4] = {-24000, -24020, -23600, -23620} ; size_t i22_startset[2] = {0, 0} ; size_t i22_countset[2] = {2, 2} ; stat = nc_put_vara(ncid, i22_id, i22_startset, i22_countset, i22_data); check_err(stat,__LINE__,__FILE__); } { float f23_data[6] = {-2187, -2196, -2205, -2106, -2115, -2124} ; size_t f23_startset[2] = {0, 0} ; size_t f23_countset[2] = {2, 3} ; stat = nc_put_vara(ncid, f23_id, f23_startset, f23_countset, f23_data); check_err(stat,__LINE__,__FILE__); } { char c31_data[3] = "+- " ; size_t c31_startset[2] = {0, 0} ; size_t c31_countset[2] = {3, 1} ; stat = nc_put_vara(ncid, c31_id, c31_startset, c31_countset, c31_data); check_err(stat,__LINE__,__FILE__); } { signed char b32_data[6] = {-24, -26, -20, -22, -16, -18} ; size_t b32_startset[2] = {0, 0} ; size_t b32_countset[2] = {3, 2} ; stat = nc_put_vara(ncid, b32_id, b32_startset, b32_countset, b32_data); check_err(stat,__LINE__,__FILE__); } { short s33_data[9] = {-375, -380, -385, -350, -355, -360, -325, -330, -335} ; size_t s33_startset[2] = {0, 0} ; size_t s33_countset[2] = {3, 3} ; stat = nc_put_vara(ncid, s33_id, s33_startset, s33_countset, s33_data); check_err(stat,__LINE__,__FILE__); } { short sr11_data[2] = {2500, 2375} ; size_t sr11_startset[3] = {0, 0, 0} ; size_t sr11_countset[3] = {2, 1, 1} ; stat = nc_put_vara(ncid, sr11_id, sr11_startset, sr11_countset, sr11_data); check_err(stat,__LINE__,__FILE__); } { int ir12_data[4] = {640000, 639980, 632000, 631980} ; size_t ir12_startset[3] = {0, 0, 0} ; size_t ir12_countset[3] = {2, 1, 2} ; stat = nc_put_vara(ncid, ir12_id, ir12_startset, ir12_countset, ir12_data); check_err(stat,__LINE__,__FILE__); } { float fr13_data[6] = {26244, 26235, 26226, 25515, 25506, 25497} ; size_t fr13_startset[3] = {0, 0, 0} ; size_t fr13_countset[3] = {2, 1, 3} ; stat = nc_put_vara(ncid, fr13_id, fr13_startset, fr13_countset, fr13_data); check_err(stat,__LINE__,__FILE__); } { char cr21_data[4] = "@DHL" ; size_t cr21_startset[3] = {0, 0, 0} ; size_t cr21_countset[3] = {2, 2, 1} ; stat = nc_put_vara(ncid, cr21_id, cr21_startset, cr21_countset, cr21_data); check_err(stat,__LINE__,__FILE__); } { signed char br22_data[8] = {64, 62, 68, 66, 56, 54, 60, 58} ; size_t br22_startset[3] = {0, 0, 0} ; size_t br22_countset[3] = {2, 2, 2} ; stat = nc_put_vara(ncid, br22_id, br22_startset, br22_countset, br22_data); check_err(stat,__LINE__,__FILE__); } { short sr23_data[12] = {2500, 2495, 2490, 2525, 2520, 2515, 2375, 2370, 2365, 2400, 2395, 2390} ; size_t sr23_startset[3] = {0, 0, 0} ; size_t sr23_countset[3] = {2, 2, 3} ; stat = nc_put_vara(ncid, sr23_id, sr23_startset, sr23_countset, sr23_data); check_err(stat,__LINE__,__FILE__); } { float fr31_data[6] = {26244, 26325, 26406, 25515, 25596, 25677} ; size_t fr31_startset[3] = {0, 0, 0} ; size_t fr31_countset[3] = {2, 3, 1} ; stat = nc_put_vara(ncid, fr31_id, fr31_startset, fr31_countset, fr31_data); check_err(stat,__LINE__,__FILE__); } { double dr32_data[12] = {40000, 39990, 40100, 40090, 40200, 40190, 39000, 38990, 39100, 39090, 39200, 39190} ; size_t dr32_startset[3] = {0, 0, 0} ; size_t dr32_countset[3] = {2, 3, 2} ; stat = nc_put_vara(ncid, dr32_id, dr32_startset, dr32_countset, dr32_data); check_err(stat,__LINE__,__FILE__); } { char cr33_data[18] = "1\000\000two3\000\0004\000\0005\000\000six" ; size_t cr33_startset[3] = {0, 0, 0} ; size_t cr33_countset[3] = {2, 3, 3} ; stat = nc_put_vara(ncid, cr33_id, cr33_startset, cr33_countset, cr33_data); check_err(stat,__LINE__,__FILE__); } { char c111_data[1] = "@" ; size_t c111_startset[3] = {0, 0, 0} ; size_t c111_countset[3] = {1, 1, 1} ; stat = nc_put_vara(ncid, c111_id, c111_startset, c111_countset, c111_data); check_err(stat,__LINE__,__FILE__); } { signed char b112_data[2] = {64, 62} ; size_t b112_startset[3] = {0, 0, 0} ; size_t b112_countset[3] = {1, 1, 2} ; stat = nc_put_vara(ncid, b112_id, b112_startset, b112_countset, b112_data); check_err(stat,__LINE__,__FILE__); } { short s113_data[3] = {2500, 2495, 2490} ; size_t s113_startset[3] = {0, 0, 0} ; size_t s113_countset[3] = {1, 1, 3} ; stat = nc_put_vara(ncid, s113_id, s113_startset, s113_countset, s113_data); check_err(stat,__LINE__,__FILE__); } { float f121_data[2] = {26244, 26325} ; size_t f121_startset[3] = {0, 0, 0} ; size_t f121_countset[3] = {1, 2, 1} ; stat = nc_put_vara(ncid, f121_id, f121_startset, f121_countset, f121_data); check_err(stat,__LINE__,__FILE__); } { double d122_data[4] = {40000, 39990, 40100, 40090} ; size_t d122_startset[3] = {0, 0, 0} ; size_t d122_countset[3] = {1, 2, 2} ; stat = nc_put_vara(ncid, d122_id, d122_startset, d122_countset, d122_data); check_err(stat,__LINE__,__FILE__); } { char c123_data[6] = "one2\000\000" ; size_t c123_startset[3] = {0, 0, 0} ; size_t c123_countset[3] = {1, 2, 3} ; stat = nc_put_vara(ncid, c123_id, c123_startset, c123_countset, c123_data); check_err(stat,__LINE__,__FILE__); } { short s131_data[3] = {2500, 2525, 2550} ; size_t s131_startset[3] = {0, 0, 0} ; size_t s131_countset[3] = {1, 3, 1} ; stat = nc_put_vara(ncid, s131_id, s131_startset, s131_countset, s131_data); check_err(stat,__LINE__,__FILE__); } { int i132_data[6] = {640000, 639980, 640400, 640380, 640800, 640780} ; size_t i132_startset[3] = {0, 0, 0} ; size_t i132_countset[3] = {1, 3, 2} ; stat = nc_put_vara(ncid, i132_id, i132_startset, i132_countset, i132_data); check_err(stat,__LINE__,__FILE__); } { float f133_data[9] = {26244, 26235, 26226, 26325, 26316, 26307, 26406, 26397, 26388} ; size_t f133_startset[3] = {0, 0, 0} ; size_t f133_countset[3] = {1, 3, 3} ; stat = nc_put_vara(ncid, f133_id, f133_startset, f133_countset, f133_data); check_err(stat,__LINE__,__FILE__); } { float f211_data[2] = {26244, 25515} ; size_t f211_startset[3] = {0, 0, 0} ; size_t f211_countset[3] = {2, 1, 1} ; stat = nc_put_vara(ncid, f211_id, f211_startset, f211_countset, f211_data); check_err(stat,__LINE__,__FILE__); } { double d212_data[4] = {40000, 39990, 39000, 38990} ; size_t d212_startset[3] = {0, 0, 0} ; size_t d212_countset[3] = {2, 1, 2} ; stat = nc_put_vara(ncid, d212_id, d212_startset, d212_countset, d212_data); check_err(stat,__LINE__,__FILE__); } { short s221_data[4] = {2500, 2525, 2375, 2400} ; size_t s221_startset[3] = {0, 0, 0} ; size_t s221_countset[3] = {2, 2, 1} ; stat = nc_put_vara(ncid, s221_id, s221_startset, s221_countset, s221_data); check_err(stat,__LINE__,__FILE__); } { int i222_data[8] = {640000, 639980, 640400, 640380, 632000, 631980, 632400, 632380} ; size_t i222_startset[3] = {0, 0, 0} ; size_t i222_countset[3] = {2, 2, 2} ; stat = nc_put_vara(ncid, i222_id, i222_startset, i222_countset, i222_data); check_err(stat,__LINE__,__FILE__); } { float f223_data[12] = {26244, 26235, 26226, 26325, 26316, 26307, 25515, 25506, 25497, 25596, 25587, 25578} ; size_t f223_startset[3] = {0, 0, 0} ; size_t f223_countset[3] = {2, 2, 3} ; stat = nc_put_vara(ncid, f223_id, f223_startset, f223_countset, f223_data); check_err(stat,__LINE__,__FILE__); } { char c231_data[6] = "@DHHLP" ; size_t c231_startset[3] = {0, 0, 0} ; size_t c231_countset[3] = {2, 3, 1} ; stat = nc_put_vara(ncid, c231_id, c231_startset, c231_countset, c231_data); check_err(stat,__LINE__,__FILE__); } { signed char b232_data[12] = {64, 62, 68, 66, 72, 70, 56, 54, 60, 58, 64, 62} ; size_t b232_startset[3] = {0, 0, 0} ; size_t b232_countset[3] = {2, 3, 2} ; stat = nc_put_vara(ncid, b232_id, b232_startset, b232_countset, b232_data); check_err(stat,__LINE__,__FILE__); } { short s233_data[18] = {2500, 2495, 2490, 2525, 2520, 2515, 2550, 2545, 2540, 2375, 2370, 2365, 2400, 2395, 2390, 2425, 2420, 2415} ; size_t s233_startset[3] = {0, 0, 0} ; size_t s233_countset[3] = {2, 3, 3} ; stat = nc_put_vara(ncid, s233_id, s233_startset, s233_countset, s233_data); check_err(stat,__LINE__,__FILE__); } { short s311_data[3] = {2500, 2375, 2250} ; size_t s311_startset[3] = {0, 0, 0} ; size_t s311_countset[3] = {3, 1, 1} ; stat = nc_put_vara(ncid, s311_id, s311_startset, s311_countset, s311_data); check_err(stat,__LINE__,__FILE__); } { int i312_data[6] = {640000, 639980, 632000, 631980, 624000, 623980} ; size_t i312_startset[3] = {0, 0, 0} ; size_t i312_countset[3] = {3, 1, 2} ; stat = nc_put_vara(ncid, i312_id, i312_startset, i312_countset, i312_data); check_err(stat,__LINE__,__FILE__); } { float f313_data[9] = {26244, 26235, 26226, 25515, 25506, 25497, 24786, 24777, 24768} ; size_t f313_startset[3] = {0, 0, 0} ; size_t f313_countset[3] = {3, 1, 3} ; stat = nc_put_vara(ncid, f313_id, f313_startset, f313_countset, f313_data); check_err(stat,__LINE__,__FILE__); } { size_t zero = 0; static double var_MINUS_name_MINUS_dashes_data[1] = {-1}; stat = nc_put_var1(ncid, var_MINUS_name_MINUS_dashes_id, &zero, var_MINUS_name_MINUS_dashes_data); check_err(stat,__LINE__,__FILE__); } { size_t zero = 0; static double var_PERIOD_name_PERIOD_dots_data[1] = {-2}; stat = nc_put_var1(ncid, var_PERIOD_name_PERIOD_dots_id, &zero, var_PERIOD_name_PERIOD_dots_data); check_err(stat,__LINE__,__FILE__); } stat = nc_close(ncid); check_err(stat,__LINE__,__FILE__); return 0; }
void seissol::LoopStatistics::writeSamples() { std::string loopStatFile = utils::Env::get<std::string>("SEISSOL_LOOP_STAT_PREFIX", ""); if (!loopStatFile.empty()) { #if defined(USE_NETCDF) && defined(USE_MPI) unsigned nRegions = m_times.size(); for (unsigned region = 0; region < nRegions; ++region) { std::ofstream file; std::stringstream ss; ss << loopStatFile << m_regions[region] << ".nc"; std::string fileName = ss.str(); int nSamples = m_times[region].size(); int sampleOffset; MPI_Scan(&nSamples, &sampleOffset, 1, MPI_INT, MPI_SUM, seissol::MPI::mpi.comm()); int ncid, stat; stat = nc_create_par(fileName.c_str(), NC_MPIIO | NC_CLOBBER | NC_NETCDF4, seissol::MPI::mpi.comm(), MPI_INFO_NULL, &ncid); check_err(stat,__LINE__,__FILE__); int sampledim, rankdim, sampletyp, offsetid, sampleid; stat = nc_def_dim(ncid, "rank", 1+seissol::MPI::mpi.size(), &rankdim); check_err(stat,__LINE__,__FILE__); stat = nc_def_dim(ncid, "sample", NC_UNLIMITED, &sampledim); check_err(stat,__LINE__,__FILE__); stat = nc_def_compound(ncid, sizeof(Sample), "Sample", &sampletyp); check_err(stat,__LINE__,__FILE__); { stat = nc_insert_compound(ncid, sampletyp, "time", NC_COMPOUND_OFFSET(Sample,time), NC_DOUBLE); check_err(stat,__LINE__,__FILE__); stat = nc_insert_compound(ncid, sampletyp, "loopLength", NC_COMPOUND_OFFSET(Sample,numIters), NC_UINT); check_err(stat,__LINE__,__FILE__); } stat = nc_def_var(ncid, "offset", NC_INT, 1, &rankdim, &offsetid); check_err(stat,__LINE__,__FILE__); stat = nc_def_var(ncid, "sample", sampletyp, 1, &sampledim, &sampleid); check_err(stat,__LINE__,__FILE__); stat = nc_enddef(ncid); check_err(stat,__LINE__,__FILE__); stat = nc_var_par_access(ncid, offsetid, NC_COLLECTIVE); check_err(stat,__LINE__,__FILE__); stat = nc_var_par_access(ncid, sampleid, NC_COLLECTIVE); check_err(stat,__LINE__,__FILE__); size_t start, count; int offsetData[2]; if (seissol::MPI::mpi.rank() == 0) { start = 0; count = 2; offsetData[0] = 0; } else { start = 1+seissol::MPI::mpi.rank(); count = 1; } offsetData[count-1] = sampleOffset; stat = nc_put_vara_int(ncid, offsetid, &start, &count, offsetData); check_err(stat,__LINE__,__FILE__); start = sampleOffset-nSamples; count = nSamples; stat = nc_put_vara(ncid, sampleid, &start, &count, m_times[region].data()); check_err(stat,__LINE__,__FILE__); stat = nc_close(ncid); check_err(stat,__LINE__,__FILE__); } #else logWarning(seissol::MPI::mpi.rank()) << "Writing loop statistics requires NetCDF and MPI."; #endif } }
/*! Main function for tst_fill_attr_vanish.c * */ int main() { int ncid, dimids[RANK_P], time_id, p_id, test_id; int ndims, dimids_in[RANK_P]; int test_data[1] = {1}; size_t test_start[1] = {0}, test_count[1] = {1}; int test_fill_val[] = {5}; double data[1] = {3.14159}; size_t start[1] = {0}, count[1] = {1}; float ddata[1][4][3]; static float P_data[LEN]; size_t cor[RANK_P] = {0, 1, 0}; size_t edg[RANK_P] = {1, 1, LEN}; float pfills[] = {3}; printf("\n*** Testing for a netCDF-4 fill-value bug.\n"); printf("*** Creating a file with no _FillValue defined. ***\n"); /* Create a 3D test file. */ if (nc_create(FILENAME, NC_CLOBBER|NC_NETCDF4, &ncid)) ERR; if (nc_set_fill(ncid, NC_NOFILL, NULL)) ERR; /* define dimensions */ if (nc_def_dim(ncid, "Time", NC_UNLIMITED, &dimids[0])) ERR; if (nc_def_dim(ncid, "X", 4, &dimids[2])) ERR; if (nc_def_dim(ncid, "Y", 3, &dimids[1])) ERR; /* define variables */ if (nc_def_var(ncid, "Time", NC_DOUBLE, 1, dimids, &time_id)) ERR; if (nc_def_var(ncid, "P", NC_FLOAT, RANK_P, dimids, &p_id)) ERR; if (nc_def_var(ncid, "Test", NC_INT, 1, &dimids[1], &test_id)) ERR; /* Add a _FillValue attribute */ if (nc_put_att_text(ncid, test_id, ATTNAME, strlen(ATTVAL), ATTVAL)) ERR; /* Add a value to the test variable */ if (nc_put_vara(ncid, test_id, test_start, test_count, test_data)) ERR; /* Add one record in coordinate variable. */ if (nc_put_vara(ncid, time_id, start, count, data)) ERR; /* That's it! */ if (nc_close(ncid)) ERR; /********************************************/ /* Reopen the file, add a fillvalue attribute. */ if (nc_open(FILENAME, NC_NOCLOBBER|NC_WRITE, &ncid)) ERR; if (nc_redef(ncid)) ERR; if (nc_inq_varid(ncid, "Test", &test_id)) ERR; /* Query existing attribute. */ { printf("**** Checking that attribute still exists:\t"); char *attval = malloc(sizeof(char) * strlen(ATTVAL)); if(nc_get_att_text(ncid,test_id,ATTNAME,attval)) {printf("Fail\n"); ERR;} else {printf("%s\n",attval);} free(attval); } printf("**** Adding _FillValue attribute.\n"); if (nc_put_att_int(ncid, test_id, "_FillValue", NC_INT, 1, test_fill_val)) ERR; /* Query existing attribute. */ { printf("**** Checking that attribute still exists, pre-write:\t"); char *attval = malloc(sizeof(char) * strlen(ATTVAL)); if(nc_get_att_text(ncid,test_id,ATTNAME,attval)) {printf("Fail\n"); ERR;} else {printf("%s\n",attval);} free(attval); } /* Close file again. */ printf( "**** Saving, closing file.\n"); if (nc_close(ncid)) ERR; /********************************************/ printf( "*** Reopening file.\n"); /* Reopen the file, checking that all attributes are preserved. */ if (nc_open(FILENAME, NC_NOCLOBBER|NC_WRITE, &ncid)) ERR; if (nc_redef(ncid)) ERR; if (nc_inq_varid(ncid, "Test", &test_id)) ERR; /* Query existing attribute. */ { printf("**** Checking that attribute still exists:\t"); char *attval = malloc(sizeof(char) * strlen(ATTVAL)); if(nc_get_att_text(ncid,test_id,ATTNAME,attval)) {printf("Fail\n"); ERR;} else {printf("%s\n",attval);} free(attval); } if (nc_close(ncid)) ERR; /********************************************/ SUMMARIZE_ERR; FINAL_RESULTS; return 0; }
int main(int argc, char *argv[]) { // parse command line options int c; while (EOF != (c = getopt(argc, argv, ""))) switch (c) { } // use the next argument as file name if (optind >= argc) { fprintf(stderr, "file name argument missing\n"); return EXIT_FAILURE; } char *filename = argv[optind]; // create the file int status; int fileid; if (NC_NOERR != (status = nc_create(filename, NC_NOCLOBBER, &fileid))) { fprintf(stderr, "cannot create file %s: %s\n", filename, nc_strerror(status)); return EXIT_FAILURE; } // define definitions of the array size_t lenx = 140, leny = 100; int x_dim, y_dim, t_dim; // dimension ids if (NC_NOERR != (status = nc_def_dim(fileid, "x", lenx, &x_dim))) { fprintf(stderr, "%s:%d: cannot define x dimension: %s\n", __FILE__, __LINE__, nc_strerror(status)); return EXIT_FAILURE; } if (NC_NOERR != (status = nc_def_dim(fileid, "y", leny, &y_dim))) { fprintf(stderr, "%s:%d: cannot define y dimension: %s\n", __FILE__, __LINE__, nc_strerror(status)); return EXIT_FAILURE; } if (NC_NOERR != (status = nc_def_dim(fileid, "t", NC_UNLIMITED, &t_dim))) { fprintf(stderr, "%s:%d: cannot define t dimension: %s\n", __FILE__, __LINE__, nc_strerror(status)); return EXIT_FAILURE; } // define the array int arrayid; int dimensions[3] = { t_dim, x_dim, y_dim }; if (NC_NOERR != (status = nc_def_var(fileid, "results", NC_DOUBLE, 3, dimensions, &arrayid))) { fprintf(stderr, "%s:%d: cannot define t dimension: %s\n", __FILE__, __LINE__, nc_strerror(status)); return EXIT_FAILURE; } // end define mode if (NC_NOERR != (status = nc_enddef(fileid))) { fprintf(stderr, "%s:%d: cannot end define mode: %s\n", __FILE__, __LINE__, nc_strerror(status)); return EXIT_FAILURE; } // now we have to do the simulation double *data = (double *)malloc(lenx * leny * sizeof(double)); for (int t = 0; t < 30; t++) { // perform the simulation simulation(data, lenx, leny, t); // add the data to the NetCDF file size_t start[3] = { t, 0, 0 }; size_t size[3] = { 1, lenx, leny }; status = nc_put_vara(fileid, arrayid, start, size, data); if (NC_NOERR != status) { fprintf(stderr, "cannot write image: %s\n", nc_strerror(status)); return EXIT_FAILURE; } } // close the file if (NC_NOERR != nc_close(fileid)) { fprintf(stderr, "%s:%d: cannot close file: %s\n", __FILE__, __LINE__, nc_strerror(status)); return EXIT_FAILURE; } return EXIT_SUCCESS; }
int main(int argc, char **argv) { int mpi_namelen; char mpi_name[MPI_MAX_PROCESSOR_NAME]; int mpi_size, mpi_rank; MPI_Comm comm = MPI_COMM_WORLD; MPI_Info info = MPI_INFO_NULL; double start_time = 0, total_time; int mpi_size_in; #define NUM_TEST_TYPES 11 nc_type test_type[NUM_TEST_TYPES] = {NC_BYTE, NC_CHAR, NC_SHORT, NC_INT, NC_FLOAT, NC_DOUBLE, NC_UBYTE, NC_USHORT, NC_UINT, NC_INT64, NC_UINT64}; int tt, fv; int j, i, k, ret; /* Initialize MPI. */ MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD, &mpi_size); MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); MPI_Get_processor_name(mpi_name, &mpi_namelen); /* Must be able to evenly divide my slabs between processors. */ if (NUM_SLABS % mpi_size) { if (!mpi_rank) printf("NUM_SLABS (%d) is not evenly divisible by mpi_size(%d)\n", NUM_SLABS, mpi_size); ERR; } if (!mpi_rank) printf("\n*** Testing parallel I/O some more.\n"); /* Test for different fill value settings. */ for (fv = 0; fv < NUM_FILL_TEST_RUNS; fv++) { /* Test for different netCDF types. */ for (tt = 0; tt < NUM_TEST_TYPES; tt++) { char file_name[NC_MAX_NAME + 1]; int fill_mode_in; void *data, *data_in; void *fill_value, *fill_value_in; size_t type_size; size_t write_start[NDIMS] = {0, 0, 1}; size_t write_count[NDIMS] = {1, DIMSIZE, DIMSIZE - 1}; size_t read_start[NDIMS] = {0, 0, 0}; size_t read_count[NDIMS] = {1, DIMSIZE, DIMSIZE}; int ncid, varid, dimids[NDIMS]; int ndims_in, nvars_in, natts_in, unlimdimid_in; /* Fill values to be expected. */ signed char byte_expected_fill_value; unsigned char char_expected_fill_value; short short_expected_fill_value; int int_expected_fill_value; float float_expected_fill_value; double double_expected_fill_value; unsigned char ubyte_expected_fill_value; unsigned short ushort_expected_fill_value; unsigned int uint_expected_fill_value; long long int int64_expected_fill_value; unsigned long long int uint64_expected_fill_value; /* Fill values used when writing. */ signed char byte_fill_value = -TEST_VAL_42; unsigned char char_fill_value = 'x'; short short_fill_value = TEST_VAL_42 * 100; int int_fill_value = TEST_VAL_42 * 1000; float float_fill_value = TEST_VAL_42 * 1000; double double_fill_value = TEST_VAL_42 * 1000; unsigned char ubyte_fill_value = TEST_VAL_42; unsigned short ushort_fill_value = TEST_VAL_42 * 100; unsigned int uint_fill_value = TEST_VAL_42 * 1000; long long int int64_fill_value = TEST_VAL_42 * 1000; unsigned long long int uint64_fill_value = TEST_VAL_42 * 1000; /* Fill values read in. */ signed char byte_fill_value_in; unsigned char char_fill_value_in; short short_fill_value_in; int int_fill_value_in; float float_fill_value_in; double double_fill_value_in; unsigned char ubyte_fill_value_in; unsigned short ushort_fill_value_in; unsigned int uint_fill_value_in; long long int int64_fill_value_in; unsigned long long int uint64_fill_value_in; /* Data to write and read. */ signed char byte_data[DIMSIZE * DIMSIZE], byte_data_in[DIMSIZE * DIMSIZE]; unsigned char char_data[DIMSIZE * DIMSIZE], char_data_in[DIMSIZE * DIMSIZE]; short short_data[DIMSIZE * DIMSIZE], short_data_in[DIMSIZE * DIMSIZE]; int int_data[DIMSIZE * DIMSIZE], int_data_in[DIMSIZE * DIMSIZE]; float float_data[DIMSIZE * DIMSIZE], float_data_in[DIMSIZE * DIMSIZE]; double double_data[DIMSIZE * DIMSIZE], double_data_in[DIMSIZE * DIMSIZE]; unsigned char ubyte_data[DIMSIZE * DIMSIZE], ubyte_data_in[DIMSIZE * DIMSIZE]; unsigned short ushort_data[DIMSIZE * DIMSIZE], ushort_data_in[DIMSIZE * DIMSIZE]; unsigned int uint_data[DIMSIZE * DIMSIZE], uint_data_in[DIMSIZE * DIMSIZE]; long long int int64_data[DIMSIZE * DIMSIZE], int64_data_in[DIMSIZE * DIMSIZE]; unsigned long long int uint64_data[DIMSIZE * DIMSIZE], uint64_data_in[DIMSIZE * DIMSIZE]; if (!mpi_rank) printf("*** writing a %d x %d x %d file from %d processors for fill value test %d type %d...\n", NUM_SLABS, DIMSIZE, DIMSIZE, mpi_size, fv, test_type[tt]); /* Initialize test data. */ switch(test_type[tt]) { case NC_BYTE: for (i = 0; i < DIMSIZE * DIMSIZE; i++) byte_data[i] = mpi_rank; data = byte_data; data_in = byte_data_in; byte_expected_fill_value = fv ? byte_fill_value : NC_FILL_BYTE; fill_value = &byte_expected_fill_value; fill_value_in = &byte_fill_value_in; break; case NC_CHAR: for (i = 0; i < DIMSIZE * DIMSIZE; i++) char_data[i] = mpi_rank; data = char_data; data_in = char_data_in; char_expected_fill_value = fv ? char_fill_value : NC_FILL_CHAR; fill_value = &char_expected_fill_value; fill_value_in = &char_fill_value_in; break; case NC_SHORT: for (i = 0; i < DIMSIZE * DIMSIZE; i++) short_data[i] = mpi_rank; data = short_data; data_in = short_data_in; short_expected_fill_value = fv ? short_fill_value : NC_FILL_SHORT; fill_value = &short_expected_fill_value; fill_value_in = &short_fill_value_in; break; case NC_INT: for (i = 0; i < DIMSIZE * DIMSIZE; i++) int_data[i] = mpi_rank; data = int_data; data_in = int_data_in; int_expected_fill_value = fv ? int_fill_value : NC_FILL_INT; fill_value = &int_expected_fill_value; fill_value_in = &int_fill_value_in; break; case NC_FLOAT: for (i = 0; i < DIMSIZE * DIMSIZE; i++) float_data[i] = mpi_rank; data = float_data; data_in = float_data_in; float_expected_fill_value = fv ? float_fill_value : NC_FILL_FLOAT; fill_value = &float_expected_fill_value; fill_value_in = &float_fill_value_in; break; case NC_DOUBLE: for (i = 0; i < DIMSIZE * DIMSIZE; i++) double_data[i] = mpi_rank; data = double_data; data_in = double_data_in; double_expected_fill_value = fv ? double_fill_value : NC_FILL_DOUBLE; fill_value = &double_expected_fill_value; fill_value_in = &double_fill_value_in; break; case NC_UBYTE: for (i = 0; i < DIMSIZE * DIMSIZE; i++) ubyte_data[i] = mpi_rank; data = ubyte_data; data_in = ubyte_data_in; ubyte_expected_fill_value = fv ? ubyte_fill_value : NC_FILL_UBYTE; fill_value = &ubyte_expected_fill_value; fill_value_in = &ubyte_fill_value_in; break; case NC_USHORT: for (i = 0; i < DIMSIZE * DIMSIZE; i++) ushort_data[i] = mpi_rank; data = ushort_data; data_in = ushort_data_in; ushort_expected_fill_value = fv ? ushort_fill_value : NC_FILL_USHORT; fill_value = &ushort_expected_fill_value; fill_value_in = &ushort_fill_value_in; break; case NC_UINT: for (i = 0; i < DIMSIZE * DIMSIZE; i++) uint_data[i] = mpi_rank; data = uint_data; data_in = uint_data_in; uint_expected_fill_value = fv ? uint_fill_value : NC_FILL_UINT; fill_value = &uint_expected_fill_value; fill_value_in = &uint_fill_value_in; break; case NC_INT64: for (i = 0; i < DIMSIZE * DIMSIZE; i++) int64_data[i] = mpi_rank; data = int64_data; data_in = int64_data_in; int64_expected_fill_value = fv ? int64_fill_value : NC_FILL_INT64; fill_value = &int64_expected_fill_value; fill_value_in = &int64_fill_value_in; break; case NC_UINT64: for (i = 0; i < DIMSIZE * DIMSIZE; i++) uint64_data[i] = mpi_rank; data = uint64_data; data_in = uint64_data_in; uint64_expected_fill_value = fv ? uint64_fill_value : NC_FILL_UINT64; fill_value = &uint64_expected_fill_value; fill_value_in = &uint64_fill_value_in; break; } /* Create a file name. */ sprintf(file_name, "%s_type_%d_fv_%d.nc", TEST_NAME, test_type[tt], fv); /* Create a parallel netcdf-4 file. */ if (nc_create_par(file_name, NC_NETCDF4, comm, info, &ncid)) ERR; /* Get the type len. */ if (nc_inq_type(ncid, test_type[tt], NULL, &type_size)) ERR; /* A global attribute holds the number of processors that created * the file. */ if (nc_put_att_int(ncid, NC_GLOBAL, "num_processors", NC_INT, 1, &mpi_size)) ERR; /* Create three dimensions. */ if (nc_def_dim(ncid, DIM1_NAME, NUM_SLABS, dimids)) ERR; if (nc_def_dim(ncid, DIM2_NAME, DIMSIZE, &dimids[1])) ERR; if (nc_def_dim(ncid, DIM3_NAME, DIMSIZE, &dimids[2])) ERR; /* Create one var. */ if (nc_def_var(ncid, VAR_NAME, test_type[tt], NDIMS, dimids, &varid)) ERR; if (nc_put_att_int(ncid, varid, "var_num_processors", NC_INT, 1, &mpi_size)) ERR; if (fv == 1) { if (nc_def_var_fill(ncid, varid, NC_FILL, fill_value)) ERR; if (nc_inq_var_fill(ncid, varid, &fill_mode_in, fill_value_in)) ERR; if (fill_mode_in != NC_FILL) ERR; if (memcmp(fill_value_in, fill_value, type_size)) ERR; } else if (fv == 2) { if (nc_def_var_fill(ncid, varid, NC_NOFILL, NULL)) ERR; if (nc_inq_var_fill(ncid, varid, &fill_mode_in, NULL)) ERR; if (!fill_mode_in) ERR; /* nofill will be true */ } /* Write metadata to file. */ if (nc_enddef(ncid)) ERR; /* Change access mode to collective, then back to independent. */ if (nc_var_par_access(ncid, varid, NC_COLLECTIVE)) ERR; if (nc_var_par_access(ncid, varid, NC_INDEPENDENT)) ERR; if (!mpi_rank) start_time = MPI_Wtime(); /* Write all the slabs this process is responsible for. */ for (i = 0; i < NUM_SLABS / mpi_size; i++) { write_start[0] = NUM_SLABS / mpi_size * mpi_rank + i; /* Write one slab of data. Due to start/count settings, * every 16th value will be a fill value. */ if (nc_put_vara(ncid, varid, write_start, write_count, data)) ERR; } /* On rank 0, keep track of time. */ if (!mpi_rank) { total_time = MPI_Wtime() - start_time; printf("%d\t%g\t%g\n", mpi_size, total_time, DIMSIZE * DIMSIZE * NUM_SLABS * sizeof(int) / total_time); } /* Close the netcdf file. */ if (nc_close(ncid)) ERR; /* Reopen the file and check it. */ if ((ret = nc_open_par(file_name, NC_NOWRITE, comm, info, &ncid))) ERR; if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR; if (ndims_in != NDIMS || nvars_in != 1 || natts_in != 1 || unlimdimid_in != -1) ERR; /* Check the attributes. */ if (nc_get_att_int(ncid, NC_GLOBAL, "num_processors", &mpi_size_in)) ERR; if (mpi_size_in != mpi_size) ERR; if (nc_get_att_int(ncid, 0, "var_num_processors", &mpi_size_in)) ERR; if (mpi_size_in != mpi_size) ERR; if (fv == 1) { if (nc_inq_var_fill(ncid, varid, &fill_mode_in, fill_value_in)) ERR; if (fill_mode_in != NC_FILL) ERR; if (memcmp(fill_value_in, fill_value, type_size)) ERR; } /* Read all the slabs this process is responsible for. */ for (i = 0; i < NUM_SLABS / mpi_size; i++) { read_start[0] = NUM_SLABS / mpi_size * mpi_rank + i; /* printf("mpi_rank %d i %d read_start[0] %ld\n", mpi_rank, i, read_start[0]); */ /* Read one slab of data. */ if (nc_get_vara(ncid, varid, read_start, read_count, data_in)) ERR; /* Check data. For the third fill value test, fill is * turned off. So don't bother testing the values where k * is zero. */ /* printf("mpi_rank %d fv %d i %d j %d k %d int_data_in[j * k] %d int_expected_fill_value %d " */ /* "expected_value %d\n", mpi_rank, fv, i, j, k, int_data_in[j * k], */ /* int_expected_fill_value, expected_value); */ switch (test_type[tt]) { case NC_BYTE: for (j = 0; j < DIMSIZE; j++) for (k = 0; k < DIMSIZE; k++) if (fv < 2 || k) if (byte_data_in[j * DIMSIZE + k] != (signed char)(k ? mpi_rank : byte_expected_fill_value)) ERR; break; case NC_SHORT: for (j = 0; j < DIMSIZE; j++) for (k = 0; k < DIMSIZE; k++) if (fv < 2 || k) if (short_data_in[j * DIMSIZE + k] != (short)(k ? mpi_rank : short_expected_fill_value)) ERR; break; case NC_INT: for (j = 0; j < DIMSIZE; j++) for (k = 0; k < DIMSIZE; k++) if (fv < 2 || k) if (int_data_in[j * DIMSIZE + k] != (int)(k ? mpi_rank : int_expected_fill_value)) ERR; break; case NC_FLOAT: for (j = 0; j < DIMSIZE; j++) for (k = 0; k < DIMSIZE; k++) if (fv < 2 || k) if (float_data_in[j * DIMSIZE + k] != (float)(k ? mpi_rank : float_expected_fill_value)) ERR; break; case NC_DOUBLE: for (j = 0; j < DIMSIZE; j++) for (k = 0; k < DIMSIZE; k++) if (fv < 2 || k) if (double_data_in[j * DIMSIZE + k] != (double)(k ? mpi_rank : double_expected_fill_value)) ERR; break; case NC_UBYTE: for (j = 0; j < DIMSIZE; j++) for (k = 0; k < DIMSIZE; k++) if (fv < 2 || k) if (ubyte_data_in[j * DIMSIZE + k] != (unsigned char)(k ? mpi_rank : ubyte_expected_fill_value)) ERR; break; case NC_USHORT: for (j = 0; j < DIMSIZE; j++) for (k = 0; k < DIMSIZE; k++) if (fv < 2 || k) if (ushort_data_in[j * DIMSIZE + k] != (unsigned short)(k ? mpi_rank : ushort_expected_fill_value)) ERR; break; case NC_UINT: for (j = 0; j < DIMSIZE; j++) for (k = 0; k < DIMSIZE; k++) if (fv < 2 || k) if (uint_data_in[j * DIMSIZE + k] != (unsigned int)(k ? mpi_rank : uint_expected_fill_value)) ERR; break; case NC_INT64: for (j = 0; j < DIMSIZE; j++) for (k = 0; k < DIMSIZE; k++) if (fv < 2 || k) if (int64_data_in[j * DIMSIZE + k] != (long long int)(k ? mpi_rank : int64_expected_fill_value)) ERR; break; case NC_UINT64: for (j = 0; j < DIMSIZE; j++) for (k = 0; k < DIMSIZE; k++) if (fv < 2 || k) if (uint64_data_in[j * DIMSIZE + k] != (unsigned long long int)(k ? mpi_rank : uint64_expected_fill_value)) ERR; break; } } /* next slab */ /* Close the netcdf file. */ if (nc_close(ncid)) ERR; if (!mpi_rank) SUMMARIZE_ERR; } /* next test type */ } /* next fill value test run */ /* Shut down MPI. */ MPI_Finalize(); if (!mpi_rank) FINAL_RESULTS; return 0; }
int main(int argc, char **argv) {/* create file that caused seg fault in ncdump */ int ncid; /* netCDF id */ /* dimension ids */ int Time_dim; int X_dim; int Y_dim; /* dimension lengths */ size_t Time_len = NC_UNLIMITED; size_t X_len = 4; size_t Y_len = 3; /* variable ids */ int Time_id; int P_id; /* rank (number of dimensions) for each variable */ # define RANK_Time 1 # define RANK_P 3 /* variable shapes */ int Time_dims[RANK_Time]; int P_dims[RANK_P]; printf("\n*** Testing preparation of fillbug test.\n"); printf("*** creating fillbug test file %s...", FILENAME); /* enter define mode */ if (nc_create(FILENAME, NC_CLOBBER|NC_NETCDF4, &ncid)) ERR; /* define dimensions */ if (nc_def_dim(ncid, "Time", Time_len, &Time_dim)) ERR; if (nc_def_dim(ncid, "X", X_len, &X_dim)) ERR; if (nc_def_dim(ncid, "Y", Y_len, &Y_dim)) ERR; /* define variables */ Time_dims[0] = Time_dim; if (nc_def_var(ncid, "Time", NC_DOUBLE, RANK_Time, Time_dims, &Time_id)) ERR; P_dims[0] = Time_dim; P_dims[1] = Y_dim; P_dims[2] = X_dim; if (nc_def_var(ncid, "P", NC_FLOAT, RANK_P, P_dims, &P_id)) ERR; /* leave define mode */ if (nc_enddef (ncid)) ERR; {/* assign variable data */ static double Time_data[1]={3.14159}; static size_t Time_startset[1] = {0}; static size_t Time_countset[1] = {1}; if (nc_put_vara(ncid, Time_id, Time_startset, Time_countset, Time_data)) ERR; } if (nc_close(ncid)) ERR; /* Try to duplicate segfault ncdump gets by making the same calls * to the netCDF-4 library, in the same order. This doesn't * result in the same segfault, so either we have missed a call * made by ncdump, or an earlier ncdump bug masks the real problem * until a call is made into the netCDF-4 library ... */ if (nc_open(FILENAME, NC_NOWRITE, &ncid)) ERR; { /* We declare local arrays with small constant sizes to avoid * all the mallocs and frees used in ncdump. For the example * above, the fixed-size arrays are ample. */ int format, ndims, nvars, ngatts, xdimid, ndims_grp, dimids_grp[3], unlimids[1], d_grp, nunlim, nvars_grp, varids_grp[3], v_grp, varid, varndims, vardims[3], varnatts, vartype, dimids[3], is_recvar, vdims[3], id, ntypes, numgrps; size_t dimsize, len; char dimname[20], varname[20]; if ( nc_inq_format(ncid, &format)) ERR; ntypes = count_udtypes(ncid); if ( nc_inq_typeids(ncid, &ntypes, NULL) ) ERR; if ( nc_inq_format(ncid, &format)) ERR; if ( nc_inq_grps(ncid, &numgrps, NULL) ) ERR; if ( nc_inq_typeids(ncid, &ntypes, NULL) ) ERR; if ( nc_inq(ncid, &ndims, &nvars, &ngatts, &xdimid) ) ERR; if ( nc_inq_ndims(ncid, &ndims_grp) ) ERR; if ( nc_inq_dimids(ncid, 0, dimids_grp, 0) ) ERR; if ( nc_inq_unlimdims(ncid, &nunlim, NULL) ) ERR; if ( nc_inq_unlimdims(ncid, &nunlim, unlimids) ) ERR; for (d_grp = 0; d_grp < ndims_grp; d_grp++) { int dimid = dimids_grp[d_grp]; if ( nc_inq_dim(ncid, dimid, dimname, &dimsize) ) ERR; } if ( nc_inq_format(ncid, &format) ) ERR; if ( nc_inq_varids(ncid, &nvars_grp, varids_grp) ) ERR; for (v_grp = 0; v_grp < nvars_grp; v_grp++) { varid = varids_grp[v_grp]; if ( nc_inq_varndims(ncid, varid, &varndims) ) ERR; if ( nc_inq_var(ncid, varid, varname, &vartype, 0, vardims, &varnatts) ) ERR; for (id = 0; id < varndims; id++) { if ( nc_inq_dimname(ncid, vardims[id], dimname) ) ERR; } } for (v_grp = 0; v_grp < nvars_grp; v_grp++) { varid = varids_grp[v_grp]; if( nc_inq_varndims(ncid, varid, &varndims) ) ERR; if( nc_inq_var(ncid, varid, varname, &vartype, 0, vardims, &varnatts) ) ERR; { is_recvar = 0; if ( nc_inq_varndims(ncid, varid, &ndims) ) ERR; if (ndims > 0) { int nunlimdims; int recdimids[3]; int dim, recdim; if ( nc_inq_vardimid(ncid, varid, dimids) ) ERR; if ( nc_inq_unlimdims(ncid, &nunlimdims, NULL) ) ERR; if ( nc_inq_unlimdims(ncid, NULL, recdimids) ) ERR; for (dim = 0; dim < ndims && is_recvar == 0; dim++) { for(recdim = 0; recdim < nunlimdims; recdim++) { if(dimids[dim] == recdimids[recdim]) { is_recvar = 1; break; } } } } } for (id = 0; id < varndims; id++) { if( nc_inq_dimlen(ncid, vardims[id], &len) ) ERR; vdims[id] = len; } if (varid == 0) { /* read Time variable */ static double Time_data; static size_t cor[RANK_Time] = {0}; static size_t edg[RANK_Time] = {1}; if (nc_get_vara(ncid, varid, cor, edg, &Time_data)) ERR; } else { /* read data slices from P variable, should get fill values */ static float P_data[4]; static size_t cor[RANK_P] = {0, 0, 0}; static size_t edg[RANK_P] = {1, 1, 4}; /* first slice retrieved OK */ if (nc_get_vara(ncid, varid, cor, edg, P_data)) ERR; /* In ncdump, reading second slice gets seg fault in * nc4_open_var_grp(), but this attempt to do all the * same netCDF calls as ncdump can't duplicate the * error, which would seem to implicate ncdump rather * than HDF5 or netCDF-4 library ... */ cor[1] = 1; if (nc_get_vara(ncid, varid, cor, edg, P_data)) ERR; } } } if (nc_close(ncid)) ERR; SUMMARIZE_ERR; FINAL_RESULTS; }
/*void generator(const char* fname,int * shapes,int *types,int dim_size,TYPE var_type){*/ int generator(const char* fname,char *dimnames[],char *varname,size_t * shapes,int dim_size,TYPE *types,TYPE var_type){ int res; int ncid,vlid; int *dimids=(int *)calloc(dim_size,sizeof(int)); int *dimvarids=(int *)calloc(dim_size,sizeof(int)); /* dimids[3],dimvarids[3];*/ /* int d1_id,d2_id,d3_id;*/ double coverage=1.0; /* char *dim_names[]={"d1","d2","d3"};*/ size_t total_size=1; size_t max_pos=0; int i; for(i=0;i<dim_size;i++){ total_size*=shapes[i]; max_pos+=shapes[i]; } /* double min=0;*/ /* double max=coverage;*/ /* TYPE types[3]={DOUBLE,DOUBLE,DOUBLE};*/ /* if((res=nc_create(fname,NC_CLOBBER|NC_64BIT_OFFSET,&ncid)))*/ /* BAIL(res);*/ if((res=nc_create(fname,NC_CLASSIC_MODEL|NC_NETCDF4,&ncid))) BAIL(res); /* if((res=nc_def_dim(ncid,"d1",dims.shape[0],&dimids[0])))*/ /* BAIL(res);*/ for(i=0;i<dim_size;i++){ if(i==0){ /* if((res=nc_def_dim(ncid,dimnames[i],NC_UNLIMITED,&dimids[i])))*/ /* BAIL(res);*/ if((res=nc_def_dim(ncid,dimnames[i],shapes[i],&dimids[i]))) BAIL(res); }else{ if((res=nc_def_dim(ncid,dimnames[i],shapes[i],&dimids[i]))) BAIL(res); } if((res=nc_def_var(ncid,dimnames[i],get_nctype(types[i]),1,&dimids[i],&dimvarids[i]))) BAIL(res); } /* if((res=nc_def_var(ncid,"d1",get_nctype(types[0]),1,&dimids[0],&dimvarids[0])))*/ /* BAIL(res);*/ /* if((res=nc_def_var(ncid,"d2",get_nctype(types[1]),1,&dimids[1],&dimvarids[1])))*/ /* BAIL(res);*/ /* if((res=nc_def_var(ncid,"d3",get_nctype(types[2]),1,&dimids[2],&dimvarids[2])))*/ /* BAIL(res);*/ if((res=nc_def_var(ncid,varname,get_nctype(var_type),dim_size,dimids,&vlid))) BAIL(res); if((res=nc_enddef(ncid))) BAIL(res); void **dimvar=(void **)calloc(dim_size,sizeof(void *)); void *buffer=calloc(total_size/shapes[0],get_type_size(var_type)); void *udata=calloc(1,get_type_size(types[0])); for(i=1;i<dim_size;i++){ dimvar[i]=calloc(shapes[i],get_type_size(types[i])); init_dimvar(dimvar[i],shapes[i],types[i]); nc_put_var(types[i],ncid,dimvarids[i],dimvar[i]); free(dimvar[i]); } size_t *start=(size_t *)calloc(dim_size,sizeof(size_t)); size_t *count=(size_t *)calloc(dim_size,sizeof(size_t)); size_t *dshape=(size_t *)calloc(dim_size,sizeof(size_t)); size_t ustart[1]={0}; size_t ucount[1]={1}; for(i=1;i<dim_size;i++){ count[i]=shapes[i]; } count[0]=1; get_dshape(dshape,shapes,dim_size); double shift=0; /* double shift=0.01;*/ for(i=0;i<shapes[0];i++){ start[0]=i; ustart[0]=i; getval(((char *)udata),i,types[0]); nc_put_vara(types[0],ncid,dimids[0],ustart,ucount,udata); if(gm==RANDOM) init_var(buffer,total_size/shapes[0],0,1,var_type); if(gm==LOCALITY){ /* printf("locality");*/ /* init_var_locality(buffer,total_size/shapes[0],i*(total_size/shapes[0]),var_type);*/ init_var_locality(buffer,total_size/shapes[0],i,shapes,dshape,dim_size,shift,var_type); } if(gm==FIXED){ init_var_fixed(buffer,total_size/shapes[0],fixsize,var_type); } nc_put_vara(var_type,ncid,vlid,start,count,buffer); } if((res=nc_close(ncid))) BAIL(res); return 0; }