Skip to content

AFNI/NIfTI Server

Sections
Personal tools
You are here: Home » AFNI » Documentation
 

Doxygen Source Code Documentation

Main Page   Alphabetical List   Data Structures   File List   Data Fields   Globals   Search  

v2i.c File Reference

#include "nc.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

Go to the source code of this file.


Defines

#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)

Functions

void nc_advise (const char *routine_name, int err, const char *fmt,...)
void NCadvise (int err, char *fmt,...)
int nccreate (const char *path, int cmode)
int ncopen (const char *path, int mode)
int ncredef (int ncid)
int ncendef (int ncid)
int ncclose (int ncid)
int ncinquire (int ncid, int *ndims, int *nvars, int *natts, int *recdim)
int ncsync (int ncid)
int ncabort (int ncid)
int ncdimdef (int ncid, const char *name, long length)
int ncdimid (int ncid, const char *name)
int ncdiminq (int ncid, int dimid, char *name, long *length)
int ncdimrename (int ncid, int dimid, const char *name)
int ncvardef (int ncid, const char *name, nc_type datatype, int ndims, const int *dim)
int ncvarid (int ncid, const char *name)
int ncvarinq (int ncid, int varid, char *name, nc_type *datatype, int *ndims, int *dim, int *natts)
int ncvarput1 (int ncid, int varid, const long *index, const void *value)
int ncvarget1 (int ncid, int varid, const long *index, void *value)
int ncvarput (int ncid, int varid, const long *start, const long *count, const void *value)
int ncvarget (int ncid, int varid, const long *start, const long *count, void *value)
int ncvarputs (int ncid, int varid, const long *start, const long *count, const long *stride, const void *value)
int ncvargets (int ncid, int varid, const long *start, const long *count, const long *stride, void *value)
int ncvarputg (int ncid, int varid, const long *start, const long *count, const long *stride, const long *map, const void *value)
int ncvargetg (int ncid, int varid, const long *start, const long *count, const long *stride, const long *map, void *value)
int ncvarrename (int ncid, int varid, const char *name)
int ncattput (int ncid, int varid, const char *name, nc_type datatype, int len, const void *value)
int ncattinq (int ncid, int varid, const char *name, nc_type *datatype, int *len)
int ncattget (int ncid, int varid, const char *name, void *value)
int ncattcopy (int ncid_in, int varid_in, const char *name, int ncid_out, int varid_out)
int ncattname (int ncid, int varid, int attnum, char *name)
int ncattrename (int ncid, int varid, const char *name, const char *newname)
int ncattdel (int ncid, int varid, const char *name)
int nctypelen (nc_type type)
int ncsetfill (int ncid, int fillmode)
int ncrecinq (int ncid, int *nrecvars, int *recvarids, long *recsizes)
int ncrecget (int ncid, long recnum, void **datap)
int ncrecput (int ncid, long recnum, void *const *datap)

Variables

int ncerr = NC_NOERR
int ncopts = (NC_FATAL | NC_VERBOSE)
const char * cdf_routine_name

Define Documentation

#define A_DECL (  name,
type,
ndims,
rhs    )     const type *const name = ((const type *)(rhs))
 

Definition at line 17 of file v2i.c.

Referenced by ncvarget(), ncvarget1(), ncvargetg(), ncvargets(), ncvarput(), ncvarput1(), ncvarputg(), and ncvarputs().

#define A_FREE (  name    ) 
 

Definition at line 20 of file v2i.c.

Referenced by ncvarget(), ncvarget1(), ncvargetg(), ncvargets(), ncvarput(), ncvarput1(), ncvarputg(), and ncvarputs().

#define A_INIT (  lhs,
type,
ndims,
rhs    ) 
 

Definition at line 22 of file v2i.c.

Referenced by ncvarget(), ncvarget1(), ncvargetg(), ncvargets(), ncvarput(), ncvarput1(), ncvarputg(), and ncvarputs().

