NetCDF  4.5.0
dvarput.c
Go to the documentation of this file.
1 
8 #include "ncdispatch.h"
9 
10 #undef VARS_USES_VARM
11 #ifndef VARS_USES_VARM
12 struct PUTodometer {
13  int rank;
14  size_t index[NC_MAX_VAR_DIMS];
15  size_t start[NC_MAX_VAR_DIMS];
16  size_t edges[NC_MAX_VAR_DIMS];
17  ptrdiff_t stride[NC_MAX_VAR_DIMS];
18  size_t stop[NC_MAX_VAR_DIMS];
19 };
20 
21 static void
22 odom_init(struct PUTodometer* odom,
23  int rank,
24  const size_t* start, const size_t* edges, const ptrdiff_t* stride)
25 {
26  int i;
27  memset(odom,0,sizeof(struct PUTodometer));
28  odom->rank = rank;
29  assert(odom->rank <= NC_MAX_VAR_DIMS);
30  for(i=0;i<odom->rank;i++) {
31  odom->start[i] = (start != NULL ? start[i] : 0);
32  odom->edges[i] = (edges != NULL ? edges[i] : 1);
33  odom->stride[i] = (stride != NULL ? stride[i] : 1);
34  odom->stop[i] = odom->start[i] + (odom->edges[i]*(size_t)odom->stride[i]);
35  odom->index[i] = odom->start[i];
36  }
37 }
38 
39 static int
40 odom_more(struct PUTodometer* odom)
41 {
42  return (odom->index[0] < odom->stop[0]);
43 }
44 
45 static int
46 odom_next(struct PUTodometer* odom)
47 {
48  int i;
49  if(odom->rank == 0) return 0;
50  for(i=odom->rank-1;i>=0;i--) {
51  odom->index[i] += (size_t)odom->stride[i];
52  if(odom->index[i] < odom->stop[i]) break;
53  if(i == 0) return 0; /* leave the 0th entry if it overflows*/
54  odom->index[i] = odom->start[i]; /* reset this position*/
55  }
56  return 1;
57 }
58 #endif
59 
63 static int
64 NC_put_vara(int ncid, int varid, const size_t *start,
65  const size_t *edges, const void *value, nc_type memtype)
66 {
67  NC* ncp;
68  int stat = NC_check_id(ncid, &ncp);
69  if(stat != NC_NOERR) return stat;
70  if(edges == NULL) {
71  size_t shape[NC_MAX_VAR_DIMS];
72  int ndims;
73  stat = nc_inq_varndims(ncid, varid, &ndims);
74  if(stat != NC_NOERR) return stat;
75  stat = NC_getshape(ncid, varid, ndims, shape);
76  if(stat != NC_NOERR) return stat;
77  return ncp->dispatch->put_vara(ncid, varid, start, shape, value, memtype);
78  } else
79  return ncp->dispatch->put_vara(ncid, varid, start, edges, value, memtype);
80 }
81 
85 static int
86 NC_put_var(int ncid, int varid, const void *value, nc_type memtype)
87 {
88  int ndims;
89  size_t shape[NC_MAX_VAR_DIMS];
90  int stat = nc_inq_varndims(ncid,varid, &ndims);
91  if(stat) return stat;
92  stat = NC_getshape(ncid,varid, ndims, shape);
93  if(stat) return stat;
94  return NC_put_vara(ncid, varid, NC_coord_zero, shape, value, memtype);
95 }
96 
100 static int
101 NC_put_var1(int ncid, int varid, const size_t *coord, const void* value,
102  nc_type memtype)
103 {
104  return NC_put_vara(ncid, varid, coord, NC_coord_one, value, memtype);
105 }
106 
110 int
111 NCDEFAULT_put_vars(int ncid, int varid, const size_t * start,
112  const size_t * edges, const ptrdiff_t * stride,
113  const void *value0, nc_type memtype)
114 {
115 #ifdef VARS_USES_VARM
116  NC* ncp;
117  int stat = NC_check_id(ncid, &ncp);
118 
119  if(stat != NC_NOERR) return stat;
120  return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,NULL,value0,memtype);
121 #else
122  /* Rebuilt put_vars code to simplify and avoid use of put_varm */
123 
124  int status = NC_NOERR;
125  int i,isstride1,isrecvar;
126  int rank;
127  struct PUTodometer odom;
128  nc_type vartype = NC_NAT;
129  NC* ncp;
130  size_t vartypelen;
131  size_t nels;
132  int memtypelen;
133  const char* value = (const char*)value0;
134  int nrecdims; /* number of record dims for a variable */
135  int is_recdim[NC_MAX_VAR_DIMS]; /* for variable's dimensions */
136  size_t varshape[NC_MAX_VAR_DIMS];
137  size_t mystart[NC_MAX_VAR_DIMS];
138  size_t myedges[NC_MAX_VAR_DIMS];
139  ptrdiff_t mystride[NC_MAX_VAR_DIMS];
140  const char* memptr = value;
141 
142  status = NC_check_id (ncid, &ncp);
143  if(status != NC_NOERR) return status;
144 
145  status = nc_inq_vartype(ncid, varid, &vartype);
146  if(status != NC_NOERR) return status;
147 
148  if(memtype == NC_NAT) memtype = vartype;
149 
150  /* compute the variable type size */
151  status = nc_inq_type(ncid,vartype,NULL,&vartypelen);
152  if(status != NC_NOERR) return status;
153 
154  if(memtype > NC_MAX_ATOMIC_TYPE)
155  memtypelen = (int)vartypelen;
156  else
157  memtypelen = nctypelen(memtype);
158 
159  /* Check gross internal/external type compatibility */
160  if(vartype != memtype) {
161  /* If !atomic, the two types must be the same */
162  if(vartype > NC_MAX_ATOMIC_TYPE
163  || memtype > NC_MAX_ATOMIC_TYPE)
164  return NC_EBADTYPE;
165  /* ok, the types differ but both are atomic */
166  if(memtype == NC_CHAR || vartype == NC_CHAR)
167  return NC_ECHAR;
168  }
169 
170  /* Get the variable rank */
171  status = nc_inq_varndims(ncid, varid, &rank);
172  if(status != NC_NOERR) return status;
173 
174  /* Get variable dimension sizes */
175  status = NC_inq_recvar(ncid,varid,&nrecdims,is_recdim);
176  if(status != NC_NOERR) return status;
177  isrecvar = (nrecdims > 0);
178  NC_getshape(ncid,varid,rank,varshape);
179 
180  /* Optimize out using various checks */
181  if (rank == 0) {
182  /*
183  * The variable is a scalar; consequently,
184  * there is only one thing to get and only one place to put it.
185  * (Why was I called?)
186  */
187  size_t edge1[1] = {1};
188  return NC_put_vara(ncid, varid, start, edge1, value0, memtype);
189  }
190 
191  /* Do various checks and fixups on start/edges/stride */
192  isstride1 = 1; /* assume so */
193  nels = 1;
194  for(i=0;i<rank;i++) {
195  size_t dimlen;
196  mystart[i] = (start == NULL ? 0 : start[i]);
197 #if 0
198  dimlen = (i == 0 && isrecvar ? numrecs : varshape[i]);
199  if(i == 0 && isrecvar) {/*do nothing*/}
200 #else
201  /* illegal value checks */
202  dimlen = varshape[i];
203  if(is_recdim[i]) {/*do nothing*/}
204 #endif
205  else {
206  /* mystart is unsigned, will never be < 0 */
207 #ifdef RELAX_COORD_BOUND
208  if (mystart[i] > dimlen) return NC_EINVALCOORDS;
209 #else
210  if (mystart[i] >= dimlen) return NC_EINVALCOORDS;
211 #endif
212  }
213  if(edges == NULL) {
214 #if 0
215  if(i == 0 && isrecvar)
216  myedges[i] = numrecs - start[i];
217 #else
218  if(is_recdim[i] && isrecvar)
219  myedges[i] = varshape[i] - start[i];
220 #endif
221  else
222  myedges[i] = varshape[i] - mystart[i];
223  } else
224  myedges[i] = edges[i];
225 #ifdef RELAX_COORD_BOUND
226  if(!is_recdim[i]) {
227  if (mystart[i] == dimlen && myedges[i] > 0)
228  return NC_EINVALCOORDS;
229  }
230 #endif
231  if(!is_recdim[i]) {
232  /* myediges is unsigned, will never be < 0 */
233  if(mystart[i] + myedges[i] > dimlen)
234  return NC_EEDGE;
235  }
236  mystride[i] = (stride == NULL ? 1 : stride[i]);
237  if(mystride[i] <= 0
238  /* cast needed for braindead systems with signed size_t */
239  || ((unsigned long) mystride[i] >= X_INT_MAX))
240  return NC_ESTRIDE;
241  if(mystride[i] != 1) isstride1 = 0;
242  nels *= myedges[i];
243  }
244 
245  if(isstride1) {
246  return NC_put_vara(ncid, varid, mystart, myedges, value, memtype);
247  }
248 
249  if(nels == 0) {
250  /* This should be here instead of before NC_put_vara call to
251  * avoid hang in parallel write for single stride.
252  * Still issue with parallel hang if stride > 1
253  */
254  return NC_NOERR; /* cannot write anything */
255  }
256 
257  /* Initial version uses and odometer to walk the variable
258  and read each value one at a time. This can later be optimized
259  to read larger chunks at a time.
260  */
261 
262 
263  odom_init(&odom,rank,mystart,myedges,mystride);
264 
265  /* walk the odometer to extract values */
266  while(odom_more(&odom)) {
267  int localstatus = NC_NOERR;
268  /* Write a single value */
269  localstatus = NC_put_vara(ncid,varid,odom.index,nc_sizevector1,memptr,memtype);
270  /* So it turns out that when get_varm is used, all errors are
271  delayed and ERANGE will be overwritten by more serious errors.
272  */
273  if(localstatus != NC_NOERR) {
274  if(status == NC_NOERR || localstatus != NC_ERANGE)
275  status = localstatus;
276  }
277  memptr += memtypelen;
278  odom_next(&odom);
279  }
280  return status;
281 #endif
282 }
283 
287 int
288 NCDEFAULT_put_varm(
289  int ncid,
290  int varid,
291  const size_t * start,
292  const size_t * edges,
293  const ptrdiff_t * stride,
294  const ptrdiff_t * imapp,
295  const void *value0,
296  nc_type memtype)
297 {
298  int status = NC_NOERR;
299  nc_type vartype = NC_NAT;
300  int varndims = 0;
301  int maxidim = 0;
302  NC* ncp;
303  int memtypelen;
304  const char* value = (char*)value0;
305 
306  status = NC_check_id (ncid, &ncp);
307  if(status != NC_NOERR) return status;
308 
309 /*
310  if(NC_indef(ncp)) return NC_EINDEFINE;
311  if(NC_readonly (ncp)) return NC_EPERM;
312 */
313 
314  /* mid body */
315  status = nc_inq_vartype(ncid, varid, &vartype);
316  if(status != NC_NOERR) return status;
317  /* Check that this is an atomic type */
318  if(vartype > NC_MAX_ATOMIC_TYPE)
319  return NC_EMAPTYPE;
320 
321  status = nc_inq_varndims(ncid, varid, &varndims);
322  if(status != NC_NOERR) return status;
323 
324  if(memtype == NC_NAT) {
325  memtype = vartype;
326  }
327 
328  if(memtype == NC_CHAR && vartype != NC_CHAR)
329  return NC_ECHAR;
330  else if(memtype != NC_CHAR && vartype == NC_CHAR)
331  return NC_ECHAR;
332 
333  memtypelen = nctypelen(memtype);
334 
335  maxidim = (int) varndims - 1;
336 
337  if (maxidim < 0)
338  {
339  /*
340  * The variable is a scalar; consequently,
341  * there s only one thing to get and only one place to put it.
342  * (Why was I called?)
343  */
344  size_t edge1[1] = {1};
345  return NC_put_vara(ncid, varid, start, edge1, value, memtype);
346  }
347 
348  /*
349  * else
350  * The variable is an array.
351  */
352  {
353  int idim;
354  size_t *mystart = NULL;
355  size_t *myedges = 0;
356  size_t *iocount= 0; /* count vector */
357  size_t *stop = 0; /* stop indexes */
358  size_t *length = 0; /* edge lengths in bytes */
359  ptrdiff_t *mystride = 0;
360  ptrdiff_t *mymap= 0;
361  size_t varshape[NC_MAX_VAR_DIMS];
362  int isrecvar;
363  size_t numrecs;
364  int stride1; /* is stride all ones? */
365 
366  /*
367  * Verify stride argument.
368  */
369  stride1 = 1; /* assume ok; */
370  if(stride != NULL) {
371  for (idim = 0; idim <= maxidim; ++idim) {
372  if ((stride[idim] == 0)
373  /* cast needed for braindead systems with signed size_t */
374  || ((unsigned long) stride[idim] >= X_INT_MAX))
375  {
376  return NC_ESTRIDE;
377  }
378  if(stride[idim] != 1) stride1 = 0;
379  }
380  }
381 
382  /* If stride1 is true, and there is no imap, then call get_vara
383  directly
384  */
385  if(stride1 && imapp == NULL) {
386  return NC_put_vara(ncid, varid, start, edges, value, memtype);
387  }
388 
389  /* Compute some dimension related values */
390  isrecvar = NC_is_recvar(ncid,varid,&numrecs);
391  NC_getshape(ncid,varid,varndims,varshape);
392 
393  /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
394  mystart = (size_t *)calloc((size_t)(varndims * 7), sizeof(ptrdiff_t));
395  if(mystart == NULL) return NC_ENOMEM;
396  myedges = mystart + varndims;
397  iocount = myedges + varndims;
398  stop = iocount + varndims;
399  length = stop + varndims;
400  mystride = (ptrdiff_t *)(length + varndims);
401  mymap = mystride + varndims;
402 
403  /*
404  * Check start, edges
405  */
406  for (idim = maxidim; idim >= 0; --idim)
407  {
408  mystart[idim] = start != NULL
409  ? start[idim]
410  : 0;
411 
412  myedges[idim] = edges != NULL
413  ? edges[idim]
414  : idim == 0 && isrecvar
415  ? numrecs - mystart[idim]
416  : varshape[idim] - mystart[idim];
417  }
418 
419  for (idim = isrecvar; idim <= maxidim; ++idim)
420  {
421 #ifdef RELAX_COORD_BOUND
422  if (mystart[idim] > varshape[idim] ||
423  (mystart[idim] == varshape[idim] && myedges[idim] > 0))
424 #else
425  if (mystart[idim] >= varshape[idim])
426 #endif
427  {
428  status = NC_EINVALCOORDS;
429  goto done;
430  }
431 
432  if (mystart[idim] + myedges[idim] > varshape[idim])
433  {
434  status = NC_EEDGE;
435  goto done;
436  }
437  }
438 
439  /*
440  * Initialize I/O parameters.
441  */
442  for (idim = maxidim; idim >= 0; --idim)
443  {
444  if (edges != NULL && edges[idim] == 0)
445  {
446  status = NC_NOERR; /* read/write no data */
447  goto done;
448  }
449 
450  mystride[idim] = stride != NULL
451  ? stride[idim]
452  : 1;
453  mymap[idim] = imapp != NULL
454  ? imapp[idim]
455  : idim == maxidim
456  ? 1
457  : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1];
458 
459  iocount[idim] = 1;
460  length[idim] = ((size_t)mymap[idim]) * myedges[idim];
461  stop[idim] = mystart[idim] + myedges[idim] * (size_t)mystride[idim];
462  }
463 
464  /* Lower body */
465  /*
466  * As an optimization, adjust I/O parameters when the fastest
467  * dimension has unity stride both externally and internally.
468  * In this case, the user could have called a simpler routine
469  * (i.e. ncvar$1()
470  */
471  if (mystride[maxidim] == 1
472  && mymap[maxidim] == 1)
473  {
474  iocount[maxidim] = myedges[maxidim];
475  mystride[maxidim] = (ptrdiff_t) myedges[maxidim];
476  mymap[maxidim] = (ptrdiff_t) length[maxidim];
477  }
478 
479  /*
480  * Perform I/O. Exit when done.
481  */
482  for (;;)
483  {
484  /* TODO: */
485  int lstatus = NC_put_vara(ncid, varid, mystart, iocount,
486  value, memtype);
487  if (lstatus != NC_NOERR) {
488  if(status == NC_NOERR || lstatus != NC_ERANGE)
489  status = lstatus;
490  }
491 
492  /*
493  * The following code permutes through the variable s
494  * external start-index space and it s internal address
495  * space. At the UPC, this algorithm is commonly
496  * called "odometer code".
497  */
498  idim = maxidim;
499  carry:
500  value += (mymap[idim] * memtypelen);
501  mystart[idim] += (size_t)mystride[idim];
502  if (mystart[idim] == stop[idim])
503  {
504  size_t l = (length[idim] * (size_t)memtypelen);
505  value -= l;
506  mystart[idim] = start[idim];
507  if (--idim < 0)
508  break; /* normal return */
509  goto carry;
510  }
511  } /* I/O loop */
512  done:
513  free(mystart);
514  } /* variable is array */
515  return status;
516 }
517 
521 static int
522 NC_put_vars(int ncid, int varid, const size_t *start,
523  const size_t *edges, const ptrdiff_t *stride,
524  const void *value, nc_type memtype)
525 {
526  NC* ncp;
527  int stat = NC_check_id(ncid, &ncp);
528 
529  if(stat != NC_NOERR) return stat;
530 #ifdef USE_NETCDF4
531  if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
532 #endif
533  return ncp->dispatch->put_vars(ncid,varid,start,edges,stride,value,memtype);
534 }
535 
539 static int
540 NC_put_varm(int ncid, int varid, const size_t *start,
541  const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t* map,
542  const void *value, nc_type memtype)
543 {
544  NC* ncp;
545  int stat = NC_check_id(ncid, &ncp);
546 
547  if(stat != NC_NOERR) return stat;
548 #ifdef USE_NETCDF4
549  if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
550 #endif
551  return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,map,value,memtype);
552 }
553  /* All these functions are part of this named group... */
558 
599 int
600 nc_put_vara(int ncid, int varid, const size_t *startp,
601  const size_t *countp, const void *op)
602 {
603  NC* ncp;
604  int stat = NC_check_id(ncid, &ncp);
605  nc_type xtype;
606  if(stat != NC_NOERR) return stat;
607  stat = nc_inq_vartype(ncid, varid, &xtype);
608  if(stat != NC_NOERR) return stat;
609  return NC_put_vara(ncid, varid, startp, countp, op, xtype);
610 }
611 
612 int
613 nc_put_vara_text(int ncid, int varid, const size_t *startp,
614  const size_t *countp, const char *op)
615 {
616  return NC_put_vara(ncid, varid, startp, countp,
617  (void*)op, NC_CHAR);
618 }
619 
620 int
621 nc_put_vara_schar(int ncid, int varid, const size_t *startp,
622  const size_t *countp, const signed char *op)
623 {
624  NC* ncp;
625  int stat = NC_check_id(ncid, &ncp);
626  if(stat != NC_NOERR) return stat;
627  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
628  NC_BYTE);
629 }
630 
631 int
632 nc_put_vara_uchar(int ncid, int varid, const size_t *startp,
633  const size_t *countp, const unsigned char *op)
634 {
635  NC* ncp;
636  int stat = NC_check_id(ncid, &ncp);
637  if(stat != NC_NOERR) return stat;
638  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
639  T_uchar);
640 }
641 
642 int
643 nc_put_vara_short(int ncid, int varid, const size_t *startp,
644  const size_t *countp, const short *op)
645 {
646  NC* ncp;
647  int stat = NC_check_id(ncid, &ncp);
648  if(stat != NC_NOERR) return stat;
649  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
650  NC_SHORT);
651 }
652 
653 int
654 nc_put_vara_int(int ncid, int varid, const size_t *startp,
655  const size_t *countp, const int *op)
656 {
657  NC* ncp;
658  int stat = NC_check_id(ncid, &ncp);
659  if(stat != NC_NOERR) return stat;
660  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
661  NC_INT);
662 }
663 
664 int
665 nc_put_vara_long(int ncid, int varid, const size_t *startp,
666  const size_t *countp, const long *op)
667 {
668  NC* ncp;
669  int stat = NC_check_id(ncid, &ncp);
670  if(stat != NC_NOERR) return stat;
671  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
672  T_long);
673 }
674 
675 int
676 nc_put_vara_float(int ncid, int varid, const size_t *startp,
677  const size_t *countp, const float *op)
678 {
679  NC* ncp;
680  int stat = NC_check_id(ncid, &ncp);
681  if(stat != NC_NOERR) return stat;
682  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
683  T_float);
684 }
685 
686 int
687 nc_put_vara_double(int ncid, int varid, const size_t *startp,
688  const size_t *countp, const double *op)
689 {
690  NC* ncp;
691  int stat = NC_check_id(ncid, &ncp);
692  if(stat != NC_NOERR) return stat;
693  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
694  T_double);
695 }
696 
697 int
698 nc_put_vara_ubyte(int ncid, int varid, const size_t *startp,
699  const size_t *countp, const unsigned char *op)
700 {
701  NC* ncp;
702  int stat = NC_check_id(ncid, &ncp);
703  if(stat != NC_NOERR) return stat;
704  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
705  T_ubyte);
706 }
707 
708 int
709 nc_put_vara_ushort(int ncid, int varid, const size_t *startp,
710  const size_t *countp, const unsigned short *op)
711 {
712  NC* ncp;
713  int stat = NC_check_id(ncid, &ncp);
714  if(stat != NC_NOERR) return stat;
715  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
716  T_ushort);
717 }
718 
719 int
720 nc_put_vara_uint(int ncid, int varid, const size_t *startp,
721  const size_t *countp, const unsigned int *op)
722 {
723  NC* ncp;
724  int stat = NC_check_id(ncid, &ncp);
725  if(stat != NC_NOERR) return stat;
726  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
727  T_uint);
728 }
729 
730 int
731 nc_put_vara_longlong(int ncid, int varid, const size_t *startp,
732  const size_t *countp, const long long *op)
733 {
734  NC* ncp;
735  int stat = NC_check_id(ncid, &ncp);
736  if(stat != NC_NOERR) return stat;
737  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
738  T_longlong);
739 }
740 
741 int
742 nc_put_vara_ulonglong(int ncid, int varid, const size_t *startp,
743  const size_t *countp, const unsigned long long *op)
744 {
745  NC* ncp;
746  int stat = NC_check_id(ncid, &ncp);
747  if(stat != NC_NOERR) return stat;
748  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
749  NC_UINT64);
750 }
751 
752 #ifdef USE_NETCDF4
753 int
754 nc_put_vara_string(int ncid, int varid, const size_t *startp,
755  const size_t *countp, const char* *op)
756 {
757  NC* ncp;
758  int stat = NC_check_id(ncid, &ncp);
759  if(stat != NC_NOERR) return stat;
760  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
761  NC_STRING);
762 }
763 
764 #endif /*USE_NETCDF4*/
765 
789 int
790 nc_put_var1(int ncid, int varid, const size_t *indexp, const void *op)
791 {
792  return NC_put_var1(ncid, varid, indexp, op, NC_NAT);
793 }
794 
795 int
796 nc_put_var1_text(int ncid, int varid, const size_t *indexp, const char *op)
797 {
798  NC* ncp;
799  int stat = NC_check_id(ncid, &ncp);
800  if(stat != NC_NOERR) return stat;
801  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_CHAR);
802 }
803 
804 int
805 nc_put_var1_schar(int ncid, int varid, const size_t *indexp, const signed char *op)
806 {
807  NC* ncp;
808  int stat = NC_check_id(ncid, &ncp);
809  if(stat != NC_NOERR) return stat;
810  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_BYTE);
811 }
812 
813 int
814 nc_put_var1_uchar(int ncid, int varid, const size_t *indexp, const unsigned char *op)
815 {
816  NC* ncp;
817  int stat = NC_check_id(ncid, &ncp);
818  if(stat != NC_NOERR) return stat;
819  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UBYTE);
820 }
821 
822 int
823 nc_put_var1_short(int ncid, int varid, const size_t *indexp, const short *op)
824 {
825  NC* ncp;
826  int stat = NC_check_id(ncid, &ncp);
827  if(stat != NC_NOERR) return stat;
828  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_SHORT);
829 }
830 
831 int
832 nc_put_var1_int(int ncid, int varid, const size_t *indexp, const int *op)
833 {
834  NC* ncp;
835  int stat = NC_check_id(ncid, &ncp);
836  if(stat != NC_NOERR) return stat;
837  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_INT);
838 }
839 
840 int
841 nc_put_var1_long(int ncid, int varid, const size_t *indexp, const long *op)
842 {
843  NC* ncp;
844  int stat = NC_check_id(ncid, &ncp);
845  if(stat != NC_NOERR) return stat;
846  return NC_put_var1(ncid, varid, indexp, (void*)op, longtype);
847 }
848 
849 int
850 nc_put_var1_float(int ncid, int varid, const size_t *indexp, const float *op)
851 {
852  NC* ncp;
853  int stat = NC_check_id(ncid, &ncp);
854  if(stat != NC_NOERR) return stat;
855  return NC_put_var1(ncid, varid, indexp, (void*)op, NC_FLOAT);
856 }
857 
858 int
859 nc_put_var1_double(int ncid, int varid, const size_t *indexp, const double *op)
860 {
861  NC* ncp;
862  int stat = NC_check_id(ncid, &ncp);
863  if(stat != NC_NOERR) return stat;
864  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_DOUBLE);
865 }
866 
867 int
868 nc_put_var1_ubyte(int ncid, int varid, const size_t *indexp, const unsigned char *op)
869 {
870  NC* ncp;
871  int stat = NC_check_id(ncid, &ncp);
872  if(stat != NC_NOERR) return stat;
873  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UBYTE);
874 }
875 
876 int
877 nc_put_var1_ushort(int ncid, int varid, const size_t *indexp, const unsigned short *op)
878 {
879  NC* ncp;
880  int stat = NC_check_id(ncid, &ncp);
881  if(stat != NC_NOERR) return stat;
882  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_USHORT);
883 }
884 
885 int
886 nc_put_var1_uint(int ncid, int varid, const size_t *indexp, const unsigned int *op)
887 {
888  NC* ncp;
889  int stat = NC_check_id(ncid, &ncp);
890  if(stat != NC_NOERR) return stat;
891  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UINT);
892 }
893 
894 int
895 nc_put_var1_longlong(int ncid, int varid, const size_t *indexp, const long long *op)
896 {
897  NC* ncp;
898  int stat = NC_check_id(ncid, &ncp);
899  if(stat != NC_NOERR) return stat;
900  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_INT64);
901 }
902 
903 int
904 nc_put_var1_ulonglong(int ncid, int varid, const size_t *indexp, const unsigned long long *op)
905 {
906  NC* ncp;
907  int stat = NC_check_id(ncid, &ncp);
908  if(stat != NC_NOERR) return stat;
909  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UINT64);
910 }
911 
912 #ifdef USE_NETCDF4
913 int
914 nc_put_var1_string(int ncid, int varid, const size_t *indexp, const char* *op)
915 {
916  NC* ncp;
917  int stat = NC_check_id(ncid, &ncp);
918  if(stat != NC_NOERR) return stat;
919  return NC_put_var1(ncid, varid, indexp, (void*)op, NC_STRING);
920 }
921 #endif /*USE_NETCDF4*/
922 
970 int
971 nc_put_var(int ncid, int varid, const void *op)
972 {
973  return NC_put_var(ncid, varid, op, NC_NAT);
974 }
975 
976 int
977 nc_put_var_text(int ncid, int varid, const char *op)
978 {
979  NC* ncp;
980  int stat = NC_check_id(ncid, &ncp);
981  if(stat != NC_NOERR) return stat;
982  return NC_put_var(ncid,varid,(void*)op,NC_CHAR);
983 }
984 
985 int
986 nc_put_var_schar(int ncid, int varid, const signed char *op)
987 {
988  NC* ncp;
989  int stat = NC_check_id(ncid, &ncp);
990  if(stat != NC_NOERR) return stat;
991  return NC_put_var(ncid,varid,(void*)op,NC_BYTE);
992 }
993 
994 int
995 nc_put_var_uchar(int ncid, int varid, const unsigned char *op)
996 {
997  NC* ncp;
998  int stat = NC_check_id(ncid, &ncp);
999  if(stat != NC_NOERR) return stat;
1000  return NC_put_var(ncid,varid,(void*)op,T_uchar);
1001 }
1002 
1003 int
1004 nc_put_var_short(int ncid, int varid, const short *op)
1005 {
1006  NC* ncp;
1007  int stat = NC_check_id(ncid, &ncp);
1008  if(stat != NC_NOERR) return stat;
1009  return NC_put_var(ncid,varid,(void*)op,NC_SHORT);
1010 }
1011 
1012 int
1013 nc_put_var_int(int ncid, int varid, const int *op)
1014 {
1015  NC* ncp;
1016  int stat = NC_check_id(ncid, &ncp);
1017  if(stat != NC_NOERR) return stat;
1018  return NC_put_var(ncid,varid,(void*)op,NC_INT);
1019 }
1020 
1021 int
1022 nc_put_var_long(int ncid, int varid, const long *op)
1023 {
1024  NC* ncp;
1025  int stat = NC_check_id(ncid, &ncp);
1026  if(stat != NC_NOERR) return stat;
1027  return NC_put_var(ncid,varid,(void*)op,T_long);
1028 }
1029 
1030 int
1031 nc_put_var_float(int ncid, int varid, const float *op)
1032 {
1033  NC* ncp;
1034  int stat = NC_check_id(ncid, &ncp);
1035  if(stat != NC_NOERR) return stat;
1036  return NC_put_var(ncid,varid,(void*)op,T_float);
1037 }
1038 
1039 int
1040 nc_put_var_double(int ncid, int varid, const double *op)
1041 {
1042  NC* ncp;
1043  int stat = NC_check_id(ncid, &ncp);
1044  if(stat != NC_NOERR) return stat;
1045  return NC_put_var(ncid,varid,(void*)op,T_double);
1046 }
1047 
1048 int
1049 nc_put_var_ubyte(int ncid, int varid, const unsigned char *op)
1050 {
1051  NC* ncp;
1052  int stat = NC_check_id(ncid, &ncp);
1053  if(stat != NC_NOERR) return stat;
1054  return NC_put_var(ncid,varid,(void*)op,T_ubyte);
1055 }
1056 
1057 int
1058 nc_put_var_ushort(int ncid, int varid, const unsigned short *op)
1059 {
1060  NC* ncp;
1061  int stat = NC_check_id(ncid, &ncp);
1062  if(stat != NC_NOERR) return stat;
1063  return NC_put_var(ncid,varid,(void*)op,T_ushort);
1064 }
1065 
1066 int
1067 nc_put_var_uint(int ncid, int varid, const unsigned int *op)
1068 {
1069  NC* ncp;
1070  int stat = NC_check_id(ncid, &ncp);
1071  if(stat != NC_NOERR) return stat;
1072  return NC_put_var(ncid,varid,(void*)op,T_uint);
1073 }
1074 
1075 int
1076 nc_put_var_longlong(int ncid, int varid, const long long *op)
1077 {
1078  NC* ncp;
1079  int stat = NC_check_id(ncid, &ncp);
1080  if(stat != NC_NOERR) return stat;
1081  return NC_put_var(ncid,varid,(void*)op,T_longlong);
1082 }
1083 
1084 int
1085 nc_put_var_ulonglong(int ncid, int varid, const unsigned long long *op)
1086 {
1087  NC* ncp;
1088  int stat = NC_check_id(ncid, &ncp);
1089  if(stat != NC_NOERR) return stat;
1090  return NC_put_var(ncid,varid,(void*)op,NC_UINT64);
1091 }
1092 
1093 #ifdef USE_NETCDF4
1094 int
1095 nc_put_var_string(int ncid, int varid, const char* *op)
1096 {
1097  NC* ncp;
1098  int stat = NC_check_id(ncid, &ncp);
1099  if(stat != NC_NOERR) return stat;
1100  return NC_put_var(ncid,varid,(void*)op,NC_STRING);
1101 }
1102 #endif /*USE_NETCDF4*/
1103 
1135 int
1136 nc_put_vars (int ncid, int varid, const size_t *startp,
1137  const size_t *countp, const ptrdiff_t *stridep,
1138  const void *op)
1139 {
1140  NC *ncp;
1141  int stat = NC_NOERR;
1142 
1143  if ((stat = NC_check_id(ncid, &ncp)))
1144  return stat;
1145  return ncp->dispatch->put_vars(ncid, varid, startp, countp,
1146  stridep, op, NC_NAT);
1147 }
1148 
1149 int
1150 nc_put_vars_text(int ncid, int varid, const size_t *startp,
1151  const size_t *countp, const ptrdiff_t *stridep,
1152  const char *op)
1153 {
1154  NC *ncp;
1155  int stat = NC_check_id(ncid, &ncp);
1156  if(stat != NC_NOERR) return stat;
1157  return NC_put_vars(ncid, varid, startp, countp,
1158  stridep,(void*)op,NC_CHAR);
1159 }
1160 
1161 int
1162 nc_put_vars_schar(int ncid, int varid, const size_t *startp,
1163  const size_t *countp, const ptrdiff_t *stridep,
1164  const signed char *op)
1165 {
1166  NC *ncp;
1167  int stat = NC_check_id(ncid, &ncp);
1168  if(stat != NC_NOERR) return stat;
1169  return NC_put_vars(ncid, varid, startp, countp,
1170  stridep,(void*)op,NC_BYTE);
1171 }
1172 
1173 int
1174 nc_put_vars_uchar(int ncid, int varid,
1175  const size_t *startp, const size_t *countp,
1176  const ptrdiff_t *stridep,
1177  const unsigned char *op)
1178 {
1179  NC *ncp;
1180  int stat = NC_check_id(ncid, &ncp);
1181  if(stat != NC_NOERR) return stat;
1182  return NC_put_vars(ncid, varid, startp, countp,
1183  stridep, (void *)op, T_uchar);
1184 }
1185 
1186 int
1187 nc_put_vars_short(int ncid, int varid,
1188  const size_t *startp, const size_t *countp,
1189  const ptrdiff_t *stridep,
1190  const short *op)
1191 {
1192  NC *ncp;
1193  int stat = NC_check_id(ncid, &ncp);
1194  if(stat != NC_NOERR) return stat;
1195  return NC_put_vars(ncid, varid, startp, countp,
1196  stridep, (void *)op, NC_SHORT);
1197 }
1198 
1199 int
1200 nc_put_vars_int(int ncid, int varid,
1201  const size_t *startp, const size_t *countp,
1202  const ptrdiff_t *stridep,
1203  const int *op)
1204 {
1205  NC *ncp;
1206  int stat = NC_check_id(ncid, &ncp);
1207  if(stat != NC_NOERR) return stat;
1208  return NC_put_vars(ncid, varid, startp, countp,
1209  stridep, (void *)op, NC_INT);
1210 }
1211 
1212 int
1213 nc_put_vars_long(int ncid, int varid,
1214  const size_t *startp, const size_t *countp,
1215  const ptrdiff_t *stridep,
1216  const long *op)
1217 {
1218  NC *ncp;
1219  int stat = NC_check_id(ncid, &ncp);
1220  if(stat != NC_NOERR) return stat;
1221  return NC_put_vars(ncid, varid, startp, countp,
1222  stridep, (void *)op, T_long);
1223 }
1224 
1225 int
1226 nc_put_vars_float(int ncid, int varid,
1227  const size_t *startp, const size_t *countp,
1228  const ptrdiff_t *stridep,
1229  const float *op)
1230 {
1231  NC *ncp;
1232  int stat = NC_check_id(ncid, &ncp);
1233  if(stat != NC_NOERR) return stat;
1234  return NC_put_vars(ncid, varid, startp, countp,
1235  stridep, (void *)op, T_float);
1236 }
1237 
1238 int
1239 nc_put_vars_double(int ncid, int varid,
1240  const size_t *startp, const size_t *countp,
1241  const ptrdiff_t *stridep,
1242  const double *op)
1243 {
1244  NC *ncp;
1245  int stat = NC_check_id(ncid, &ncp);
1246  if(stat != NC_NOERR) return stat;
1247  return NC_put_vars(ncid, varid, startp, countp,
1248  stridep, (void *)op, T_double);
1249 }
1250 
1251 int
1252 nc_put_vars_ubyte(int ncid, int varid,
1253  const size_t *startp, const size_t *countp,
1254  const ptrdiff_t *stridep,
1255  const unsigned char *op)
1256 {
1257  NC *ncp;
1258  int stat = NC_check_id(ncid, &ncp);
1259  if(stat != NC_NOERR) return stat;
1260  return NC_put_vars(ncid, varid, startp, countp,
1261  stridep, (void *)op, T_ubyte);
1262 }
1263 
1264 int
1265 nc_put_vars_ushort(int ncid, int varid,
1266  const size_t *startp, const size_t *countp,
1267  const ptrdiff_t *stridep,
1268  const unsigned short *op)
1269 {
1270  NC *ncp;
1271  int stat = NC_check_id(ncid, &ncp);
1272  if(stat != NC_NOERR) return stat;
1273  return NC_put_vars(ncid, varid, startp, countp,
1274  stridep, (void *)op, T_ushort);
1275 }
1276 
1277 int
1278 nc_put_vars_uint(int ncid, int varid,
1279  const size_t *startp, const size_t *countp,
1280  const ptrdiff_t *stridep,
1281  const unsigned int *op)
1282 {
1283  NC *ncp;
1284  int stat = NC_check_id(ncid, &ncp);
1285  if(stat != NC_NOERR) return stat;
1286  return NC_put_vars(ncid, varid, startp, countp,
1287  stridep, (void *)op, T_uint);
1288 }
1289 
1290 int
1291 nc_put_vars_longlong(int ncid, int varid,
1292  const size_t *startp, const size_t *countp,
1293  const ptrdiff_t *stridep,
1294  const long long *op)
1295 {
1296  NC *ncp;
1297  int stat = NC_check_id(ncid, &ncp);
1298  if(stat != NC_NOERR) return stat;
1299  return NC_put_vars(ncid, varid, startp, countp,
1300  stridep, (void *)op, T_longlong);
1301 }
1302 
1303 int
1304 nc_put_vars_ulonglong(int ncid, int varid,
1305  const size_t *startp, const size_t *countp,
1306  const ptrdiff_t *stridep,
1307  const unsigned long long *op)
1308 {
1309  NC *ncp;
1310  int stat = NC_check_id(ncid, &ncp);
1311  if(stat != NC_NOERR) return stat;
1312  return NC_put_vars(ncid, varid, startp, countp,
1313  stridep, (void *)op, NC_UINT64);
1314 }
1315 
1316 #ifdef USE_NETCDF4
1317 int
1318 nc_put_vars_string(int ncid, int varid,
1319  const size_t *startp, const size_t *countp,
1320  const ptrdiff_t *stridep,
1321  const char**op)
1322 {
1323  NC *ncp;
1324  int stat = NC_check_id(ncid, &ncp);
1325  if(stat != NC_NOERR) return stat;
1326  return NC_put_vars(ncid, varid, startp, countp, stridep,
1327  (void *)op, NC_STRING);
1328 }
1329 #endif /*USE_NETCDF4*/
1330 
1375 int
1376 nc_put_varm (int ncid, int varid, const size_t *startp,
1377  const size_t *countp, const ptrdiff_t *stridep,
1378  const ptrdiff_t *imapp, const void *op)
1379 {
1380  NC *ncp;
1381  int stat = NC_NOERR;
1382 
1383  if ((stat = NC_check_id(ncid, &ncp)))
1384  return stat;
1385  return ncp->dispatch->put_varm(ncid, varid, startp, countp,
1386  stridep, imapp, op, NC_NAT);
1387 }
1388 
1389 int
1390 nc_put_varm_text(int ncid, int varid, const size_t *startp,
1391  const size_t *countp, const ptrdiff_t *stridep,
1392  const ptrdiff_t *imapp, const char *op)
1393 {
1394  NC *ncp;
1395  int stat = NC_check_id(ncid, &ncp);
1396  if(stat != NC_NOERR) return stat;
1397  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1398  (void *)op, NC_CHAR);
1399 }
1400 
1401 int
1402 nc_put_varm_schar(int ncid, int varid,
1403  const size_t *startp, const size_t *countp,
1404  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1405  const signed char *op)
1406 {
1407  NC *ncp;
1408  int stat = NC_check_id(ncid, &ncp);
1409  if(stat != NC_NOERR) return stat;
1410  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1411  (void *)op, NC_BYTE);
1412 }
1413 
1414 int
1415 nc_put_varm_uchar(int ncid, int varid,
1416  const size_t *startp, const size_t *countp,
1417  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1418  const unsigned char *op)
1419 {
1420  NC *ncp;
1421  int stat = NC_check_id(ncid, &ncp);
1422  if(stat != NC_NOERR) return stat;
1423  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1424  (void *)op, T_uchar);
1425 }
1426 
1427 int
1428 nc_put_varm_short(int ncid, int varid,
1429  const size_t *startp, const size_t *countp,
1430  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1431  const short *op)
1432 {
1433  NC *ncp;
1434  int stat = NC_check_id(ncid, &ncp);
1435  if(stat != NC_NOERR) return stat;
1436  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1437  (void *)op, NC_SHORT);
1438 }
1439 
1440 int
1441 nc_put_varm_int(int ncid, int varid,
1442  const size_t *startp, const size_t *countp,
1443  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1444  const int *op)
1445 {
1446  NC *ncp;
1447  int stat = NC_check_id(ncid, &ncp);
1448  if(stat != NC_NOERR) return stat;
1449  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1450  (void *)op, NC_INT);
1451 }
1452 
1453 int
1454 nc_put_varm_long(int ncid, int varid,
1455  const size_t *startp, const size_t *countp,
1456  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1457  const long *op)
1458 {
1459  NC *ncp;
1460  int stat = NC_check_id(ncid, &ncp);
1461  if(stat != NC_NOERR) return stat;
1462  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1463  (void *)op, T_long);
1464 }
1465 
1466 int
1467 nc_put_varm_float(int ncid, int varid,
1468  const size_t *startp, const size_t *countp,
1469  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1470  const float *op)
1471 {
1472  NC *ncp;
1473  int stat = NC_check_id(ncid, &ncp);
1474  if(stat != NC_NOERR) return stat;
1475  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1476  (void *)op, T_float);
1477 }
1478 
1479 int
1480 nc_put_varm_double(int ncid, int varid,
1481  const size_t *startp, const size_t *countp,
1482  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1483  const double *op)
1484 {
1485  NC *ncp;
1486  int stat = NC_check_id(ncid, &ncp);
1487  if(stat != NC_NOERR) return stat;
1488  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1489  (void *)op, T_double);
1490 }
1491 
1492 int
1493 nc_put_varm_ubyte(int ncid, int varid,
1494  const size_t *startp, const size_t *countp,
1495  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1496  const unsigned char *op)
1497 {
1498  NC *ncp;
1499  int stat = NC_check_id(ncid, &ncp);
1500  if(stat != NC_NOERR) return stat;
1501  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1502  (void *)op, T_ubyte);
1503 }
1504 
1505 int
1506 nc_put_varm_ushort(int ncid, int varid,
1507  const size_t *startp, const size_t *countp,
1508  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1509  const unsigned short *op)
1510 {
1511  NC *ncp;
1512  int stat = NC_check_id(ncid, &ncp);
1513  if(stat != NC_NOERR) return stat;
1514  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1515  (void *)op, T_ushort);
1516 }
1517 
1518 int
1519 nc_put_varm_uint(int ncid, int varid,
1520  const size_t *startp, const size_t *countp,
1521  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1522  const unsigned int *op)
1523 {
1524  NC *ncp;
1525  int stat = NC_check_id(ncid, &ncp);
1526  if(stat != NC_NOERR) return stat;
1527  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1528  (void *)op, T_uint);
1529 }
1530 
1531 int
1532 nc_put_varm_longlong(int ncid, int varid,
1533  const size_t *startp, const size_t *countp,
1534  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1535  const long long *op)
1536 {
1537  NC *ncp;
1538  int stat = NC_check_id(ncid, &ncp);
1539  if(stat != NC_NOERR) return stat;
1540  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1541  (void *)op, T_longlong);
1542 }
1543 
1544 int
1545 nc_put_varm_ulonglong(int ncid, int varid,
1546  const size_t *startp, const size_t *countp,
1547  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1548  const unsigned long long *op)
1549 {
1550  NC *ncp;
1551  int stat = NC_check_id(ncid, &ncp);
1552  if(stat != NC_NOERR) return stat;
1553  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1554  (void *)op, NC_UINT64);
1555 }
1556 
1557 #ifdef USE_NETCDF4
1558 int
1559 nc_put_varm_string(int ncid, int varid,
1560  const size_t *startp, const size_t *countp,
1561  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1562  const char**op)
1563 {
1564  NC *ncp;
1565  int stat = NC_check_id(ncid, &ncp);
1566  if(stat != NC_NOERR) return stat;
1567  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1568  (void *)op, NC_STRING);
1569 }
1570 #endif /*USE_NETCDF4*/
1571  /*End of named group... */
int nc_put_var_long(int ncid, int varid, const long *op)
Write an entire variable with one call.
Definition: dvarput.c:1022
#define NC_ENOMEM
Memory allocation (malloc) failure.
Definition: netcdf.h:388
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.
Definition: dvarput.c:1493
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.
Definition: dvarput.c:1239
#define NC_CHAR
ISO/ASCII character.
Definition: netcdf.h:35
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.
Definition: dvarput.c:1174
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.
Definition: dvarput.c:621
int nc_put_var1_string(int ncid, int varid, const size_t *indexp, const char **op)
Write one datum.
Definition: dvarput.c:914
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.
Definition: dvarput.c:1278
#define NC_UBYTE
unsigned 1 byte int
Definition: netcdf.h:41
#define NC_EMAPTYPE
Mapped access for atomic types only.
Definition: netcdf.h:443
#define NC_ERANGE
Math result not representable.
Definition: netcdf.h:387
#define NC_MAX_VAR_DIMS
max per variable dimensions
Definition: netcdf.h:262
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.
Definition: dvarput.c:632
#define NC_UINT
unsigned 4-byte int
Definition: netcdf.h:43
int nc_put_var_uint(int ncid, int varid, const unsigned int *op)
Write an entire variable with one call.
Definition: dvarput.c:1067
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.
Definition: dvarput.c:1291
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.
Definition: dvarput.c:731
int nc_put_var_ulonglong(int ncid, int varid, const unsigned long long *op)
Write an entire variable with one call.
Definition: dvarput.c:1085
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.
Definition: dvarput.c:1506
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.
Definition: dvarput.c:1200
#define NC_EINVALCOORDS
Index exceeds dimension bound.
Definition: netcdf.h:340
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.
Definition: dvarput.c:1252
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.
Definition: dvarput.c:1265
int nc_put_var_schar(int ncid, int varid, const signed char *op)
Write an entire variable with one call.
Definition: dvarput.c:986
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.
Definition: dvarput.c:687
int nc_put_var_int(int ncid, int varid, const int *op)
Write an entire variable with one call.
Definition: dvarput.c:1013
int nc_put_var1_uchar(int ncid, int varid, const size_t *indexp, const unsigned char *op)
Write one datum.
Definition: dvarput.c:814
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.
Definition: dvarput.c:676
#define NC_INT64
signed 8-byte int
Definition: netcdf.h:44
int nc_put_var(int ncid, int varid, const void *op)
Write an entire variable with one call.
Definition: dvarput.c:971
int nc_put_var1_ushort(int ncid, int varid, const size_t *indexp, const unsigned short *op)
Write one datum.
Definition: dvarput.c:877
#define NC_STRING
string
Definition: netcdf.h:46
int nc_put_vara(int ncid, int varid, const size_t *startp, const size_t *countp, const void *op)
Write an array of values to a variable.
Definition: dvarput.c:600
#define NC_DOUBLE
double precision floating point number
Definition: netcdf.h:40
EXTERNL int nc_inq_varndims(int ncid, int varid, int *ndimsp)
Learn how many dimensions are associated with a variable.
Definition: dvarinq.c:192
int nc_put_var1_double(int ncid, int varid, const size_t *indexp, const double *op)
Write one datum.
Definition: dvarput.c:859
int nc_put_varm(int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const ptrdiff_t *imapp, const void *op)
Write a mapped array of values to a variable.
Definition: dvarput.c:1376
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.
Definition: dvarput.c:1187
int nc_type
The nc_type type is just an int.
Definition: netcdf.h:24
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.
Definition: dvarput.c:1441
int nc_put_vars(int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const void *op)
Write a strided array of values to a variable.
Definition: dvarput.c:1136
int nc_put_var_string(int ncid, int varid, const char **op)
Write an entire variable with one call.
Definition: dvarput.c:1095
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.
Definition: dvarput.c:643
#define NC_BYTE
signed 1 byte integer
Definition: netcdf.h:34
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.
Definition: dvarput.c:720
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.
Definition: dvarput.c:1428
int nc_put_var_ubyte(int ncid, int varid, const unsigned char *op)
Write an entire variable with one call.
Definition: dvarput.c:1049
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.
Definition: dvarput.c:1226
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.
Definition: dvarput.c:754
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.
Definition: dvarput.c:613
int nc_put_var1_float(int ncid, int varid, const size_t *indexp, const float *op)
Write one datum.
Definition: dvarput.c:850
int nc_put_var_longlong(int ncid, int varid, const long long *op)
Write an entire variable with one call.
Definition: dvarput.c:1076
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.
Definition: dvarput.c:698
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.
Definition: dvarput.c:1390
int nc_put_var1_int(int ncid, int varid, const size_t *indexp, const int *op)
Write one datum.
Definition: dvarput.c:832
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.
Definition: dvarput.c:1559
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.
Definition: dvarput.c:1545
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.
Definition: dvarput.c:709
#define NC_EBADTYPE
Not a netcdf data type.
Definition: netcdf.h:350
int nc_put_var1_longlong(int ncid, int varid, const size_t *indexp, const long long *op)
Write one datum.
Definition: dvarput.c:895
#define NC_EEDGE
Start+count exceeds dimension bound.
Definition: netcdf.h:378
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.
Definition: dvarput.c:665
#define NC_ESTRIDE
Illegal stride.
Definition: netcdf.h:379
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.
Definition: dvarput.c:1532
int nc_put_var1(int ncid, int varid, const size_t *indexp, const void *op)
Write one datum.
Definition: dvarput.c:790
#define NC_INT
signed 4 byte integer
Definition: netcdf.h:37
#define NC_NAT
Not A Type.
Definition: netcdf.h:33
int nc_put_var1_schar(int ncid, int varid, const size_t *indexp, const signed char *op)
Write one datum.
Definition: dvarput.c:805
EXTERNL int nc_inq_vartype(int ncid, int varid, nc_type *xtypep)
Learn the type of a variable.
Definition: dvarinq.c:169
EXTERNL int nc_inq_type(int ncid, nc_type xtype, char *name, size_t *size)
Inquire about a type.
Definition: dfile.c:1582
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.
Definition: dvarput.c:654
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.
Definition: dvarput.c:1402
#define NC_USHORT
unsigned 2-byte int
Definition: netcdf.h:42
int nc_put_var1_ulonglong(int ncid, int varid, const size_t *indexp, const unsigned long long *op)
Write one datum.
Definition: dvarput.c:904
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.
Definition: dvarput.c:1480
int nc_put_var1_short(int ncid, int varid, const size_t *indexp, const short *op)
Write one datum.
Definition: dvarput.c:823
int nc_put_var_double(int ncid, int varid, const double *op)
Write an entire variable with one call.
Definition: dvarput.c:1040
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.
Definition: dvarput.c:1454
int nc_put_var_text(int ncid, int varid, const char *op)
Write an entire variable with one call.
Definition: dvarput.c:977
#define NC_SHORT
signed 2 byte integer
Definition: netcdf.h:36
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.
Definition: dvarput.c:1519
int nc_put_var1_text(int ncid, int varid, const size_t *indexp, const char *op)
Write one datum.
Definition: dvarput.c:796
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.
Definition: dvarput.c:742
int nc_put_var_float(int ncid, int varid, const float *op)
Write an entire variable with one call.
Definition: dvarput.c:1031
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.
Definition: dvarput.c:1150
int nc_put_var1_long(int ncid, int varid, const size_t *indexp, const long *op)
Write one datum.
Definition: dvarput.c:841
int nc_put_var_ushort(int ncid, int varid, const unsigned short *op)
Write an entire variable with one call.
Definition: dvarput.c:1058
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.
Definition: dvarput.c:1162
#define NC_NOERR
No Error.
Definition: netcdf.h:308
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.
Definition: dvarput.c:1213
#define NC_ECHAR
Attempt to convert between text & numbers.
Definition: netcdf.h:369
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.
Definition: dvarput.c:1304
int nc_put_var1_uint(int ncid, int varid, const size_t *indexp, const unsigned int *op)
Write one datum.
Definition: dvarput.c:886
int nc_put_var_uchar(int ncid, int varid, const unsigned char *op)
Write an entire variable with one call.
Definition: dvarput.c:995
int nc_put_var_short(int ncid, int varid, const short *op)
Write an entire variable with one call.
Definition: dvarput.c:1004
#define NC_FLOAT
single precision floating point number
Definition: netcdf.h:39
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.
Definition: dvarput.c:1467
int nc_put_var1_ubyte(int ncid, int varid, const size_t *indexp, const unsigned char *op)
Write one datum.
Definition: dvarput.c:868
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.
Definition: dvarput.c:1415
#define NC_UINT64
unsigned 8-byte int
Definition: netcdf.h:45
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.
Definition: dvarput.c:1318

Return to the Main Unidata NetCDF page.
Generated on Thu Oct 26 2017 08:14:39 for NetCDF. NetCDF is a Unidata library.