18 int ncopts = (NC_FATAL | NC_VERBOSE) ;
21 #if SIZEOF_LONG == SIZEOF_SIZE_T 28 # define A_DECL(name, type, ndims, rhs) \ 29 const type *const name = ((const type *)(rhs)) 33 # define A_INIT(lhs, type, ndims, rhs) 47 nvdims(
int ncid,
int varid)
53 nc_advise(
"ncvdims", status,
"ncid %d", ncid);
61 static void* nvmalloc(off_t size) {
69 #define NDIMS_DECL const int ndims = nvdims(ncid, varid); \ 72 # define A_DECL(name, type, ndims, rhs) \ 73 type *const name = (type*) nvmalloc((ndims) * sizeof(type)) 77 ALLOC_ONSTACK(name, type, ndims)
80 # define A_FREE(name) \ 83 # define A_INIT(lhs, type, ndims, rhs) \ 85 if((off_t)ndims >= 0) { \ 86 const long *lp = rhs; \ 88 type *const end = lhs + ndims; \ 91 *tp++ = (type) *lp++; \ 96 if ((off_t)ndims < 0) {nc_advise("nvdims",NC_EMAXDIMS,"ndims %d",ndims); return -1;} 101 typedef signed char schar;
108 numrecvars(
int ncid,
int* nrecvarsp,
int *recvarids)
118 status = nc_inq_nvars(ncid, &nvars);
126 if (recdimid == -1) {
131 for (varid = 0; varid < nvars; varid++) {
138 if (ndims > 0 && dimids[0] == recdimid) {
139 if (recvarids != NULL)
140 recvarids[nrecvars] = varid;
144 *nrecvarsp = nrecvars;
154 ncrecsize(
int ncid,
int varid,
size_t *recsizep)
177 if (ndims == 0 || dimids[0] != recdimid) {
180 size = nctypelen(type);
181 for (
id = 1;
id < ndims;
id++) {
188 *recsizep = (size_t)size;
198 dimsizes(
int ncid,
int varid,
size_t *sizes)
211 if (ndims == 0 || sizes == NULL)
213 for (
id = 0;
id < ndims;
id++) {
243 status = nc_inq_nvars(ncid, &nvars);
254 status = numrecvars(ncid, &nrvars, rvarids);
258 if (nrecvarsp != NULL)
259 *nrecvarsp = (size_t)nrvars;
261 if (recvarids != NULL)
262 for (varid = 0; varid < nrvars; varid++)
263 recvarids[varid] = rvarids[varid];
265 if (recsizes != NULL)
266 for (varid = 0; varid < nrvars; varid++) {
268 status = ncrecsize(ncid, rvarids[varid], &rsize);
271 recsizes[varid] = rsize;
296 status = numrecvars(ncid, &nrvars, rvarids);
304 for (varid = 1; varid < nrvars; varid++)
307 for (varid = 0; varid < nrvars; varid++) {
308 if (datap[varid] != NULL) {
309 status = dimsizes(ncid, rvarids[varid], edges);
314 status =
nc_put_vara(ncid, rvarids[varid], start, edges, datap[varid]);
342 status = numrecvars(ncid, &nrvars, rvarids);
350 for (varid = 1; varid < nrvars; varid++)
353 for (varid = 0; varid < nrvars; varid++) {
354 if (datap[varid] != NULL) {
355 status = dimsizes(ncid, rvarids[varid], edges);
359 status =
nc_get_vara(ncid, rvarids[varid], start, edges, datap[varid]);
370 nc_advise(
const char *routine_name,
int err,
const char *fmt,...)
379 if( ncopts & NC_VERBOSE )
381 (void) fprintf(stderr,
"%s: ", routine_name);
383 (void) vfprintf(stderr,fmt,args);
387 (void) fprintf(stderr,
": %s",
390 (void) fputc(
'\n',stderr);
391 (void) fflush(stderr);
394 if( (ncopts & NC_FATAL) && err !=
NC_NOERR )
403 nccreate(
const char* path,
int cmode)
406 const int status =
nc_create(path, cmode, &ncid);
409 nc_advise(
"nccreate", status,
"filename \"%s\"", path);
417 ncopen(
const char *path,
int mode)
420 const int status =
nc_open(path, mode, &ncid);
423 nc_advise(
"ncopen", status,
"filename \"%s\"", path);
436 nc_advise(
"ncredef", status,
"ncid %d", ncid);
449 nc_advise(
"ncendef", status,
"ncid %d", ncid);
462 nc_advise(
"ncclose", status,
"ncid %d", ncid);
480 const int status =
nc_inq(ncid, &nd, &nv, &na, recdim);
484 nc_advise(
"ncinquire", status,
"ncid %d", ncid);
505 const int status =
nc_sync(ncid);
508 nc_advise(
"ncsync", status,
"ncid %d", ncid);
522 nc_advise(
"ncabort", status,
"ncid %d", ncid);
540 nc_advise(
"ncdimdef", status,
"ncid %d", ncid);
543 status =
nc_def_dim(ncid, name, (
size_t)length, &dimid);
546 nc_advise(
"ncdimdef", status,
"ncid %d", ncid);
554 ncdimid(
int ncid,
const char* name)
560 nc_advise(
"ncdimid", status,
"ncid %d", ncid);
576 const int status =
nc_inq_dim(ncid, dimid, name, &ll);
580 nc_advise(
"ncdiminq", status,
"ncid %d", ncid);
602 nc_advise(
"ncdimrename", status,
"ncid %d", ncid);
619 const int status =
nc_def_var(ncid, name, datatype, ndims, dim, &varid);
622 nc_advise(
"ncvardef", status,
"ncid %d", ncid);
639 nc_advise(
"ncvarid", status,
"ncid %d", ncid);
658 const int status =
nc_inq_var(ncid, varid, name, datatype,
663 nc_advise(
"ncvarinq", status,
"ncid %d", ncid);
687 A_DECL(coordp,
size_t, (
size_t)ndims, index);
688 A_INIT(coordp,
size_t, (
size_t)ndims, index);
690 const int status =
nc_put_var1(ncid, varid, coordp, value);
694 nc_advise(
"ncvarput1", status,
"ncid %d", ncid);
711 A_DECL(coordp,
size_t, ndims, index);
712 A_INIT(coordp,
size_t, ndims, index);
714 const int status =
nc_get_var1(ncid, varid, coordp, value);
718 nc_advise(
"ncdimid", status,
"ncid %d", ncid);
736 A_DECL(stp,
size_t, ndims, start);
737 A_DECL(cntp,
size_t, ndims, count);
738 A_INIT(stp,
size_t, ndims, start);
739 A_INIT(cntp,
size_t, ndims, count);
741 const int status =
nc_put_vara(ncid, varid, stp, cntp, value);
746 nc_advise(
"ncvarput", status,
"ncid %d", ncid);
764 A_DECL(stp,
size_t, ndims, start);
765 A_DECL(cntp,
size_t, ndims, count);
766 A_INIT(stp,
size_t, ndims, start);
767 A_INIT(cntp,
size_t, ndims, count);
769 const int status =
nc_get_vara(ncid, varid, stp, cntp, value);
774 nc_advise(
"ncvarget", status,
"ncid %d; varid %d", ncid, varid);
793 return ncvarput(ncid, varid, start, count, value);
798 A_DECL(stp,
size_t, ndims, start);
799 A_DECL(cntp,
size_t, ndims, count);
800 A_DECL(strdp, ptrdiff_t, ndims, stride);
801 A_INIT(stp,
size_t, ndims, start);
802 A_INIT(cntp,
size_t, ndims, count);
803 A_INIT(strdp, ptrdiff_t, ndims, stride);
805 const int status =
nc_put_vars(ncid, varid, stp, cntp, strdp, value);
811 nc_advise(
"ncvarputs", status,
"ncid %d", ncid);
831 return ncvarget(ncid, varid, start, count, value);
835 A_DECL(stp,
size_t, ndims, start);
836 A_DECL(cntp,
size_t, ndims, count);
837 A_DECL(strdp, ptrdiff_t, ndims, stride);
838 A_INIT(stp,
size_t, ndims, start);
839 A_INIT(cntp,
size_t, ndims, count);
840 A_INIT(strdp, ptrdiff_t, ndims, stride);
842 const int status =
nc_get_vars(ncid, varid, stp, cntp, strdp, value);
848 nc_advise(
"ncvargets", status,
"ncid %d", ncid);
870 return ncvarputs(ncid, varid, start, count, stride, value);
883 el_size = nctypelen(type);
884 imp = (ptrdiff_t*) malloc(ndims *
sizeof(ptrdiff_t));
885 for (i=0; i<ndims; i++) imp[i] = map[i] / el_size;
889 A_DECL(stp,
size_t, ndims, start);
890 A_DECL(cntp,
size_t, ndims, count);
891 A_DECL(strdp, ptrdiff_t, ndims, stride);
892 A_INIT(stp,
size_t, ndims, start);
893 A_INIT(cntp,
size_t, ndims, count);
894 A_INIT(strdp, ptrdiff_t, ndims, stride);
897 stp, cntp, strdp, imp, value);
898 if (imp!=NULL) free(imp);
904 nc_advise(
"ncvarputg", status,
"ncid %d", ncid);
927 return ncvargets(ncid, varid, start, count, stride, value);
940 el_size = nctypelen(type);
941 imp = (ptrdiff_t*) malloc(ndims *
sizeof(ptrdiff_t));
942 for (i=0; i<ndims; i++) imp[i] = map[i] / el_size;
946 A_DECL(stp,
size_t, ndims, start);
947 A_DECL(cntp,
size_t, ndims, count);
948 A_DECL(strdp, ptrdiff_t, ndims, stride);
949 A_INIT(stp,
size_t, ndims, start);
950 A_INIT(cntp,
size_t, ndims, count);
951 A_INIT(strdp, ptrdiff_t, ndims, stride);
954 stp, cntp, strdp, imp, value);
955 if (imp!=NULL) free(imp);
961 nc_advise(
"ncvargetg", status,
"ncid %d", ncid);
981 nc_advise(
"ncvarrename", status,
"ncid %d", ncid);
998 const int status =
nc_put_att(ncid, varid, name, datatype, len, value);
1001 nc_advise(
"ncattput", status,
"ncid %d", ncid);
1018 const int status =
nc_inq_att(ncid, varid, name, datatype, &ll);
1021 nc_advise(
"ncattinq", status,
1022 "ncid %d; varid %d; attname \"%s\"",
1043 const int status =
nc_get_att(ncid, varid, name, value);
1046 nc_advise(
"ncattget", status,
"ncid %d", ncid);
1062 const int status = nc_copy_att(ncid_in, varid_in, name, ncid_out, varid_out);
1065 nc_advise(
"ncattcopy", status,
"%s", name);
1083 nc_advise(
"ncattname", status,
"ncid %d", ncid);
1098 const int status =
nc_rename_att(ncid, varid, name, newname);
1101 nc_advise(
"ncattrename", status,
"ncid %d", ncid);
1115 const int status =
nc_del_att(ncid, varid, name);
1118 nc_advise(
"ncattdel", status,
"ncid %d", ncid);
1135 const int status =
nc_set_fill(ncid, fillmode, &oldmode);
1138 nc_advise(
"ncsetfill", status,
"ncid %d", ncid);
1161 status = nc_inq_rec(ncid, &nrv, recvarids, rs);
1164 nc_advise(
"ncrecinq", status,
"ncid %d", ncid);
1165 if(rs != NULL) free(rs);
1169 if(nrecvars != NULL)
1170 *nrecvars = (int) nrv;
1172 if(recsizes != NULL)
1175 for(ii = 0; ii < nrv; ii++)
1177 recsizes[ii] = (long) rs[ii];
1181 if(rs != NULL) free(rs);
1194 const int status = nc_get_rec(ncid, (
size_t)recnum, datap);
1197 nc_advise(
"ncrecget", status,
"ncid %d", ncid);
1211 const int status = nc_put_rec(ncid, (
size_t)recnum, datap);
1214 nc_advise(
"ncrecput", status,
"ncid %d", ncid);
EXTERNL int nc_rename_att(int ncid, int varid, const char *name, const char *newname)
Rename an attribute.
#define MAX_NC_DIMS
Backward compatible alias.
#define NC_ENOMEM
Memory allocation (malloc) failure.
EXTERNL int nc_inq_vardimid(int ncid, int varid, int *dimidsp)
Learn the dimension IDs associated with a variable.
EXTERNL int nc_inq_att(int ncid, int varid, const char *name, nc_type *xtypep, size_t *lenp)
Return information about a netCDF attribute.
EXTERNL int nc_def_var(int ncid, const char *name, nc_type xtype, int ndims, const int *dimidsp, int *varidp)
Define a new variable.
EXTERNL int nc_def_dim(int ncid, const char *name, size_t len, int *idp)
Define a new dimension.
EXTERNL int nc_redef(int ncid)
Put open netcdf dataset into define mode.
EXTERNL int nc_rename_dim(int ncid, int dimid, const char *name)
Rename a dimension.
Main header file for the C API.
EXTERNL int nc_put_vara(int ncid, int varid, const size_t *startp, const size_t *countp, const void *op)
Write an array of values to a variable.
EXTERNL int nc_inq_dim(int ncid, int dimid, char *name, size_t *lenp)
Find the name and length of a dimension.
EXTERNL int nc_inq_varndims(int ncid, int varid, int *ndimsp)
Learn how many dimensions are associated with a variable.
EXTERNL int nc_put_varm(int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const void *op)
Write a mapped array of values to a variable.
EXTERNL int nc_inq(int ncid, int *ndimsp, int *nvarsp, int *nattsp, int *unlimdimidp)
Inquire about a file or group.
EXTERNL int nc_get_varm(int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, void *ip)
Read a mapped array from a variable.
int nc_type
The nc_type type is just an int.
EXTERNL int nc_put_vars(int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const void *op)
Write a strided array of values to a variable.
#define NC_EDIMSIZE
Invalid dimension size.
#define MAX_NC_VARS
Backward compatible alias.
EXTERNL int nc_rename_var(int ncid, int varid, const char *name)
Rename a variable.
EXTERNL int nc_del_att(int ncid, int varid, const char *name)
Delete an attribute.
EXTERNL int nc_close(int ncid)
Close an open netCDF dataset.
EXTERNL int nc_inq_dimlen(int ncid, int dimid, size_t *lenp)
Find the length of a dimension.
EXTERNL int nc_get_att(int ncid, int varid, const char *name, void *ip)
Get an attribute of any type.
EXTERNL int nc_abort(int ncid)
No longer necessary for user to invoke manually.
EXTERNL int nc_get_var1(int ncid, int varid, const size_t *indexp, void *ip)
Read a single datum from a variable.
EXTERNL int nc_put_var1(int ncid, int varid, const size_t *indexp, const void *op)
Write one datum.
EXTERNL int nc_set_fill(int ncid, int fillmode, int *old_modep)
Change the fill-value mode to improve write performance.
EXTERNL int nc_inq_vartype(int ncid, int varid, nc_type *xtypep)
Learn the type of a variable.
EXTERNL int nc_put_att(int ncid, int varid, const char *name, nc_type xtype, size_t len, const void *op)
Write an attribute.
#define NC_ISSYSERR(err)
The netcdf version 3 functions all return integer error status.
EXTERNL int nc_inq_varid(int ncid, const char *name, int *varidp)
Find the ID of a variable, from the name.
EXTERNL int nc_inq_dimid(int ncid, const char *name, int *idp)
Find the ID of a dimension from the name.
EXTERNL int nc_get_vars(int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, void *ip)
Read a strided array from a variable.
EXTERNL int nc_inq_unlimdim(int ncid, int *unlimdimidp)
Find the ID of the unlimited dimension.
#define NC_MAX_VARS
Maximum for classic library.
EXTERNL int nc_inq_var(int ncid, int varid, char *name, nc_type *xtypep, int *ndimsp, int *dimidsp, int *nattsp)
Learn about a variable.
#define NC_NOERR
No Error.
EXTERNL int nc_open(const char *path, int mode, int *ncidp)
Open an existing netCDF file.
EXTERNL int nc_enddef(int ncid)
Leave define mode.
EXTERNL const char * nc_strerror(int ncerr)
Given an error number, return an error message.
EXTERNL int nc_sync(int ncid)
Synchronize an open netcdf dataset to disk.
EXTERNL int nc_get_vara(int ncid, int varid, const size_t *startp, const size_t *countp, void *ip)
Read an array of values from a variable.
EXTERNL int nc_create(const char *path, int cmode, int *ncidp)
Create a new netCDF file.
EXTERNL int nc_inq_attname(int ncid, int varid, int attnum, char *name)
Find the name of an attribute.