#define NDIMS_DECL
 

Definition at line 16 of file v2i.c.

Referenced by ncvarget(), ncvarget1(), ncvargetg(), ncvargets(), ncvarput(), ncvarput1(), ncvarputg(), and ncvarputs().

Function Documentation

void nc_advise (  const char *    routine_name,
int    err,
const char *    fmt,
...   
) 
 

Definition at line 103 of file v2i.c.

References args, NC_ISSYSERR, nc_strerror(), ncerr, and ncopts.

Referenced by has_c_format_att(), ncabort(), NCadvise(), ncattcopy(), ncattdel(), ncattget(), ncattinq(), ncattname(), ncattput(), ncattrename(), ncclose(), nccreate(), ncdimdef(), ncdimid(), ncdiminq(), ncdimrename(), ncendef(), ncinquire(), ncopen(), ncrecget(), ncrecinq(), ncrecput(), ncredef(), ncsetfill(), ncsync(), nctypelen(), ncvardef(), ncvarget(), ncvarget1(), ncvargetg(), ncvargets(), ncvarid(), ncvarinq(), ncvarput(), ncvarput1(), ncvarputg(), ncvarputs(), and ncvarrename(). 

00104 {
00105         va_list args;
00106 
00107         if(NC_ISSYSERR(err))
00108                 ncerr = NC_SYSERR;
00109         else
00110                 ncerr = err;
00111 
00112         if( ncopts & NC_VERBOSE )
00113         {
00114                 (void) fprintf(stderr,"%s: ", routine_name);
00115                 va_start(args ,fmt);
00116                 (void) vfprintf(stderr,fmt,args);
00117                 va_end(args);
00118                 if(err != NC_NOERR)
00119                 {
00120                         (void) fprintf(stderr,": %s",
00121                                 nc_strerror(err));
00122                 }
00123                 (void) fputc('\n',stderr);
00124                 (void) fflush(stderr);  /* to ensure log files are current */
00125         }
00126 
00127         if( (ncopts & NC_FATAL) && err != NC_NOERR )
00128         {
00129                 exit(ncopts);
00130         }
00131 }

int ncabort (  int    ncid ) 
 

Definition at line 265 of file v2i.c.

References nc_abort(), and nc_advise(). 

00266 {
00267         const int status = nc_abort(ncid);
00268         if(status != NC_NOERR)
00269         {
00270                 nc_advise("ncabort", status, "ncid %d", ncid);
00271                 return -1;
00272         }
00273         return 0;
00274 }

void NCadvise (  int    err,
char *    fmt,
...   
) 
 

Definition at line 138 of file v2i.c.

References args, cdf_routine_name, and nc_advise(). 

00139 {
00140         va_list args;
00141 
00142         va_start(args ,fmt);
00143         nc_advise(cdf_routine_name, err, fmt, args);
00144         va_end(args);
00145 }

int ncattcopy (  int    ncid_in,
int    varid_in,
const char *    name,
int    ncid_out,
int    varid_out
) 
 

Definition at line 763 of file v2i.c.

References name, nc_advise(), and nc_copy_att(). 

00770 {
00771         const int status = nc_copy_att(ncid_in, varid_in, name, ncid_out, varid_out);
00772         if(status != NC_NOERR)
00773         {
00774                 nc_advise("ncattcopy", status, "%s", name);
00775                 return -1;
00776         }
00777         return 0;
00778 }

int ncattdel (  int    ncid,
int    varid,
const char *    name
) 
 

Definition at line 818 of file v2i.c.

References name, nc_advise(), and nc_del_att(). 

00823 {
00824          const int status = nc_del_att(ncid, varid, name);
00825         if(status != NC_NOERR)
00826         {
00827                 nc_advise("ncattdel", status, "ncid %d", ncid);
00828                 return -1;
00829         }
00830         return 1;
00831 }

int ncattget (  int    ncid,
int    varid,
const char *    name,
void *    value
) 
 

