NetCDF  4.4.0-rc3
dvar.c
Go to the documentation of this file.
1 
8 #include "ncdispatch.h"
9 #include "netcdf_f.h"
10 
206 int
207 nc_def_var(int ncid, const char *name, nc_type xtype,
208  int ndims, const int *dimidsp, int *varidp)
209 {
210  NC* ncp;
211  int stat = NC_NOERR;
212 
213  if ((stat = NC_check_id(ncid, &ncp)))
214  return stat;
215  return ncp->dispatch->def_var(ncid, name, xtype, ndims,
216  dimidsp, varidp);
217 }
279 int
280 nc_rename_var(int ncid, int varid, const char *name)
281 {
282  NC* ncp;
283  int stat = NC_check_id(ncid, &ncp);
284  if(stat != NC_NOERR) return stat;
285  return ncp->dispatch->rename_var(ncid, varid, name);
286 }
292 int
293 NC_is_recvar(int ncid, int varid, size_t* nrecs)
294 {
295  int status = NC_NOERR;
296  int unlimid;
297  int ndims;
298  int dimset[NC_MAX_VAR_DIMS];
299 
300  status = nc_inq_unlimdim(ncid,&unlimid);
301  if(status != NC_NOERR) return 0; /* no unlimited defined */
302  status = nc_inq_varndims(ncid,varid,&ndims);
303  if(status != NC_NOERR) return 0; /* no unlimited defined */
304  if(ndims == 0) return 0; /* scalar */
305  status = nc_inq_vardimid(ncid,varid,dimset);
306  if(status != NC_NOERR) return 0; /* no unlimited defined */
307  status = nc_inq_dim(ncid,dimset[0],NULL,nrecs);
308  if(status != NC_NOERR) return 0;
309  return (dimset[0] == unlimid ? 1: 0);
310 }
311 
328 int
329 NC_inq_recvar(int ncid, int varid, int *nrecdims, int *is_recdim)
330 {
331  int status = NC_NOERR;
332  int unlimid;
333  int nvardims;
334  int dimset[NC_MAX_VAR_DIMS];
335  int dim;
336 
337  *nrecdims = 0;
338  status = nc_inq_varndims(ncid,varid,&nvardims);
339  if(status != NC_NOERR) return status;
340  if(nvardims == 0) return NC_NOERR; /* scalars have no dims */
341  for(dim = 0; dim < nvardims; dim++)
342  is_recdim[dim] = 0;
343  status = nc_inq_unlimdim(ncid, &unlimid);
344  if(status != NC_NOERR) return status;
345  if(unlimid == -1) return status; /* no unlimited dims for any variables */
346 #ifdef USE_NETCDF4
347  {
348  int nunlimdims;
349  int unlimids[NC_MAX_DIMS];
350  int recdim;
351  status = nc_inq_unlimdims(ncid, &nunlimdims, unlimids); /* for group or file, not variable */
352  if(status != NC_NOERR) return status;
353  if(nunlimdims == 0) return status;
354  status = nc_inq_vardimid(ncid, varid, dimset);
355  if(status != NC_NOERR) return status;
356  for (dim = 0; dim < nvardims; dim++) { /* netCDF-4 rec dims need not be first dim for a rec var */
357  for(recdim = 0; recdim < nunlimdims; recdim++) {
358  if(dimset[dim] == unlimids[recdim]) {
359  is_recdim[dim] = 1;
360  *nrecdims += 1;
361  }
362  }
363  }
364  }
365 #else
366  status = nc_inq_vardimid(ncid, varid, dimset);
367  if(status != NC_NOERR) return status;
368  if(dimset[0] == unlimid) {
369  is_recdim[0] = 1;
370  *nrecdims++;
371  }
372 #endif /* USE_NETCDF4 */
373  return status;
374 }
375 
376 /* Ok to use NC pointers because
377  all IOSP's will use that structure,
378  but not ok to use e.g. NC_Var pointers
379  because they may be different structure
380  entirely.
381 */
382 
391 int
392 nctypelen(nc_type type)
393 {
394  switch(type){
395  case NC_CHAR :
396  return ((int)sizeof(char));
397  case NC_BYTE :
398  return ((int)sizeof(signed char));
399  case NC_SHORT :
400  return ((int)sizeof(short));
401  case NC_INT :
402  return ((int)sizeof(int));
403  case NC_FLOAT :
404  return ((int)sizeof(float));
405  case NC_DOUBLE :
406  return ((int)sizeof(double));
407 
408  /* These can occur in netcdf-3 code */
409  case NC_UBYTE :
410  return ((int)sizeof(unsigned char));
411  case NC_USHORT :
412  return ((int)(sizeof(unsigned short)));
413  case NC_UINT :
414  return ((int)sizeof(unsigned int));
415  case NC_INT64 :
416  return ((int)sizeof(signed long long));
417  case NC_UINT64 :
418  return ((int)sizeof(unsigned long long));
419 #ifdef USE_NETCDF4
420  case NC_STRING :
421  return ((int)sizeof(char*));
422 #endif /*USE_NETCDF4*/
423 
424  default:
425  return -1;
426  }
427 }
428 
432 size_t
433 NC_atomictypelen(nc_type xtype)
434 {
435  size_t sz = 0;
436  switch(xtype) {
437  case NC_NAT: sz = 0; break;
438  case NC_BYTE: sz = sizeof(signed char); break;
439  case NC_CHAR: sz = sizeof(char); break;
440  case NC_SHORT: sz = sizeof(short); break;
441  case NC_INT: sz = sizeof(int); break;
442  case NC_FLOAT: sz = sizeof(float); break;
443  case NC_DOUBLE: sz = sizeof(double); break;
444  case NC_INT64: sz = sizeof(signed long long); break;
445  case NC_UBYTE: sz = sizeof(unsigned char); break;
446  case NC_USHORT: sz = sizeof(unsigned short); break;
447  case NC_UINT: sz = sizeof(unsigned int); break;
448  case NC_UINT64: sz = sizeof(unsigned long long); break;
449 #ifdef USE_NETCDF4
450  case NC_STRING: sz = sizeof(char*); break;
451 #endif
452  default: break;
453  }
454  return sz;
455 }
456 
460 char *
461 NC_atomictypename(nc_type xtype)
462 {
463  char* nm = NULL;
464  switch(xtype) {
465  case NC_NAT: nm = "undefined"; break;
466  case NC_BYTE: nm = "byte"; break;
467  case NC_CHAR: nm = "char"; break;
468  case NC_SHORT: nm = "short"; break;
469  case NC_INT: nm = "int"; break;
470  case NC_FLOAT: nm = "float"; break;
471  case NC_DOUBLE: nm = "double"; break;
472  case NC_INT64: nm = "int64"; break;
473  case NC_UBYTE: nm = "ubyte"; break;
474  case NC_USHORT: nm = "ushort"; break;
475  case NC_UINT: nm = "uint"; break;
476  case NC_UINT64: nm = "uint64"; break;
477 #ifdef USE_NETCDF4
478  case NC_STRING: nm = "string"; break;
479 #endif
480  default: break;
481  }
482  return nm;
483 }
484 
489 int
490 NC_getshape(int ncid, int varid, int ndims, size_t* shape)
491 {
492  int dimids[NC_MAX_VAR_DIMS];
493  int i;
494  int status = NC_NOERR;
495 
496  if ((status = nc_inq_vardimid(ncid, varid, dimids)))
497  return status;
498  for(i = 0; i < ndims; i++)
499  if ((status = nc_inq_dimlen(ncid, dimids[i], &shape[i])))
500  break;
501 
502  return status;
503 }
504 
505 #ifdef USE_NETCDF4
506 
531 int
532 nc_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems,
533  float preemption)
534 {
535  NC* ncp;
536  int stat = NC_check_id(ncid, &ncp);
537  if(stat != NC_NOERR) return stat;
538  return ncp->dispatch->set_var_chunk_cache(ncid, varid, size,
539  nelems, preemption);
540 }
541 
569 int
570 nc_get_var_chunk_cache(int ncid, int varid, size_t *sizep, size_t *nelemsp,
571  float *preemptionp)
572 {
573  NC* ncp;
574  int stat = NC_check_id(ncid, &ncp);
575  if(stat != NC_NOERR) return stat;
576  return ncp->dispatch->get_var_chunk_cache(ncid, varid, sizep,
577  nelemsp, preemptionp);
578 }
579 
593 int
594 nc_free_string(size_t len, char **data)
595 {
596  int i;
597  for (i = 0; i < len; i++)
598  free(data[i]);
599  return NC_NOERR;
600 }
601 
602 int
603 nc_def_var_deflate(int ncid, int varid, int shuffle, int deflate, int deflate_level)
604 {
605  NC* ncp;
606  int stat = NC_check_id(ncid,&ncp);
607  if(stat != NC_NOERR) return stat;
608  return ncp->dispatch->def_var_deflate(ncid,varid,shuffle,deflate,deflate_level);
609 }
610 
611 int
612 nc_def_var_fletcher32(int ncid, int varid, int fletcher32)
613 {
614  NC* ncp;
615  int stat = NC_check_id(ncid,&ncp);
616  if(stat != NC_NOERR) return stat;
617  return ncp->dispatch->def_var_fletcher32(ncid,varid,fletcher32);
618 }
619 
620 int
621 nc_def_var_chunking(int ncid, int varid, int storage,
622  const size_t *chunksizesp)
623 {
624  NC* ncp;
625  int stat = NC_check_id(ncid, &ncp);
626  if(stat != NC_NOERR) return stat;
627  return ncp->dispatch->def_var_chunking(ncid, varid, storage,
628  chunksizesp);
629 }
630 
631 int
632 nc_def_var_fill(int ncid, int varid, int no_fill, const void *fill_value)
633 {
634  NC* ncp;
635  int stat = NC_check_id(ncid,&ncp);
636  if(stat != NC_NOERR) return stat;
637  return ncp->dispatch->def_var_fill(ncid,varid,no_fill,fill_value);
638 }
639 
640 int
641 nc_def_var_endian(int ncid, int varid, int endian)
642 {
643  NC* ncp;
644  int stat = NC_check_id(ncid,&ncp);
645  if(stat != NC_NOERR) return stat;
646  return ncp->dispatch->def_var_endian(ncid,varid,endian);
647 }
648 
649 #endif /* USE_NETCDF4 */
#define NC_CHAR
ISO/ASCII character.
Definition: netcdf.h:39
int nc_get_var_chunk_cache(int ncid, int varid, size_t *sizep, size_t *nelemsp, float *preemptionp)
Definition: dvar.c:570
EXTERNL int nc_inq_vardimid(int ncid, int varid, int *dimidsp)
Learn the dimension IDs associated with a variable.
Definition: dvarinq.c:213
int nc_def_var(int ncid, const char *name, nc_type xtype, int ndims, const int *dimidsp, int *varidp)
Define a new variable.
Definition: dvar.c:207
#define NC_UBYTE
unsigned 1 byte int
Definition: netcdf.h:45
#define NC_MAX_VAR_DIMS
max per variable dimensions
Definition: netcdf.h:236
#define NC_UINT
unsigned 4-byte int
Definition: netcdf.h:47
#define NC_INT64
signed 8-byte int
Definition: netcdf.h:48
#define NC_STRING
string
Definition: netcdf.h:50
#define NC_DOUBLE
double precision floating point number
Definition: netcdf.h:44
EXTERNL int nc_inq_dim(int ncid, int dimid, char *name, size_t *lenp)
Find the name and length of a dimension.
Definition: ddim.c:215
EXTERNL int nc_inq_varndims(int ncid, int varid, int *ndimsp)
Learn how many dimensions are associated with a variable.
Definition: dvarinq.c:191
int nc_type
The nc_type type is just an int.
Definition: netcdf.h:28
#define NC_BYTE
signed 1 byte integer
Definition: netcdf.h:38
int nc_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems, float preemption)
Definition: dvar.c:532
int nc_rename_var(int ncid, int varid, const char *name)
Rename a variable.
Definition: dvar.c:280
EXTERNL int nc_inq_dimlen(int ncid, int dimid, size_t *lenp)
Find the length of a dimension.
Definition: ddim.c:450
#define NC_INT
signed 4 byte integer
Definition: netcdf.h:41
#define NC_NAT
Not A Type.
Definition: netcdf.h:37
int nc_free_string(size_t len, char **data)
Free string space allocated by the library.
Definition: dvar.c:594
#define NC_USHORT
unsigned 2-byte int
Definition: netcdf.h:46
EXTERNL int nc_inq_unlimdim(int ncid, int *unlimdimidp)
Find the ID of the unlimited dimension.
Definition: ddim.c:336
#define NC_MAX_DIMS
Maximum for classic library.
Definition: netcdf.h:232
#define NC_SHORT
signed 2 byte integer
Definition: netcdf.h:40
EXTERNL int nc_inq_unlimdims(int ncid, int *nunlimdimsp, int *unlimdimidsp)
Return number and list of unlimited dimensions.
Definition: dvarinq.c:555
#define NC_NOERR
No Error.
Definition: netcdf.h:282
#define NC_FLOAT
single precision floating point number
Definition: netcdf.h:43
#define NC_UINT64
unsigned 8-byte int
Definition: netcdf.h:49

Return to the Main Unidata NetCDF page.
Generated on Sun Nov 1 2015 19:54:55 for NetCDF. NetCDF is a Unidata library.