Loading...
Searching...
No Matches
dv2i.c
Go to the documentation of this file.
#ifndef NO_NETCDF_2
#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include "netcdf.h"
#include <math.h>
MSC_EXTRA int ncopts = (NC_FATAL | NC_VERBOSE) ;
MSC_EXTRA int ncerr = NC_NOERR ;
#if SIZEOF_LONG == SIZEOF_SIZE_T
/*
* We don't have to copy the arguments to switch from 'long'
* to 'size_t' or 'ptrdiff_t'. Use dummy macros.
*/
# define NDIMS_DECL
# define A_DECL(name, type, ndims, rhs) \
const type *const name = ((const type *)(rhs))
# define A_FREE(name)
# define A_INIT(lhs, type, ndims, rhs)
#else
/*
* We do have to copy the arguments to switch from 'long'
* to 'size_t' or 'ptrdiff_t'. In my tests on an SGI,
* any additional cost was lost in measurement variation.
*
* This stanza is true on Windows with MinGW-64
*/
# include "onstack.h"
static int
nvdims(int ncid, int varid)
{
int ndims=-1, status;
if ((status = nc_inq_varndims(ncid, varid, &ndims)))
{
nc_advise("ncvdims", status, "ncid %d", ncid);
return -1;
}
return ndims;
}
/* Used to avoid errors on 64-bit windows related to
c89 macros and flow control/conditionals. */
static void* nvmalloc(off_t size) {
if(size < 0)
return NULL;
return malloc(size);
}
#define NDIMS_DECL const int ndims = nvdims(ncid, varid); \
# define A_DECL(name, type, ndims, rhs) \
type *const name = (type*) nvmalloc((ndims) * sizeof(type))
#if 0
ALLOC_ONSTACK(name, type, ndims)
#endif
# define A_FREE(name) \
FREE_ONSTACK(name)
# define A_INIT(lhs, type, ndims, rhs) \
{ \
if((off_t)ndims >= 0) { \
const long *lp = rhs; \
type *tp = lhs; \
type *const end = lhs + ndims; \
while(tp < end) \
{ \
*tp++ = (type) *lp++; \
} \
} \
} \
\
if ((off_t)ndims < 0) {nc_advise("nvdims",NC_EMAXDIMS,"ndims %d",ndims); return -1;}
#endif
typedef signed char schar;
static int
numrecvars(int ncid, int* nrecvarsp, int *recvarids)
{
int status = NC_NOERR;
int nvars = 0;
int ndims = 0;
int nrecvars = 0;
int varid;
int recdimid;
int dimids[MAX_NC_DIMS];
status = nc_inq_nvars(ncid, &nvars);
if(status != NC_NOERR)
return status;
status = nc_inq_unlimdim(ncid, &recdimid);
if(status != NC_NOERR)
return status;
if (recdimid == -1) {
*nrecvarsp = 0;
return NC_NOERR;
}
nrecvars = 0;
for (varid = 0; varid < nvars; varid++) {
status = nc_inq_varndims(ncid, varid, &ndims);
if(status != NC_NOERR)
return status;
status = nc_inq_vardimid(ncid, varid, dimids);
if(status != NC_NOERR)
return status;
if (ndims > 0 && dimids[0] == recdimid) {
if (recvarids != NULL)
recvarids[nrecvars] = varid;
nrecvars++;
}
}
*nrecvarsp = nrecvars;
return NC_NOERR;
}
static int
ncrecsize(int ncid, int varid, size_t *recsizep)
{
int status = NC_NOERR;
int recdimid;
nc_type type;
int ndims;
int dimids[MAX_NC_DIMS];
int id;
int size;
*recsizep = 0;
status = nc_inq_unlimdim(ncid, &recdimid);
if(status != NC_NOERR)
return status;
status = nc_inq_vartype(ncid, varid, &type);
if(status != NC_NOERR)
return status;
status = nc_inq_varndims(ncid, varid, &ndims);
if(status != NC_NOERR)
return status;
status = nc_inq_vardimid(ncid, varid, dimids);
if(status != NC_NOERR)
return status;
if (ndims == 0 || dimids[0] != recdimid) {
return NC_NOERR;
}
size = nctypelen(type);
for (id = 1; id < ndims; id++) {
size_t len;
status = nc_inq_dimlen(ncid, dimids[id], &len);
if(status != NC_NOERR)
return status;
size *= (int)len;
}
*recsizep = (size_t)size;
return NC_NOERR;
}
static int
dimsizes(int ncid, int varid, size_t *sizes)
{
int status = NC_NOERR;
int ndims;
int id;
int dimids[MAX_NC_DIMS];
status = nc_inq_varndims(ncid, varid, &ndims);
if(status != NC_NOERR)
return status;
status = nc_inq_vardimid(ncid, varid, dimids);
if(status != NC_NOERR)
return status;
if (ndims == 0 || sizes == NULL)
return NC_NOERR;
for (id = 0; id < ndims; id++) {
size_t len;
status = nc_inq_dimlen(ncid, dimids[id], &len);
if(status != NC_NOERR)
return status;
sizes[id] = len;
}
return NC_NOERR;
}
int
nc_inq_rec(
int ncid,
size_t *nrecvarsp,
int *recvarids,
size_t *recsizes)
{
int status = NC_NOERR;
int nvars = 0;
int recdimid;
int varid;
int rvarids[MAX_NC_VARS];
int nrvars = 0;
status = nc_inq_nvars(ncid, &nvars);
if(status != NC_NOERR)
return status;
status = nc_inq_unlimdim(ncid, &recdimid);
if(status != NC_NOERR)
return status;
if (recdimid == -1)
return NC_NOERR;
status = numrecvars(ncid, &nrvars, rvarids);
if(status != NC_NOERR)
return status;
if (nrecvarsp != NULL)
*nrecvarsp = (size_t)nrvars;
if (recvarids != NULL)
for (varid = 0; varid < nrvars; varid++)
recvarids[varid] = rvarids[varid];
if (recsizes != NULL)
for (varid = 0; varid < nrvars; varid++) {
size_t rsize;
status = ncrecsize(ncid, rvarids[varid], &rsize);
if (status != NC_NOERR)
return status;
recsizes[varid] = rsize;
}
return NC_NOERR;
}
int
nc_put_rec(
int ncid,
size_t recnum,
void* const* datap)
{
int status = NC_NOERR;
int varid;
int rvarids[MAX_NC_VARS];
int nrvars;
size_t start[MAX_NC_DIMS];
size_t edges[MAX_NC_DIMS];
status = numrecvars(ncid, &nrvars, rvarids);
if(status != NC_NOERR)
return status;
if (nrvars == 0)
return NC_NOERR;
start[0] = recnum;
for (varid = 1; varid < nrvars; varid++)
start[varid] = 0;
for (varid = 0; varid < nrvars; varid++) {
if (datap[varid] != NULL) {
status = dimsizes(ncid, rvarids[varid], edges);
if(status != NC_NOERR)
return status;
edges[0] = 1; /* only 1 record's worth */
status = nc_put_vara(ncid, rvarids[varid], start, edges, datap[varid]);
if(status != NC_NOERR)
return status;
}
}
return 0;
}
int
nc_get_rec(
int ncid,
size_t recnum,
void **datap)
{
int status = NC_NOERR;
int varid;
int rvarids[MAX_NC_VARS];
int nrvars;
size_t start[MAX_NC_DIMS];
size_t edges[MAX_NC_DIMS];
status = numrecvars(ncid, &nrvars, rvarids);
if(status != NC_NOERR)
return status;
if (nrvars == 0)
return NC_NOERR;
start[0] = recnum;
for (varid = 1; varid < nrvars; varid++)
start[varid] = 0;
for (varid = 0; varid < nrvars; varid++) {
if (datap[varid] != NULL) {
status = dimsizes(ncid, rvarids[varid], edges);
if(status != NC_NOERR)
return status;
edges[0] = 1; /* only 1 record's worth */
status = nc_get_vara(ncid, rvarids[varid], start, edges, datap[varid]);
if(status != NC_NOERR)
return status;
}
}
return 0;
}
void
nc_advise(const char *routine_name, int err, const char *fmt,...)
{
va_list args;
if(NC_ISSYSERR(err))
ncerr = NC_SYSERR;
else
ncerr = err;
if( ncopts & NC_VERBOSE )
{
(void) fprintf(stderr,"%s: ", routine_name);
va_start(args ,fmt);
(void) vfprintf(stderr,fmt,args);
va_end(args);
if(err != NC_NOERR)
{
(void) fprintf(stderr,": %s",
nc_strerror(err));
}
(void) fputc('\n',stderr);
(void) fflush(stderr); /* to ensure log files are current */
}
if( (ncopts & NC_FATAL) && err != NC_NOERR )
{
exit(ncopts);
}
}
/* End error handling */
int
nccreate(const char* path, int cmode)
{
int ncid;
const int status = nc_create(path, cmode, &ncid);
if(status != NC_NOERR)
{
nc_advise("nccreate", status, "filename \"%s\"", path);
return -1;
}
return ncid;
}
int
ncopen(const char *path, int mode)
{
int ncid;
const int status = nc_open(path, mode, &ncid);
if(status != NC_NOERR)
{
nc_advise("ncopen", status, "filename \"%s\"", path);
return -1;
}
return ncid;
}
int
ncredef(int ncid)
{
const int status = nc_redef(ncid);
if(status != NC_NOERR)
{
nc_advise("ncredef", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncendef(int ncid)
{
const int status = nc_enddef(ncid);
if(status != NC_NOERR)
{
nc_advise("ncendef", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncclose(int ncid)
{
const int status = nc_close(ncid);
if(status != NC_NOERR)
{
nc_advise("ncclose", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncinquire(
int ncid,
int* ndims,
int* nvars,
int* natts,
int* recdim
)
{
int nd, nv, na;
const int status = nc_inq(ncid, &nd, &nv, &na, recdim);
if(status != NC_NOERR)
{
nc_advise("ncinquire", status, "ncid %d", ncid);
return -1;
}
/* else */
if(ndims != NULL)
*ndims = (int) nd;
if(nvars != NULL)
*nvars = (int) nv;
if(natts != NULL)
*natts = (int) na;
return ncid;
}
int
ncsync(int ncid)
{
const int status = nc_sync(ncid);
if(status != NC_NOERR)
{
nc_advise("ncsync", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncabort(int ncid)
{
const int status = nc_abort(ncid);
if(status != NC_NOERR)
{
nc_advise("ncabort", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncdimdef(
int ncid,
const char* name,
long length
)
{
int dimid;
int status = NC_NOERR;
if(length < 0) {
status = NC_EDIMSIZE;
nc_advise("ncdimdef", status, "ncid %d", ncid);
return -1;
}
status = nc_def_dim(ncid, name, (size_t)length, &dimid);
if(status != NC_NOERR)
{
nc_advise("ncdimdef", status, "ncid %d", ncid);
return -1;
}
return dimid;
}
int
ncdimid(int ncid, const char* name)
{
int dimid;
const int status = nc_inq_dimid(ncid, name, &dimid);
if(status != NC_NOERR)
{
nc_advise("ncdimid", status, "ncid %d", ncid);
return -1;
}
return dimid;
}
int
ncdiminq(
int ncid,
int dimid,
char* name,
long* length
)
{
size_t ll;
const int status = nc_inq_dim(ncid, dimid, name, &ll);
if(status != NC_NOERR)
{
nc_advise("ncdiminq", status, "ncid %d", ncid);
return -1;
}
/* else */
if(length != NULL)
*length = (int) ll;
return dimid;
}
int
ncdimrename(
int ncid,
int dimid,
const char* name
)
{
const int status = nc_rename_dim(ncid, dimid, name);
if(status != NC_NOERR)
{
nc_advise("ncdimrename", status, "ncid %d", ncid);
return -1;
}
return dimid;
}
int
ncvardef(
int ncid,
const char* name,
nc_type datatype,
int ndims,
const int* dim
)
{
int varid = -1;
const int status = nc_def_var(ncid, name, datatype, ndims, dim, &varid);
if(status != NC_NOERR)
{
nc_advise("ncvardef", status, "ncid %d", ncid);
return -1;
}
return varid;
}
int
ncvarid(
int ncid,
const char* name
)
{
int varid = -1;
const int status = nc_inq_varid(ncid, name, &varid);
if(status != NC_NOERR)
{
nc_advise("ncvarid", status, "ncid %d", ncid);
return -1;
}
return varid;
}
int
ncvarinq(
int ncid,
int varid,
char* name,
nc_type* datatype,
int* ndims,
int* dim,
int* natts
)
{
int nd, na;
const int status = nc_inq_var(ncid, varid, name, datatype,
&nd, dim, &na);
if(status != NC_NOERR)
{
nc_advise("ncvarinq", status, "ncid %d", ncid);
return -1;
}
/* else */
if(ndims != NULL)
*ndims = (int) nd;
if(natts != NULL)
*natts = (int) na;
return varid;
}
int
ncvarput1(
int ncid,
int varid,
const long* index,
const void* value
)
{
NDIMS_DECL
A_DECL(coordp, size_t, (size_t)ndims, index);
A_INIT(coordp, size_t, (size_t)ndims, index);
{
const int status = nc_put_var1(ncid, varid, coordp, value);
A_FREE(coordp);
if(status != NC_NOERR)
{
nc_advise("ncvarput1", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
int
ncvarget1(
int ncid,
int varid,
const long* index,
void* value
)
{
NDIMS_DECL
A_DECL(coordp, size_t, ndims, index);
A_INIT(coordp, size_t, ndims, index);
{
const int status = nc_get_var1(ncid, varid, coordp, value);
A_FREE(coordp);
if(status != NC_NOERR)
{
nc_advise("ncdimid", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
int
ncvarput(
int ncid,
int varid,
const long* start,
const long* count,
const void* value
)
{
NDIMS_DECL
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
{
const int status = nc_put_vara(ncid, varid, stp, cntp, value);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvarput", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
int
ncvarget(
int ncid,
int varid,
const long* start,
const long* count,
void* value
)
{
NDIMS_DECL
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
{
const int status = nc_get_vara(ncid, varid, stp, cntp, value);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvarget", status, "ncid %d; varid %d", ncid, varid);
return -1;
}
}
return 0;
}
int
ncvarputs(
int ncid,
int varid,
const long* start,
const long* count,
const long* stride,
const void* value
)
{
if(stride == NULL)
return ncvarput(ncid, varid, start, count, value);
/* else */
{
NDIMS_DECL
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_DECL(strdp, ptrdiff_t, ndims, stride);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
A_INIT(strdp, ptrdiff_t, ndims, stride);
{
const int status = nc_put_vars(ncid, varid, stp, cntp, strdp, value);
A_FREE(strdp);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvarputs", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
}
int
ncvargets(
int ncid,
int varid,
const long* start,
const long* count,
const long* stride,
void* value
)
{
if(stride == NULL)
return ncvarget(ncid, varid, start, count, value);
/* else */
{
NDIMS_DECL
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_DECL(strdp, ptrdiff_t, ndims, stride);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
A_INIT(strdp, ptrdiff_t, ndims, stride);
{
const int status = nc_get_vars(ncid, varid, stp, cntp, strdp, value);
A_FREE(strdp);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvargets", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
}
int
ncvarputg(
int ncid,
int varid,
const long* start,
const long* count,
const long* stride,
const long* map,
const void* value
)
{
int ndims = 0;
if(map == NULL)
return ncvarputs(ncid, varid, start, count, stride, value);
/* else */
{
ptrdiff_t *imp=NULL;
if (map != NULL) {
int ret = NC_NOERR;
/* make map[ndims-1] number of elements instead of bytes */
int i, el_size;
nc_type type;
ret = nc_inq_varndims(ncid, varid, &ndims);
if(ret) return ret;
ret = nc_inq_vartype(ncid, varid, &type);
if(ret) return ret;
el_size = nctypelen(type);
imp = (ptrdiff_t*) malloc((size_t)ndims * sizeof(ptrdiff_t));
for (i=0; i<ndims; i++) imp[i] = map[i] / el_size;
}
{
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_DECL(strdp, ptrdiff_t, ndims, stride);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
A_INIT(strdp, ptrdiff_t, ndims, stride);
{
const int status = nc_put_varm(ncid, varid,
stp, cntp, strdp, imp, value);
if (imp!=NULL) free(imp);
A_FREE(strdp);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvarputg", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
}
}
int
ncvargetg(
int ncid,
int varid,
const long* start,
const long* count,
const long* stride,
const long* map,
void* value
)
{
int ndims = 0;
if(map == NULL)
return ncvargets(ncid, varid, start, count, stride, value);
/* else */
{
ptrdiff_t *imp=NULL;
if (map != NULL) {
int ret = NC_NOERR;
/* make map[ndims-1] number of elements instead of bytes */
int i, el_size;
nc_type type;
ret = nc_inq_varndims(ncid, varid, &ndims);
if(ret) return ret;
ret = nc_inq_vartype(ncid, varid, &type);
if(ret) return ret;
el_size = nctypelen(type);
imp = (ptrdiff_t*) malloc((size_t)ndims * sizeof(ptrdiff_t));
for (i=0; i<ndims; i++) imp[i] = map[i] / el_size;
}
{
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_DECL(strdp, ptrdiff_t, ndims, stride);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
A_INIT(strdp, ptrdiff_t, ndims, stride);
{
const int status = nc_get_varm(ncid, varid,
stp, cntp, strdp, imp, value);
if (imp!=NULL) free(imp);
A_FREE(strdp);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvargetg", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
}
}
int
ncvarrename(
int ncid,
int varid,
const char* name
)
{
const int status = nc_rename_var(ncid, varid, name);
if(status != NC_NOERR)
{
nc_advise("ncvarrename", status, "ncid %d", ncid);
return -1;
}
return varid;
}
int
ncattput(
int ncid,
int varid,
const char* name,
nc_type datatype,
int len,
const void* value
)
{
const int status = nc_put_att(ncid, varid, name, datatype, (size_t)len, value);
if(status != NC_NOERR)
{
nc_advise("ncattput", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncattinq(
int ncid,
int varid,
const char* name,
nc_type* datatype,
int* len
)
{
size_t ll;
const int status = nc_inq_att(ncid, varid, name, datatype, &ll);
if(status != NC_NOERR)
{
nc_advise("ncattinq", status,
"ncid %d; varid %d; attname \"%s\"",
ncid, varid, name);
return -1;
}
if(len != NULL)
*len = (int) ll;
return 1;
}
int
ncattget(
int ncid,
int varid,
const char* name,
void* value
)
{
const int status = nc_get_att(ncid, varid, name, value);
if(status != NC_NOERR)
{
nc_advise("ncattget", status, "ncid %d", ncid);
return -1;
}
return 1;
}
int
ncattcopy(
int ncid_in,
int varid_in,
const char* name,
int ncid_out,
int varid_out
)
{
const int status = nc_copy_att(ncid_in, varid_in, name, ncid_out, varid_out);
if(status != NC_NOERR)
{
nc_advise("ncattcopy", status, "%s", name);
return -1;
}
return 0;
}
int
ncattname(
int ncid,
int varid,
int attnum,
char* name
)
{
const int status = nc_inq_attname(ncid, varid, attnum, name);
if(status != NC_NOERR)
{
nc_advise("ncattname", status, "ncid %d", ncid);
return -1;
}
return attnum;
}
int
ncattrename(
int ncid,
int varid,
const char* name,
const char* newname
)
{
const int status = nc_rename_att(ncid, varid, name, newname);
if(status != NC_NOERR)
{
nc_advise("ncattrename", status, "ncid %d", ncid);
return -1;
}
return 1;
}
int
ncattdel(
int ncid,
int varid,
const char* name
)
{
const int status = nc_del_att(ncid, varid, name);
if(status != NC_NOERR)
{
nc_advise("ncattdel", status, "ncid %d", ncid);
return -1;
}
return 1;
}
#endif /* NO_NETCDF_2 */
#ifndef NO_NETCDF_2
int
ncsetfill(
int ncid,
int fillmode
)
{
int oldmode = -1;
const int status = nc_set_fill(ncid, fillmode, &oldmode);
if(status != NC_NOERR)
{
nc_advise("ncsetfill", status, "ncid %d", ncid);
return -1;
}
return oldmode;
}
int
ncrecinq(
int ncid,
int* nrecvars,
int* recvarids,
long* recsizes
)
{
size_t nrv = 0;
size_t *rs = NULL;
int status = NC_NOERR;
rs = (size_t*)malloc(sizeof(size_t)*NC_MAX_VARS);
if(rs == NULL)
return NC_ENOMEM;
status = nc_inq_rec(ncid, &nrv, recvarids, rs);
if(status != NC_NOERR)
{
nc_advise("ncrecinq", status, "ncid %d", ncid);
if(rs != NULL) free(rs);
return -1;
}
if(nrecvars != NULL)
*nrecvars = (int) nrv;
if(recsizes != NULL)
{
size_t ii;
for(ii = 0; ii < nrv; ii++)
{
recsizes[ii] = (long) rs[ii];
}
}
if(rs != NULL) free(rs);
return (int) nrv;
}
int
ncrecget(
int ncid,
long recnum,
void** datap
)
{
const int status = nc_get_rec(ncid, (size_t)recnum, datap);
if(status != NC_NOERR)
{
nc_advise("ncrecget", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncrecput(
int ncid,
long recnum,
void* const* datap
)
{
const int status = nc_put_rec(ncid, (size_t)recnum, datap);
if(status != NC_NOERR)
{
nc_advise("ncrecput", status, "ncid %d", ncid);
return -1;
}
return 0;
}
#endif /* NO_NETCDF_2 */
NDIMS_DECL
#define NDIMS_DECL
NDIMS declaration.
Definition dv2i.c:45
schar
signed char schar
Signed character type.
Definition dv2i.c:121
ncrecsize
static int ncrecsize(int ncid, int varid, size_t *recsizep)
Computes record size (in bytes) of the record variable with a specified variable id.
Definition dv2i.c:188
A_INIT
#define A_INIT(lhs, type, ndims, rhs)
Init a variable.
Definition dv2i.c:53
dimsizes
static int dimsizes(int ncid, int varid, size_t *sizes)
Retrieves the dimension sizes of a variable with a specified variable id in an open netCDF file.
Definition dv2i.c:240
A_FREE
#define A_FREE(name)
Free a variable.
Definition dv2i.c:51
numrecvars
static int numrecvars(int ncid, int *nrecvarsp, int *recvarids)
Computes number of record variables in an open netCDF file, and an array of the record variable ids,...
Definition dv2i.c:136
nc_put_att
EXTERNL int nc_put_att(int ncid, int varid, const char *name, nc_type xtype, size_t len, const void *op)
Write an attribute of any type.
Definition dattput.c:222
nc_get_att
EXTERNL int nc_get_att(int ncid, int varid, const char *name, void *ip)
Get an attribute of any type.
Definition dattget.c:133
nc_inq_att
EXTERNL int nc_inq_att(int ncid, int varid, const char *name, nc_type *xtypep, size_t *lenp)
Return information about a netCDF attribute.
Definition dattinq.c:86
nc_del_att
EXTERNL int nc_del_att(int ncid, int varid, const char *name)
Delete an attribute.
Definition datt.c:177
nc_rename_att
EXTERNL int nc_rename_att(int ncid, int varid, const char *name, const char *newname)
Rename an attribute.
Definition datt.c:113
nc_inq_attname
EXTERNL int nc_inq_attname(int ncid, int varid, int attnum, char *name)
Find the name of an attribute.
Definition dattinq.c:255
nc_close
EXTERNL int nc_close(int ncid)
Close an open netCDF dataset.
Definition dfile.c:1334
nc_abort
EXTERNL int nc_abort(int ncid)
No longer necessary for user to invoke manually.
Definition dfile.c:1281
nc_create
EXTERNL int nc_create(const char *path, int cmode, int *ncidp)
Create a new netCDF file.
Definition dfile.c:432
nc_inq
EXTERNL int nc_inq(int ncid, int *ndimsp, int *nvarsp, int *nattsp, int *unlimdimidp)
Inquire about a file or group.
Definition dfile.c:1669
nc_set_fill
EXTERNL int nc_set_fill(int ncid, int fillmode, int *old_modep)
Change the fill-value mode to improve write performance.
Definition dfile.c:1508
nc_enddef
EXTERNL int nc_enddef(int ncid)
Leave define mode.
Definition dfile.c:1061
nc_redef
EXTERNL int nc_redef(int ncid)
Put open netcdf dataset into define mode.
Definition dfile.c:997
nc_open
EXTERNL int nc_open(const char *path, int mode, int *ncidp)
Open an existing netCDF file.
Definition dfile.c:698
nc_sync
EXTERNL int nc_sync(int ncid)
Synchronize an open netcdf dataset to disk.
Definition dfile.c:1229
nc_inq_dimlen
EXTERNL int nc_inq_dimlen(int ncid, int dimid, size_t *lenp)
Find the length of a dimension.
Definition ddim.c:467
nc_def_dim
EXTERNL int nc_def_dim(int ncid, const char *name, size_t len, int *idp)
Define a new dimension.
Definition ddim.c:121
nc_rename_dim
EXTERNL int nc_rename_dim(int ncid, int dimid, const char *name)
Rename a dimension.
Definition ddim.c:285
nc_inq_dim
EXTERNL int nc_inq_dim(int ncid, int dimid, char *name, size_t *lenp)
Find the name and length of a dimension.
Definition ddim.c:216
nc_inq_unlimdim
EXTERNL int nc_inq_unlimdim(int ncid, int *unlimdimidp)
Find the ID of the unlimited dimension.
Definition ddim.c:350
nc_inq_dimid
EXTERNL int nc_inq_dimid(int ncid, const char *name, int *idp)
Find the ID of a dimension from the name.
Definition ddim.c:152
nc_strerror
EXTERNL const char * nc_strerror(int ncerr)
Given an error number, return an error message.
Definition derror.c:87
ncvardef
int ncvardef(int ncid, const char *name, nc_type datatype, int ndims, const int *dim)
Define a variable.
Definition dv2i.c:856
ncclose
int ncclose(int ncid)
Close a file.
Definition dv2i.c:606
ncvarputg
int ncvarputg(int ncid, int varid, const long *start, const long *count, const long *stride, const long *map, const void *value)
Write mapped data.
Definition dv2i.c:1231
ncattget
int ncattget(int ncid, int varid, const char *name, void *value)
Read an attribute.
Definition dv2i.c:1479
ncattinq
int ncattinq(int ncid, int varid, const char *name, nc_type *datatype, int *len)
Learn about an attribute.
Definition dv2i.c:1440
ncattrename
int ncattrename(int ncid, int varid, const char *name, const char *newname)
Rename an attribute.
Definition dv2i.c:1574
ncattname
int ncattname(int ncid, int varid, int attnum, char *name)
Learn attribute name from its number.
Definition dv2i.c:1543
ncvarput1
int ncvarput1(int ncid, int varid, const long *index, const void *value)
Write 1 data value.
Definition dv2i.c:965
ncvarid
int ncvarid(int ncid, const char *name)
Learn a variable ID from the name.
Definition dv2i.c:887
nccreate
int nccreate(const char *path, int cmode)
Create a netCDF file.
Definition dv2i.c:511
ncendef
int ncendef(int ncid)
End define mode for file.
Definition dv2i.c:583
ncopen
int ncopen(const char *path, int mode)
Open a netCDF file.
Definition dv2i.c:536
ncrecput
int ncrecput(int ncid, long recnum, void *const *datap)
Write one record's worth of data, except don't write to variables for which the address of the data t...
Definition dv2i.c:1754
ncattcopy
int ncattcopy(int ncid_in, int varid_in, const char *name, int ncid_out, int varid_out)
Copy an attribute.
Definition dv2i.c:1511
ncdimrename
int ncdimrename(int ncid, int dimid, const char *name)
Rename a dimension.
Definition dv2i.c:825
nc_get_rec
int nc_get_rec(int ncid, size_t recnum, void **datap)
Read one record's worth of data, except don't read from variables for which the address of the data t...
Definition dv2i.c:416
ncattdel
int ncattdel(int ncid, int varid, const char *name)
Delete an attribute.
Definition dv2i.c:1604
ncvarputs
int ncvarputs(int ncid, int varid, const long *start, const long *count, const long *stride, const void *value)
Write strided data.
Definition dv2i.c:1125
ncvarput
int ncvarput(int ncid, int varid, const long *start, const long *count, const void *value)
Write some data.
Definition dv2i.c:1040
ncdiminq
int ncdiminq(int ncid, int dimid, char *name, long *length)
Learn about a dimension.
Definition dv2i.c:788
ncvarget1
int ncvarget1(int ncid, int varid, const long *index, void *value)
Read 1 data value.
Definition dv2i.c:1002
ncvargetg
int ncvargetg(int ncid, int varid, const long *start, const long *count, const long *stride, const long *map, void *value)
Read mapped data.
Definition dv2i.c:1304
ncinquire
int ncinquire(int ncid, int *ndims, int *nvars, int *natts, int *recdim)
Learn about a file.
Definition dv2i.c:635
ncvarinq
int ncvarinq(int ncid, int varid, char *name, nc_type *datatype, int *ndims, int *dim, int *natts)
Learn about a variable.
Definition dv2i.c:920
ncattput
int ncattput(int ncid, int varid, const char *name, nc_type datatype, int len, const void *value)
Write an attribute.
Definition dv2i.c:1405
nc_advise
void nc_advise(const char *routine_name, int err, const char *fmt,...)
Show an error message and exit (based on ncopts).
Definition dv2i.c:466
ncabort
int ncabort(int ncid)
Abort defining a file.
Definition dv2i.c:700
ncsync
int ncsync(int ncid)
Sync a file.
Definition dv2i.c:677
ncrecinq
int ncrecinq(int ncid, int *nrecvars, int *recvarids, long *recsizes)
Learn record variables and the lengths of the record dimension.
Definition dv2i.c:1666
ncrecget
int ncrecget(int ncid, long recnum, void **datap)
Read one record's worth of data, except don't read from variables for which the address of the data t...
Definition dv2i.c:1723
ncsetfill
int ncsetfill(int ncid, int fillmode)
Set the fill mode.
Definition dv2i.c:1636
ncdimdef
int ncdimdef(int ncid, const char *name, long length)
Define a dimension.
Definition dv2i.c:726
ncvarget
int ncvarget(int ncid, int varid, const long *start, const long *count, void *value)
Read some data.
Definition dv2i.c:1082
ncvargets
int ncvargets(int ncid, int varid, const long *start, const long *count, const long *stride, void *value)
Read strided data.
Definition dv2i.c:1178
nc_put_rec
int nc_put_rec(int ncid, size_t recnum, void *const *datap)
Write one record's worth of data, except don't write to variables for which the address of the data t...
Definition dv2i.c:355
ncredef
int ncredef(int ncid)
Put file in define mode.
Definition dv2i.c:560
ncvarrename
int ncvarrename(int ncid, int varid, const char *name)
Rename a variable.
Definition dv2i.c:1373
ncdimid
int ncdimid(int ncid, const char *name)
Find dimension ID from name.
Definition dv2i.c:761
nc_inq_rec
int nc_inq_rec(int ncid, size_t *nrecvarsp, int *recvarids, size_t *recsizes)
Retrieves the number of record variables, the record variable ids, and the record size of each record...
Definition dv2i.c:289
nc_inq_varndims
EXTERNL int nc_inq_varndims(int ncid, int varid, int *ndimsp)
Learn how many dimensions are associated with a variable.
Definition dvarinq.c:202
nc_get_vars
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.
Definition dvarget.c:1173
nc_inq_vartype
EXTERNL int nc_inq_vartype(int ncid, int varid, nc_type *xtypep)
Learn the type of a variable.
Definition dvarinq.c:178
nc_inq_varid
EXTERNL int nc_inq_varid(int ncid, const char *name, int *varidp)
Find the ID of a variable, from the name.
Definition dvarinq.c:60
nc_put_varm
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.
Definition dvarput.c:1243
nc_get_vara
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.
Definition dvarget.c:746
nc_put_vars
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.
Definition dvarput.c:1048
nc_get_varm
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.
Definition dvarget.c:1370
nc_inq_var
EXTERNL int nc_inq_var(int ncid, int varid, char *name, nc_type *xtypep, int *ndimsp, int *dimidsp, int *nattsp)
Learn about a variable.
Definition dvarinq.c:124
nc_inq_vardimid
EXTERNL int nc_inq_vardimid(int ncid, int varid, int *dimidsp)
Learn the dimension IDs associated with a variable.
Definition dvarinq.c:225
nc_get_var1
EXTERNL int nc_get_var1(int ncid, int varid, const size_t *indexp, void *ip)
Read a single datum from a variable.
Definition dvarget.c:894
nc_def_var
EXTERNL int nc_def_var(int ncid, const char *name, nc_type xtype, int ndims, const int *dimidsp, int *varidp)
Define a new variable.
Definition dvar.c:214
nc_rename_var
EXTERNL int nc_rename_var(int ncid, int varid, const char *name)
Rename a variable.
Definition dvar.c:944
nc_put_var1
EXTERNL int nc_put_var1(int ncid, int varid, const size_t *indexp, const void *op)
Write one datum.
Definition dvarput.c:783
nc_put_vara
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.
Definition dvarput.c:633
netcdf.h
Main header file for the C API.
nc_inq_nvars
EXTERNL int nc_inq_nvars(int ncid, int *nvarsp)
Learn the number of variables in a file or group.
Definition dfile.c:1688
NC_MAX_VARS
#define NC_MAX_VARS
Maximum for classic library.
Definition netcdf.h:329
NC_SYSERR
#define NC_SYSERR
V2 API system error.
Definition netcdf.h:2060
NC_VERBOSE
#define NC_VERBOSE
For V2 API, be verbose on error.
Definition netcdf.h:2067
MSC_EXTRA
#define MSC_EXTRA
Needed for DLL build.
Definition netcdf.h:609
MAX_NC_DIMS
#define MAX_NC_DIMS
Backward compatible alias.
Definition netcdf.h:2045
NC_ENOMEM
#define NC_ENOMEM
Memory allocation (malloc) failure.
Definition netcdf.h:497
NC_EDIMSIZE
#define NC_EDIMSIZE
Invalid dimension size.
Definition netcdf.h:499
ncopts
EXTERNL int ncopts
V2 API error handling.
Definition netcdf.h:2070
nc_copy_att
EXTERNL int nc_copy_att(int ncid_in, int varid_in, const char *name, int ncid_out, int varid_out)
Copy an attribute from one open file to another.
Definition dcopy.c:587
NC_ISSYSERR
#define NC_ISSYSERR(err)
The netcdf version 3 functions all return integer error status.
Definition netcdf.h:415
NC_NOERR
#define NC_NOERR
No Error.
Definition netcdf.h:417
NC_FATAL
#define NC_FATAL
For V2 API, exit on error.
Definition netcdf.h:2066
MAX_NC_VARS
#define MAX_NC_VARS
Backward compatible alias.
Definition netcdf.h:2047
nc_type
int nc_type
The nc_type type is just an int.
Definition netcdf.h:25