Definition at line 745 of file v2i.c.

References name, nc_advise(), and nc_get_att(). 

00751 {
00752         const int status = nc_get_att(ncid, varid, name, value);
00753         if(status != NC_NOERR)
00754         {
00755                 nc_advise("ncattget", status, "ncid %d", ncid);
00756                 return -1;
00757         }
00758         return 1;
00759 }

int ncattinq (  int    ncid,
int    varid,
const char *    name,
nc_type *    datatype,
int *    len
) 
 

Definition at line 720 of file v2i.c.

References name, nc_advise(), and nc_inq_att(). 

00727 {
00728         size_t ll;
00729         const int status = nc_inq_att(ncid, varid, name, datatype, &ll);
00730         if(status != NC_NOERR)
00731         {
00732                 nc_advise("ncattinq", status, "ncid %d", ncid);
00733                 return -1;
00734         }
00735         
00736         if(len != NULL)
00737                 *len = (int) ll;
00738 
00739         return 1;
00740 
00741 }

int ncattname (  int    ncid,
int    varid,
int    attnum,
char *    name
) 
 

Definition at line 782 of file v2i.c.

References name, nc_advise(), and nc_inq_attname(). 

00788 {
00789         const int status = nc_inq_attname(ncid, varid, attnum, name);
00790         if(status != NC_NOERR)
00791         {
00792                 nc_advise("ncattname", status, "ncid %d", ncid);
00793                 return -1;
00794         }
00795         return attnum;
00796 }

int ncattput (  int    ncid,
int    varid,
const char *    name,
nc_type    datatype,
int    len,
const void *    value
) 
 

Definition at line 700 of file v2i.c.

References name, nc_advise(), and nc_put_att().

Referenced by main(). 

00708 {
00709         const int status = nc_put_att(ncid, varid, name, datatype, len, value);
00710         if(status != NC_NOERR)
00711         {
00712                 nc_advise("ncattput", status, "ncid %d", ncid);
00713                 return -1;
00714         }
00715         return 0;
00716 }

int ncattrename (  int    ncid,
int    varid,
const char *    name,
const char *    newname
) 
 

Definition at line 800 of file v2i.c.

References name, nc_advise(), and nc_rename_att(). 

00806 {
00807         const int status = nc_rename_att(ncid, varid, name, newname);
00808         if(status != NC_NOERR)
00809         {
00810                 nc_advise("ncattrename", status, "ncid %d", ncid);
00811                 return -1;
00812         }
00813         return 1;
00814 }

int ncclose (  int    ncid ) 
 

Definition at line 205 of file v2i.c.

References nc_advise(), and nc_close().

Referenced by main(). 

00206 {
00207         const int status = nc_close(ncid);
00208         if(status != NC_NOERR)
00209         {
00210                 nc_advise("ncclose", status, "ncid %d", ncid);
00211                 return -1;
00212                 
00213         }
00214         return 0;
00215 }

int nccreate (  const char *    path,
int    cmode
) 
 

Definition at line 151 of file v2i.c.

References nc_advise(), and nc_create().

Referenced by main(). 

00152 {
00153         int ncid;
00154         const int status = nc_create(path, cmode, &ncid);
00155         if(status != NC_NOERR)
00156         {
00157                 nc_advise("nccreate", status, "filename \"%s\"", path);
00158                 return -1;
00159         }
00160         return ncid;
00161 }

int ncdimdef (  int    ncid,
const char *    name,
long    length
) 
 

Definition at line 278 of file v2i.c.

References name, nc_advise(), and nc_def_dim().

Referenced by main(). 

00283 {
00284         int dimid;
00285         const int status =  nc_def_dim(ncid, name, (size_t)length, &dimid);
00286         if(status != NC_NOERR)
00287         {
00288                 nc_advise("ncdimdef", status, "ncid %d", ncid);
00289                 return -1;
00290         }
00291         return dimid;
00292 }

