NetCDF  4.7.0
dvarget.c
Go to the documentation of this file.
1 
9 #include "ncdispatch.h"
10 
15 struct GETodometer {
16  int rank;
17  size_t index[NC_MAX_VAR_DIMS];
18  size_t start[NC_MAX_VAR_DIMS];
19  size_t edges[NC_MAX_VAR_DIMS];
20  ptrdiff_t stride[NC_MAX_VAR_DIMS];
21  size_t stop[NC_MAX_VAR_DIMS];
22 };
23 
24 
35 static void
36 odom_init(struct GETodometer* odom, int rank, const size_t* start,
37  const size_t* edges, const ptrdiff_t* stride)
38 {
39  int i;
40  memset(odom,0,sizeof(struct GETodometer));
41  odom->rank = rank;
42  assert(odom->rank <= NC_MAX_VAR_DIMS);
43  for(i=0;i<odom->rank;i++) {
44  odom->start[i] = (start != NULL ? start[i] : 0);
45  odom->edges[i] = (edges != NULL ? edges[i] : 1);
46  odom->stride[i] = (stride != NULL ? stride[i] : 1);
47  odom->stop[i] = odom->start[i] + (odom->edges[i]*((size_t)odom->stride[i]));
48  odom->index[i] = odom->start[i];
49  }
50 }
51 
59 static int
60 odom_more(struct GETodometer* odom)
61 {
62  return (odom->index[0] < odom->stop[0]);
63 }
64 
72 static int
73 odom_next(struct GETodometer* odom)
74 {
75  int i;
76  if(odom->rank == 0) return 0;
77  for(i=odom->rank-1;i>=0;i--) {
78  odom->index[i] += (size_t)odom->stride[i];
79  if(odom->index[i] < odom->stop[i]) break;
80  if(i == 0) return 0; /* leave the 0th entry if it overflows*/
81  odom->index[i] = odom->start[i]; /* reset this position*/
82  }
83  return 1;
84 }
85 
90 int
91 NC_get_vara(int ncid, int varid,
92  const size_t *start, const size_t *edges,
93  void *value, nc_type memtype)
94 {
95  NC* ncp;
96  size_t *my_count = (size_t *)edges;
97  int stat = NC_check_id(ncid, &ncp);
98  if(stat != NC_NOERR) return stat;
99 
100  if(start == NULL || edges == NULL) {
101  stat = NC_check_nulls(ncid, varid, start, &my_count, NULL);
102  if(stat != NC_NOERR) return stat;
103  }
104  stat = ncp->dispatch->get_vara(ncid,varid,start,my_count,value,memtype);
105  if(edges == NULL) free(my_count);
106  return stat;
107 }
108 
135 static int
136 NC_get_var(int ncid, int varid, void *value, nc_type memtype)
137 {
138  return NC_get_vara(ncid, varid, NC_coord_zero, NULL, value, memtype);
139 }
140 
145 int
146 NCDEFAULT_get_vars(int ncid, int varid, const size_t * start,
147  const size_t * edges, const ptrdiff_t * stride,
148  void *value0, nc_type memtype)
149 {
150  /* Rebuilt get_vars code to simplify and avoid use of get_varm */
151 
152  int status = NC_NOERR;
153  int i,simplestride,isrecvar;
154  int rank;
155  struct GETodometer odom;
156  nc_type vartype = NC_NAT;
157  NC* ncp;
158  int memtypelen;
159  size_t vartypelen;
160  size_t nels;
161  char* value = (char*)value0;
162  size_t numrecs;
163  size_t varshape[NC_MAX_VAR_DIMS];
164  size_t mystart[NC_MAX_VAR_DIMS];
165  size_t myedges[NC_MAX_VAR_DIMS];
166  ptrdiff_t mystride[NC_MAX_VAR_DIMS];
167  char *memptr = NULL;
168 
169  status = NC_check_id (ncid, &ncp);
170  if(status != NC_NOERR) return status;
171 
172  status = nc_inq_vartype(ncid, varid, &vartype);
173  if(status != NC_NOERR) return status;
174 
175  if(memtype == NC_NAT) memtype = vartype;
176 
177  /* compute the variable type size */
178  status = nc_inq_type(ncid,vartype,NULL,&vartypelen);
179  if(status != NC_NOERR) return status;
180 
181  if(memtype > NC_MAX_ATOMIC_TYPE)
182  memtypelen = (int)vartypelen;
183  else
184  memtypelen = nctypelen(memtype);
185 
186  /* Check gross internal/external type compatibility */
187  if(vartype != memtype) {
188  /* If !atomic, the two types must be the same */
189  if(vartype > NC_MAX_ATOMIC_TYPE
190  || memtype > NC_MAX_ATOMIC_TYPE)
191  return NC_EBADTYPE;
192  /* ok, the types differ but both are atomic */
193  if(memtype == NC_CHAR || vartype == NC_CHAR)
194  return NC_ECHAR;
195  }
196 
197  /* Get the variable rank */
198  status = nc_inq_varndims(ncid, varid, &rank);
199  if(status != NC_NOERR) return status;
200 
201  /* Start array is always required for non-scalar vars. */
202  if(rank > 0 && start == NULL)
203  return NC_EINVALCOORDS;
204 
205  /* Get variable dimension sizes */
206  isrecvar = NC_is_recvar(ncid,varid,&numrecs);
207  NC_getshape(ncid,varid,rank,varshape);
208 
209  /* Optimize out using various checks */
210  if (rank == 0) {
211  /*
212  * The variable is a scalar; consequently,
213  * there s only one thing to get and only one place to put it.
214  * (Why was I called?)
215  */
216  size_t edge1[1] = {1};
217  return NC_get_vara(ncid, varid, start, edge1, value, memtype);
218  }
219 
220  /* Do various checks and fixups on start/edges/stride */
221  simplestride = 1; /* assume so */
222  nels = 1;
223  for(i=0;i<rank;i++) {
224  size_t dimlen;
225  mystart[i] = (start == NULL ? 0 : start[i]);
226  /* illegal value checks */
227  dimlen = (i == 0 && isrecvar ? numrecs : varshape[i]);
228  /* mystart is unsigned, never < 0 */
229 #ifdef RELAX_COORD_BOUND
230  if (mystart[i] > dimlen) return NC_EINVALCOORDS;
231 #else
232  if (mystart[i] >= dimlen) return NC_EINVALCOORDS;
233 #endif
234  if(edges == NULL) {
235  if(i == 0 && isrecvar)
236  myedges[i] = numrecs - start[i];
237  else
238  myedges[i] = varshape[i] - mystart[i];
239  } else
240  myedges[i] = edges[i];
241 #ifdef RELAX_COORD_BOUND
242  if (mystart[i] == dimlen && myedges[i] > 0) return NC_EINVALCOORDS;
243 #endif
244  /* myedges is unsigned, never < 0 */
245  if(mystart[i] + myedges[i] > dimlen)
246  return NC_EEDGE;
247  mystride[i] = (stride == NULL ? 1 : stride[i]);
248  if(mystride[i] <= 0
249  /* cast needed for braindead systems with signed size_t */
250  || ((unsigned long) mystride[i] >= X_INT_MAX))
251  return NC_ESTRIDE;
252  if(mystride[i] != 1) simplestride = 0;
253  if(myedges[i] == 0)
254  nels = 0;
255  }
256  if(nels == 0)
257  return NC_NOERR; /* cannot read anything */
258  if(simplestride) {
259  return NC_get_vara(ncid, varid, mystart, myedges, value, memtype);
260  }
261 
262  /* memptr indicates where to store the next value */
263  memptr = value;
264 
265  odom_init(&odom,rank,mystart,myedges,mystride);
266 
267  /* walk the odometer to extract values */
268  while(odom_more(&odom)) {
269  int localstatus = NC_NOERR;
270  /* Read a single value */
271  localstatus = NC_get_vara(ncid,varid,odom.index,nc_sizevector1,memptr,memtype);
272  /* So it turns out that when get_varm is used, all errors are
273  delayed and ERANGE will be overwritten by more serious errors.
274  */
275  if(localstatus != NC_NOERR) {
276  if(status == NC_NOERR || localstatus != NC_ERANGE)
277  status = localstatus;
278  }
279  memptr += memtypelen;
280  odom_next(&odom);
281  }
282  return status;
283 }
284 
288 static int
289 NC_get_var1(int ncid, int varid, const size_t *coord, void* value,
290  nc_type memtype)
291 {
292  return NC_get_vara(ncid, varid, coord, NC_coord_one, value, memtype);
293 }
294 
298 int
299 NCDEFAULT_get_varm(int ncid, int varid, const size_t *start,
300  const size_t *edges, const ptrdiff_t *stride,
301  const ptrdiff_t *imapp, void *value0, nc_type memtype)
302 {
303  int status = NC_NOERR;
304  nc_type vartype = NC_NAT;
305  int varndims,maxidim;
306  NC* ncp;
307  int memtypelen;
308  char* value = (char*)value0;
309 
310  status = NC_check_id (ncid, &ncp);
311  if(status != NC_NOERR) return status;
312 
313 /*
314  if(NC_indef(ncp)) return NC_EINDEFINE;
315 */
316 
317  status = nc_inq_vartype(ncid, varid, &vartype);
318  if(status != NC_NOERR) return status;
319  /* Check that this is an atomic type */
320  if(vartype > NC_MAX_ATOMIC_TYPE)
321  return NC_EMAPTYPE;
322 
323  status = nc_inq_varndims(ncid, varid, &varndims);
324  if(status != NC_NOERR) return status;
325 
326  if(memtype == NC_NAT) {
327  memtype = vartype;
328  }
329 
330  if(memtype == NC_CHAR && vartype != NC_CHAR)
331  return NC_ECHAR;
332  else if(memtype != NC_CHAR && vartype == NC_CHAR)
333  return NC_ECHAR;
334 
335  memtypelen = nctypelen(memtype);
336 
337  maxidim = (int) varndims - 1;
338 
339  if (maxidim < 0)
340  {
341  /*
342  * The variable is a scalar; consequently,
343  * there s only one thing to get and only one place to put it.
344  * (Why was I called?)
345  */
346  size_t edge1[1] = {1};
347  return NC_get_vara(ncid, varid, start, edge1, value, memtype);
348  }
349 
350  /*
351  * else
352  * The variable is an array.
353  */
354  {
355  int idim;
356  size_t *mystart = NULL;
357  size_t *myedges;
358  size_t *iocount; /* count vector */
359  size_t *stop; /* stop indexes */
360  size_t *length; /* edge lengths in bytes */
361  ptrdiff_t *mystride;
362  ptrdiff_t *mymap;
363  size_t varshape[NC_MAX_VAR_DIMS];
364  int isrecvar;
365  size_t numrecs;
366 
367  /* Compute some dimension related values */
368  isrecvar = NC_is_recvar(ncid,varid,&numrecs);
369  NC_getshape(ncid,varid,varndims,varshape);
370 
371  /*
372  * Verify stride argument; also see if stride is all ones
373  */
374  if(stride != NULL) {
375  int stride1 = 1;
376  for (idim = 0; idim <= maxidim; ++idim)
377  {
378  if (stride[idim] == 0
379  /* cast needed for braindead systems with signed size_t */
380  || ((unsigned long) stride[idim] >= X_INT_MAX))
381  {
382  return NC_ESTRIDE;
383  }
384  if(stride[idim] != 1) stride1 = 0;
385  }
386  /* If stride1 is true, and there is no imap
387  then call get_vara directly.
388  */
389  if(stride1 && imapp == NULL) {
390  return NC_get_vara(ncid, varid, start, edges, value, memtype);
391  }
392  }
393 
394  /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
395  /* Allocate space for mystart,mystride,mymap etc.all at once */
396  mystart = (size_t *)calloc((size_t)(varndims * 7), sizeof(ptrdiff_t));
397  if(mystart == NULL) return NC_ENOMEM;
398  myedges = mystart + varndims;
399  iocount = myedges + varndims;
400  stop = iocount + varndims;
401  length = stop + varndims;
402  mystride = (ptrdiff_t *)(length + varndims);
403  mymap = mystride + varndims;
404 
405  /*
406  * Check start, edges
407  */
408  for (idim = maxidim; idim >= 0; --idim)
409  {
410  size_t dimlen =
411  idim == 0 && isrecvar
412  ? numrecs
413  : varshape[idim];
414 
415  mystart[idim] = start != NULL
416  ? start[idim]
417  : 0;
418 
419 #ifdef RELAX_COORD_BOUND
420  if (mystart[idim] > dimlen)
421 #else
422  if (mystart[idim] >= dimlen)
423 #endif
424  {
425  status = NC_EINVALCOORDS;
426  goto done;
427  }
428 
429 #ifdef COMPLEX
430  myedges[idim] = edges != NULL
431  ? edges[idim]
432  : idim == 0 && isrecvar
433  ? numrecs - mystart[idim]
434  : varshape[idim] - mystart[idim];
435 #else
436  if(edges != NULL)
437  myedges[idim] = edges[idim];
438  else if (idim == 0 && isrecvar)
439  myedges[idim] = numrecs - mystart[idim];
440  else
441  myedges[idim] = varshape[idim] - mystart[idim];
442 #endif
443 
444 #ifdef RELAX_COORD_BOUND
445  if (mystart[idim] == dimlen && myedges[idim] > 0)
446  {
447  status = NC_EINVALCOORDS;
448  goto done;
449  }
450 #endif
451 
452  if (mystart[idim] + myedges[idim] > dimlen)
453  {
454  status = NC_EEDGE;
455  goto done;
456  }
457  }
458 
459 
460  /*
461  * Initialize I/O parameters.
462  */
463  for (idim = maxidim; idim >= 0; --idim)
464  {
465  if (edges != NULL && edges[idim] == 0)
466  {
467  status = NC_NOERR; /* read/write no data */
468  goto done;
469  }
470 
471  mystride[idim] = stride != NULL
472  ? stride[idim]
473  : 1;
474 
475  /* Remember: in netCDF-2 imapp is byte oriented, not index oriented
476  * Starting from netCDF-3, imapp is index oriented */
477 #ifdef COMPLEX
478  mymap[idim] = (imapp != NULL
479  ? imapp[idim]
480  : (idim == maxidim ? 1
481  : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]));
482 #else
483  if(imapp != NULL)
484  mymap[idim] = imapp[idim];
485  else if (idim == maxidim)
486  mymap[idim] = 1;
487  else
488  mymap[idim] =
489  mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1];
490 #endif
491  iocount[idim] = 1;
492  length[idim] = ((size_t)mymap[idim]) * myedges[idim];
493  stop[idim] = (mystart[idim] + myedges[idim] * (size_t)mystride[idim]);
494  }
495 
496  /* Lower body */
497  /*
498  * As an optimization, adjust I/O parameters when the fastest
499  * dimension has unity stride both externally and internally.
500  * In this case, the user could have called a simpler routine
501  * (i.e. ncvar$1()
502  */
503  if (mystride[maxidim] == 1
504  && mymap[maxidim] == 1)
505  {
506  iocount[maxidim] = myedges[maxidim];
507  mystride[maxidim] = (ptrdiff_t) myedges[maxidim];
508  mymap[maxidim] = (ptrdiff_t) length[maxidim];
509  }
510 
511  /*
512  * Perform I/O. Exit when done.
513  */
514  for (;;)
515  {
516  /* TODO: */
517  int lstatus = NC_get_vara(ncid, varid, mystart, iocount,
518  value, memtype);
519  if (lstatus != NC_NOERR) {
520  if(status == NC_NOERR || lstatus != NC_ERANGE)
521  status = lstatus;
522  }
523  /*
524  * The following code permutes through the variable s
525  * external start-index space and it s internal address
526  * space. At the UPC, this algorithm is commonly
527  * called "odometer code".
528  */
529  idim = maxidim;
530  carry:
531  value += (((int)mymap[idim]) * memtypelen);
532  mystart[idim] += (size_t)mystride[idim];
533  if (mystart[idim] == stop[idim])
534  {
535  size_t l = (length[idim] * (size_t)memtypelen);
536  value -= l;
537  mystart[idim] = start[idim];
538  if (--idim < 0)
539  break; /* normal return */
540  goto carry;
541  }
542  } /* I/O loop */
543  done:
544  free(mystart);
545  } /* variable is array */
546  return status;
547 }
548 
581 static int
582 NC_get_vars(int ncid, int varid, const size_t *start,
583  const size_t *edges, const ptrdiff_t *stride, void *value,
584  nc_type memtype)
585 {
586  NC* ncp;
587  size_t *my_count = (size_t *)edges;
588  ptrdiff_t *my_stride = (ptrdiff_t *)stride;
589  int stat;
590 
591  stat = NC_check_id(ncid, &ncp);
592  if(stat != NC_NOERR) return stat;
593 
594  /* Handle any NULL parameters. */
595  if(start == NULL || edges == NULL || stride == NULL) {
596  stat = NC_check_nulls(ncid, varid, start, &my_count, &my_stride);
597  if(stat != NC_NOERR) return stat;
598  }
599 
600  stat = ncp->dispatch->get_vars(ncid,varid,start,my_count,my_stride,
601  value,memtype);
602  if(edges == NULL) free(my_count);
603  if(stride == NULL) free(my_stride);
604  return stat;
605 }
606 
643 static int
644 NC_get_varm(int ncid, int varid, const size_t *start,
645  const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t* map,
646  void *value, nc_type memtype)
647 {
648  NC* ncp;
649  size_t *my_count = (size_t *)edges;
650  ptrdiff_t *my_stride = (ptrdiff_t *)stride;
651  int stat;
652 
653  stat = NC_check_id(ncid, &ncp);
654  if(stat != NC_NOERR) return stat;
655 
656  /* Handle any NULL parameters. */
657  if(start == NULL || edges == NULL || stride == NULL) {
658  stat = NC_check_nulls(ncid, varid, start, &my_count, &my_stride);
659  if(stat != NC_NOERR) return stat;
660  }
661 
662  stat = ncp->dispatch->get_varm(ncid, varid, start, my_count, my_stride,
663  map, value, memtype);
664  if(edges == NULL) free(my_count);
665  if(stride == NULL) free(my_stride);
666  return stat;
667 }
668  /* All these functions are part of this named group... */
673 
749 int
750 nc_get_vara(int ncid, int varid, const size_t *startp,
751  const size_t *countp, void *ip)
752 {
753  NC* ncp;
754  nc_type xtype = NC_NAT;
755  int stat = NC_check_id(ncid, &ncp);
756  if(stat != NC_NOERR) return stat;
757  stat = nc_inq_vartype(ncid, varid, &xtype);
758  if(stat != NC_NOERR) return stat;
759  return NC_get_vara(ncid, varid, startp, countp, ip, xtype);
760 }
761 
762 int
763 nc_get_vara_text(int ncid, int varid, const size_t *startp,
764  const size_t *countp, char *ip)
765 {
766  return NC_get_vara(ncid, varid, startp, countp, (void *)ip, NC_CHAR);
767 }
768 
769 int
770 nc_get_vara_schar(int ncid, int varid, const size_t *startp,
771  const size_t *countp, signed char *ip)
772 {
773  return NC_get_vara(ncid, varid, startp, countp, (void *)ip, NC_BYTE);
774 }
775 
776 int
777 nc_get_vara_uchar(int ncid, int varid, const size_t *startp,
778  const size_t *countp, unsigned char *ip)
779 {
780  return NC_get_vara(ncid, varid, startp, countp, (void *)ip, T_uchar);
781 }
782 
783 int
784 nc_get_vara_short(int ncid, int varid, const size_t *startp,
785  const size_t *countp, short *ip)
786 {
787  return NC_get_vara(ncid, varid, startp, countp, (void *)ip, NC_SHORT);
788 }
789 
790 int
791 nc_get_vara_int(int ncid, int varid,
792  const size_t *startp, const size_t *countp, int *ip)
793 {
794  return NC_get_vara(ncid,varid,startp,countp, (void *)ip,NC_INT);
795 }
796 
797 int
798 nc_get_vara_long(int ncid, int varid,
799  const size_t *startp, const size_t *countp, long *ip)
800 {
801  return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_long);
802 }
803 
804 int
805 nc_get_vara_float(int ncid, int varid,
806  const size_t *startp, const size_t *countp, float *ip)
807 {
808  return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_float);
809 }
810 
811 int
812 nc_get_vara_double(int ncid, int varid, const size_t *startp,
813  const size_t *countp, double *ip)
814 {
815  return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_double);
816 }
817 
818 int
819 nc_get_vara_ubyte(int ncid, int varid,
820  const size_t *startp, const size_t *countp, unsigned char *ip)
821 {
822  return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_ubyte);
823 }
824 
825 int
826 nc_get_vara_ushort(int ncid, int varid,
827  const size_t *startp, const size_t *countp, unsigned short *ip)
828 {
829  return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_ushort);
830 }
831 
832 int
833 nc_get_vara_uint(int ncid, int varid,
834  const size_t *startp, const size_t *countp, unsigned int *ip)
835 {
836  return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_uint);
837 }
838 
839 int
840 nc_get_vara_longlong(int ncid, int varid,
841  const size_t *startp, const size_t *countp, long long *ip)
842 {
843  return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_longlong);
844 }
845 
846 int
847 nc_get_vara_ulonglong(int ncid, int varid, const size_t *startp,
848  const size_t *countp, unsigned long long *ip)
849 {
850  return NC_get_vara(ncid,varid,startp,countp, (void *)ip,NC_UINT64);
851 }
852 
853 #ifdef USE_NETCDF4
854 int
855 nc_get_vara_string(int ncid, int varid, const size_t *startp,
856  const size_t *countp, char* *ip)
857 {
858  return NC_get_vara(ncid,varid,startp,countp, (void *)ip,NC_STRING);
859 }
860 
861 #endif /*USE_NETCDF4*/
862 
899 int
900 nc_get_var1(int ncid, int varid, const size_t *indexp, void *ip)
901 {
902  return NC_get_var1(ncid, varid, indexp, ip, NC_NAT);
903 }
904 
905 int
906 nc_get_var1_text(int ncid, int varid, const size_t *indexp, char *ip)
907 {
908  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_CHAR);
909 }
910 
911 int
912 nc_get_var1_schar(int ncid, int varid, const size_t *indexp, signed char *ip)
913 {
914  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_BYTE);
915 }
916 
917 int
918 nc_get_var1_uchar(int ncid, int varid, const size_t *indexp, unsigned char *ip)
919 {
920  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_UBYTE);
921 }
922 
923 int
924 nc_get_var1_short(int ncid, int varid, const size_t *indexp, short *ip)
925 {
926  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_SHORT);
927 }
928 
929 int
930 nc_get_var1_int(int ncid, int varid, const size_t *indexp, int *ip)
931 {
932  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_INT);
933 }
934 
935 int
936 nc_get_var1_long(int ncid, int varid, const size_t *indexp,
937  long *ip)
938 {
939  return NC_get_var1(ncid, varid, indexp, (void *)ip, longtype);
940 }
941 
942 int
943 nc_get_var1_float(int ncid, int varid, const size_t *indexp,
944  float *ip)
945 {
946  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_FLOAT);
947 }
948 
949 int
950 nc_get_var1_double(int ncid, int varid, const size_t *indexp,
951  double *ip)
952 {
953  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_DOUBLE);
954 }
955 
956 int
957 nc_get_var1_ubyte(int ncid, int varid, const size_t *indexp,
958  unsigned char *ip)
959 {
960  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_UBYTE);
961 }
962 
963 int
964 nc_get_var1_ushort(int ncid, int varid, const size_t *indexp,
965  unsigned short *ip)
966 {
967  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_USHORT);
968 }
969 
970 int
971 nc_get_var1_uint(int ncid, int varid, const size_t *indexp,
972  unsigned int *ip)
973 {
974  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_UINT);
975 }
976 
977 int
978 nc_get_var1_longlong(int ncid, int varid, const size_t *indexp,
979  long long *ip)
980 {
981  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_INT64);
982 }
983 
984 int
985 nc_get_var1_ulonglong(int ncid, int varid, const size_t *indexp,
986  unsigned long long *ip)
987 {
988  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_UINT64);
989 }
990 
991 #ifdef USE_NETCDF4
992 int
993 nc_get_var1_string(int ncid, int varid, const size_t *indexp, char* *ip)
994 {
995  return NC_get_var1(ncid, varid, indexp, (void *)ip, NC_STRING);
996 }
997 #endif /*USE_NETCDF4*/
998 
1044 int
1045 nc_get_var(int ncid, int varid, void *ip)
1046 {
1047  return NC_get_var(ncid, varid, ip, NC_NAT);
1048 }
1049 
1050 int
1051 nc_get_var_text(int ncid, int varid, char *ip)
1052 {
1053  return NC_get_var(ncid, varid, (void *)ip, NC_CHAR);
1054 }
1055 
1056 int
1057 nc_get_var_schar(int ncid, int varid, signed char *ip)
1058 {
1059  return NC_get_var(ncid, varid, (void *)ip, NC_BYTE);
1060 }
1061 
1062 int
1063 nc_get_var_uchar(int ncid, int varid, unsigned char *ip)
1064 {
1065  return NC_get_var(ncid,varid, (void *)ip, NC_UBYTE);
1066 }
1067 
1068 int
1069 nc_get_var_short(int ncid, int varid, short *ip)
1070 {
1071  return NC_get_var(ncid, varid, (void *)ip, NC_SHORT);
1072 }
1073 
1074 int
1075 nc_get_var_int(int ncid, int varid, int *ip)
1076 {
1077  return NC_get_var(ncid,varid, (void *)ip, NC_INT);
1078 }
1079 
1080 int
1081 nc_get_var_long(int ncid, int varid, long *ip)
1082 {
1083  return NC_get_var(ncid,varid, (void *)ip, longtype);
1084 }
1085 
1086 int
1087 nc_get_var_float(int ncid, int varid, float *ip)
1088 {
1089  return NC_get_var(ncid,varid, (void *)ip, NC_FLOAT);
1090 }
1091 
1092 int
1093 nc_get_var_double(int ncid, int varid, double *ip)
1094 {
1095  return NC_get_var(ncid,varid, (void *)ip, NC_DOUBLE);
1096 }
1097 
1098 int
1099 nc_get_var_ubyte(int ncid, int varid, unsigned char *ip)
1100 {
1101  return NC_get_var(ncid,varid, (void *)ip, NC_UBYTE);
1102 }
1103 
1104 int
1105 nc_get_var_ushort(int ncid, int varid, unsigned short *ip)
1106 {
1107  return NC_get_var(ncid,varid, (void *)ip, NC_USHORT);
1108 }
1109 
1110 int
1111 nc_get_var_uint(int ncid, int varid, unsigned int *ip)
1112 {
1113  return NC_get_var(ncid,varid, (void *)ip, NC_UINT);
1114 }
1115 
1116 int
1117 nc_get_var_longlong(int ncid, int varid, long long *ip)
1118 {
1119  return NC_get_var(ncid,varid, (void *)ip, NC_INT64);
1120 }
1121 
1122 int
1123 nc_get_var_ulonglong(int ncid, int varid, unsigned long long *ip)
1124 {
1125  return NC_get_var(ncid,varid, (void *)ip,NC_UINT64);
1126 }
1127 
1128 #ifdef USE_NETCDF4
1129 int
1130 nc_get_var_string(int ncid, int varid, char* *ip)
1131 {
1132  return NC_get_var(ncid,varid, (void *)ip,NC_STRING);
1133 }
1134 #endif /*USE_NETCDF4*/
1135 
1178 int
1179 nc_get_vars(int ncid, int varid, const size_t * startp,
1180  const size_t * countp, const ptrdiff_t * stridep,
1181  void *ip)
1182 {
1183  return NC_get_vars(ncid, varid, startp, countp, stridep,
1184  ip, NC_NAT);
1185 }
1186 
1187 int
1188 nc_get_vars_text(int ncid, int varid, const size_t *startp,
1189  const size_t *countp, const ptrdiff_t * stridep,
1190  char *ip)
1191 {
1192  return NC_get_vars(ncid,varid,startp, countp, stridep,
1193  (void *)ip, NC_CHAR);
1194 }
1195 
1196 int
1197 nc_get_vars_schar(int ncid, int varid, const size_t *startp,
1198  const size_t *countp, const ptrdiff_t * stridep,
1199  signed char *ip)
1200 {
1201  return NC_get_vars(ncid,varid,startp, countp, stridep,
1202  (void *)ip, NC_BYTE);
1203 }
1204 
1205 int
1206 nc_get_vars_uchar(int ncid, int varid, const size_t *startp,
1207  const size_t *countp, const ptrdiff_t * stridep,
1208  unsigned char *ip)
1209 {
1210  return NC_get_vars(ncid,varid,startp, countp, stridep,
1211  (void *)ip, T_uchar);
1212 }
1213 
1214 int
1215 nc_get_vars_short(int ncid, int varid, const size_t *startp,
1216  const size_t *countp, const ptrdiff_t *stridep,
1217  short *ip)
1218 {
1219  return NC_get_vars(ncid,varid,startp, countp, stridep,
1220  (void *)ip, NC_SHORT);
1221 }
1222 
1223 int
1224 nc_get_vars_int(int ncid, int varid, const size_t *startp,
1225  const size_t *countp, const ptrdiff_t * stridep,
1226  int *ip)
1227 {
1228  return NC_get_vars(ncid,varid,startp, countp, stridep,
1229  (void *)ip, NC_INT);
1230 }
1231 
1232 int
1233 nc_get_vars_long(int ncid, int varid, const size_t *startp,
1234  const size_t *countp, const ptrdiff_t * stridep,
1235  long *ip)
1236 {
1237  return NC_get_vars(ncid,varid,startp, countp, stridep,
1238  (void *)ip, T_long);
1239 }
1240 
1241 int
1242 nc_get_vars_float(int ncid, int varid, const size_t *startp,
1243  const size_t *countp, const ptrdiff_t * stridep,
1244  float *ip)
1245 {
1246  return NC_get_vars(ncid,varid,startp, countp, stridep,
1247  (void *)ip, T_float);
1248 }
1249 
1250 int
1251 nc_get_vars_double(int ncid, int varid, const size_t *startp,
1252  const size_t *countp, const ptrdiff_t * stridep,
1253  double *ip)
1254 {
1255  return NC_get_vars(ncid,varid,startp, countp, stridep,
1256  (void *)ip, T_double);
1257 }
1258 
1259 int
1260 nc_get_vars_ubyte(int ncid, int varid, const size_t *startp,
1261  const size_t *countp, const ptrdiff_t * stridep,
1262  unsigned char *ip)
1263 {
1264  return NC_get_vars(ncid,varid, startp, countp, stridep,
1265  (void *)ip, T_ubyte);
1266 }
1267 
1268 int
1269 nc_get_vars_ushort(int ncid, int varid, const size_t *startp,
1270  const size_t *countp, const ptrdiff_t * stridep,
1271  unsigned short *ip)
1272 {
1273  return NC_get_vars(ncid,varid,startp,countp, stridep,
1274  (void *)ip, T_ushort);
1275 }
1276 
1277 int
1278 nc_get_vars_uint(int ncid, int varid, const size_t *startp,
1279  const size_t *countp, const ptrdiff_t * stridep,
1280  unsigned int *ip)
1281 {
1282  return NC_get_vars(ncid,varid,startp, countp, stridep,
1283  (void *)ip, T_uint);
1284 }
1285 
1286 int
1287 nc_get_vars_longlong(int ncid, int varid, const size_t *startp,
1288  const size_t *countp, const ptrdiff_t * stridep,
1289  long long *ip)
1290 {
1291  return NC_get_vars(ncid, varid, startp, countp, stridep,
1292  (void *)ip, T_longlong);
1293 }
1294 
1295 int
1296 nc_get_vars_ulonglong(int ncid, int varid, const size_t *startp,
1297  const size_t *countp, const ptrdiff_t * stridep,
1298  unsigned long long *ip)
1299 {
1300  return NC_get_vars(ncid, varid, startp, countp, stridep,
1301  (void *)ip, NC_UINT64);
1302 }
1303 
1304 #ifdef USE_NETCDF4
1305 int
1306 nc_get_vars_string(int ncid, int varid,
1307  const size_t *startp, const size_t *countp,
1308  const ptrdiff_t * stridep,
1309  char* *ip)
1310 {
1311  return NC_get_vars(ncid, varid, startp, countp, stridep,
1312  (void *)ip, NC_STRING);
1313 }
1314 #endif /*USE_NETCDF4*/
1315 
1373 int
1374 nc_get_varm(int ncid, int varid, const size_t * startp,
1375  const size_t * countp, const ptrdiff_t * stridep,
1376  const ptrdiff_t * imapp, void *ip)
1377 {
1378  return NC_get_varm(ncid, varid, startp, countp, stridep, imapp, ip, NC_NAT);
1379 }
1380 
1381 int
1382 nc_get_varm_schar(int ncid, int varid,
1383  const size_t *startp, const size_t *countp,
1384  const ptrdiff_t *stridep,
1385  const ptrdiff_t *imapp, signed char *ip)
1386 {
1387  return NC_get_varm(ncid, varid, startp, countp,
1388  stridep, imapp, (void *)ip, NC_BYTE);
1389 }
1390 
1391 int
1392 nc_get_varm_uchar(int ncid, int varid,
1393  const size_t *startp, const size_t *countp,
1394  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1395  unsigned char *ip)
1396 {
1397  return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,T_uchar);
1398 }
1399 
1400 int
1401 nc_get_varm_short(int ncid, int varid, const size_t *startp,
1402  const size_t *countp, const ptrdiff_t *stridep,
1403  const ptrdiff_t *imapp, short *ip)
1404 {
1405  return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,NC_SHORT);
1406 }
1407 
1408 int
1409 nc_get_varm_int(int ncid, int varid,
1410  const size_t *startp, const size_t *countp,
1411  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1412  int *ip)
1413 {
1414  return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,NC_INT);
1415 }
1416 
1417 int
1418 nc_get_varm_long(int ncid, int varid,
1419  const size_t *startp, const size_t *countp,
1420  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1421  long *ip)
1422 {
1423  return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,T_long);
1424 }
1425 
1426 int
1427 nc_get_varm_float(int ncid, int varid,
1428  const size_t *startp, const size_t *countp,
1429  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1430  float *ip)
1431 {
1432  return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,T_float);
1433 }
1434 
1435 int
1436 nc_get_varm_double(int ncid, int varid,
1437  const size_t *startp, const size_t *countp,
1438  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1439  double *ip)
1440 {
1441  return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,T_double);
1442 }
1443 
1444 int
1445 nc_get_varm_ubyte(int ncid, int varid,
1446  const size_t *startp, const size_t *countp,
1447  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1448  unsigned char *ip)
1449 {
1450  return NC_get_varm(ncid,varid,startp,countp,stridep,
1451  imapp, (void *)ip, T_ubyte);
1452 }
1453 
1454 int
1455 nc_get_varm_ushort(int ncid, int varid,
1456  const size_t *startp, const size_t *countp,
1457  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1458  unsigned short *ip)
1459 {
1460  return NC_get_varm(ncid, varid, startp, countp, stridep,
1461  imapp, (void *)ip, T_ushort);
1462 }
1463 
1464 int
1465 nc_get_varm_uint(int ncid, int varid,
1466  const size_t *startp, const size_t *countp,
1467  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1468  unsigned int *ip)
1469 {
1470  return NC_get_varm(ncid, varid, startp, countp,
1471  stridep, imapp, (void *)ip, T_uint);
1472 }
1473 
1474 int
1475 nc_get_varm_longlong(int ncid, int varid, const size_t *startp,
1476  const size_t *countp, const ptrdiff_t *stridep,
1477  const ptrdiff_t *imapp, long long *ip)
1478 {
1479  return NC_get_varm(ncid, varid, startp, countp, stridep, imapp,
1480  (void *)ip, T_longlong);
1481 }
1482 
1483 int
1484 nc_get_varm_ulonglong(int ncid, int varid,
1485  const size_t *startp, const size_t *countp,
1486  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1487  unsigned long long *ip)
1488 {
1489  return NC_get_varm(ncid, varid, startp, countp, stridep, imapp,
1490  (void *)ip, NC_UINT64);
1491 }
1492 
1493 int
1494 nc_get_varm_text(int ncid, int varid, const size_t *startp,
1495  const size_t *countp, const ptrdiff_t *stridep,
1496  const ptrdiff_t *imapp, char *ip)
1497 {
1498  return NC_get_varm(ncid, varid, startp, countp, stridep, imapp,
1499  (void *)ip, NC_CHAR);
1500 }
1501 
1502 #ifdef USE_NETCDF4
1503 int
1504 nc_get_varm_string(int ncid, int varid, const size_t *startp,
1505  const size_t *countp, const ptrdiff_t *stridep,
1506  const ptrdiff_t *imapp, char **ip)
1507 {
1508  return NC_get_varm(ncid, varid, startp, countp, stridep, imapp,
1509  (void *)ip, NC_STRING);
1510 }
1512 #endif /*USE_NETCDF4*/
1513 
1514  /* End of named group... */
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.
Definition: dvarget.c:833
int nc_get_var_uint(int ncid, int varid, unsigned int *ip)
Read an entire variable in one call.
Definition: dvarget.c:1111
int nc_get_var1_text(int ncid, int varid, const size_t *indexp, char *ip)
Read a single datum from a variable.
Definition: dvarget.c:906
#define NC_ENOMEM
Memory allocation (malloc) failure.
Definition: netcdf.h:405
int nc_get_var_ulonglong(int ncid, int varid, unsigned long long *ip)
Read an entire variable in one call.
Definition: dvarget.c:1123
#define NC_CHAR
ISO/ASCII character.
Definition: netcdf.h:36
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.
Definition: dvarget.c:1401
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.
Definition: dvarget.c:1445
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.
Definition: dvarget.c:812
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.
Definition: dvarget.c:1427
#define NC_UBYTE
unsigned 1 byte int
Definition: netcdf.h:42
#define NC_EMAPTYPE
Mapped access for atomic types only.
Definition: netcdf.h:458
#define NC_ERANGE
Math result not representable.
Definition: netcdf.h:404
#define NC_MAX_VAR_DIMS
max per variable dimensions
Definition: netcdf.h:276
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.
Definition: dvarget.c:1188
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.
Definition: dvarget.c:1260
int nc_get_var1_string(int ncid, int varid, const size_t *indexp, char **ip)
Read a single datum from a variable.
Definition: dvarget.c:993
#define NC_UINT
unsigned 4-byte int
Definition: netcdf.h:44
int nc_get_var_long(int ncid, int varid, long *ip)
Read an entire variable in one call.
Definition: dvarget.c:1081
#define NC_EINVALCOORDS
Index exceeds dimension bound.
Definition: netcdf.h:357
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.
Definition: dvarget.c:1382
#define NC_INT64
signed 8-byte int
Definition: netcdf.h:45
#define NC_STRING
string
Definition: netcdf.h:47
#define NC_DOUBLE
double precision floating point number
Definition: netcdf.h:41
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.
Definition: dvarget.c:1251
EXTERNL int nc_inq_varndims(int ncid, int varid, int *ndimsp)
Learn how many dimensions are associated with a variable.
Definition: dvarinq.c:204
int nc_get_var_schar(int ncid, int varid, signed char *ip)
Read an entire variable in one call.
Definition: dvarget.c:1057
int nc_get_varm(int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, void *ip)
Read a mapped array from a variable.
Definition: dvarget.c:1374
int nc_type
The nc_type type is just an int.
Definition: netcdf.h:25
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.
Definition: dvarget.c:855
#define NC_BYTE
signed 1 byte integer
Definition: netcdf.h:35
int nc_get_var1_longlong(int ncid, int varid, const size_t *indexp, long long *ip)
Read a single datum from a variable.
Definition: dvarget.c:978
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.
Definition: dvarget.c:1409
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.
Definition: dvarget.c:1287
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.
Definition: dvarget.c:826
int nc_get_var(int ncid, int varid, void *ip)
Read an entire variable in one call.
Definition: dvarget.c:1045
int nc_get_var_int(int ncid, int varid, int *ip)
Read an entire variable in one call.
Definition: dvarget.c:1075
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.
Definition: dvarget.c:784
int nc_get_var_ushort(int ncid, int varid, unsigned short *ip)
Read an entire variable in one call.
Definition: dvarget.c:1105
int nc_get_var_double(int ncid, int varid, double *ip)
Read an entire variable in one call.
Definition: dvarget.c:1093
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.
Definition: dvarget.c:805
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.
Definition: dvarget.c:1465
int nc_get_var_string(int ncid, int varid, char **ip)
Read an entire variable in one call.
Definition: dvarget.c:1130
#define NC_EBADTYPE
Not a netcdf data type.
Definition: netcdf.h:367
#define NC_EEDGE
Start+count exceeds dimension bound.
Definition: netcdf.h:395
int nc_get_var1_ubyte(int ncid, int varid, const size_t *indexp, unsigned char *ip)
Read a single datum from a variable.
Definition: dvarget.c:957
int nc_get_var1_uchar(int ncid, int varid, const size_t *indexp, unsigned char *ip)
Read a single datum from a variable.
Definition: dvarget.c:918
int nc_get_var1(int ncid, int varid, const size_t *indexp, void *ip)
Read a single datum from a variable.
Definition: dvarget.c:900
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.
Definition: dvarget.c:791
#define NC_ESTRIDE
Illegal stride.
Definition: netcdf.h:396
int nc_get_var1_uint(int ncid, int varid, const size_t *indexp, unsigned int *ip)
Read a single datum from a variable.
Definition: dvarget.c:971
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.
Definition: dvarget.c:840
#define NC_INT
signed 4 byte integer
Definition: netcdf.h:38
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.
Definition: dvarget.c:847
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.
Definition: dvarget.c:1206
int nc_get_var_text(int ncid, int varid, char *ip)
Read an entire variable in one call.
Definition: dvarget.c:1051
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.
Definition: dvarget.c:1392
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.
Definition: dvarget.c:1296
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.
Definition: dvarget.c:1224
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.
Definition: dvarget.c:819
int nc_get_var1_float(int ncid, int varid, const size_t *indexp, float *ip)
Read a single datum from a variable.
Definition: dvarget.c:943
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.
Definition: dvarget.c:763
#define NC_NAT
Not A Type.
Definition: netcdf.h:34
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.
Definition: dvarget.c:770
EXTERNL int nc_inq_vartype(int ncid, int varid, nc_type *xtypep)
Learn the type of a variable.
Definition: dvarinq.c:180
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.
Definition: dvarget.c:1242
EXTERNL int nc_inq_type(int ncid, nc_type xtype, char *name, size_t *size)
Inquire about a type.
Definition: dfile.c:1719
#define NC_USHORT
unsigned 2-byte int
Definition: netcdf.h:43
int nc_get_var_ubyte(int ncid, int varid, unsigned char *ip)
Read an entire variable in one call.
Definition: dvarget.c:1099
int nc_get_var_longlong(int ncid, int varid, long long *ip)
Read an entire variable in one call.
Definition: dvarget.c:1117
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.
Definition: dvarget.c:1215
int nc_get_var1_ushort(int ncid, int varid, const size_t *indexp, unsigned short *ip)
Read a single datum from a variable.
Definition: dvarget.c:964
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.
Definition: dvarget.c:1494
int nc_get_var1_schar(int ncid, int varid, const size_t *indexp, signed char *ip)
Read a single datum from a variable.
Definition: dvarget.c:912
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.
Definition: dvarget.c:1197
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.
Definition: dvarget.c:1233
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.
Definition: dvarget.c:1269
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.
Definition: dvarget.c:777
int nc_get_var_float(int ncid, int varid, float *ip)
Read an entire variable in one call.
Definition: dvarget.c:1087
int nc_get_var1_short(int ncid, int varid, const size_t *indexp, short *ip)
Read a single datum from a variable.
Definition: dvarget.c:924
int nc_get_vars(int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, void *ip)
Read a strided array from a variable.
Definition: dvarget.c:1179
int nc_get_var_short(int ncid, int varid, short *ip)
Read an entire variable in one call.
Definition: dvarget.c:1069
#define NC_SHORT
signed 2 byte integer
Definition: netcdf.h:37
int nc_get_var1_ulonglong(int ncid, int varid, const size_t *indexp, unsigned long long *ip)
Read a single datum from a variable.
Definition: dvarget.c:985
int nc_get_var1_double(int ncid, int varid, const size_t *indexp, double *ip)
Read a single datum from a variable.
Definition: dvarget.c:950
int nc_get_var_uchar(int ncid, int varid, unsigned char *ip)
Read an entire variable in one call.
Definition: dvarget.c:1063
#define NC_NOERR
No Error.
Definition: netcdf.h:325
#define NC_ECHAR
Attempt to convert between text & numbers.
Definition: netcdf.h:386
int nc_get_var1_long(int ncid, int varid, const size_t *indexp, long *ip)
Read a single datum from a variable.
Definition: dvarget.c:936
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.
Definition: dvarget.c:1418
int nc_get_var1_int(int ncid, int varid, const size_t *indexp, int *ip)
Read a single datum from a variable.
Definition: dvarget.c:930
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.
Definition: dvarget.c:1455
#define NC_FLOAT
single precision floating point number
Definition: netcdf.h:40
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.
Definition: dvarget.c:1504
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.
Definition: dvarget.c:1436
int nc_get_vara(int ncid, int varid, const size_t *startp, const size_t *countp, void *ip)
Read an array of values from a variable.
Definition: dvarget.c:750
#define NC_UINT64
unsigned 8-byte int
Definition: netcdf.h:46
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.
Definition: dvarget.c:798
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.
Definition: dvarget.c:1475
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.
Definition: dvarget.c:1306
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.
Definition: dvarget.c:1278
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.
Definition: dvarget.c:1484

Return to the Main Unidata NetCDF page.
Generated on Mon Apr 29 2019 10:59:59 for NetCDF. NetCDF is a Unidata library.