NetCDF  4.3.2
 All Data Structures Files Functions Variables Typedefs Macros Modules Pages
dvarput.c
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,simplestride,isrecvar;
126  int rank;
127  struct PUTodometer odom;
128  nc_type vartype = NC_NAT;
129  NC* ncp;
130  size_t vartypelen;
131  int memtypelen;
132  const char* value = (const char*)value0;
133  size_t numrecs;
134  size_t varshape[NC_MAX_VAR_DIMS];
135  size_t mystart[NC_MAX_VAR_DIMS];
136  size_t myedges[NC_MAX_VAR_DIMS];
137  ptrdiff_t mystride[NC_MAX_VAR_DIMS];
138 
139  const char* memptr = value;
140 
141  status = NC_check_id (ncid, &ncp);
142  if(status != NC_NOERR) return status;
143 
144  status = nc_inq_vartype(ncid, varid, &vartype);
145  if(status != NC_NOERR) return status;
146 
147  if(memtype == NC_NAT) memtype = vartype;
148 
149  /* compute the variable type size */
150  status = nc_inq_type(ncid,vartype,NULL,&vartypelen);
151  if(status != NC_NOERR) return status;
152 
153  if(memtype > NC_MAX_ATOMIC_TYPE)
154  memtypelen = (int)vartypelen;
155  else
156  memtypelen = nctypelen(memtype);
157 
158  /* Check gross internal/external type compatibility */
159  if(vartype != memtype) {
160  /* If !atomic, the two types must be the same */
161  if(vartype > NC_MAX_ATOMIC_TYPE
162  || memtype > NC_MAX_ATOMIC_TYPE)
163  return NC_EBADTYPE;
164  /* ok, the types differ but both are atomic */
165  if(memtype == NC_CHAR || vartype == NC_CHAR)
166  return NC_ECHAR;
167  }
168 
169  /* Get the variable rank */
170  status = nc_inq_varndims(ncid, varid, &rank);
171  if(status != NC_NOERR) return status;
172 
173  /* Get variable dimension sizes */
174  isrecvar = NC_is_recvar(ncid,varid,&numrecs);
175  NC_getshape(ncid,varid,rank,varshape);
176 
177  /* Optimize out using various checks */
178  if (rank == 0) {
179  /*
180  * The variable is a scalar; consequently,
181  * there is only one thing to get and only one place to put it.
182  * (Why was I called?)
183  */
184  size_t edge1[1] = {1};
185  return NC_put_vara(ncid, varid, start, edge1, value0, memtype);
186  }
187 
188  /* Do various checks and fixups on start/edges/stride */
189  simplestride = 1; /* assume so */
190  for(i=0;i<rank;i++) {
191  size_t dimlen;
192  mystart[i] = (start == NULL ? 0 : start[i]);
193  if(edges == NULL) {
194  if(i == 0 && isrecvar)
195  myedges[i] = numrecs - start[i];
196  else
197  myedges[i] = varshape[i] - mystart[i];
198  } else
199  myedges[i] = edges[i];
200  if(myedges[i] == 0)
201  return NC_NOERR; /* cannot write anything */
202  mystride[i] = (stride == NULL ? 1 : stride[i]);
203  if(mystride[i] <= 0
204  /* cast needed for braindead systems with signed size_t */
205  || ((unsigned long) mystride[i] >= X_INT_MAX))
206  return NC_ESTRIDE;
207  if(mystride[i] != 1) simplestride = 0;
208  /* illegal value checks */
209  dimlen = (i == 0 && isrecvar ? numrecs : varshape[i]);
210  if(i == 0 && isrecvar) {/*do nothing*/}
211  else {
212  /* mystart is unsigned, will never be < 0 */
213  //if(mystart[i] < 0 || mystart[i] > dimlen)
214  if(mystart[i] > dimlen)
215  return NC_EINVALCOORDS;
216  /* myediges is unsigned, will never be < 0 */
217  //if(myedges[i] < 0 || (mystart[i] + myedges[i] > dimlen))
218  if(mystart[i] + myedges[i] > dimlen)
219  return NC_EEDGE;
220  }
221  }
222  if(simplestride) {
223  return NC_put_vara(ncid, varid, mystart, myedges, value, memtype);
224  }
225 
226  /* Initial version uses and odometer to walk the variable
227  and read each value one at a time. This can later be optimized
228  to read larger chunks at a time.
229  */
230 
231 
232  odom_init(&odom,rank,mystart,myedges,mystride);
233 
234  /* walk the odometer to extract values */
235  while(odom_more(&odom)) {
236  int localstatus = NC_NOERR;
237  /* Write a single value */
238  localstatus = NC_put_vara(ncid,varid,odom.index,nc_sizevector1,memptr,memtype);
239  /* So it turns out that when get_varm is used, all errors are
240  delayed and ERANGE will be overwritten by more serious errors.
241  */
242  if(localstatus != NC_NOERR) {
243  if(status == NC_NOERR || localstatus != NC_ERANGE)
244  status = localstatus;
245  }
246  memptr += memtypelen;
247  odom_next(&odom);
248  }
249  return status;
250 #endif
251 }
252 
256 int
257 NCDEFAULT_put_varm(
258  int ncid,
259  int varid,
260  const size_t * start,
261  const size_t * edges,
262  const ptrdiff_t * stride,
263  const ptrdiff_t * imapp,
264  const void *value0,
265  nc_type memtype)
266 {
267  int status = NC_NOERR;
268  nc_type vartype = NC_NAT;
269  int varndims = 0;
270  int maxidim = 0;
271  NC* ncp;
272  int memtypelen;
273  ptrdiff_t cvtmap[NC_MAX_VAR_DIMS];
274  const char* value = (char*)value0;
275 
276  status = NC_check_id (ncid, &ncp);
277  if(status != NC_NOERR) return status;
278 
279 /*
280  if(NC_indef(ncp)) return NC_EINDEFINE;
281  if(NC_readonly (ncp)) return NC_EPERM;
282 */
283 
284  /* mid body */
285  status = nc_inq_vartype(ncid, varid, &vartype);
286  if(status != NC_NOERR) return status;
287  /* Check that this is an atomic type */
288  if(vartype > NC_MAX_ATOMIC_TYPE)
289  return NC_EMAPTYPE;
290 
291  status = nc_inq_varndims(ncid, varid, &varndims);
292  if(status != NC_NOERR) return status;
293 
294  if(memtype == NC_NAT) {
295  if(imapp != NULL && varndims != 0) {
296  /*
297  * convert map units from bytes to units of sizeof(type)
298  */
299  size_t ii;
300  const ptrdiff_t szof = (ptrdiff_t) nctypelen(vartype);
301  for(ii = 0; ii < varndims; ii++) {
302  if(imapp[ii] % szof != 0) {
303  /*free(cvtmap);*/
304  return NC_EINVAL;
305  }
306  cvtmap[ii] = imapp[ii] / szof;
307  }
308  imapp = cvtmap;
309  }
310  memtype = vartype;
311  }
312 
313  if(memtype == NC_CHAR && vartype != NC_CHAR)
314  return NC_ECHAR;
315  else if(memtype != NC_CHAR && vartype == NC_CHAR)
316  return NC_ECHAR;
317 
318  memtypelen = nctypelen(memtype);
319 
320  maxidim = (int) varndims - 1;
321 
322  if (maxidim < 0)
323  {
324  /*
325  * The variable is a scalar; consequently,
326  * there s only one thing to get and only one place to put it.
327  * (Why was I called?)
328  */
329  size_t edge1[1] = {1};
330  return NC_put_vara(ncid, varid, start, edge1, value, memtype);
331  }
332 
333  /*
334  * else
335  * The variable is an array.
336  */
337  {
338  int idim;
339  size_t *mystart = NULL;
340  size_t *myedges;
341  size_t *iocount; /* count vector */
342  size_t *stop; /* stop indexes */
343  size_t *length; /* edge lengths in bytes */
344  ptrdiff_t *mystride;
345  ptrdiff_t *mymap;
346  size_t varshape[NC_MAX_VAR_DIMS];
347  int isrecvar;
348  size_t numrecs;
349  int stride1; /* is stride all ones? */
350 
351  /*
352  * Verify stride argument.
353  */
354  stride1 = 1; /* assume ok; */
355  if(stride != NULL) {
356  for (idim = 0; idim <= maxidim; ++idim) {
357  if ((stride[idim] == 0)
358  /* cast needed for braindead systems with signed size_t */
359  || ((unsigned long) stride[idim] >= X_INT_MAX))
360  {
361  return NC_ESTRIDE;
362  }
363  if(stride[idim] != 1) stride1 = 0;
364  }
365  }
366 
367  /* If stride1 is true, and there is no imap, then call get_vara
368  directly
369  */
370  if(stride1 && imapp == NULL) {
371  return NC_put_vara(ncid, varid, start, edges, value, memtype);
372  }
373 
374  /* Compute some dimension related values */
375  isrecvar = NC_is_recvar(ncid,varid,&numrecs);
376  NC_getshape(ncid,varid,varndims,varshape);
377 
378  /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
379  mystart = (size_t *)calloc((size_t)(varndims * 7), sizeof(ptrdiff_t));
380  if(mystart == NULL) return NC_ENOMEM;
381  myedges = mystart + varndims;
382  iocount = myedges + varndims;
383  stop = iocount + varndims;
384  length = stop + varndims;
385  mystride = (ptrdiff_t *)(length + varndims);
386  mymap = mystride + varndims;
387 
388  /*
389  * Initialize I/O parameters.
390  */
391  for (idim = maxidim; idim >= 0; --idim)
392  {
393  mystart[idim] = start != NULL
394  ? start[idim]
395  : 0;
396 
397  if (edges != NULL && edges[idim] == 0)
398  {
399  status = NC_NOERR; /* read/write no data */
400  goto done;
401  }
402 
403  myedges[idim] = edges != NULL
404  ? edges[idim]
405  : idim == 0 && isrecvar
406  ? numrecs - mystart[idim]
407  : varshape[idim] - mystart[idim];
408  mystride[idim] = stride != NULL
409  ? stride[idim]
410  : 1;
411  mymap[idim] = imapp != NULL
412  ? imapp[idim]
413  : idim == maxidim
414  ? 1
415  : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1];
416 
417  iocount[idim] = 1;
418  length[idim] = ((size_t)mymap[idim]) * myedges[idim];
419  stop[idim] = mystart[idim] + myedges[idim] * (size_t)mystride[idim];
420  }
421 
422  /*
423  * Check start, edges
424  */
425  for (idim = isrecvar; idim < maxidim; ++idim)
426  {
427  if (mystart[idim] > varshape[idim])
428  {
429  status = NC_EINVALCOORDS;
430  goto done;
431  }
432  if (mystart[idim] + myedges[idim] > varshape[idim])
433  {
434  status = NC_EEDGE;
435  goto done;
436  }
437  }
438 
439  /* Lower body */
440  /*
441  * As an optimization, adjust I/O parameters when the fastest
442  * dimension has unity stride both externally and internally.
443  * In this case, the user could have called a simpler routine
444  * (i.e. ncvar$1()
445  */
446  if (mystride[maxidim] == 1
447  && mymap[maxidim] == 1)
448  {
449  iocount[maxidim] = myedges[maxidim];
450  mystride[maxidim] = (ptrdiff_t) myedges[maxidim];
451  mymap[maxidim] = (ptrdiff_t) length[maxidim];
452  }
453 
454  /*
455  * Perform I/O. Exit when done.
456  */
457  for (;;)
458  {
459  /* TODO: */
460  int lstatus = NC_put_vara(ncid, varid, mystart, iocount,
461  value, memtype);
462  if (lstatus != NC_NOERR) {
463  if(status == NC_NOERR || lstatus != NC_ERANGE)
464  status = lstatus;
465  }
466 
467  /*
468  * The following code permutes through the variable s
469  * external start-index space and it s internal address
470  * space. At the UPC, this algorithm is commonly
471  * called "odometer code".
472  */
473  idim = maxidim;
474  carry:
475  value += (mymap[idim] * memtypelen);
476  mystart[idim] += (size_t)mystride[idim];
477  if (mystart[idim] == stop[idim])
478  {
479  size_t l = (length[idim] * (size_t)memtypelen);
480  value -= l;
481  mystart[idim] = start[idim];
482  if (--idim < 0)
483  break; /* normal return */
484  goto carry;
485  }
486  } /* I/O loop */
487  done:
488  free(mystart);
489  } /* variable is array */
490  return status;
491 }
492 
496 static int
497 NC_put_vars(int ncid, int varid, const size_t *start,
498  const size_t *edges, const ptrdiff_t *stride,
499  const void *value, nc_type memtype)
500 {
501  NC* ncp;
502  int stat = NC_check_id(ncid, &ncp);
503 
504  if(stat != NC_NOERR) return stat;
505 #ifdef USE_NETCDF4
506  if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
507 #endif
508  return ncp->dispatch->put_vars(ncid,varid,start,edges,stride,value,memtype);
509 }
510 
514 static int
515 NC_put_varm(int ncid, int varid, const size_t *start,
516  const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t* map,
517  const void *value, nc_type memtype)
518 {
519  NC* ncp;
520  int stat = NC_check_id(ncid, &ncp);
521 
522  if(stat != NC_NOERR) return stat;
523 #ifdef USE_NETCDF4
524  if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
525 #endif
526  return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,map,value,memtype);
527 }
528  /* All these functions are part of this named group... */
533 
574 int
575 nc_put_vara(int ncid, int varid, const size_t *startp,
576  const size_t *countp, const void *op)
577 {
578  NC* ncp;
579  int stat = NC_check_id(ncid, &ncp);
580  nc_type xtype;
581  if(stat != NC_NOERR) return stat;
582  stat = nc_inq_vartype(ncid, varid, &xtype);
583  if(stat != NC_NOERR) return stat;
584  return NC_put_vara(ncid, varid, startp, countp, op, xtype);
585 }
586 
587 int
588 nc_put_vara_text(int ncid, int varid, const size_t *startp,
589  const size_t *countp, const char *op)
590 {
591  return NC_put_vara(ncid, varid, startp, countp,
592  (void*)op, NC_CHAR);
593 }
594 
595 int
596 nc_put_vara_schar(int ncid, int varid, const size_t *startp,
597  const size_t *countp, const signed char *op)
598 {
599  NC* ncp;
600  int stat = NC_check_id(ncid, &ncp);
601  if(stat != NC_NOERR) return stat;
602  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
603  NC_BYTE);
604 }
605 
606 int
607 nc_put_vara_uchar(int ncid, int varid, const size_t *startp,
608  const size_t *countp, const unsigned char *op)
609 {
610  NC* ncp;
611  int stat = NC_check_id(ncid, &ncp);
612  if(stat != NC_NOERR) return stat;
613  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
614  T_uchar);
615 }
616 
617 int
618 nc_put_vara_short(int ncid, int varid, const size_t *startp,
619  const size_t *countp, const short *op)
620 {
621  NC* ncp;
622  int stat = NC_check_id(ncid, &ncp);
623  if(stat != NC_NOERR) return stat;
624  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
625  NC_SHORT);
626 }
627 
628 int
629 nc_put_vara_int(int ncid, int varid, const size_t *startp,
630  const size_t *countp, const int *op)
631 {
632  NC* ncp;
633  int stat = NC_check_id(ncid, &ncp);
634  if(stat != NC_NOERR) return stat;
635  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
636  NC_INT);
637 }
638 
639 int
640 nc_put_vara_long(int ncid, int varid, const size_t *startp,
641  const size_t *countp, const long *op)
642 {
643  NC* ncp;
644  int stat = NC_check_id(ncid, &ncp);
645  if(stat != NC_NOERR) return stat;
646  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
647  T_long);
648 }
649 
650 int
651 nc_put_vara_float(int ncid, int varid, const size_t *startp,
652  const size_t *countp, const float *op)
653 {
654  NC* ncp;
655  int stat = NC_check_id(ncid, &ncp);
656  if(stat != NC_NOERR) return stat;
657  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
658  T_float);
659 }
660 
661 int
662 nc_put_vara_double(int ncid, int varid, const size_t *startp,
663  const size_t *countp, const double *op)
664 {
665  NC* ncp;
666  int stat = NC_check_id(ncid, &ncp);
667  if(stat != NC_NOERR) return stat;
668  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
669  T_double);
670 }
671 
672 int
673 nc_put_vara_ubyte(int ncid, int varid, const size_t *startp,
674  const size_t *countp, const unsigned char *op)
675 {
676  NC* ncp;
677  int stat = NC_check_id(ncid, &ncp);
678  if(stat != NC_NOERR) return stat;
679  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
680  T_ubyte);
681 }
682 
683 int
684 nc_put_vara_ushort(int ncid, int varid, const size_t *startp,
685  const size_t *countp, const unsigned short *op)
686 {
687  NC* ncp;
688  int stat = NC_check_id(ncid, &ncp);
689  if(stat != NC_NOERR) return stat;
690  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
691  T_ushort);
692 }
693 
694 int
695 nc_put_vara_uint(int ncid, int varid, const size_t *startp,
696  const size_t *countp, const unsigned int *op)
697 {
698  NC* ncp;
699  int stat = NC_check_id(ncid, &ncp);
700  if(stat != NC_NOERR) return stat;
701  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
702  T_uint);
703 }
704 
705 int
706 nc_put_vara_longlong(int ncid, int varid, const size_t *startp,
707  const size_t *countp, const long long *op)
708 {
709  NC* ncp;
710  int stat = NC_check_id(ncid, &ncp);
711  if(stat != NC_NOERR) return stat;
712  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
713  T_longlong);
714 }
715 
716 int
717 nc_put_vara_ulonglong(int ncid, int varid, const size_t *startp,
718  const size_t *countp, const unsigned long long *op)
719 {
720  NC* ncp;
721  int stat = NC_check_id(ncid, &ncp);
722  if(stat != NC_NOERR) return stat;
723  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
724  NC_UINT64);
725 }
726 
727 #ifdef USE_NETCDF4
728 int
729 nc_put_vara_string(int ncid, int varid, const size_t *startp,
730  const size_t *countp, const char* *op)
731 {
732  NC* ncp;
733  int stat = NC_check_id(ncid, &ncp);
734  if(stat != NC_NOERR) return stat;
735  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
736  NC_STRING);
737 }
738 
739 #endif /*USE_NETCDF4*/
740 
764 int
765 nc_put_var1(int ncid, int varid, const size_t *indexp, const void *op)
766 {
767  return NC_put_var1(ncid, varid, indexp, op, NC_NAT);
768 }
769 
770 int
771 nc_put_var1_text(int ncid, int varid, const size_t *indexp, const char *op)
772 {
773  NC* ncp;
774  int stat = NC_check_id(ncid, &ncp);
775  if(stat != NC_NOERR) return stat;
776  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_CHAR);
777 }
778 
779 int
780 nc_put_var1_schar(int ncid, int varid, const size_t *indexp, const signed char *op)
781 {
782  NC* ncp;
783  int stat = NC_check_id(ncid, &ncp);
784  if(stat != NC_NOERR) return stat;
785  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_BYTE);
786 }
787 
788 int
789 nc_put_var1_uchar(int ncid, int varid, const size_t *indexp, const unsigned char *op)
790 {
791  NC* ncp;
792  int stat = NC_check_id(ncid, &ncp);
793  if(stat != NC_NOERR) return stat;
794  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UBYTE);
795 }
796 
797 int
798 nc_put_var1_short(int ncid, int varid, const size_t *indexp, const short *op)
799 {
800  NC* ncp;
801  int stat = NC_check_id(ncid, &ncp);
802  if(stat != NC_NOERR) return stat;
803  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_SHORT);
804 }
805 
806 int
807 nc_put_var1_int(int ncid, int varid, const size_t *indexp, const int *op)
808 {
809  NC* ncp;
810  int stat = NC_check_id(ncid, &ncp);
811  if(stat != NC_NOERR) return stat;
812  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_INT);
813 }
814 
815 int
816 nc_put_var1_long(int ncid, int varid, const size_t *indexp, const long *op)
817 {
818  NC* ncp;
819  int stat = NC_check_id(ncid, &ncp);
820  if(stat != NC_NOERR) return stat;
821  return NC_put_var1(ncid, varid, indexp, (void*)op, longtype);
822 }
823 
824 int
825 nc_put_var1_float(int ncid, int varid, const size_t *indexp, const float *op)
826 {
827  NC* ncp;
828  int stat = NC_check_id(ncid, &ncp);
829  if(stat != NC_NOERR) return stat;
830  return NC_put_var1(ncid, varid, indexp, (void*)op, NC_FLOAT);
831 }
832 
833 int
834 nc_put_var1_double(int ncid, int varid, const size_t *indexp, const double *op)
835 {
836  NC* ncp;
837  int stat = NC_check_id(ncid, &ncp);
838  if(stat != NC_NOERR) return stat;
839  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_DOUBLE);
840 }
841 
842 int
843 nc_put_var1_ubyte(int ncid, int varid, const size_t *indexp, const unsigned char *op)
844 {
845  NC* ncp;
846  int stat = NC_check_id(ncid, &ncp);
847  if(stat != NC_NOERR) return stat;
848  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UBYTE);
849 }
850 
851 int
852 nc_put_var1_ushort(int ncid, int varid, const size_t *indexp, const unsigned short *op)
853 {
854  NC* ncp;
855  int stat = NC_check_id(ncid, &ncp);
856  if(stat != NC_NOERR) return stat;
857  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_USHORT);
858 }
859 
860 int
861 nc_put_var1_uint(int ncid, int varid, const size_t *indexp, const unsigned int *op)
862 {
863  NC* ncp;
864  int stat = NC_check_id(ncid, &ncp);
865  if(stat != NC_NOERR) return stat;
866  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UINT);
867 }
868 
869 int
870 nc_put_var1_longlong(int ncid, int varid, const size_t *indexp, const long long *op)
871 {
872  NC* ncp;
873  int stat = NC_check_id(ncid, &ncp);
874  if(stat != NC_NOERR) return stat;
875  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_INT64);
876 }
877 
878 int
879 nc_put_var1_ulonglong(int ncid, int varid, const size_t *indexp, const unsigned long long *op)
880 {
881  NC* ncp;
882  int stat = NC_check_id(ncid, &ncp);
883  if(stat != NC_NOERR) return stat;
884  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UINT64);
885 }
886 
887 #ifdef USE_NETCDF4
888 int
889 nc_put_var1_string(int ncid, int varid, const size_t *indexp, const char* *op)
890 {
891  NC* ncp;
892  int stat = NC_check_id(ncid, &ncp);
893  if(stat != NC_NOERR) return stat;
894  return NC_put_var1(ncid, varid, indexp, (void*)op, NC_STRING);
895 }
896 #endif /*USE_NETCDF4*/
897 
945 int
946 nc_put_var(int ncid, int varid, const void *op)
947 {
948  return NC_put_var(ncid, varid, op, NC_NAT);
949 }
950 
951 int
952 nc_put_var_text(int ncid, int varid, const char *op)
953 {
954  NC* ncp;
955  int stat = NC_check_id(ncid, &ncp);
956  if(stat != NC_NOERR) return stat;
957  return NC_put_var(ncid,varid,(void*)op,NC_CHAR);
958 }
959 
960 int
961 nc_put_var_schar(int ncid, int varid, const signed char *op)
962 {
963  NC* ncp;
964  int stat = NC_check_id(ncid, &ncp);
965  if(stat != NC_NOERR) return stat;
966  return NC_put_var(ncid,varid,(void*)op,NC_BYTE);
967 }
968 
969 int
970 nc_put_var_uchar(int ncid, int varid, const unsigned char *op)
971 {
972  NC* ncp;
973  int stat = NC_check_id(ncid, &ncp);
974  if(stat != NC_NOERR) return stat;
975  return NC_put_var(ncid,varid,(void*)op,T_uchar);
976 }
977 
978 int
979 nc_put_var_short(int ncid, int varid, const short *op)
980 {
981  NC* ncp;
982  int stat = NC_check_id(ncid, &ncp);
983  if(stat != NC_NOERR) return stat;
984  return NC_put_var(ncid,varid,(void*)op,NC_SHORT);
985 }
986 
987 int
988 nc_put_var_int(int ncid, int varid, const int *op)
989 {
990  NC* ncp;
991  int stat = NC_check_id(ncid, &ncp);
992  if(stat != NC_NOERR) return stat;
993  return NC_put_var(ncid,varid,(void*)op,NC_INT);
994 }
995 
996 int
997 nc_put_var_long(int ncid, int varid, const long *op)
998 {
999  NC* ncp;
1000  int stat = NC_check_id(ncid, &ncp);
1001  if(stat != NC_NOERR) return stat;
1002  return NC_put_var(ncid,varid,(void*)op,T_long);
1003 }
1004 
1005 int
1006 nc_put_var_float(int ncid, int varid, const float *op)
1007 {
1008  NC* ncp;
1009  int stat = NC_check_id(ncid, &ncp);
1010  if(stat != NC_NOERR) return stat;
1011  return NC_put_var(ncid,varid,(void*)op,T_float);
1012 }
1013 
1014 int
1015 nc_put_var_double(int ncid, int varid, const double *op)
1016 {
1017  NC* ncp;
1018  int stat = NC_check_id(ncid, &ncp);
1019  if(stat != NC_NOERR) return stat;
1020  return NC_put_var(ncid,varid,(void*)op,T_double);
1021 }
1022 
1023 int
1024 nc_put_var_ubyte(int ncid, int varid, const unsigned char *op)
1025 {
1026  NC* ncp;
1027  int stat = NC_check_id(ncid, &ncp);
1028  if(stat != NC_NOERR) return stat;
1029  return NC_put_var(ncid,varid,(void*)op,T_ubyte);
1030 }
1031 
1032 int
1033 nc_put_var_ushort(int ncid, int varid, const unsigned short *op)
1034 {
1035  NC* ncp;
1036  int stat = NC_check_id(ncid, &ncp);
1037  if(stat != NC_NOERR) return stat;
1038  return NC_put_var(ncid,varid,(void*)op,T_ushort);
1039 }
1040 
1041 int
1042 nc_put_var_uint(int ncid, int varid, const unsigned int *op)
1043 {
1044  NC* ncp;
1045  int stat = NC_check_id(ncid, &ncp);
1046  if(stat != NC_NOERR) return stat;
1047  return NC_put_var(ncid,varid,(void*)op,T_uint);
1048 }
1049 
1050 int
1051 nc_put_var_longlong(int ncid, int varid, const long long *op)
1052 {
1053  NC* ncp;
1054  int stat = NC_check_id(ncid, &ncp);
1055  if(stat != NC_NOERR) return stat;
1056  return NC_put_var(ncid,varid,(void*)op,T_longlong);
1057 }
1058 
1059 int
1060 nc_put_var_ulonglong(int ncid, int varid, const unsigned long long *op)
1061 {
1062  NC* ncp;
1063  int stat = NC_check_id(ncid, &ncp);
1064  if(stat != NC_NOERR) return stat;
1065  return NC_put_var(ncid,varid,(void*)op,NC_UINT64);
1066 }
1067 
1068 #ifdef USE_NETCDF4
1069 int
1070 nc_put_var_string(int ncid, int varid, const char* *op)
1071 {
1072  NC* ncp;
1073  int stat = NC_check_id(ncid, &ncp);
1074  if(stat != NC_NOERR) return stat;
1075  return NC_put_var(ncid,varid,(void*)op,NC_STRING);
1076 }
1077 #endif /*USE_NETCDF4*/
1078 
1110 int
1111 nc_put_vars (int ncid, int varid, const size_t *startp,
1112  const size_t *countp, const ptrdiff_t *stridep,
1113  const void *op)
1114 {
1115  NC *ncp;
1116  int stat = NC_NOERR;
1117 
1118  if ((stat = NC_check_id(ncid, &ncp)))
1119  return stat;
1120  return ncp->dispatch->put_vars(ncid, varid, startp, countp,
1121  stridep, op, NC_NAT);
1122 }
1123 
1124 int
1125 nc_put_vars_text(int ncid, int varid, const size_t *startp,
1126  const size_t *countp, const ptrdiff_t *stridep,
1127  const char *op)
1128 {
1129  NC *ncp;
1130  int stat = NC_check_id(ncid, &ncp);
1131  if(stat != NC_NOERR) return stat;
1132  return NC_put_vars(ncid, varid, startp, countp,
1133  stridep,(void*)op,NC_CHAR);
1134 }
1135 
1136 int
1137 nc_put_vars_schar(int ncid, int varid, const size_t *startp,
1138  const size_t *countp, const ptrdiff_t *stridep,
1139  const signed char *op)
1140 {
1141  NC *ncp;
1142  int stat = NC_check_id(ncid, &ncp);
1143  if(stat != NC_NOERR) return stat;
1144  return NC_put_vars(ncid, varid, startp, countp,
1145  stridep,(void*)op,NC_BYTE);
1146 }
1147 
1148 int
1149 nc_put_vars_uchar(int ncid, int varid,
1150  const size_t *startp, const size_t *countp,
1151  const ptrdiff_t *stridep,
1152  const unsigned 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, T_uchar);
1159 }
1160 
1161 int
1162 nc_put_vars_short(int ncid, int varid,
1163  const size_t *startp, const size_t *countp,
1164  const ptrdiff_t *stridep,
1165  const short *op)
1166 {
1167  NC *ncp;
1168  int stat = NC_check_id(ncid, &ncp);
1169  if(stat != NC_NOERR) return stat;
1170  return NC_put_vars(ncid, varid, startp, countp,
1171  stridep, (void *)op, NC_SHORT);
1172 }
1173 
1174 int
1175 nc_put_vars_int(int ncid, int varid,
1176  const size_t *startp, const size_t *countp,
1177  const ptrdiff_t *stridep,
1178  const int *op)
1179 {
1180  NC *ncp;
1181  int stat = NC_check_id(ncid, &ncp);
1182  if(stat != NC_NOERR) return stat;
1183  return NC_put_vars(ncid, varid, startp, countp,
1184  stridep, (void *)op, NC_INT);
1185 }
1186 
1187 int
1188 nc_put_vars_long(int ncid, int varid,
1189  const size_t *startp, const size_t *countp,
1190  const ptrdiff_t *stridep,
1191  const long *op)
1192 {
1193  NC *ncp;
1194  int stat = NC_check_id(ncid, &ncp);
1195  if(stat != NC_NOERR) return stat;
1196  return NC_put_vars(ncid, varid, startp, countp,
1197  stridep, (void *)op, T_long);
1198 }
1199 
1200 int
1201 nc_put_vars_float(int ncid, int varid,
1202  const size_t *startp, const size_t *countp,
1203  const ptrdiff_t *stridep,
1204  const float *op)
1205 {
1206  NC *ncp;
1207  int stat = NC_check_id(ncid, &ncp);
1208  if(stat != NC_NOERR) return stat;
1209  return NC_put_vars(ncid, varid, startp, countp,
1210  stridep, (void *)op, T_float);
1211 }
1212 
1213 int
1214 nc_put_vars_double(int ncid, int varid,
1215  const size_t *startp, const size_t *countp,
1216  const ptrdiff_t *stridep,
1217  const double *op)
1218 {
1219  NC *ncp;
1220  int stat = NC_check_id(ncid, &ncp);
1221  if(stat != NC_NOERR) return stat;
1222  return NC_put_vars(ncid, varid, startp, countp,
1223  stridep, (void *)op, T_double);
1224 }
1225 
1226 int
1227 nc_put_vars_ubyte(int ncid, int varid,
1228  const size_t *startp, const size_t *countp,
1229  const ptrdiff_t *stridep,
1230  const unsigned char *op)
1231 {
1232  NC *ncp;
1233  int stat = NC_check_id(ncid, &ncp);
1234  if(stat != NC_NOERR) return stat;
1235  return NC_put_vars(ncid, varid, startp, countp,
1236  stridep, (void *)op, T_ubyte);
1237 }
1238 
1239 int
1240 nc_put_vars_ushort(int ncid, int varid,
1241  const size_t *startp, const size_t *countp,
1242  const ptrdiff_t *stridep,
1243  const unsigned short *op)
1244 {
1245  NC *ncp;
1246  int stat = NC_check_id(ncid, &ncp);
1247  if(stat != NC_NOERR) return stat;
1248  return NC_put_vars(ncid, varid, startp, countp,
1249  stridep, (void *)op, T_ushort);
1250 }
1251 
1252 int
1253 nc_put_vars_uint(int ncid, int varid,
1254  const size_t *startp, const size_t *countp,
1255  const ptrdiff_t *stridep,
1256  const unsigned int *op)
1257 {
1258  NC *ncp;
1259  int stat = NC_check_id(ncid, &ncp);
1260  if(stat != NC_NOERR) return stat;
1261  return NC_put_vars(ncid, varid, startp, countp,
1262  stridep, (void *)op, T_uint);
1263 }
1264 
1265 int
1266 nc_put_vars_longlong(int ncid, int varid,
1267  const size_t *startp, const size_t *countp,
1268  const ptrdiff_t *stridep,
1269  const long long *op)
1270 {
1271  NC *ncp;
1272  int stat = NC_check_id(ncid, &ncp);
1273  if(stat != NC_NOERR) return stat;
1274  return NC_put_vars(ncid, varid, startp, countp,
1275  stridep, (void *)op, T_longlong);
1276 }
1277 
1278 int
1279 nc_put_vars_ulonglong(int ncid, int varid,
1280  const size_t *startp, const size_t *countp,
1281  const ptrdiff_t *stridep,
1282  const unsigned long long *op)
1283 {
1284  NC *ncp;
1285  int stat = NC_check_id(ncid, &ncp);
1286  if(stat != NC_NOERR) return stat;
1287  return NC_put_vars(ncid, varid, startp, countp,
1288  stridep, (void *)op, NC_UINT64);
1289 }
1290 
1291 #ifdef USE_NETCDF4
1292 int
1293 nc_put_vars_string(int ncid, int varid,
1294  const size_t *startp, const size_t *countp,
1295  const ptrdiff_t *stridep,
1296  const char**op)
1297 {
1298  NC *ncp;
1299  int stat = NC_check_id(ncid, &ncp);
1300  if(stat != NC_NOERR) return stat;
1301  return NC_put_vars(ncid, varid, startp, countp, stridep,
1302  (void *)op, NC_STRING);
1303 }
1304 #endif /*USE_NETCDF4*/
1305 
1349 int
1350 nc_put_varm (int ncid, int varid, const size_t *startp,
1351  const size_t *countp, const ptrdiff_t *stridep,
1352  const ptrdiff_t *imapp, const void *op)
1353 {
1354  NC *ncp;
1355  int stat = NC_NOERR;
1356 
1357  if ((stat = NC_check_id(ncid, &ncp)))
1358  return stat;
1359  return ncp->dispatch->put_varm(ncid, varid, startp, countp,
1360  stridep, imapp, op, NC_NAT);
1361 }
1362 
1363 int
1364 nc_put_varm_text(int ncid, int varid, const size_t *startp,
1365  const size_t *countp, const ptrdiff_t *stridep,
1366  const ptrdiff_t *imapp, const char *op)
1367 {
1368  NC *ncp;
1369  int stat = NC_check_id(ncid, &ncp);
1370  if(stat != NC_NOERR) return stat;
1371  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1372  (void *)op, NC_CHAR);
1373 }
1374 
1375 int
1376 nc_put_varm_schar(int ncid, int varid,
1377  const size_t *startp, const size_t *countp,
1378  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1379  const signed char *op)
1380 {
1381  NC *ncp;
1382  int stat = NC_check_id(ncid, &ncp);
1383  if(stat != NC_NOERR) return stat;
1384  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1385  (void *)op, NC_BYTE);
1386 }
1387 
1388 int
1389 nc_put_varm_uchar(int ncid, int varid,
1390  const size_t *startp, const size_t *countp,
1391  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1392  const unsigned 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, T_uchar);
1399 }
1400 
1401 int
1402 nc_put_varm_short(int ncid, int varid,
1403  const size_t *startp, const size_t *countp,
1404  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1405  const short *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_SHORT);
1412 }
1413 
1414 int
1415 nc_put_varm_int(int ncid, int varid,
1416  const size_t *startp, const size_t *countp,
1417  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1418  const int *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, NC_INT);
1425 }
1426 
1427 int
1428 nc_put_varm_long(int ncid, int varid,
1429  const size_t *startp, const size_t *countp,
1430  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1431  const long *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, T_long);
1438 }
1439 
1440 int
1441 nc_put_varm_float(int ncid, int varid,
1442  const size_t *startp, const size_t *countp,
1443  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1444  const float *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, T_float);
1451 }
1452 
1453 int
1454 nc_put_varm_double(int ncid, int varid,
1455  const size_t *startp, const size_t *countp,
1456  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1457  const double *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_double);
1464 }
1465 
1466 int
1467 nc_put_varm_ubyte(int ncid, int varid,
1468  const size_t *startp, const size_t *countp,
1469  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1470  const unsigned char *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_ubyte);
1477 }
1478 
1479 int
1480 nc_put_varm_ushort(int ncid, int varid,
1481  const size_t *startp, const size_t *countp,
1482  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1483  const unsigned short *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_ushort);
1490 }
1491 
1492 int
1493 nc_put_varm_uint(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 int *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_uint);
1503 }
1504 
1505 int
1506 nc_put_varm_longlong(int ncid, int varid,
1507  const size_t *startp, const size_t *countp,
1508  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1509  const long long *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_longlong);
1516 }
1517 
1518 int
1519 nc_put_varm_ulonglong(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 long long *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, NC_UINT64);
1529 }
1530 
1531 #ifdef USE_NETCDF4
1532 int
1533 nc_put_varm_string(int ncid, int varid,
1534  const size_t *startp, const size_t *countp,
1535  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1536  const char**op)
1537 {
1538  NC *ncp;
1539  int stat = NC_check_id(ncid, &ncp);
1540  if(stat != NC_NOERR) return stat;
1541  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1542  (void *)op, NC_STRING);
1543 }
1544 #endif /*USE_NETCDF4*/
1545  /*End of named group... */
1549 
int nc_put_var_long(int ncid, int varid, const long *op)
Write an entire variable with one call.
Definition: dvarput.c:997
#define NC_ENOMEM
Memory allocation (malloc) failure.
Definition: netcdf.h:353
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:1467
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:1214
#define NC_CHAR
ISO/ASCII character.
Definition: netcdf.h:38
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:1149
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:596
int nc_put_var1_string(int ncid, int varid, const size_t *indexp, const char **op)
Write one datum.
Definition: dvarput.c:889
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:1253
#define NC_UBYTE
unsigned 1 byte int
Definition: netcdf.h:44
#define NC_EMAPTYPE
Mapped access for atomic types only.
Definition: netcdf.h:406
#define NC_ERANGE
Math result not representable.
Definition: netcdf.h:352
#define NC_MAX_VAR_DIMS
max per variable dimensions
Definition: netcdf.h:232
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:607
#define NC_UINT
unsigned 4-byte int
Definition: netcdf.h:46
int nc_put_var_uint(int ncid, int varid, const unsigned int *op)
Write an entire variable with one call.
Definition: dvarput.c:1042
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:1266
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:706
int nc_put_var_ulonglong(int ncid, int varid, const unsigned long long *op)
Write an entire variable with one call.
Definition: dvarput.c:1060
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:1480
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:1175
#define NC_EINVALCOORDS
Index exceeds dimension bound.
Definition: netcdf.h:310
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:1227
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:1240
int nc_put_var_schar(int ncid, int varid, const signed char *op)
Write an entire variable with one call.
Definition: dvarput.c:961
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:662
int nc_put_var_int(int ncid, int varid, const int *op)
Write an entire variable with one call.
Definition: dvarput.c:988
int nc_put_var1_uchar(int ncid, int varid, const size_t *indexp, const unsigned char *op)
Write one datum.
Definition: dvarput.c:789
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:651
#define NC_INT64
signed 8-byte int
Definition: netcdf.h:47
int nc_put_var(int ncid, int varid, const void *op)
Write an entire variable with one call.
Definition: dvarput.c:946
int nc_put_var1_ushort(int ncid, int varid, const size_t *indexp, const unsigned short *op)
Write one datum.
Definition: dvarput.c:852
#define NC_STRING
string
Definition: netcdf.h:49
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:575
#define NC_DOUBLE
double precision floating point number
Definition: netcdf.h:43
EXTERNL int nc_inq_varndims(int ncid, int varid, int *ndimsp)
Learn how many dimensions are associated with a variable.
Definition: dvarinq.c:191
int nc_put_var1_double(int ncid, int varid, const size_t *indexp, const double *op)
Write one datum.
Definition: dvarput.c:834
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:1350
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:1162
int nc_type
The nc_type type is just an int.
Definition: netcdf.h:27
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:1415
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:1111
int nc_put_var_string(int ncid, int varid, const char **op)
Write an entire variable with one call.
Definition: dvarput.c:1070
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:618
#define NC_BYTE
signed 1 byte integer
Definition: netcdf.h:37
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:695
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:1402
int nc_put_var_ubyte(int ncid, int varid, const unsigned char *op)
Write an entire variable with one call.
Definition: dvarput.c:1024
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:1201
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:729
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:588
int nc_put_var1_float(int ncid, int varid, const size_t *indexp, const float *op)
Write one datum.
Definition: dvarput.c:825
int nc_put_var_longlong(int ncid, int varid, const long long *op)
Write an entire variable with one call.
Definition: dvarput.c:1051
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:673
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:1364
int nc_put_var1_int(int ncid, int varid, const size_t *indexp, const int *op)
Write one datum.
Definition: dvarput.c:807
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:1533
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:1519
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:684
#define NC_EBADTYPE
Not a netcdf data type.
Definition: netcdf.h:315
int nc_put_var1_longlong(int ncid, int varid, const size_t *indexp, const long long *op)
Write one datum.
Definition: dvarput.c:870
#define NC_EEDGE
Start+count exceeds dimension bound.
Definition: netcdf.h:343
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:640
#define NC_ESTRIDE
Illegal stride.
Definition: netcdf.h:344
#define NC_EINVAL
Invalid Argument.
Definition: netcdf.h:288
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:1506
int nc_put_var1(int ncid, int varid, const size_t *indexp, const void *op)
Write one datum.
Definition: dvarput.c:765
#define NC_INT
signed 4 byte integer
Definition: netcdf.h:40
#define NC_NAT
Not A Type.
Definition: netcdf.h:36
int nc_put_var1_schar(int ncid, int varid, const size_t *indexp, const signed char *op)
Write one datum.
Definition: dvarput.c:780
EXTERNL int nc_inq_vartype(int ncid, int varid, nc_type *xtypep)
Learn the type of a variable.
Definition: dvarinq.c:168
EXTERNL int nc_inq_type(int ncid, nc_type xtype, char *name, size_t *size)
Inquire about a type.
Definition: dfile.c:1448
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:629
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:1376
#define NC_USHORT
unsigned 2-byte int
Definition: netcdf.h:45
int nc_put_var1_ulonglong(int ncid, int varid, const size_t *indexp, const unsigned long long *op)
Write one datum.
Definition: dvarput.c:879
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:1454
int nc_put_var1_short(int ncid, int varid, const size_t *indexp, const short *op)
Write one datum.
Definition: dvarput.c:798
int nc_put_var_double(int ncid, int varid, const double *op)
Write an entire variable with one call.
Definition: dvarput.c:1015
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:1428
int nc_put_var_text(int ncid, int varid, const char *op)
Write an entire variable with one call.
Definition: dvarput.c:952
#define NC_SHORT
signed 2 byte integer
Definition: netcdf.h:39
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:1493
int nc_put_var1_text(int ncid, int varid, const size_t *indexp, const char *op)
Write one datum.
Definition: dvarput.c:771
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:717
int nc_put_var_float(int ncid, int varid, const float *op)
Write an entire variable with one call.
Definition: dvarput.c:1006
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:1125
int nc_put_var1_long(int ncid, int varid, const size_t *indexp, const long *op)
Write one datum.
Definition: dvarput.c:816
int nc_put_var_ushort(int ncid, int varid, const unsigned short *op)
Write an entire variable with one call.
Definition: dvarput.c:1033
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:1137
#define NC_NOERR
No Error.
Definition: netcdf.h:278
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:1188
#define NC_ECHAR
Attempt to convert between text & numbers.
Definition: netcdf.h:334
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:1279
int nc_put_var1_uint(int ncid, int varid, const size_t *indexp, const unsigned int *op)
Write one datum.
Definition: dvarput.c:861
int nc_put_var_uchar(int ncid, int varid, const unsigned char *op)
Write an entire variable with one call.
Definition: dvarput.c:970
int nc_put_var_short(int ncid, int varid, const short *op)
Write an entire variable with one call.
Definition: dvarput.c:979
#define NC_FLOAT
single precision floating point number
Definition: netcdf.h:42
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:1441
int nc_put_var1_ubyte(int ncid, int varid, const size_t *indexp, const unsigned char *op)
Write one datum.
Definition: dvarput.c:843
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:1389
#define NC_UINT64
unsigned 8-byte int
Definition: netcdf.h:48
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:1293
Functions for writing data to variables.
Definition: dvarput.c:12

Return to the Main Unidata NetCDF page.
Generated on Sun Nov 23 2014 16:17:49 for NetCDF. NetCDF is a Unidata library.