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

Return to the Main Unidata NetCDF page.
Generated on Sat Sep 22 2018 10:25:33 for NetCDF. NetCDF is a Unidata library.