int ncdimid (  int    ncid,
const char *    name
) 
 

Definition at line 296 of file v2i.c.

References name, nc_advise(), and nc_inq_dimid(). 

00297 {
00298         int dimid;
00299         const int status =  nc_inq_dimid(ncid, name, &dimid);
00300         if(status != NC_NOERR)
00301         {
00302                 nc_advise("ncdimid", status, "ncid %d", ncid);
00303                 return -1;
00304         }
00305         return dimid;
00306 }

int ncdiminq (  int    ncid,
int    dimid,
char *    name,
long *    length
) 
 

Definition at line 310 of file v2i.c.

References name, nc_advise(), and nc_inq_dim(). 

00316 {
00317         size_t ll;
00318         const int status = nc_inq_dim(ncid, dimid, name, &ll);
00319 
00320         if(status != NC_NOERR)
00321         {
00322                 nc_advise("ncdiminq", status, "ncid %d", ncid);
00323                 return -1;
00324         }
00325         /* else */
00326         
00327         if(length != NULL)
00328                 *length = (int) ll;
00329 
00330         return dimid;
00331 }

int ncdimrename (  int    ncid,
int    dimid,
const char *    name
) 
 

Definition at line 335 of file v2i.c.

References name, nc_advise(), and nc_rename_dim(). 

00340 {
00341         const int status = nc_rename_dim(ncid, dimid, name);
00342         if(status != NC_NOERR)
00343         {
00344                 nc_advise("ncdimrename", status, "ncid %d", ncid);
00345                 return -1;
00346         }
00347         return dimid;
00348 }

int ncendef (  int    ncid ) 
 

Definition at line 192 of file v2i.c.

References nc_advise(), and nc_enddef().

Referenced by main(). 

00193 {
00194         const int status = nc_enddef(ncid);
00195         if(status != NC_NOERR)
00196         {
00197                 nc_advise("ncendef", status, "ncid %d", ncid);
00198                 return -1;
00199         }
00200         return 0;
00201 }

int ncinquire (  int    ncid,
int *    ndims,
int *    nvars,
int *    natts,
int *    recdim
) 
 

Definition at line 219 of file v2i.c.

References nc_advise(), nc_inq(), and ndims. 

00226 {
00227         int nd, nv, na;
00228         const int status = nc_inq(ncid, &nd, &nv, &na, recdim);
00229 
00230         if(status != NC_NOERR)
00231         {
00232                 nc_advise("ncinquire", status, "ncid %d", ncid);
00233                 return -1;
00234         }
00235         /* else */
00236 
00237         if(ndims != NULL)
00238                 *ndims = (int) nd;
00239 
00240         if(nvars != NULL)
00241                 *nvars = (int) nv;
00242 
00243         if(natts != NULL)
00244                 *natts = (int) na;
00245 
00246         return ncid;
00247 }

int ncopen (  const char *    path,
int    mode
) 
 

Definition at line 165 of file v2i.c.

References nc_advise(), and nc_open(). 

00166 {
00167         int ncid;
00168         const int status = nc_open(path, mode, &ncid);
00169         if(status != NC_NOERR)
00170         {
00171                 nc_advise("ncopen", status, "filename \"%s\"", path);
00172                 return -1;
00173         }
00174         return ncid;
00175 }

int ncrecget (  int    ncid,
long    recnum,
void **    datap
) 
 

Definition at line 919 of file v2i.c.

References nc_advise(), and nc_get_rec(). 

00924 {
00925         const int status = nc_get_rec(ncid, (size_t)recnum, datap);
00926         if(status != NC_NOERR)
00927         {
00928                 nc_advise("ncrecget", status, "ncid %d", ncid);
00929                 return -1;
00930         }
00931         return 0;
00932 }

int ncrecinq (  int    ncid,
int *    nrecvars,
int *    recvarids,
long *    recsizes
) 
 

Definition at line 886 of file v2i.c.

