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

Return to the Main Unidata NetCDF page.
Generated on Fri May 11 2018 21:22:18 for NetCDF. NetCDF is a Unidata library.