13 #include <nc4internal.h>
14 #include "nc4dispatch.h"
18 #define NC_SZIP_EC_OPTION_MASK 4
19 #define NC_SZIP_NN_OPTION_MASK 32
20 #define NC_SZIP_MAX_PIXELS_PER_BLOCK 32
23 #define DEFAULT_1D_UNLIM_SIZE (4096)
25 #define NC_ARRAY_GROWBY 4
27 extern int nc4_get_default_fill_value(const NC_TYPE_INFO_T *type_info,
42 nc4_reopen_dataset(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *var)
46 if (var->hdf_datasetid)
48 if ((access_pid = H5Pcreate(H5P_DATASET_ACCESS)) < 0)
50 if (H5Pset_chunk_cache(access_pid, var->chunk_cache_nelems,
51 var->chunk_cache_size,
52 var->chunk_cache_preemption) < 0)
54 if (H5Dclose(var->hdf_datasetid) < 0)
56 if ((var->hdf_datasetid = H5Dopen2(grp->hdf_grpid, var->name,
59 if (H5Pclose(access_pid) < 0)
85 NC4_set_var_chunk_cache(
int ncid,
int varid,
size_t size,
size_t nelems,
90 NC_HDF5_FILE_INFO_T *h5;
95 if (preemption < 0 || preemption > 1)
99 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
101 assert(nc && grp && h5);
104 if (varid < 0 || varid >= grp->vars.nelems)
106 var = grp->vars.value[varid];
107 assert(var && var->varid == varid);
110 var->chunk_cache_size = size;
111 var->chunk_cache_nelems = nelems;
112 var->chunk_cache_preemption = preemption;
114 if ((retval = nc4_reopen_dataset(grp, var)))
134 nc_set_var_chunk_cache_ints(
int ncid,
int varid,
int size,
int nelems,
137 size_t real_size = H5D_CHUNK_CACHE_NBYTES_DEFAULT;
138 size_t real_nelems = H5D_CHUNK_CACHE_NSLOTS_DEFAULT;
139 float real_preemption = CHUNK_CACHE_PREEMPTION;
142 real_size = ((size_t) size) * MEGABYTE;
145 real_nelems = nelems;
148 real_preemption = preemption / 100.;
150 return NC4_set_var_chunk_cache(ncid, varid, real_size, real_nelems,
171 NC4_get_var_chunk_cache(
int ncid,
int varid,
size_t *sizep,
172 size_t *nelemsp,
float *preemptionp)
176 NC_HDF5_FILE_INFO_T *h5;
181 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
183 assert(nc && grp && h5);
186 if (varid < 0 || varid >= grp->vars.nelems)
188 var = grp->vars.value[varid];
189 assert(var && var->varid == varid);
193 *sizep = var->chunk_cache_size;
195 *nelemsp = var->chunk_cache_nelems;
197 *preemptionp = var->chunk_cache_preemption;
219 nc_get_var_chunk_cache_ints(
int ncid,
int varid,
int *sizep,
220 int *nelemsp,
int *preemptionp)
222 size_t real_size, real_nelems;
223 float real_preemption;
226 if ((ret = NC4_get_var_chunk_cache(ncid, varid, &real_size,
227 &real_nelems, &real_preemption)))
231 *sizep = real_size / MEGABYTE;
233 *nelemsp = (int)real_nelems;
235 *preemptionp = (int)(real_preemption * 100);
254 check_chunksizes(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *var,
const size_t *chunksizes)
261 if ((retval = nc4_get_typelen_mem(grp->nc4_info, var->type_info->nc_typeid, 0, &type_len)))
263 if (var->type_info->nc_type_class ==
NC_VLEN)
264 dprod = (double)
sizeof(hvl_t);
266 dprod = (double)type_len;
267 for (d = 0; d < var->ndims; d++)
268 dprod *= (
double)chunksizes[d];
288 nc4_find_default_chunksizes2(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *var)
292 float num_values = 1, num_unlim = 0;
294 size_t suggested_size;
296 double total_chunk_size;
299 if (var->type_info->nc_type_class ==
NC_STRING)
300 type_size =
sizeof(
char *);
302 type_size = var->type_info->size;
307 total_chunk_size = (double) type_size;
312 for (d = 0; d < var->ndims; d++)
315 if (! var->dim[d]->unlimited)
316 num_values *= (float)var->dim[d]->len;
319 var->chunksizes[d] = 1;
325 if (var->ndims == 1 && num_unlim == 1) {
326 if (DEFAULT_CHUNK_SIZE / type_size <= 0)
328 else if (DEFAULT_CHUNK_SIZE / type_size > DEFAULT_1D_UNLIM_SIZE)
329 suggested_size = DEFAULT_1D_UNLIM_SIZE;
331 suggested_size = DEFAULT_CHUNK_SIZE / type_size;
332 var->chunksizes[0] = suggested_size / type_size;
333 LOG((4,
"%s: name %s dim %d DEFAULT_CHUNK_SIZE %d num_values %f type_size %d "
334 "chunksize %ld", __func__, var->name, d, DEFAULT_CHUNK_SIZE, num_values, type_size, var->chunksizes[0]));
336 if (var->ndims > 1 && var->ndims == num_unlim) {
337 suggested_size = pow((
double)DEFAULT_CHUNK_SIZE/type_size, 1.0/(
double)(var->ndims));
338 for (d = 0; d < var->ndims; d++)
340 var->chunksizes[d] = suggested_size ? suggested_size : 1;
341 LOG((4,
"%s: name %s dim %d DEFAULT_CHUNK_SIZE %d num_values %f type_size %d "
342 "chunksize %ld", __func__, var->name, d, DEFAULT_CHUNK_SIZE, num_values, type_size, var->chunksizes[d]));
348 for (d = 0; d < var->ndims; d++)
349 if (!var->chunksizes[d])
351 suggested_size = (pow((
double)DEFAULT_CHUNK_SIZE/(num_values * type_size),
352 1.0/(
double)(var->ndims - num_unlim)) * var->dim[d]->len - .5);
353 if (suggested_size > var->dim[d]->len)
354 suggested_size = var->dim[d]->len;
355 var->chunksizes[d] = suggested_size ? suggested_size : 1;
356 LOG((4,
"%s: name %s dim %d DEFAULT_CHUNK_SIZE %d num_values %f type_size %d "
357 "chunksize %ld", __func__, var->name, d, DEFAULT_CHUNK_SIZE, num_values, type_size, var->chunksizes[d]));
362 for (d = 0; d < var->ndims; d++)
363 total_chunk_size *= (
double) var->chunksizes[d];
364 LOG((4,
"total_chunk_size %f", total_chunk_size));
368 retval = check_chunksizes(grp, var, var->chunksizes);
376 for ( ; retval ==
NC_EBADCHUNK; retval = check_chunksizes(grp, var, var->chunksizes))
377 for (d = 0; d < var->ndims; d++)
378 var->chunksizes[d] = var->chunksizes[d]/2 ? var->chunksizes[d]/2 : 1;
384 for (d = 0; d < var->ndims; d++)
388 assert(var->chunksizes[d] > 0);
389 num_chunks = (var->dim[d]->len + var->chunksizes[d] - 1) / var->chunksizes[d];
391 overhang = (num_chunks * var->chunksizes[d]) - var->dim[d]->len;
392 var->chunksizes[d] -= overhang / num_chunks;
410 nc4_vararray_add(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *var)
412 NC_VAR_INFO_T **vp = NULL;
414 if (grp->vars.nalloc == 0) {
415 assert(grp->vars.nelems == 0);
416 vp = (NC_VAR_INFO_T **) malloc(NC_ARRAY_GROWBY *
sizeof(NC_VAR_INFO_T *));
419 grp->vars.value = vp;
420 grp->vars.nalloc = NC_ARRAY_GROWBY;
422 else if(grp->vars.nelems +1 > grp->vars.nalloc) {
423 vp = (NC_VAR_INFO_T **) realloc(grp->vars.value,
424 (grp->vars.nalloc + NC_ARRAY_GROWBY) *
sizeof(NC_VAR_INFO_T *));
427 grp->vars.value = vp;
428 grp->vars.nalloc += NC_ARRAY_GROWBY;
431 assert(var->varid == grp->vars.nelems);
432 grp->vars.value[grp->vars.nelems] = var;
470 NC4_def_var(
int ncid,
const char *name,
nc_type xtype,
471 int ndims,
const int *dimidsp,
int *varidp)
476 NC_HDF5_FILE_INFO_T *h5;
477 NC_TYPE_INFO_T *type_info = NULL;
483 if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
490 if (!(h5->flags & NC_INDEF))
494 if ((retval = NC4_redef(ncid)))
497 assert(!h5->no_write);
500 if ((retval = nc4_check_name(name, norm_name)))
516 if((
unsigned long) ndims > X_INT_MAX)
520 if ((retval = nc4_check_dup_name(grp, norm_name)))
524 if (ndims && !dimidsp)
528 for (d = 0; d < ndims; d++)
529 if ((retval = nc4_find_dim(grp, dimidsp[d], &dim, NULL)))
533 LOG((2,
"%s: name %s type %d ndims %d", __func__, norm_name, xtype, ndims));
537 for (dd = 0; dd < ndims; dd++)
538 LOG((4,
"dimid[%d] %d", dd, dimidsp[dd]));
547 if (!(type_info = calloc(1,
sizeof(NC_TYPE_INFO_T))))
549 type_info->nc_typeid = xtype;
551 if ((retval = nc4_get_hdf_typeid(h5, xtype, &type_info->hdf_typeid,
552 type_info->endianness)))
554 if ((type_info->native_hdf_typeid = H5Tget_native_type(type_info->hdf_typeid,
555 H5T_DIR_DEFAULT)) < 0)
557 if ((retval = nc4_get_typelen_mem(h5, type_info->nc_typeid, 0,
563 type_info->nc_type_class =
NC_CHAR;
568 if ((
class = H5Tget_class(type_info->hdf_typeid)) < 0)
577 type_info->nc_type_class =
NC_INT;
581 type_info->nc_type_class =
NC_FLOAT;
592 if (nc4_find_type(grp->nc4_info, xtype, &type_info))
597 if ((retval = nc4_var_add(&var)))
601 if (!(var->name = malloc((strlen(norm_name) + 1) *
sizeof(
char))))
603 strcpy(var->name, norm_name);
604 var->hash = hash_fast(norm_name, strlen(norm_name));
605 var->varid = grp->nvars++;
607 var->is_new_var = NC_TRUE;
610 if ((retval = nc4_vararray_add(grp, var)))
614 var->type_info = type_info;
615 var->type_info->rc++;
621 if (!(var->dim = calloc(ndims,
sizeof(NC_DIM_INFO_T *))))
623 if (!(var->dimids = calloc(ndims,
sizeof(
int))))
631 if (var->type_info->nc_type_class <
NC_STRING)
632 var->no_fill = h5->fill_mode;
640 var->contiguous = NC_TRUE;
641 for (d = 0; d < ndims; d++)
643 NC_GRP_INFO_T *dim_grp;
646 if ((retval = nc4_find_dim(grp, dimidsp[d], &dim, &dim_grp)))
650 if (d == 0 && dim_grp == grp && dim->hash == var->hash && strcmp(dim->name, norm_name) == 0)
652 var->dimscale = NC_TRUE;
653 dim->coord_var = var;
658 if (dim->hdf_dimscaleid)
661 if ((retval = rec_detach_scales(grp, dimidsp[d], dim->hdf_dimscaleid)) < 0)
665 if (H5Dclose(dim->hdf_dimscaleid) < 0)
667 dim->hdf_dimscaleid = 0;
671 if (H5Gunlink(grp->hdf_grpid, dim->name) < 0)
678 var->contiguous = NC_FALSE;
681 var->dimids[d] = dimidsp[d];
687 LOG((4,
"allocating array of %d size_t to hold chunksizes for var %s",
688 var->ndims, var->name));
690 if (!(var->chunksizes = calloc(var->ndims,
sizeof(
size_t))))
693 if ((retval = nc4_find_default_chunksizes2(grp, var)))
698 if ((retval = nc4_adjust_var_cache(grp, var)))
706 for (dim = grp->dim; dim; dim = dim->l.next)
707 if (dim->hash == var->hash && !strcmp(dim->name, norm_name) &&
708 (!var->ndims || dimidsp[0] != dim->dimid))
712 if (strlen(norm_name) + strlen(NON_COORD_PREPEND) >
NC_MAX_NAME)
714 if (!(var->hdf5_name = malloc((strlen(NON_COORD_PREPEND) +
715 strlen(norm_name) + 1) *
sizeof(
char))))
718 sprintf(var->hdf5_name,
"%s%s", NON_COORD_PREPEND, norm_name);
725 if (!var->dimscale && ndims)
726 if (!(var->dimscale_attached = calloc(ndims,
sizeof(nc_bool_t))))
731 *varidp = var->varid;
732 LOG((4,
"new varid %d", var->varid));
736 if ((retval = nc4_type_free(type_info)))
780 NC4_inq_var_all(
int ncid,
int varid,
char *name,
nc_type *xtypep,
781 int *ndimsp,
int *dimidsp,
int *nattsp,
782 int *shufflep,
int *deflatep,
int *deflate_levelp,
783 int *fletcher32p,
int *contiguousp,
size_t *chunksizesp,
784 int *no_fill,
void *fill_valuep,
int *endiannessp,
785 unsigned int* idp,
size_t* nparamsp,
unsigned int* params
790 NC_HDF5_FILE_INFO_T *h5;
797 LOG((2,
"%s: ncid 0x%x varid %d", __func__, ncid, varid));
800 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
813 for (att = grp->att; att; att = att->l.next)
821 if (varid < 0 || varid >= grp->vars.nelems)
823 var = grp->vars.value[varid];
824 assert(var && var->varid == varid);
828 strcpy(name, var->name);
830 *xtypep = var->type_info->nc_typeid;
832 *ndimsp = var->ndims;
834 for (d = 0; d < var->ndims; d++)
835 dimidsp[d] = var->dimids[d];
838 for (att = var->att; att; att = att->l.next)
844 if (!var->contiguous && chunksizesp)
845 for (d = 0; d < var->ndims; d++)
847 chunksizesp[d] = var->chunksizes[d];
848 LOG((4,
"chunksizesp[%d]=%d", d, chunksizesp[d]));
856 *deflatep = (int)var->deflate;
858 *deflate_levelp = var->deflate_level;
860 *shufflep = (int)var->shuffle;
862 *fletcher32p = (int)var->fletcher32;
865 *idp = var->filterid;
867 *nparamsp = (var->params == NULL ? 0 : var->nparams);
868 if (params && var->params != NULL)
869 memcpy(params,var->params,var->nparams*
sizeof(
unsigned int));
873 *no_fill = (int)var->no_fill;
877 if (!var->no_fill && fill_valuep)
882 if (var->type_info->nc_type_class ==
NC_STRING)
884 assert(*(
char **)var->fill_value);
886 if (!(*(
char **)fill_valuep = strdup(*(
char **)var->fill_value)))
888 free(*(
char **)fill_valuep);
894 assert(var->type_info->size);
895 memcpy(fill_valuep, var->fill_value, var->type_info->size);
900 if (var->type_info->nc_type_class ==
NC_STRING)
902 if (!(*(
char **)fill_valuep = calloc(1,
sizeof(
char *))))
905 if ((retval = nc4_get_default_fill_value(var->type_info, (
char **)fill_valuep)))
907 free(*(
char **)fill_valuep);
913 if ((retval = nc4_get_default_fill_value(var->type_info, fill_valuep)))
921 *endiannessp = var->type_info->endianness;
958 nc_def_var_extra(
int ncid,
int varid,
int *shuffle,
int *deflate,
959 int *deflate_level,
int *fletcher32,
int *contiguous,
960 const size_t *chunksizes,
int *no_fill,
961 const void *fill_value,
int *endianness)
965 NC_HDF5_FILE_INFO_T *h5;
971 assert((deflate && deflate_level && shuffle) ||
972 (!deflate && !deflate_level && !shuffle));
974 LOG((2,
"%s: ncid 0x%x varid %d", __func__, ncid, varid));
977 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
979 assert(nc && grp && h5);
986 if (varid < 0 || varid >= grp->vars.nelems)
988 var = grp->vars.value[varid];
989 assert(var && var->varid == varid);
993 if (deflate || fletcher32 || shuffle)
1003 if (deflate && !deflate_level)
1020 var->contiguous = NC_FALSE;
1021 var->deflate = *deflate;
1023 var->deflate_level = *deflate_level;
1024 LOG((3,
"%s: *deflate_level %d", __func__, *deflate_level));
1030 var->shuffle = *shuffle;
1031 var->contiguous = NC_FALSE;
1037 var->fletcher32 = *fletcher32;
1038 var->contiguous = NC_FALSE;
1044 if (contiguous && *contiguous)
1046 if (var->deflate || var->fletcher32 || var->shuffle)
1049 for (d = 0; d < var->ndims; d++)
1050 if (var->dim[d]->unlimited)
1052 var->contiguous = NC_TRUE;
1058 var->contiguous = NC_FALSE;
1065 if ((retval = check_chunksizes(grp, var, chunksizes)))
1069 for (d = 0; d < var->ndims; d++)
1070 if(!var->dim[d]->unlimited && var->dim[d]->len > 0 && chunksizes[d] > var->dim[d]->len)
1074 for (d = 0; d < var->ndims; d++)
1075 var->chunksizes[d] = chunksizes[d];
1081 if (!var->contiguous && (deflate || contiguous))
1085 if (var->chunksizes && !var->chunksizes[0])
1086 if ((retval = nc4_find_default_chunksizes2(grp, var)))
1090 if ((retval = nc4_adjust_var_cache(grp, var)))
1102 if (var->type_info->nc_typeid ==
NC_STRING)
1106 var->no_fill = NC_TRUE;
1109 var->no_fill = NC_FALSE;
1113 if (fill_value && !var->no_fill)
1116 LOG((4,
"Copying fill value into metadata for variable %s",
1120 retval = NC4_del_att(ncid, varid,
_FillValue);
1131 var->type_info->endianness = *endianness;
1158 NC4_def_var_deflate(
int ncid,
int varid,
int shuffle,
int deflate,
1161 return nc_def_var_extra(ncid, varid, &shuffle, &deflate,
1162 &deflate_level, NULL, NULL, NULL, NULL, NULL, NULL);
1184 NC4_def_var_fletcher32(
int ncid,
int varid,
int fletcher32)
1186 return nc_def_var_extra(ncid, varid, NULL, NULL, NULL, &fletcher32,
1187 NULL, NULL, NULL, NULL, NULL);
1213 NC4_def_var_chunking(
int ncid,
int varid,
int contiguous,
const size_t *chunksizesp)
1215 return nc_def_var_extra(ncid, varid, NULL, NULL, NULL, NULL,
1216 &contiguous, chunksizesp, NULL, NULL, NULL);
1236 nc_inq_var_chunking_ints(
int ncid,
int varid,
int *contiguousp,
int *chunksizesp)
1241 NC_HDF5_FILE_INFO_T *h5;
1247 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
1252 if ((retval = nc4_find_g_var_nc(nc, ncid, varid, &grp, &var)))
1257 if (!(cs = malloc(var->ndims *
sizeof(
size_t))))
1260 retval = NC4_inq_var_all(ncid, varid, NULL, NULL, NULL, NULL, NULL,
1261 NULL, NULL, NULL, NULL, contiguousp, cs, NULL,
1262 NULL, NULL, NULL, NULL, NULL);
1265 if (chunksizesp && var->contiguous ==
NC_CHUNKED)
1266 for (i = 0; i < var->ndims; i++)
1268 chunksizesp[i] = (int)cs[i];
1299 nc_def_var_chunking_ints(
int ncid,
int varid,
int contiguous,
int *chunksizesp)
1304 NC_HDF5_FILE_INFO_T *h5;
1309 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
1314 if ((retval = nc4_find_g_var_nc(nc, ncid, varid, &grp, &var)))
1319 if (!(cs = malloc(var->ndims *
sizeof(
size_t))))
1323 for (i = 0; i < var->ndims; i++)
1324 cs[i] = chunksizesp[i];
1326 retval = nc_def_var_extra(ncid, varid, NULL, NULL, NULL, NULL,
1327 &contiguous, cs, NULL, NULL, NULL);
1358 NC4_def_var_fill(
int ncid,
int varid,
int no_fill,
const void *fill_value)
1360 return nc_def_var_extra(ncid, varid, NULL, NULL, NULL, NULL, NULL,
1361 NULL, &no_fill, fill_value, NULL);
1387 NC4_def_var_endian(
int ncid,
int varid,
int endianness)
1389 return nc_def_var_extra(ncid, varid, NULL, NULL, NULL, NULL, NULL,
1390 NULL, NULL, NULL, &endianness);
1414 const unsigned int* parms)
1419 NC_HDF5_FILE_INFO_T *h5;
1422 LOG((2,
"%s: ncid 0x%x varid %d", __func__, ncid, varid));
1425 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
1428 assert(nc && grp && h5);
1431 if (varid < 0 || varid >= grp->vars.nelems)
1433 var = grp->vars.value[varid];
1435 assert(var->varid == varid);
1447 #ifdef HAVE_H5Z_SZIP
1453 if(id == H5Z_FILTER_SZIP)
1459 unsigned int fcfg = 0;
1460 herr_t herr = H5Zget_filter_info(
id,&fcfg);
1463 if((H5Z_FILTER_CONFIG_ENCODE_ENABLED & fcfg) == 0
1464 || (H5Z_FILTER_CONFIG_DECODE_ENABLED & fcfg) == 0)
1470 var->nparams = nparams;
1473 var->params = (
unsigned int*)calloc(nparams,
sizeof(
unsigned int));
1474 if(var->params == NULL)
return NC_ENOMEM;
1475 memcpy(var->params,parms,
sizeof(
unsigned int)*var->nparams);
1493 NC4_inq_varid(
int ncid,
const char *name,
int *varidp)
1508 LOG((2,
"%s: ncid 0x%x name %s", __func__, ncid, name));
1511 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, NULL)))
1515 if ((retval = nc4_normalize_name(name, norm_name)))
1518 nn_hash = hash_fast(norm_name, strlen(norm_name));
1521 for (i=0; i < grp->vars.nelems; i++)
1523 var = grp->vars.value[i];
1525 if (nn_hash == var->hash && !(strcmp(var->name, norm_name)))
1527 *varidp = var->varid;
1552 NC4_rename_var(
int ncid,
int varid,
const char *name)
1556 NC_HDF5_FILE_INFO_T *h5;
1557 NC_VAR_INFO_T *var, *tmp_var;
1565 LOG((2,
"%s: ncid 0x%x varid %d name %s", __func__, ncid, varid,
1569 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
1571 assert(h5 && grp && h5);
1583 if ((retval = NC_check_name(name)))
1587 nn_hash = hash_fast(name, strlen(name));
1589 for (i=0; i < grp->vars.nelems; i++)
1591 var = grp->vars.value[i];
1593 if (nn_hash == var->hash && !strncmp(var->name, name,
NC_MAX_NAME))
1595 if (var->varid == varid)
1604 if (!(h5->flags & NC_INDEF) && strlen(name) > strlen(var->name) &&
1615 if (var->ndims && var->dim[0]->hdf_dimscaleid)
1617 if ((retval = delete_existing_dimscale_dataset(grp, var->dim[0]->dimid, var->dim[0])))
1621 LOG((3,
"Moving dataset %s to %s", var->name, name));
1622 if (H5Gmove(grp->hdf_grpid, var->name, name) < 0)
1628 if (!(var->name = malloc((strlen(name) + 1) *
sizeof(
char))))
1630 strcpy(var->name, name);
1631 var->hash = nn_hash;
1632 LOG((3,
"var is now %s", var->name));
1635 if (var->dimscale && strcmp(var->name, var->dim[0]->name))
1638 if ((retval = nc4_break_coord_var(grp, var, var->dim[0])))
1648 NC_GRP_INFO_T *dim_grp;
1655 if ((retval = nc4_find_dim(grp, var->dimids[0], &dim, &dim_grp)))
1657 if (!strcmp(dim->name, name) && dim_grp == grp)
1660 if ((retval = nc4_reform_coord_var(grp, var, dim)))
1662 var->became_coord_var = NC_TRUE;
1690 NC4_var_par_access(
int ncid,
int varid,
int par_access)
1692 #ifndef USE_PARALLEL4
1697 NC_HDF5_FILE_INFO_T *h5;
1701 LOG((1,
"%s: ncid 0x%x varid %d par_access %d", __func__, ncid,
1702 varid, par_access));
1708 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
1716 if (varid < 0 || varid >= grp->vars.nelems)
1718 var = grp->vars.value[varid];
1720 assert(var->varid == varid);
1746 NC4_put_vara(
int ncid,
int varid,
const size_t *startp,
1747 const size_t *countp,
const void *op,
int memtype)
1751 if (!(nc = nc4_find_nc_file(ncid, NULL)))
1754 return nc4_put_vara(nc, ncid, varid, startp, countp, memtype, 0, (
void *)op);
1774 const size_t *countp,
void *ip,
int memtype)
1777 NC_HDF5_FILE_INFO_T* h5;
1779 LOG((2,
"%s: ncid 0x%x varid %d memtype %d", __func__, ncid, varid,
1782 if (!(nc = nc4_find_nc_file(ncid, &h5)))
1786 return nc4_get_vara(nc, ncid, varid, startp, countp, memtype,
#define _FillValue
Name of fill value attribute.
#define NC_ENOMEM
Memory allocation (malloc) failure.
#define NC_CHUNKED
In HDF5 files you can set storage for each variable to be either contiguous or chunked, with nc_def_var_chunking().
#define NC_CHAR
ISO/ASCII character.
#define NC_MAX_INT
Max or min values for a type.
#define NC_CONTIGUOUS
In HDF5 files you can set storage for each variable to be either contiguous or chunked, with nc_def_var_chunking().
#define NC_CLASSIC_MODEL
Enforce classic model on netCDF-4.
#define NC_ERANGE
Math result not representable.
#define NC_MAX_VAR_DIMS
max per variable dimensions
int NC4_get_vara(int ncid, int varid, const size_t *startp, const size_t *countp, void *ip, int memtype)
Read an array of values.
#define NC_EHDFERR
Error at HDF5 layer.
#define NC_MPIIO
Turn on MPI I/O.
#define NC_ENOTINDEFINE
Operation not allowed in data mode.
#define NC_DOUBLE
double precision floating point number
#define NC_INDEPENDENT
Use with nc_var_par_access() to set parallel access to independent.
#define NC_EMAXDIMS
NC_MAX_DIMS exceeded.
int nc_type
The nc_type type is just an int.
#define NC_COLLECTIVE
Use with nc_var_par_access() to set parallel access to collective.
#define H5Z_FILTER_SZIP
ID of HDF SZIP filter.
#define NC_MIN_DEFLATE_LEVEL
Minimum deflate level.
#define NC_ENAMEINUSE
String match to name in use.
int NC4_def_var_filter(int ncid, int varid, unsigned int id, size_t nparams, const unsigned int *parms)
#define NC_VLEN
vlen (variable-length) types
#define NC_EFILTER
Filter operation failed.
#define NC_EBADTYPE
Not a netcdf data type.
#define NC_EDIMMETA
Problem with dimension metadata.
#define NC_MAX_DEFLATE_LEVEL
Maximum deflate level.
#define NC_EINVAL
Invalid Argument.
#define NC_INT
signed 4 byte integer
#define NC_ESTRICTNC3
Attempting netcdf-4 operation on strict nc3 netcdf-4 file.
#define NC_MAX_NAME
Maximum for classic library.
#define NC_NAT
Not A Type.
#define NC_EBADTYPID
Bad type ID.
EXTERNL int nc_put_att(int ncid, int varid, const char *name, nc_type xtype, size_t len, const void *op)
Write an attribute.
#define NC_EBADID
Not a netcdf id.
#define NC_ENOPAR
Parallel operation on file opened for non-parallel access.
#define NC_MAX_UINT
Max or min values for a type.
#define NC_ENDIAN_NATIVE
In HDF5 files you can set the endianness of variables with nc_def_var_endian().
#define NC_ENOTVAR
Variable not found.
#define NC_EMAXNAME
NC_MAX_NAME exceeded.
#define NC_EPERM
Write to read only.
#define NC_NOERR
No Error.
#define NC_GLOBAL
Attribute id to put/get a global attribute.
#define NC_ELATEDEF
Attempt to define var properties, like deflate, after enddef.
#define NC_FLOAT
single precision floating point number
#define NC_ENOTATT
Attribute not found.
#define NC_MPIPOSIX
Turn on MPI POSIX I/O.
#define NC_EBADCHUNK
Bad chunksize.