References nc_advise(), and nc_inq_rec(). 

00892 {
00893         size_t nrv = 0;
00894         size_t rs[NC_MAX_VARS]; /* TODO */
00895         const int status = nc_inq_rec(ncid, &nrv, recvarids, rs);
00896         if(status != NC_NOERR)
00897         {
00898                 nc_advise("ncrecinq", status, "ncid %d", ncid);
00899                 return -1;
00900         }
00901 
00902         if(nrecvars != NULL)
00903                 *nrecvars = (int) nrv;
00904 
00905         if(recsizes != NULL)
00906         {
00907                 size_t ii;
00908                 for(ii = 0; ii < nrv; ii++)
00909                 {
00910                         recsizes[ii] = (long) rs[ii];
00911                 }
00912         }
00913 
00914         return (int) nrv;
00915 }

int ncrecput (  int    ncid,
long    recnum,
void *const *    datap
) 
 

Definition at line 936 of file v2i.c.

References nc_advise(), and nc_put_rec(). 

00941 {
00942         const int status = nc_put_rec(ncid, (size_t)recnum, datap);
00943         if(status != NC_NOERR)
00944         {
00945                 nc_advise("ncrecput", status, "ncid %d", ncid);
00946                 return -1;
00947         }
00948         return 0;
00949 }

int ncredef (  int    ncid ) 
 

Definition at line 179 of file v2i.c.

References nc_advise(), and nc_redef(). 

00180 {
00181         const int status =  nc_redef(ncid);
00182         if(status != NC_NOERR)
00183         {
00184                 nc_advise("ncredef", status, "ncid %d", ncid);
00185                 return -1;
00186         }
00187         return 0;
00188 }

int ncsetfill (  int    ncid,
int    fillmode
) 
 

Definition at line 869 of file v2i.c.

References nc_advise(), and nc_set_fill(). 

00873 {
00874         int oldmode = -1;
00875         const int status = nc_set_fill(ncid, fillmode, &oldmode);
00876         if(status != NC_NOERR)
00877         {
00878                 nc_advise("ncsetfill", status, "ncid %d", ncid);
00879                 return -1;
00880         }
00881         return oldmode;
00882 }

int ncsync (  int    ncid ) 
 

Definition at line 251 of file v2i.c.

References nc_advise(), and nc_sync(). 

00252 {
00253         const int status = nc_sync(ncid);
00254         if(status != NC_NOERR)
00255         {
00256                 nc_advise("ncsync", status, "ncid %d", ncid);
00257                 return -1;
00258                 
00259         }
00260         return 0;
00261 }

int nctypelen (  nc_type    type ) 
 

Definition at line 842 of file v2i.c.

References nc_advise().

Referenced by nc_get_varm(), nc_inq_rec(), and nc_put_varm(). 

00843 {
00844         switch(type){
00845         case NC_BYTE :
00846         case NC_CHAR :
00847                 return((int)sizeof(char));
00848         case NC_SHORT :
00849                 return(int)(sizeof(short));
00850         case NC_INT :
00851                 return((int)sizeof(int));
00852         case NC_FLOAT :
00853                 return((int)sizeof(float));
00854         case NC_DOUBLE : 
00855                 return((int)sizeof(double));
00856         }
00857 
00858 #ifndef NO_NETCDF_2
00859         /* else */
00860         nc_advise("nctypelen", NC_EBADTYPE, "Unknown type %d",
00861                 (int)type);
00862 #endif /* NO_NETCDF_2 */
00863         return -1;
00864 }

int ncvardef (  int    ncid,
const char *    name,
nc_type    datatype,
int    ndims,
const int *    dim
) 
 

Definition at line 352 of file v2i.c.

References name, nc_advise(), nc_def_var(), and ndims.

Referenced by main(). 

