![]() |
NetCDF
4.4.0
|
Variables hold multi-dimensional arrays of data. More...
Functions | |
int | nc_set_var_chunk_cache (int ncid, int varid, size_t size, size_t nelems, float preemption) |
int | nc_get_var_chunk_cache (int ncid, int varid, size_t *sizep, size_t *nelemsp, float *preemptionp) |
int | nc_free_string (size_t len, char **data) |
Free string space allocated by the library. More... | |
static int | NC_get_var (int ncid, int varid, void *value, nc_type memtype) |
static int | NC_get_vars (int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, void *value, nc_type memtype) |
static int | NC_get_varm (int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, void *value, nc_type memtype) |
Defining Variables | |
int | nc_def_var (int ncid, const char *name, nc_type xtype, int ndims, const int *dimidsp, int *varidp) |
Define a new variable. More... | |
Rename a Variable | |
int | nc_rename_var (int ncid, int varid, const char *name) |
Rename a variable. More... | |
Reading Data from Variables | |
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. More... | |
int | nc_get_vara_text (int ncid, int varid, const size_t *startp, const size_t *countp, char *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_schar (int ncid, int varid, const size_t *startp, const size_t *countp, signed char *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_uchar (int ncid, int varid, const size_t *startp, const size_t *countp, unsigned char *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_short (int ncid, int varid, const size_t *startp, const size_t *countp, short *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_int (int ncid, int varid, const size_t *startp, const size_t *countp, int *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_long (int ncid, int varid, const size_t *startp, const size_t *countp, long *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_float (int ncid, int varid, const size_t *startp, const size_t *countp, float *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_double (int ncid, int varid, const size_t *startp, const size_t *countp, double *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_ubyte (int ncid, int varid, const size_t *startp, const size_t *countp, unsigned char *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_ushort (int ncid, int varid, const size_t *startp, const size_t *countp, unsigned short *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_uint (int ncid, int varid, const size_t *startp, const size_t *countp, unsigned int *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_longlong (int ncid, int varid, const size_t *startp, const size_t *countp, long long *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_ulonglong (int ncid, int varid, const size_t *startp, const size_t *countp, unsigned long long *ip) |
Read an array of values from a variable. More... | |
int | nc_get_vara_string (int ncid, int varid, const size_t *startp, const size_t *countp, char **ip) |
Read an array of values from a variable. More... | |
int | nc_get_var1 (int ncid, int varid, const size_t *indexp, void *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_text (int ncid, int varid, const size_t *indexp, char *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_schar (int ncid, int varid, const size_t *indexp, signed char *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_uchar (int ncid, int varid, const size_t *indexp, unsigned char *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_short (int ncid, int varid, const size_t *indexp, short *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_int (int ncid, int varid, const size_t *indexp, int *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_long (int ncid, int varid, const size_t *indexp, long *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_float (int ncid, int varid, const size_t *indexp, float *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_double (int ncid, int varid, const size_t *indexp, double *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_ubyte (int ncid, int varid, const size_t *indexp, unsigned char *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_ushort (int ncid, int varid, const size_t *indexp, unsigned short *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_uint (int ncid, int varid, const size_t *indexp, unsigned int *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_longlong (int ncid, int varid, const size_t *indexp, long long *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_ulonglong (int ncid, int varid, const size_t *indexp, unsigned long long *ip) |
Read a single datum from a variable. More... | |
int | nc_get_var1_string (int ncid, int varid, const size_t *indexp, char **ip) |
Read a single datum from a variable. More... | |
int | nc_get_var (int ncid, int varid, void *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_text (int ncid, int varid, char *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_schar (int ncid, int varid, signed char *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_uchar (int ncid, int varid, unsigned char *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_short (int ncid, int varid, short *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_int (int ncid, int varid, int *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_long (int ncid, int varid, long *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_float (int ncid, int varid, float *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_double (int ncid, int varid, double *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_ubyte (int ncid, int varid, unsigned char *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_ushort (int ncid, int varid, unsigned short *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_uint (int ncid, int varid, unsigned int *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_longlong (int ncid, int varid, long long *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_ulonglong (int ncid, int varid, unsigned long long *ip) |
Read an entire variable in one call. More... | |
int | nc_get_var_string (int ncid, int varid, char **ip) |
Read an entire variable in one call. More... | |
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. More... | |
int | nc_get_vars_text (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, char *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_schar (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, signed char *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_uchar (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, unsigned char *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_short (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, short *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_int (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, int *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_long (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, long *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_float (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, float *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_double (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, double *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_ubyte (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, unsigned char *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_ushort (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, unsigned short *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_uint (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, unsigned int *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_longlong (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, long long *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_ulonglong (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, unsigned long long *ip) |
Read a strided array from a variable. More... | |
int | nc_get_vars_string (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, char **ip) |
Read a strided array from a variable. More... | |
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. More... | |
int | nc_get_varm_schar (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, signed char *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_uchar (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, unsigned char *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_short (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, short *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_int (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, int *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_long (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, long *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_float (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, float *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_double (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, double *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_ubyte (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, unsigned char *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_ushort (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, unsigned short *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_uint (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, unsigned int *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_longlong (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, long long *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_ulonglong (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, unsigned long long *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_text (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, char *ip) |
Read a mapped array from a variable. More... | |
int | nc_get_varm_string (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, char **ip) |
Read a mapped array from a variable. More... | |
Learning about Variables | |
int | nc_inq_varid (int ncid, const char *name, int *varidp) |
Find the ID of a variable, from the name. More... | |
int | nc_inq_var (int ncid, int varid, char *name, nc_type *xtypep, int *ndimsp, int *dimidsp, int *nattsp) |
Learn about a variable. More... | |
int | nc_inq_varname (int ncid, int varid, char *name) |
Learn the name of a variable. More... | |
int | nc_inq_vartype (int ncid, int varid, nc_type *typep) |
Learn the type of a variable. More... | |
int | nc_inq_varndims (int ncid, int varid, int *ndimsp) |
Learn how many dimensions are associated with a variable. More... | |
int | nc_inq_vardimid (int ncid, int varid, int *dimidsp) |
Learn the dimension IDs associated with a variable. More... | |
int | nc_inq_varnatts (int ncid, int varid, int *nattsp) |
Learn how many attributes are associated with a variable. More... | |
int | nc_inq_var_deflate (int ncid, int varid, int *shufflep, int *deflatep, int *deflate_levelp) |
Learn the storage and deflate settings for a variable. More... | |
int | nc_inq_var_szip (int ncid, int varid, int *options_maskp, int *pixels_per_blockp) |
Learn the szip settings of a variable. More... | |
int | nc_inq_var_fletcher32 (int ncid, int varid, int *fletcher32p) |
Learn the checksum settings for a variable. More... | |
int | nc_inq_var_chunking (int ncid, int varid, int *storagep, size_t *chunksizesp) |
This is a wrapper for nc_inq_var_all(). More... | |
int | nc_inq_var_fill (int ncid, int varid, int *no_fill, void *fill_valuep) |
Learn the fill mode of a variable. More... | |
int | nc_inq_var_endian (int ncid, int varid, int *endianp) |
Find the endianness of a variable. More... | |
int | nc_inq_unlimdims (int ncid, int *nunlimdimsp, int *unlimdimidsp) |
Return number and list of unlimited dimensions. More... | |
Writing Data to Variables | |
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. More... | |
int | nc_put_vara_text (int ncid, int varid, const size_t *startp, const size_t *countp, const char *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_schar (int ncid, int varid, const size_t *startp, const size_t *countp, const signed char *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_uchar (int ncid, int varid, const size_t *startp, const size_t *countp, const unsigned char *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_short (int ncid, int varid, const size_t *startp, const size_t *countp, const short *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_int (int ncid, int varid, const size_t *startp, const size_t *countp, const int *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_long (int ncid, int varid, const size_t *startp, const size_t *countp, const long *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_float (int ncid, int varid, const size_t *startp, const size_t *countp, const float *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_double (int ncid, int varid, const size_t *startp, const size_t *countp, const double *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_ubyte (int ncid, int varid, const size_t *startp, const size_t *countp, const unsigned char *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_ushort (int ncid, int varid, const size_t *startp, const size_t *countp, const unsigned short *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_uint (int ncid, int varid, const size_t *startp, const size_t *countp, const unsigned int *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_longlong (int ncid, int varid, const size_t *startp, const size_t *countp, const long long *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_ulonglong (int ncid, int varid, const size_t *startp, const size_t *countp, const unsigned long long *op) |
Write an array of values to a variable. More... | |
int | nc_put_vara_string (int ncid, int varid, const size_t *startp, const size_t *countp, const char **op) |
Write an array of values to a variable. More... | |
int | nc_put_var1 (int ncid, int varid, const size_t *indexp, const void *op) |
Write one datum. More... | |
int | nc_put_var1_text (int ncid, int varid, const size_t *indexp, const char *op) |
Write one datum. More... | |
int | nc_put_var1_schar (int ncid, int varid, const size_t *indexp, const signed char *op) |
Write one datum. More... | |
int | nc_put_var1_uchar (int ncid, int varid, const size_t *indexp, const unsigned char *op) |
Write one datum. More... | |
int | nc_put_var1_short (int ncid, int varid, const size_t *indexp, const short *op) |
Write one datum. More... | |
int | nc_put_var1_int (int ncid, int varid, const size_t *indexp, const int *op) |
Write one datum. More... | |
int | nc_put_var1_long (int ncid, int varid, const size_t *indexp, const long *op) |
Write one datum. More... | |
int | nc_put_var1_float (int ncid, int varid, const size_t *indexp, const float *op) |
Write one datum. More... | |
int | nc_put_var1_double (int ncid, int varid, const size_t *indexp, const double *op) |
Write one datum. More... | |
int | nc_put_var1_ubyte (int ncid, int varid, const size_t *indexp, const unsigned char *op) |
Write one datum. More... | |
int | nc_put_var1_ushort (int ncid, int varid, const size_t *indexp, const unsigned short *op) |
Write one datum. More... | |
int | nc_put_var1_uint (int ncid, int varid, const size_t *indexp, const unsigned int *op) |
Write one datum. More... | |
int | nc_put_var1_longlong (int ncid, int varid, const size_t *indexp, const long long *op) |
Write one datum. More... | |
int | nc_put_var1_ulonglong (int ncid, int varid, const size_t *indexp, const unsigned long long *op) |
Write one datum. More... | |
int | nc_put_var1_string (int ncid, int varid, const size_t *indexp, const char **op) |
Write one datum. More... | |
int | nc_put_var (int ncid, int varid, const void *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_text (int ncid, int varid, const char *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_schar (int ncid, int varid, const signed char *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_uchar (int ncid, int varid, const unsigned char *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_short (int ncid, int varid, const short *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_int (int ncid, int varid, const int *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_long (int ncid, int varid, const long *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_float (int ncid, int varid, const float *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_double (int ncid, int varid, const double *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_ubyte (int ncid, int varid, const unsigned char *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_ushort (int ncid, int varid, const unsigned short *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_uint (int ncid, int varid, const unsigned int *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_longlong (int ncid, int varid, const long long *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_ulonglong (int ncid, int varid, const unsigned long long *op) |
Write an entire variable with one call. More... | |
int | nc_put_var_string (int ncid, int varid, const char **op) |
Write an entire variable with one call. More... | |
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. More... | |
int | nc_put_vars_text (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const char *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_schar (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const signed char *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_uchar (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const unsigned char *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_short (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const short *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_int (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const int *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_long (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const long *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_float (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const float *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_double (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const double *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_ubyte (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const unsigned char *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_ushort (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const unsigned short *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_uint (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const unsigned int *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_longlong (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const long long *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_ulonglong (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const unsigned long long *op) |
Write a strided array of values to a variable. More... | |
int | nc_put_vars_string (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const char **op) |
Write a strided array of values to a variable. More... | |
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. More... | |
int | nc_put_varm_text (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const char *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_schar (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const signed char *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_uchar (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const unsigned char *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_short (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const short *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_int (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const int *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_long (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const long *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_float (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const float *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_double (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const double *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_ubyte (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const unsigned char *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_ushort (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const unsigned short *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_uint (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const unsigned int *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_longlong (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const long long *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_ulonglong (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const unsigned long long *op) |
Write a mapped array of values to a variable. More... | |
int | nc_put_varm_string (int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const char **op) |
Write a mapped array of values to a variable. More... | |
Variables hold multi-dimensional arrays of data.
Variables for a netCDF dataset are defined when the dataset is created, while the netCDF dataset is in define mode. Other variables may be added later by reentering define mode. A netCDF variable has a name, a type, and a shape, which are specified when it is defined. A variable may also have values, which are established later in data mode.
Ordinarily, the name, type, and shape are fixed when the variable is first defined. The name may be changed, but the type and shape of a variable cannot be changed. However, a variable defined in terms of the unlimited dimension can grow without bound in that dimension.
A netCDF variable in an open netCDF dataset is referred to by a small integer called a variable ID.
Variable IDs reflect the order in which variables were defined within a netCDF dataset. Variable IDs are 0, 1, 2,..., in the order in which the variables were defined. A function is available for getting the variable ID from the variable name and vice-versa.
Attributes (see Attributes) may be associated with a variable to specify such properties as units.
Operations supported on variables are:
External Data Types
NetCDF supported six atomic data types through version 3.6.0 (char, byte, short, int, float, and double). Starting with version 4.0, many new atomic and user defined data types are supported (unsigned int types, strings, compound types, variable length arrays, enums, opaque).
The additional data types are only supported in netCDF-4/HDF5 files. To create netCDF-4/HDF5 files, use the HDF5 flag in nc_create. (see nc_create).
NetCDF-3 classic and 64-bit offset files support 6 atomic data types, and none of the user defined datatype introduced in NetCDF-4.
The following table gives the netCDF-3 external data types and the corresponding type constants for defining variables in the C interface:
Type | C define | Bits |
byte | NC_BYTE | 8 |
char | NC_CHAR | 8 |
short | NC_SHORT | 16 |
int | NC_INT | 32 |
float | NC_FLOAT | 32 |
double | NC_DOUBLE | 64 |
The first column gives the netCDF external data type, which is the same as the CDL data type. The next column gives the corresponding C pre-processor macro for use in netCDF functions (the pre-processor macros are defined in the netCDF C header-file netcdf.h). The last column gives the number of bits used in the external representation of values of the corresponding type.
NetCDF-4 files support all of the atomic data types from netCDF-3, plus additional unsigned integer types, 64-bit integer types, and a string type.
Type | C define | Bits |
byte | NC_BYTE | 8 |
unsigned byte | NC_UBYTE^ | 8 |
char | NC_CHAR | 8 |
short | NC_SHORT | 16 |
unsigned short | NC_USHORT^ | 16 |
int | NC_INT | 32 |
unsigned int | NC_UINT^ | 32 |
unsigned long long | NC_UINT64^ | 64 |
long long | NC_INT64^ | 64 |
float | NC_FLOAT | 32 |
double | NC_DOUBLE | 64 |
char ** | NC_STRING^ | string length + 1 |
^This type was introduced in netCDF-4, and is not supported in netCDF classic or 64-bit offset format files, or in netCDF-4 files if they are created with the NC_CLASSIC_MODEL flags.
int nc_def_var | ( | int | ncid, |
const char * | name, | ||
nc_type | xtype, | ||
int | ndims, | ||
const int * | dimidsp, | ||
int * | varidp | ||
) |
Define a new variable.
This function adds a new variable to an open netCDF dataset or group. It returns (as an argument) a variable ID, given the netCDF ID, the variable name, the variable type, the number of dimensions, and a list of the dimension IDs.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
name | Variable NetCDF Names. |
xtype | Data Types of the variable. |
ndims | Number of dimensions for the variable. For example, 2 specifies a matrix, 1 specifies a vector, and 0 means the variable is a scalar with no dimensions. Must not be negative or greater than the predefined constant NC_MAX_VAR_DIMS. |
dimidsp | Vector of ndims dimension IDs corresponding to the variable dimensions. For classic model netCDF files, if the ID of the unlimited dimension is included, it must be first. This argument is ignored if ndims is 0. For expanded model netCDF4/HDF5 files, there may be any number of unlimited dimensions, and they may be used in any element of the dimids array. |
varidp | Pointer to location for the returned variable ID. |
Here is an example using nc_def_var to create a variable named rh of type double with three dimensions, time, lat, and lon in a new netCDF dataset named foo.nc:
int nc_free_string | ( | size_t | len, |
char ** | data | ||
) |
Free string space allocated by the library.
When you read string type the library will allocate the storage space for the data. This storage space must be freed, so pass the pointer back to this function, when you're done with the data, and it will free the string memory.
len | The number of character arrays in the array. |
data | The pointer to the data array. |
int nc_get_var | ( | int | ncid, |
int | varid, | ||
void * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1 | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
void * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_double | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
double * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_float | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
float * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_int | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
int * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_long | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
long * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_longlong | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
long long * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_schar | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
signed char * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_short | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
short * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_string | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
char ** | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_text | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
char * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_ubyte | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
unsigned char * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_uchar | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
unsigned char * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_uint | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
unsigned int * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_ulonglong | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
unsigned long long * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var1_ushort | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
unsigned short * | ip | ||
) |
Read a single datum from a variable.
Inputs are the netCDF ID, the variable ID, a multidimensional index that specifies which value to get, and the address of a location into which the data value will be read. The value is converted from the external data type of the variable, if necessary.
The nc_get_var1() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_var1_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_chunk_cache | ( | int | ncid, |
int | varid, | ||
size_t * | sizep, | ||
size_t * | nelemsp, | ||
float * | preemptionp | ||
) |
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
sizep | The total size of the raw data chunk cache, in bytes, will be put here. Ignored if NULL. |
nelemsp | The number of chunk slots in the raw data chunk cache hash table will be put here. Ignored if NULL. |
preemptionp | The preemption will be put here. The preemtion value is between 0 and 1 inclusive and indicates how much chunks that have been fully read are favored for preemption. A value of zero means fully read chunks are treated no differently than other chunks (the preemption is strictly LRU) while a value of one means fully read chunks are always preempted before other chunks. Ignored if NULL. |
int nc_get_var_double | ( | int | ncid, |
int | varid, | ||
double * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_float | ( | int | ncid, |
int | varid, | ||
float * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_int | ( | int | ncid, |
int | varid, | ||
int * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_long | ( | int | ncid, |
int | varid, | ||
long * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_longlong | ( | int | ncid, |
int | varid, | ||
long long * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_schar | ( | int | ncid, |
int | varid, | ||
signed char * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_short | ( | int | ncid, |
int | varid, | ||
short * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_string | ( | int | ncid, |
int | varid, | ||
char ** | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_text | ( | int | ncid, |
int | varid, | ||
char * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_ubyte | ( | int | ncid, |
int | varid, | ||
unsigned char * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_uchar | ( | int | ncid, |
int | varid, | ||
unsigned char * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_uint | ( | int | ncid, |
int | varid, | ||
unsigned int * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_ulonglong | ( | int | ncid, |
int | varid, | ||
unsigned long long * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_var_ushort | ( | int | ncid, |
int | varid, | ||
unsigned short * | ip | ||
) |
Read an entire variable in one call.
This function will read all the values from a netCDF variable of an open netCDF dataset.
This is the simplest interface to use for reading the value of a scalar variable or when all the values of a multidimensional variable can be read at once. The values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to read all the values of a record variable into an array but there are more records in the file than you assume, more data will be read than you expect, which may cause a segmentation violation. To avoid such problems, it is better to use the nc_get_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_var() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
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.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
Definition at line 626 of file dvarget.c.
int nc_get_vara_double | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
double * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_float | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
float * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_int | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
int * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_long | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
long * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_longlong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
long long * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_schar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
signed char * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_short | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
short * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_string | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
char ** | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_text | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
char * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_ubyte | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
unsigned char * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_uchar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
unsigned char * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_uint | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
unsigned int * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_ulonglong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
unsigned long long * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
int nc_get_vara_ushort | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
unsigned short * | ip | ||
) |
Read an array of values from a variable.
The array to be read is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The data values are read into consecutive locations with the last dimension varying fastest. The netCDF dataset must be in data mode (for netCDF-4/HDF5 files, the switch to data mode will happen automatically, unless the classic model is used).
The nc_get_vara() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
Other nc_get_vara_ functions will convert data to the desired output type as needed.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Here is an example using nc_get_vara_double() to read all the values of the variable named rh from an existing netCDF dataset named foo.nc. For simplicity in this example, we assume that we know that rh is dimensioned with time, lat, and lon, and that there are three time values, five lat values, and ten lon values.
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.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_double | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
double * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_float | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
float * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_int | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
int * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_long | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
long * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_longlong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
long long * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_schar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
signed char * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_short | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
short * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_string | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
char ** | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_text | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
char * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_ubyte | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
unsigned char * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_uchar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
unsigned char * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_uint | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
unsigned int * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_ulonglong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
unsigned long long * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_varm_ushort | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
unsigned short * | ip | ||
) |
Read a mapped array from a variable.
The nc_get_varm_ type family of functions reads a mapped array section of values from a netCDF variable of an open netCDF dataset. The mapped array section is specified by giving a corner, a vector of edge lengths, a stride vector, and an index mapping vector. The index mapping vector is a vector of integers that specifies the mapping between the dimensions of a netCDF variable and the in-memory structure of the internal data array. No assumptions are made about the ordering or length of the dimensions of the data array. The netCDF dataset must be in data mode.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_get_varm() function will only read a variable of an atomic type; it will not read user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
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.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_double | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
double * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_float | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
float * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_int | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
int * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_long | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
long * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_longlong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
long long * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_schar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
signed char * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_short | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
short * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_string | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
char ** | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_text | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
char * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_ubyte | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
unsigned char * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_uchar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
unsigned char * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_uint | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
unsigned int * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_ulonglong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
unsigned long long * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_get_vars_ushort | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
unsigned short * | ip | ||
) |
Read a strided array from a variable.
This function reads a subsampled (strided) array section of values from a netCDF variable of an open netCDF dataset. The subsampled array section is specified by giving a corner, a vector of edge lengths, and a stride vector. The values are read with the last dimension of the netCDF variable varying fastest. The netCDF dataset must be in data mode.
The nc_get_vars() function will read a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
ip | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_inq_unlimdims | ( | int | ncid, |
int * | nunlimdimsp, | ||
int * | unlimdimidsp | ||
) |
Return number and list of unlimited dimensions.
In netCDF-4 files, it's possible to have multiple unlimited dimensions. This function returns a list of the unlimited dimension ids visible in a group.
Dimensions are visible in a group if they have been defined in that group, or any ancestor group.
ncid | NetCDF group ID, from a previous call to nc_open, nc_create, nc_def_grp, etc. |
nunlimdimsp | A pointer to an int which will get the number of visible unlimited dimensions. Ignored if NULL. |
unlimdimidsp | A pointer to an already allocated array of int which will get the ids of all visible unlimited dimensions. Ignored if NULL. To allocate the correct length for this array, call nc_inq_unlimdims with a NULL for this parameter and use the nunlimdimsp parameter to get the number of visible unlimited dimensions. |
This function will return one of the following values.
int nc_inq_var | ( | int | ncid, |
int | varid, | ||
char * | name, | ||
nc_type * | xtypep, | ||
int * | ndimsp, | ||
int * | dimidsp, | ||
int * | nattsp | ||
) |
Learn about a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
name | Returned NetCDF Names of variable. Ignored if NULL. |
xtypep | Pointer where typeid will be stored. Ignored if NULL. |
ndimsp | Pointer where number of dimensions will be stored. Ignored if NULL. |
dimidsp | Pointer where array of dimension IDs will be stored. Ignored if NULL. |
nattsp | Pointer where number of attributes will be stored. Ignored if NULL. |
Here is an example using nc_inq_var() to find out about a variable named rh in an existing netCDF dataset named foo.nc:
int nc_inq_var_chunking | ( | int | ncid, |
int | varid, | ||
int * | storagep, | ||
size_t * | chunksizesp | ||
) |
This is a wrapper for nc_inq_var_all().
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
storagep | Address of returned storage property, returned as NC_CONTIGUOUS if this variable uses contiguous storage, or NC_CHUNKED if it uses chunked storage. Ignored if NULL. |
chunksizesp | The chunksizes will be copied here. Ignored if NULL. |
int nc_inq_var_deflate | ( | int | ncid, |
int | varid, | ||
int * | shufflep, | ||
int * | deflatep, | ||
int * | deflate_levelp | ||
) |
Learn the storage and deflate settings for a variable.
This is a wrapper for nc_inq_var_all().
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
shufflep | A 1 will be written here if the shuffle filter is turned on for this variable, and a 0 otherwise. Ignored if NULL. |
deflatep | If this pointer is non-NULL, the nc_inq_var_deflate function will write a 1 if the deflate filter is turned on for this variable, and a 0 otherwise. Ignored if NULL. |
deflate_levelp | If the deflate filter is in use for this variable, the deflate_level will be writen here. Ignored if NULL. |
int nc_inq_var_endian | ( | int | ncid, |
int | varid, | ||
int * | endianp | ||
) |
Find the endianness of a variable.
This is a wrapper for nc_inq_var_all().
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
endianp | Storage which will get NC_ENDIAN_LITTLE if this variable is stored in little-endian format, NC_ENDIAN_BIG if it is stored in big-endian format, and NC_ENDIAN_NATIVE if the endianness is not set, and the variable is not created yet. |
int nc_inq_var_fill | ( | int | ncid, |
int | varid, | ||
int * | no_fill, | ||
void * | fill_valuep | ||
) |
Learn the fill mode of a variable.
The fill mode of a variable is set by nc_def_var_fill().
This is a wrapper for nc_inq_var_all().
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
no_fill | Pointer to an integer which will get a 1 if no_fill mode is set for this variable. Ignored if NULL. |
fill_valuep | A pointer which will get the fill value for this variable. Ignored if NULL. |
int nc_inq_var_fletcher32 | ( | int | ncid, |
int | varid, | ||
int * | fletcher32p | ||
) |
Learn the checksum settings for a variable.
This is a wrapper for nc_inq_var_all().
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
fletcher32p | Will be set to NC_FLETCHER32 if the fletcher32 checksum filter is turned on for this variable, and NC_NOCHECKSUM if it is not. Ignored if NULL. |
int nc_inq_var_szip | ( | int | ncid, |
int | varid, | ||
int * | options_maskp, | ||
int * | pixels_per_blockp | ||
) |
Learn the szip settings of a variable.
This function returns the szip settings for a variable. NetCDF does not allow variables to be created with szip (due to license problems with the szip library), but we do enable read-only access of HDF5 files with szip compression.
This is a wrapper for nc_inq_var_all().
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
options_maskp | The szip options mask will be copied to this pointer. Ignored if NULL. |
pixels_per_blockp | The szip pixels per block will be copied here. Ignored if NULL. |
int nc_inq_vardimid | ( | int | ncid, |
int | varid, | ||
int * | dimidsp | ||
) |
Learn the dimension IDs associated with a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
dimidsp | Pointer where array of dimension IDs will be stored. Ignored if NULL. |
Definition at line 213 of file dvarinq.c.
int nc_inq_varid | ( | int | ncid, |
const char * | name, | ||
int * | varidp | ||
) |
Find the ID of a variable, from the name.
The function nc_inq_varid returns the ID of a netCDF variable, given its name.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
name | Name of the variable. |
varidp | Pointer to location for returned variable ID. Ignored if NULL. |
Here is an example using nc_inq_varid to find out the ID of a variable named rh in an existing netCDF dataset named foo.nc:
int nc_inq_varname | ( | int | ncid, |
int | varid, | ||
char * | name | ||
) |
Learn the name of a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
name | Returned variable name. The caller must allocate space for the returned name. The maximum length is NC_MAX_NAME. Ignored if NULL. |
Definition at line 146 of file dvarinq.c.
int nc_inq_varnatts | ( | int | ncid, |
int | varid, | ||
int * | nattsp | ||
) |
Learn how many attributes are associated with a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
nattsp | Pointer where number of attributes will be stored. Ignored if NULL. |
Definition at line 236 of file dvarinq.c.
int nc_inq_varndims | ( | int | ncid, |
int | varid, | ||
int * | ndimsp | ||
) |
Learn how many dimensions are associated with a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
ndimsp | Pointer where number of dimensions will be stored. Ignored if NULL. |
Definition at line 191 of file dvarinq.c.
int nc_inq_vartype | ( | int | ncid, |
int | varid, | ||
nc_type * | typep | ||
) |
Learn the type of a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
typep | Pointer where typeid will be stored. Ignored if NULL. |
Definition at line 168 of file dvarinq.c.
int nc_put_var | ( | int | ncid, |
int | varid, | ||
const void * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var1 | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const void * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_double | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const double * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_float | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const float * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_int | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const int * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_long | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const long * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_longlong | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const long long * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_schar | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const signed char * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_short | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const short * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_string | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const char ** | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_text | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const char * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_ubyte | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const unsigned char * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_uchar | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const unsigned char * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_uint | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const unsigned int * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_ulonglong | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const unsigned long long * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var1_ushort | ( | int | ncid, |
int | varid, | ||
const size_t * | indexp, | ||
const unsigned short * | op | ||
) |
Write one datum.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
indexp | Index vector with one element for each dimension. |
op | Pointer from where the data will be copied. |
int nc_put_var_double | ( | int | ncid, |
int | varid, | ||
const double * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_float | ( | int | ncid, |
int | varid, | ||
const float * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_int | ( | int | ncid, |
int | varid, | ||
const int * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_long | ( | int | ncid, |
int | varid, | ||
const long * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_longlong | ( | int | ncid, |
int | varid, | ||
const long long * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_schar | ( | int | ncid, |
int | varid, | ||
const signed char * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_short | ( | int | ncid, |
int | varid, | ||
const short * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_string | ( | int | ncid, |
int | varid, | ||
const char ** | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_text | ( | int | ncid, |
int | varid, | ||
const char * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_ubyte | ( | int | ncid, |
int | varid, | ||
const unsigned char * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_uchar | ( | int | ncid, |
int | varid, | ||
const unsigned char * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_uint | ( | int | ncid, |
int | varid, | ||
const unsigned int * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_ulonglong | ( | int | ncid, |
int | varid, | ||
const unsigned long long * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
int nc_put_var_ushort | ( | int | ncid, |
int | varid, | ||
const unsigned short * | op | ||
) |
Write an entire variable with one call.
The nc_put_var_ type family of functions write all the values of a variable into a netCDF variable of an open netCDF dataset. This is the simplest interface to use for writing a value in a scalar variable or whenever all the values of a multidimensional variable can all be written at once. The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The values are converted to the external data type of the variable, if necessary.
Take care when using this function with record variables (variables that use the NC_UNLIMITED dimension). If you try to write all the values of a record variable into a netCDF file that has no record data yet (hence has 0 records), nothing will be written. Similarly, if you try to write all the values of a record variable but there are more records in the file than you assume, more in-memory data will be accessed than you supply, which may result in a segmentation violation. To avoid such problems, it is better to use the nc_put_vara interfaces for variables that use the NC_UNLIMITED dimension.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
op | Pointer from where the data will be copied. |
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.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
Definition at line 573 of file dvarput.c.
int nc_put_vara_double | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const double * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_float | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const float * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_int | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const int * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_long | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const long * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_longlong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const long long * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_schar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const signed char * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_short | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const short * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_string | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const char ** | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_text | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const char * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_ubyte | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const unsigned char * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_uchar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const unsigned char * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_uint | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const unsigned int * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_ulonglong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const unsigned long long * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vara_ushort | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const unsigned short * | op | ||
) |
Write an array of values to a variable.
The values to be written are associated with the netCDF variable by assuming that the last dimension of the netCDF variable varies fastest in the C interface. The netCDF dataset must be in data mode. The array to be written is specified by giving a corner and a vector of edge lengths to Specify a Hyperslab.
The functions for types ubyte, ushort, uint, longlong, ulonglong, and string are only available for netCDF-4/HDF5 files.
The nc_put_var() function will write a variable of any type, including user defined type. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
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.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_double | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const double * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_float | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const float * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_int | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const int * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_long | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const long * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_longlong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const long long * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_schar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const signed char * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_short | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const short * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_string | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const char ** | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_text | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const char * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_ubyte | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const unsigned char * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_uchar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const unsigned char * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_uint | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const unsigned int * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_ulonglong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const unsigned long long * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_varm_ushort | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const ptrdiff_t * | imapp, | ||
const unsigned short * | op | ||
) |
Write a mapped array of values to a variable.
The nc_put_varm() function will only write a variable of an atomic type; it will not write user defined types. For this function, the type of the data in memory must match the type of the variable - no data conversion is done.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
imapp | Mapping vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
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.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_double | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const double * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_float | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const float * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_int | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const int * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_long | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const long * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_longlong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const long long * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_schar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const signed char * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_short | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const short * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_string | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const char ** | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_text | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const char * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_ubyte | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const unsigned char * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_uchar | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const unsigned char * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_uint | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const unsigned int * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_ulonglong | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const unsigned long long * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_put_vars_ushort | ( | int | ncid, |
int | varid, | ||
const size_t * | startp, | ||
const size_t * | countp, | ||
const ptrdiff_t * | stridep, | ||
const unsigned short * | op | ||
) |
Write a strided array of values to a variable.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
startp | Start vector with one element for each dimension to Specify a Hyperslab. |
countp | Count vector with one element for each dimension to Specify a Hyperslab. |
stridep | Stride vector with one element for each dimension to Specify a Hyperslab. |
op | Pointer where the data will be copied. Memory must be allocated by the user before this function is called. |
int nc_rename_var | ( | int | ncid, |
int | varid, | ||
const char * | name | ||
) |
Rename a variable.
This function changes the name of a netCDF variable in an open netCDF file or group. You cannot rename a variable to have the name of any existing variable.
For classic format, 64-bit offset format, and netCDF-4/HDF5 with classic mode, if the new name is longer than the old name, the netCDF dataset must be in define mode.
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
name | New name of the variable. |
Here is an example using nc_rename_var to rename the variable rh to rel_hum in an existing netCDF dataset named foo.nc:
Definition at line 280 of file dvar.c.
int nc_set_var_chunk_cache | ( | int | ncid, |
int | varid, | ||
size_t | size, | ||
size_t | nelems, | ||
float | preemption | ||
) |
ncid | NetCDF or group ID, from a previous call to nc_open(), nc_create(), nc_def_grp(), or associated inquiry functions such as nc_inq_ncid(). |
varid | Variable ID |
size | The total size of the raw data chunk cache, in bytes. |
nelems | The number of chunk slots in the raw data chunk cache. |
preemption | The preemption, a value between 0 and 1 inclusive that indicates how much chunks that have been fully read are favored for preemption. A value of zero means fully read chunks are treated no differently than other chunks (the preemption is strictly LRU) while a value of one means fully read chunks are always preempted before other chunks. |