int main(int argc, char **argv) { int i, j; int status; int ncid1, ncid2; int ndims, nvars, ngatts, unlimdimid; char name[NC_MAX_NAME]; nc_type type, *vartypes; MPI_Offset attlen, dimlen, varsize; MPI_Offset *shape, *start; void *valuep; int *dimids, *varids, **vardims, *varndims, *varnatts; params opts; int rank; int nprocs; int NC_mode; MPI_Comm comm = MPI_COMM_WORLD; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank == 0) fprintf(stderr, "Testing read ... "); parse_read_args(argc, argv, rank, &opts); /********** START OF NETCDF ACCESS **************/ /* Read a netCDF file and write it out to another file */ /** * Open the input dataset - ncid1: * File name: "../data/test_int.nc" * Dataset API: Collective * And create the output dataset - ncid2: * File name: "testread.nc" * Dataset API: Collective */ status = ncmpi_open(comm, opts.infname, 0, MPI_INFO_NULL, &ncid1); if (status != NC_NOERR) handle_error(status); status = ncmpi_inq_version(ncid1, &NC_mode); status = ncmpi_create(comm, opts.outfname, NC_CLOBBER|NC_mode, MPI_INFO_NULL, &ncid2); if (status != NC_NOERR) handle_error(status); /** * Inquire the dataset definitions of input dataset AND * Add dataset definitions for output dataset. */ status = ncmpi_inq(ncid1, &ndims, &nvars, &ngatts, &unlimdimid); if (status != NC_NOERR) handle_error(status); /* Inquire global attributes, assume CHAR attributes. */ for (i = 0; i < ngatts; i++) { status = ncmpi_inq_attname(ncid1, NC_GLOBAL, i, name); if (status != NC_NOERR) handle_error(status); status = ncmpi_inq_att (ncid1, NC_GLOBAL, name, &type, &attlen); if (status != NC_NOERR) handle_error(status); switch (type) { case NC_CHAR: valuep = (void *)malloc(attlen * sizeof(char)); status = ncmpi_get_att_text(ncid1, NC_GLOBAL, name, (char*)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_att_text (ncid2, NC_GLOBAL, name, attlen, (char *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; case NC_SHORT: valuep = (void *)malloc(attlen * sizeof(short)); status = ncmpi_get_att_short(ncid1, NC_GLOBAL, name, (short*)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_att_short (ncid2, NC_GLOBAL, name, type, attlen, (short *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; case NC_INT: valuep = (void *)malloc(attlen * sizeof(int)); status = ncmpi_get_att_int(ncid1, NC_GLOBAL, name, (int*)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_att_int (ncid2, NC_GLOBAL, name, type, attlen, (int *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; case NC_FLOAT: valuep = (void *)malloc(attlen * sizeof(float)); status = ncmpi_get_att_float(ncid1, NC_GLOBAL, name, (float*)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_att_float (ncid2, NC_GLOBAL, name, type, attlen, (float *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; case NC_DOUBLE: valuep = (void *)malloc(attlen * sizeof(double)); status = ncmpi_get_att_double(ncid1, NC_GLOBAL, name, (double*)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_att_double (ncid2, NC_GLOBAL, name, type, attlen, (double *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; default: ; /* handle unexpected types */ } } /* Inquire dimension */ dimids = (int*) malloc(ndims * sizeof(int)); for (i = 0; i < ndims; i++) { status = ncmpi_inq_dim(ncid1, i, name, &dimlen); if (status != NC_NOERR) handle_error(status); if (i == unlimdimid) dimlen = NC_UNLIMITED; status = ncmpi_def_dim(ncid2, name, dimlen, dimids+i); if (status != NC_NOERR) handle_error(status); } free(dimids); vartypes = (nc_type*) malloc(nvars * sizeof(nc_type)); varids = (int*) malloc(nvars * sizeof(int)); varndims = (int*) malloc(nvars * sizeof(int)); varnatts = (int*) malloc(nvars * sizeof(int)); vardims = (int**) malloc(nvars * sizeof(int*)); /* Inquire variables */ for (i = 0; i < nvars; i++) { status = ncmpi_inq_varndims(ncid1, i, varndims+i); if (status != NC_NOERR) handle_error(status); vardims[i] = (int*) malloc(varndims[i] * sizeof(int)); status = ncmpi_inq_var (ncid1, i, name, vartypes+i, varndims+i, vardims[i], varnatts+i); if (status != NC_NOERR) handle_error(status); status = ncmpi_def_var(ncid2, name, vartypes[i], varndims[i], vardims[i], varids+i); if (status != NC_NOERR) handle_error(status); /* var attributes, assume CHAR attributes */ for (j = 0; j < varnatts[i]; j++) { status = ncmpi_inq_attname(ncid1, i, j, name); if (status != NC_NOERR) handle_error(status); status = ncmpi_inq_att (ncid1, i, name, &type, &attlen); if (status != NC_NOERR) handle_error(status); switch (type) { case NC_CHAR: valuep = (void *)malloc(attlen * sizeof(char)); status = ncmpi_get_att_text(ncid1, i, name, (char*)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_att_text (ncid2, varids[i], name, attlen, (char *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; case NC_SHORT: valuep = (void *)malloc(attlen * sizeof(short)); status = ncmpi_get_att_short(ncid1, i, name, (short*)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_att_short (ncid2, varids[i], name, type, attlen, (short *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; case NC_INT: valuep = (void *)malloc(attlen * sizeof(int)); status = ncmpi_get_att_int(ncid1, i, name, (int*)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_att_int (ncid2, varids[i], name, type, attlen, (int *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; case NC_FLOAT: valuep = (void *)malloc(attlen * sizeof(float)); status = ncmpi_get_att_float(ncid1, i, name, (float*)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_att_float (ncid2, varids[i], name, type, attlen, (float *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; case NC_DOUBLE: valuep = (void *)malloc(attlen * sizeof(double)); status = ncmpi_get_att_double(ncid1, i, name, (double*)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_att_double (ncid2, varids[i], name, type, attlen, (double *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; default: ; /* handle unexpected types */ } } } /** * End Define Mode (switch to data mode) for output dataset * Dataset API: Collective */ status = ncmpi_enddef(ncid2); if (status != NC_NOERR) handle_error(status); /** * Read data of variables from input dataset * (ONLY DEAL WITH: NC_INT, NC_FLOAT, NC_DOUBLE for now) * Write the data out to the corresponding variables in the output dataset * * Data Partition (Assume 4 processors): * square: 2-D, (Block, *), 25*100 from 100*100 * cube: 3-D, (Block, *, *), 25*100*100 from 100*100*100 * xytime: 3-D, (Block, *, *), 25*100*100 from 100*100*100 * time: 1-D, Block-wise, 25 from 100 * * Data Mode API: collective */ for (i = 0; i < nvars; i++) { shape = (MPI_Offset*) calloc(varndims[i] * 2, sizeof(MPI_Offset)); start = shape + varndims[i]; varsize = 1; for (j = 0; j < varndims[i]; j++) { status = ncmpi_inq_dim(ncid1, vardims[i][j], name, shape + j); if (status != NC_NOERR) handle_error(status); if (j == 0) { shape[j] /= nprocs; start[j] = shape[j] * rank; } varsize *= shape[j]; } switch (vartypes[i]) { case NC_CHAR: break; case NC_SHORT: valuep = (void *)malloc(varsize * sizeof(short)); status = ncmpi_get_vara_short_all(ncid1, i, start, shape, (short *)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_vara_short_all(ncid2, varids[i], start, shape, (short *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; case NC_INT: valuep = (void *)malloc(varsize * sizeof(int)); status = ncmpi_get_vara_int_all(ncid1, i, start, shape, (int *)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_vara_int_all(ncid2, varids[i], start, shape, (int *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; case NC_FLOAT: valuep = (void *)malloc(varsize * sizeof(float)); status = ncmpi_get_vara_float_all(ncid1, i, start, shape, (float *)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_vara_float_all(ncid2, varids[i], start, shape, (float *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; case NC_DOUBLE: valuep = (void *)malloc(varsize * sizeof(double)); status = ncmpi_get_vara_double_all(ncid1, i, start, shape, (double *)valuep); if (status != NC_NOERR) handle_error(status); status = ncmpi_put_vara_double_all(ncid2, varids[i], start, shape, (double *)valuep); if (status != NC_NOERR) handle_error(status); free(valuep); break; default: ; /* handle unexpected types */ } free(vardims[i]); free(shape); } /** * Close the datasets * Dataset API: collective */ status = ncmpi_close(ncid1); if (status != NC_NOERR) handle_error(status); status = ncmpi_close(ncid2); if (status != NC_NOERR) handle_error(status); free(vartypes); free(varids); free(varndims); free(varnatts); free(vardims); /******************* END OF NETCDF ACCESS ****************/ if (rank == 0) fprintf(stderr, "OK\nInput file %s copied to: %s!\n", opts.infname, opts.outfname); MPI_Finalize(); return 0; }
int main(int argc, char **argv) { int rank, nprocs, ncid, pres_varid, temp_varid; int lat_varid, lon_varid; /* The start and count arrays will tell the netCDF library where to read our data. */ MPI_Offset start[NDIMS], count[NDIMS]; /* Program variables to hold the data we will read. We will only need enough space to hold one timestep of data; one record. */ float **pres_in=NULL; /* [NLVL/nprocs][NLAT][NLON] */ float **temp_in=NULL; /* [NLVL/nprocs][NLAT][NLON] */ /* These program variables hold the latitudes and longitudes. */ float lats[NLAT], lons[NLON]; /* Loop indexes. */ int lvl, lat, lon, rec, i = 0; /* Error handling. */ int err, nerrs=0; char *filename = FILE_NAME; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (argc > 2) { if (!rank) printf("Usage: %s [filename]\n",argv[0]); MPI_Finalize(); return 1; } if (argc == 2) filename = argv[1]; if (rank == 0) { char *cmd_str = (char*)malloc(strlen(argv[0]) + 256); sprintf(cmd_str, "*** TESTING C %s for reading file", basename(argv[0])); printf("%-66s ------ ", cmd_str); free(cmd_str); } /* Open the file. */ err = ncmpi_open(MPI_COMM_WORLD, filename, NC_NOWRITE, MPI_INFO_NULL, &ncid); CHECK_ERR /* Get the varids of the latitude and longitude coordinate * variables. */ err = ncmpi_inq_varid(ncid, LAT_NAME, &lat_varid); CHECK_ERR err = ncmpi_inq_varid(ncid, LON_NAME, &lon_varid); CHECK_ERR /* Read the coordinate variable data. */ memset(lats, 0, sizeof(float)*NLAT); memset(lons, 0, sizeof(float)*NLON); err = ncmpi_get_var_float_all(ncid, lat_varid, &lats[0]); CHECK_ERR err = ncmpi_get_var_float_all(ncid, lon_varid, &lons[0]); CHECK_ERR /* Check the coordinate variable data. */ for (lat = 0; lat < NLAT; lat++) if (lats[lat] != START_LAT + 5.*lat) { printf("\nError at line %d in %s: expect %e but got %e\n", __LINE__,__FILE__, START_LAT+5.*lat,lats[lat]); nerrs++; goto fn_exit; } for (lon = 0; lon < NLON; lon++) if (lons[lon] != START_LON + 5.*lon) { printf("\nError at line %d in %s: expect %e but got %e\n", __LINE__,__FILE__, START_LON+5.*lon,lons[lon]); nerrs++; goto fn_exit; } /* Get the varids of the pressure and temperature netCDF * variables. */ err = ncmpi_inq_varid(ncid, PRES_NAME, &pres_varid); CHECK_ERR err = ncmpi_inq_varid(ncid, TEMP_NAME, &temp_varid); CHECK_ERR /* Read the data. Since we know the contents of the file we know * that the data arrays in this program are the correct size to * hold one timestep. */ count[0] = 1; count[2] = NLAT; count[3] = NLON; start[2] = 0; start[3] = 0; /* divide NLVL dimension among processes */ count[1] = NLVL / nprocs; start[1] = count[1] * rank; if (rank < NLVL % nprocs) { start[1] += rank; count[1]++; } else { start[1] += NLVL % nprocs; } if (count[1] == 0) start[1] = 0; /* allocate read buffers */ pres_in = (float**) malloc(count[1]*2 * sizeof(float*)); temp_in = pres_in + count[1]; if (count[1] > 0) { pres_in[0] = (float*) malloc(count[1]*2 * NLAT*NLON * sizeof(float)); temp_in[0] = pres_in[0] + count[1] * NLAT*NLON; for (i=1; i<count[1]; i++) { pres_in[i] = pres_in[i-1] + NLAT*NLON; temp_in[i] = temp_in[i-1] + NLAT*NLON; } } /* Read and check one record at a time. */ for (rec = 0; rec < NREC; rec++) { start[0] = rec; err = ncmpi_get_vara_float_all(ncid, pres_varid, start, count, &pres_in[0][0]); CHECK_ERR err = ncmpi_get_vara_float_all(ncid, temp_varid, start, count, &temp_in[0][0]); CHECK_ERR /* Check the data. */ i = (int)start[1] * NLAT * NLON; for (lvl=0; lvl<count[1]; lvl++) for (lat = 0; lat < NLAT; lat++) for (lon = 0; lon < NLON; lon++) { if (pres_in[lvl][lat*NLON+lon] != SAMPLE_PRESSURE + i) { printf("\nError at line %d in %s: expect %e but got %e\n", __LINE__,__FILE__, SAMPLE_PRESSURE+i,pres_in[lvl][lat*NLON+lon]); nerrs++; goto fn_exit; } if (temp_in[lvl][lat*NLON+lon] != SAMPLE_TEMP + i) { printf("\nError at line %d in %s: expect %e but got %e\n", __LINE__,__FILE__, SAMPLE_TEMP+i,temp_in[lvl][lat*NLON+lon]); nerrs++; goto fn_exit; } i++; } } /* next record */ fn_exit: /* Close the file. */ err = ncmpi_close(ncid); CHECK_ERR if (pres_in != NULL) { if (pres_in[0] != NULL) free(pres_in[0]); free(pres_in); } /* check if there is any malloc residue */ MPI_Offset malloc_size, sum_size; err = ncmpi_inq_malloc_size(&malloc_size); if (err == NC_NOERR) { MPI_Reduce(&malloc_size, &sum_size, 1, MPI_OFFSET, MPI_SUM, 0, MPI_COMM_WORLD); if (rank == 0 && sum_size > 0) printf("heap memory allocated by PnetCDF internally has %lld bytes yet to be freed\n", sum_size); } MPI_Allreduce(MPI_IN_PLACE, &nerrs, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD); if (rank == 0) { if (nerrs) printf(FAIL_STR,nerrs); else printf(PASS_STR); } MPI_Finalize(); return (nerrs > 0); }
// Traj_NcEnsemble::readArray() int Traj_NcEnsemble::readArray(int set, FrameArray& f_ensemble) { # ifdef HAS_PNETCDF MPI_Offset pstart_[4]; MPI_Offset pcount_[4]; # define start_ pstart_ # define count_ pcount_ # endif start_[0] = set; // Frame start_[2] = 0; // Atoms start_[3] = 0; // XYZ count_[0] = 1; // Frame count_[1] = 1; // Ensemble count_[3] = 3; // XYZ //rprintf("DEBUG: Reading frame %i\n", set+1); for (int member = ensembleStart_; member != ensembleEnd_; member++) { # ifdef MPI Frame& frm = f_ensemble[0]; # else Frame& frm = f_ensemble[member]; # endif start_[1] = member; // Ensemble count_[2] = Ncatom(); // Atoms // Read Coords # ifdef HAS_PNETCDF if (checkPNCerr(ncmpi_get_vara_float_all(ncid_, coordVID_, start_, count_, Coord_))) # else if (NC::CheckErr(nc_get_vara_float(ncid_, coordVID_, start_, count_, Coord_))) # endif { rprinterr("Error: Getting coordinates for frame %i\n", set+1); return 1; } FloatToDouble(frm.xAddress(), Coord_); //mprintf("Frm=%8i Rep=%8i ", set+1, member+1); // DEBUG //frm.printAtomCoord(0); // DEBUG // Read Velocities if (velocityVID_ != -1) { # ifdef HAS_PNETCDF if (checkPNCerr(ncmpi_get_vara_float_all(ncid_, velocityVID_, start_, count_, Coord_))) # else if (NC::CheckErr(nc_get_vara_float(ncid_, velocityVID_, start_, count_, Coord_))) # endif { rprinterr("Error: Getting velocities for frame %i\n", set+1); return 1; } FloatToDouble(frm.vAddress(), Coord_); } // Read Box if (cellLengthVID_ != -1) { count_[2] = 3; # ifdef HAS_PNETCDF if (checkPNCerr(ncmpi_get_vara_double_all(ncid_, cellLengthVID_, start_, count_, frm.bAddress()))) # else if (NC::CheckErr(nc_get_vara_double(ncid_, cellLengthVID_, start_, count_, frm.bAddress()))) # endif { rprinterr("Error: Getting cell lengths for frame %i.\n", set+1); return 1; } # ifdef HAS_PNETCDF if (checkPNCerr(ncmpi_get_vara_double_all(ncid_, cellAngleVID_, start_, count_, frm.bAddress()+3))) # else if (NC::CheckErr(nc_get_vara_double(ncid_, cellAngleVID_, start_, count_, frm.bAddress()+3))) # endif { rprinterr("Error: Getting cell angles for frame %i.\n", set+1); return 1; } } // Read Temperature if (TempVID_!=-1) { # ifdef HAS_PNETCDF if (checkPNCerr(ncmpi_get_vara_double_all(ncid_, TempVID_, start_, count_, frm.tAddress()))) # else if (NC::CheckErr(nc_get_vara_double(ncid_, TempVID_, start_, count_, frm.tAddress()))) # endif { rprinterr("Error: Getting replica temperature for frame %i.\n", set+1); return 1; } //fprintf(stderr,"DEBUG: Replica Temperature %lf\n",F->T); } // Read indices if (indicesVID_!=-1) { count_[2] = remd_dimension_; # ifdef HAS_PNETCDF if (checkPNCerr(ncmpi_get_vara_int_all(ncid_, indicesVID_, start_, count_, frm.iAddress()))) # else if (NC::CheckErr(nc_get_vara_int(ncid_, indicesVID_, start_, count_, frm.iAddress()))) # endif { rprinterr("Error: Getting replica indices for frame %i.\n", set+1); return 1; } // DEBUG //char buffer[128]; //char* ptr = buffer; //ptr += sprintf(buffer,"DEBUG:\tReplica indices:"); //for (int dim=0; dim < remd_dimension_; dim++) ptr += sprintf(ptr, " %i", frm.RemdIndices()[dim]); //sprintf(ptr,"\n"); //rprintf("%s", buffer); } } # ifdef HAS_PNETCDF // DEBUG # undef start_ # undef count_ # endif return 0; }
/* reads input in pnetcdf format nblocks: (output) local number of blocks tot_blocks: (output) total number of blocks vblocks: (output) pointer to array of vblocks in_file: input file name comm: MPI communicator gids: (output) gids of local blocks (allocated by this function) num_neighbors: (output) number of neighbors for each local block (allocated by this function) neighbors: (output) gids of neighbors of each local block (allocated by this function) side effects: allocates vblocks, gids, num_neighbors, neighbors */ void pnetcdf_read(int *nblocks, int *tot_blocks, struct vblock_t ***vblocks, char *in_file, MPI_Comm comm, int *gids, int *num_neighbors, int **neighbors) { #ifdef USEPNETCDF int err; int ncid, varids[23], dimids[8]; MPI_Offset start[2], count[2]; nc_type type; int ndims, natts; int dims[2]; int rank, groupsize; /* MPI usual */ /* open file for reading */ err = ncmpi_open(comm, in_file, NC_NOWRITE, MPI_INFO_NULL, &ncid); ERR; err = ncmpi_inq_varid(ncid, "block_off_num_verts", &varids[5]); ERR; err = ncmpi_inq_varid(ncid, "block_off_num_complete_cells", &varids[6]); ERR; err = ncmpi_inq_varid(ncid, "block_off_tot_num_cell_faces", &varids[7]); ERR; err = ncmpi_inq_varid(ncid, "block_off_tot_num_face_verts", &varids[8]); ERR; err = ncmpi_inq_varid(ncid, "block_off_num_orig_particles", &varids[9]); ERR; /* get number of blocks */ MPI_Offset num_g_blocks; /* 64 bit version of tot_blcoks */ err = ncmpi_inq_dimlen(ncid, dimids[0], &num_g_blocks); ERR; *tot_blocks = num_g_blocks; MPI_Comm_rank(comm, &rank); MPI_Comm_size(comm, &groupsize); int start_block_ofst = rank * (*tot_blocks / groupsize); *nblocks = (rank < groupsize - 1 ? (*tot_blocks / groupsize) : *tot_blocks - (rank * *tot_blocks / groupsize)); /* block offsets */ int64_t *block_ofsts = (int64_t*)malloc(*tot_blocks * sizeof(int64_t)); *vblocks = (struct vblock_t**)malloc(*nblocks * sizeof(struct vblock_t*)); /* read all blocks */ gids = (int *)malloc(*nblocks * sizeof(int)); num_neighbors = (int *)malloc(*nblocks * sizeof(int)); neighbors = (int **)malloc(*nblocks * sizeof(int *)); int b; for (b = 0; b < *nblocks; b++) { struct vblock_t* v = (struct vblock_t*)malloc(sizeof(struct vblock_t)); /* quantities */ start[0] = start_block_ofst + b; count[0] = 1; err = ncmpi_inq_varid(ncid, "num_verts", &varids[0]); ERR; err = ncmpi_get_vara_int_all(ncid, varids[0], start, count, &(v->num_verts)); ERR; err = ncmpi_inq_varid(ncid, "num_complete_cells", &varids[1]); ERR; err = ncmpi_get_vara_int_all(ncid, varids[1], start, count, &(v->num_complete_cells)); ERR; err = ncmpi_inq_varid(ncid, "tot_num_cell_faces", &varids[2]); ERR; err = ncmpi_get_vara_int_all(ncid, varids[2], start, count, &(v->tot_num_cell_faces)); ERR; err = ncmpi_inq_varid(ncid, "tot_num_face_verts", &varids[3]); ERR; err = ncmpi_get_vara_int_all(ncid, varids[3], start, count, &(v->tot_num_face_verts)); ERR; err = ncmpi_inq_varid(ncid, "num_orig_particles", &varids[4]); ERR; err = ncmpi_get_vara_int_all(ncid, varids[4], start, count, &(v->num_orig_particles)); ERR; err = ncmpi_inq_varid(ncid, "neighbors", &varids[21]); ERR; err = ncmpi_inq_var(ncid, varids[21], 0, &type, &ndims, dimids, &natts); /* block bounds */ start[0] = start_block_ofst + b; start[1] = 0; count[0] = 1; count[1] = 3; err = ncmpi_inq_varid(ncid, "mins", &varids[11]); ERR; err = ncmpi_get_vara_float_all(ncid, varids[11], start, count, v->mins); ERR; err = ncmpi_inq_varid(ncid, "maxs", &varids[12]); ERR; err = ncmpi_get_vara_float_all(ncid, varids[12], start, count, v->maxs); ERR; /* save_verts */ start[0] = 0; count[0] = *tot_blocks; err = ncmpi_get_vara_longlong_all(ncid, varids[5], start, count, block_ofsts); ERR; v->save_verts = (float *)malloc(v->num_verts * 3 * sizeof(float)); start[0] = block_ofsts[start_block_ofst + b]; start[1] = 0; count[0] = v->num_verts; count[1] = 3; err = ncmpi_inq_varid(ncid, "save_verts", &varids[13]); ERR; err = ncmpi_get_vara_float_all(ncid, varids[13], start, count, v->save_verts); ERR; /* sites */ start[0] = 0; count[0] = *tot_blocks; err = ncmpi_get_vara_longlong_all(ncid, varids[9], start, count, block_ofsts); ERR; v->sites = (float *)malloc(v->num_orig_particles * 3 * sizeof(float)); start[0] = block_ofsts[start_block_ofst + b]; start[1] = 0; count[0] = v->num_orig_particles; count[1] = 3; err = ncmpi_inq_varid(ncid, "sites", &varids[14]); ERR; err = ncmpi_get_vara_float_all(ncid, varids[14], start, count, v->sites); ERR; /* complete cells */ start[0] = 0; count[0] = *tot_blocks; err = ncmpi_get_vara_longlong_all(ncid, varids[6], start, count, block_ofsts); ERR; v->complete_cells = (int *)malloc(v->num_complete_cells * sizeof(int)); start[0] = block_ofsts[start_block_ofst + b]; count[0] = v->num_complete_cells; err = ncmpi_inq_varid(ncid, "complete_cells", &varids[15]); ERR; err = ncmpi_get_vara_int_all(ncid, varids[15], start, count, v->complete_cells); ERR; /* areas, uses same block offsets as complete cells */ v->areas = (float *)malloc(v->num_complete_cells * sizeof(float)); start[0] = block_ofsts[start_block_ofst + b]; count[0] = v->num_complete_cells; err = ncmpi_inq_varid(ncid, "areas", &varids[16]); ERR; err = ncmpi_get_vara_float_all(ncid, varids[16], start, count, v->areas); ERR; /* volumes, uses same block offsets as complete cells */ v->vols = (float *)malloc(v->num_complete_cells * sizeof(float)); start[0] = block_ofsts[start_block_ofst + b]; count[0] = v->num_complete_cells; err = ncmpi_inq_varid(ncid, "vols", &varids[17]); ERR; err = ncmpi_get_vara_float_all(ncid, varids[17], start, count, v->vols); ERR; /* num_cell_faces, uses same block offsets as complete cells */ v->num_cell_faces = (int *)malloc(v->num_complete_cells * sizeof(int)); start[0] = block_ofsts[start_block_ofst + b]; count[0] = v->num_complete_cells; err = ncmpi_inq_varid(ncid, "num_cell_faces", &varids[18]); ERR; err = ncmpi_get_vara_int_all(ncid, varids[18], start, count, v->num_cell_faces); ERR; /* num_face_verts */ start[0] = 0; count[0] = *tot_blocks; err = ncmpi_get_vara_longlong_all(ncid, varids[7], start, count, block_ofsts); ERR; v->num_face_verts = (int *)malloc(v->tot_num_cell_faces * sizeof(int)); start[0] = block_ofsts[start_block_ofst + b]; count[0] = v->tot_num_cell_faces; err = ncmpi_inq_varid(ncid, "num_face_verts", &varids[19]); ERR; err = ncmpi_get_vara_int_all(ncid, varids[19], start, count, v->num_face_verts); ERR; /* face_verts */ start[0] = 0; count[0] = *tot_blocks; err = ncmpi_get_vara_longlong_all(ncid, varids[8], start, count, block_ofsts); ERR; v->face_verts = (int *)malloc(v->tot_num_face_verts * sizeof(int)); start[0] = block_ofsts[start_block_ofst + b]; count[0] = v->tot_num_face_verts; err = ncmpi_inq_varid(ncid, "face_verts", &varids[20]); ERR; err = ncmpi_get_vara_int_all(ncid, varids[20], start, count, v->face_verts); ERR; /* neighbors */ MPI_Offset n; /* temporary 64-bit version of number of neighbors */ err = ncmpi_inq_varid(ncid, "neighbors", &varids[21]); ERR; err = ncmpi_inq_var(ncid, varids[2], 0, &type, &ndims, dims, &natts); ERR; err = ncmpi_inq_dimlen(ncid, dims[0], &n); ERR; num_neighbors[b] = n; neighbors[b] = (int *)malloc(num_neighbors[b] * sizeof(int)); start[0] = start_block_ofst + b; count[0] = num_neighbors[b]; err = ncmpi_get_vara_int_all(ncid, varids[21], start, count, neighbors[b]); ERR; /* gids */ start[0] = start_block_ofst + b; count[0] = 1; err = ncmpi_inq_varid(ncid, "g_block_ids", &varids[22]); ERR; err = ncmpi_get_vara_int_all(ncid, varids[22], start, count, &gids[b]); ERR; (*vblocks)[b] = v; } /* cleanup */ err = ncmpi_close(ncid); ERR; free(block_ofsts); #endif }