00359 {
00360         int varid = -1;
00361         const int status = nc_def_var(ncid, name, datatype, ndims, dim, &varid);
00362         if(status != NC_NOERR)
00363         {
00364                 nc_advise("ncvardef", status, "ncid %d", ncid);
00365                 return -1;
00366         }
00367         return varid;
00368 }

int ncvarget (  int    ncid,
int    varid,
const long *    start,
const long *    count,
void *    value
) 
 

Definition at line 497 of file v2i.c.

References A_DECL, A_FREE, A_INIT, nc_advise(), nc_get_vara(), ndims, and NDIMS_DECL.

Referenced by ncvargets(). 

00504 {
00505         NDIMS_DECL
00506         A_DECL(stp, size_t, ndims, start);
00507         A_DECL(cntp, size_t, ndims, count);
00508         A_INIT(stp, size_t, ndims, start);
00509         A_INIT(cntp, size_t, ndims, count);
00510         {
00511         const int status = nc_get_vara(ncid, varid, stp, cntp, value);
00512         A_FREE(cntp);
00513         A_FREE(stp);
00514         if(status != NC_NOERR)
00515         {
00516                 nc_advise("ncvarget", status, "ncid %d", ncid);
00517                 return -1;
00518         }
00519         }
00520         return 0;
00521 }

int ncvarget1 (  int    ncid,
int    varid,
const long *    index,
void *    value
) 
 

Definition at line 445 of file v2i.c.

References A_DECL, A_FREE, A_INIT, nc_advise(), nc_get_var1(), ndims, and NDIMS_DECL. 

00451 {
00452         NDIMS_DECL
00453         A_DECL(coordp, size_t, ndims, index);
00454         A_INIT(coordp, size_t, ndims, index);
00455         {
00456         const int status = nc_get_var1(ncid, varid, coordp, value);
00457         A_FREE(coordp);
00458         if(status != NC_NOERR)
00459         {
00460                 nc_advise("ncdimid", status, "ncid %d", ncid);
00461                 return -1;
00462         }
00463         }
00464         return 0;
00465 }

int ncvargetg (  int    ncid,
int    varid,
const long *    start,
const long *    count,
const long *    stride,
const long *    map,
void *    value
) 
 

Definition at line 641 of file v2i.c.

References A_DECL, A_FREE, A_INIT, nc_advise(), nc_get_varm(), ncvargets(), ndims, NDIMS_DECL, and stride. 

00650 {
00651         if(map == NULL)
00652                 return ncvargets(ncid, varid, start, count, stride, value);
00653         /* else */
00654         {
00655         NDIMS_DECL
00656         A_DECL(stp, size_t, ndims, start);
00657         A_DECL(cntp, size_t, ndims, count);
00658         A_DECL(strdp, ptrdiff_t, ndims, stride);
00659         A_DECL(imp, ptrdiff_t, ndims, map);
00660         A_INIT(stp, size_t, ndims, start);
00661         A_INIT(cntp, size_t, ndims, count);
00662         A_INIT(strdp, ptrdiff_t, ndims, stride);
00663         A_INIT(imp, ptrdiff_t, ndims, map);
00664         {
00665         const int status = nc_get_varm(ncid, varid,
00666                         stp, cntp, strdp, imp, value);
00667         A_FREE(imp);
00668         A_FREE(strdp);
00669         A_FREE(cntp);
00670         A_FREE(stp);
00671         if(status != NC_NOERR)
00672         {
00673                 nc_advise("ncvargetg", status, "ncid %d", ncid);
00674                 return -1;
00675         }
00676         }
00677         return 0;
00678         }
00679 }

int ncvargets (  int    ncid,
int    varid,
const long *    start,
const long *    count,
const long *    stride,
void *    value
) 
 

Definition at line 562 of file v2i.c.

References A_DECL, A_FREE, A_INIT, nc_advise(), nc_get_vars(), ncvarget(), ndims, NDIMS_DECL, and stride.

Referenced by ncvargetg(). 

00570 {
00571         if(stride == NULL)
00572                 return ncvarget(ncid, varid, start, count, value);
00573         /* else */
00574         {
00575         NDIMS_DECL
00576         A_DECL(stp, size_t, ndims, start);
00577         A_DECL(cntp, size_t, ndims, count);
00578         A_DECL(strdp, ptrdiff_t, ndims, stride);
00579         A_INIT(stp, size_t, ndims, start);
00580         A_INIT(cntp, size_t, ndims, count);
00581         A_INIT(strdp, ptrdiff_t, ndims, stride);
00582         {
00583         const int status = nc_get_vars(ncid, varid, stp, cntp, strdp, value);
00584         A_FREE(strdp);
00585         A_FREE(cntp);
00586         A_FREE(stp);
00587         if(status != NC_NOERR)
00588         {
00589                 nc_advise("ncvargets", status, "ncid %d", ncid);
00590                 return -1;
00591         }
00592         }
00593         return 0;
00594         }
00595 }

int ncvarid (  int    ncid,
const char *    name
) 
 

Definition at line 372 of file v2i.c.

References name, nc_advise(), and nc_inq_varid(). 

00376 {
00377         int varid = -1;
00378         const int status = nc_inq_varid(ncid, name, &varid);
00379         if(status != NC_NOERR)
00380         {
00381                 nc_advise("ncvarid", status, "ncid %d", ncid);
00382                 return -1;
00383         }
00384         return varid;
00385 }

int ncvarinq (  int    ncid,
int    varid,
char *    name,
nc_type *    datatype,
int *    ndims,
int *    dim,
int *    natts
) 
 

Definition at line 389 of file v2i.c.

References name, nc_advise(), nc_inq_var(), and ndims. 

00398 {
00399         int nd, na;
00400         const int status = nc_inq_var(ncid, varid, name, datatype,
00401                  &nd, dim, &na);
00402 
00403         if(status != NC_NOERR)
00404         {
00405                 nc_advise("ncvarinq", status, "ncid %d", ncid);
00406                 return -1;
00407         }
00408         /* else */
00409         
00410         if(ndims != NULL)
00411                 *ndims = (int) nd;
00412 
00413         if(natts != NULL)
00414                 *natts = (int) na;
00415 
00416         return varid;
00417 }

int ncvarput (  int    ncid,
int    varid,
const long *    start,
const long *    count,
const void *    value
) 
 

Definition at line 469 of file v2i.c.

References A_DECL, A_FREE, A_INIT, nc_advise(), nc_put_vara(), ndims, and NDIMS_DECL.

Referenced by main(), and ncvarputs(). 

00476 {
00477         NDIMS_DECL
00478         A_DECL(stp, size_t, ndims, start);
00479         A_DECL(cntp, size_t, ndims, count);
00480         A_INIT(stp, size_t, ndims, start);
00481         A_INIT(cntp, size_t, ndims, count);
00482         {
00483         const int status = nc_put_vara(ncid, varid, stp, cntp, value);
00484         A_FREE(cntp);
00485         A_FREE(stp);
00486         if(status != NC_NOERR)
00487         {
00488                 nc_advise("ncvarput", status, "ncid %d", ncid);
00489                 return -1;
00490         }
00491         }
00492         return 0;
00493 }

int ncvarput1 (  int    ncid,
int    varid,
const long *    index,
const void *    value
) 
 

Definition at line 421 of file v2i.c.

References A_DECL, A_FREE, A_INIT, nc_advise(), nc_put_var1(), ndims, and NDIMS_DECL.

Referenced by main(). 

00427 {
00428         NDIMS_DECL
00429         A_DECL(coordp, size_t, ndims, index);
00430         A_INIT(coordp, size_t, ndims, index);
00431         {
00432         const int status = nc_put_var1(ncid, varid, coordp, value);
00433         A_FREE(coordp);
00434         if(status != NC_NOERR)
00435         {
00436                 nc_advise("ncvarput1", status, "ncid %d", ncid);
00437                 return -1;
00438         }
00439         }
00440         return 0;
00441 }

int ncvarputg (  int    ncid,
int    varid,
const long *    start,
const long *    count,
const long *    stride,
const long *    map,
const void *    value
) 
 

Definition at line 599 of file v2i.c.

References A_DECL, A_FREE, A_INIT, nc_advise(), nc_put_varm(), ncvarputs(), ndims, NDIMS_DECL, and stride. 

00608 {
00609         if(map == NULL)
00610                 return ncvarputs(ncid, varid, start, count, stride, value);
00611         /* else */
00612         {
00613         NDIMS_DECL
00614         A_DECL(stp, size_t, ndims, start);
00615         A_DECL(cntp, size_t, ndims, count);
00616         A_DECL(strdp, ptrdiff_t, ndims, stride);
00617         A_DECL(imp, ptrdiff_t, ndims, map);
00618         A_INIT(stp, size_t, ndims, start);
00619         A_INIT(cntp, size_t, ndims, count);
00620         A_INIT(strdp, ptrdiff_t, ndims, stride);
00621         A_INIT(imp, ptrdiff_t, ndims, map);
00622         {
00623         const int status = nc_put_varm(ncid, varid,
00624                          stp, cntp, strdp, imp, value);
00625         A_FREE(imp);
00626         A_FREE(strdp);
00627         A_FREE(cntp);
00628         A_FREE(stp);
00629         if(status != NC_NOERR)
00630         {
00631                 nc_advise("ncvarputg", status, "ncid %d", ncid);
00632                 return -1;
00633         }
00634         }
00635         return 0;
00636         }
00637 }

int ncvarputs (  int    ncid,
int    varid,
const long *    start,
const long *    count,
const long *    stride,
const void *    value
) 
 

Definition at line 525 of file v2i.c.

References A_DECL, A_FREE, A_INIT, nc_advise(), nc_put_vars(), ncvarput(), ndims, NDIMS_DECL, and stride.

Referenced by ncvarputg(). 

00533 {
00534         if(stride == NULL)
00535                 return ncvarput(ncid, varid, start, count, value);
00536         /* else */
00537         {
00538         NDIMS_DECL
00539         A_DECL(stp, size_t, ndims, start);
00540         A_DECL(cntp, size_t, ndims, count);
00541         A_DECL(strdp, ptrdiff_t, ndims, stride);
00542         A_INIT(stp, size_t, ndims, start);
00543         A_INIT(cntp, size_t, ndims, count);
00544         A_INIT(strdp, ptrdiff_t, ndims, stride);
00545         {
00546         const int status = nc_put_vars(ncid, varid, stp, cntp, strdp, value);
00547         A_FREE(strdp);
00548         A_FREE(cntp);
00549         A_FREE(stp);
00550         if(status != NC_NOERR)
00551         {
00552                 nc_advise("ncvarputs", status, "ncid %d", ncid);
00553                 return -1;
00554         }
00555         }
00556         return 0;
00557         }
00558 }

int ncvarrename (  int    ncid,
int    varid,
const char *    name
) 
 

Definition at line 683 of file v2i.c.

References name, nc_advise(), and nc_rename_var(). 

00688 {
00689         const int status = nc_rename_var(ncid, varid, name);
00690         if(status != NC_NOERR)
00691         {
00692                 nc_advise("ncvarrename", status, "ncid %d", ncid);
00693                 return -1;
00694         }
00695         return varid;
00696 }

Variable Documentation

const char* cdf_routine_name
 

Definition at line 88 of file v2i.c.

Referenced by NCadvise().

int ncerr = NC_NOERR
 

Definition at line 75 of file v2i.c.

Referenced by nc_advise().

int ncopts = (NC_FATAL | NC_VERBOSE)
 

Definition at line 82 of file v2i.c.

Referenced by nc_advise().

 
Powered by Plone

This site conforms to the following standards: