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++)
269 if (chunksizes[d] < 1)
271 dprod *= (double) chunksizes[d];
292 nc4_find_default_chunksizes2(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *var)
296 float num_values = 1, num_unlim = 0;
298 size_t suggested_size;
300 double total_chunk_size;
303 if (var->type_info->nc_type_class ==
NC_STRING)
304 type_size =
sizeof(
char *);
306 type_size = var->type_info->size;
311 total_chunk_size = (double) type_size;
316 for (d = 0; d < var->ndims; d++)
319 if (! var->dim[d]->unlimited)
320 num_values *= (float)var->dim[d]->len;
323 var->chunksizes[d] = 1;
329 if (var->ndims == 1 && num_unlim == 1) {
330 if (DEFAULT_CHUNK_SIZE / type_size <= 0)
332 else if (DEFAULT_CHUNK_SIZE / type_size > DEFAULT_1D_UNLIM_SIZE)
333 suggested_size = DEFAULT_1D_UNLIM_SIZE;
335 suggested_size = DEFAULT_CHUNK_SIZE / type_size;
336 var->chunksizes[0] = suggested_size / type_size;
337 LOG((4,
"%s: name %s dim %d DEFAULT_CHUNK_SIZE %d num_values %f type_size %d " 338 "chunksize %ld", __func__, var->name, d, DEFAULT_CHUNK_SIZE, num_values, type_size, var->chunksizes[0]));
340 if (var->ndims > 1 && var->ndims == num_unlim) {
341 suggested_size = pow((
double)DEFAULT_CHUNK_SIZE/type_size, 1.0/(
double)(var->ndims));
342 for (d = 0; d < var->ndims; d++)
344 var->chunksizes[d] = suggested_size ? suggested_size : 1;
345 LOG((4,
"%s: name %s dim %d DEFAULT_CHUNK_SIZE %d num_values %f type_size %d " 346 "chunksize %ld", __func__, var->name, d, DEFAULT_CHUNK_SIZE, num_values, type_size, var->chunksizes[d]));
352 for (d = 0; d < var->ndims; d++)
353 if (!var->chunksizes[d])
355 suggested_size = (pow((
double)DEFAULT_CHUNK_SIZE/(num_values * type_size),
356 1.0/(
double)(var->ndims - num_unlim)) * var->dim[d]->len - .5);
357 if (suggested_size > var->dim[d]->len)
358 suggested_size = var->dim[d]->len;
359 var->chunksizes[d] = suggested_size ? suggested_size : 1;
360 LOG((4,
"%s: name %s dim %d DEFAULT_CHUNK_SIZE %d num_values %f type_size %d " 361 "chunksize %ld", __func__, var->name, d, DEFAULT_CHUNK_SIZE, num_values, type_size, var->chunksizes[d]));
366 for (d = 0; d < var->ndims; d++)
367 total_chunk_size *= (
double) var->chunksizes[d];
368 LOG((4,
"total_chunk_size %f", total_chunk_size));
372 retval = check_chunksizes(grp, var, var->chunksizes);
380 for ( ; retval ==
NC_EBADCHUNK; retval = check_chunksizes(grp, var, var->chunksizes))
381 for (d = 0; d < var->ndims; d++)
382 var->chunksizes[d] = var->chunksizes[d]/2 ? var->chunksizes[d]/2 : 1;
388 for (d = 0; d < var->ndims; d++)
392 assert(var->chunksizes[d] > 0);
393 num_chunks = (var->dim[d]->len + var->chunksizes[d] - 1) / var->chunksizes[d];
395 overhang = (num_chunks * var->chunksizes[d]) - var->dim[d]->len;
396 var->chunksizes[d] -= overhang / num_chunks;
413 int nc4_vararray_add(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *var)
415 NC_VAR_INFO_T **vp = NULL;
417 if (grp->vars.nalloc == 0) {
418 assert(grp->vars.nelems == 0);
419 vp = (NC_VAR_INFO_T **) malloc(NC_ARRAY_GROWBY *
sizeof(NC_VAR_INFO_T *));
422 grp->vars.value = vp;
423 grp->vars.nalloc = NC_ARRAY_GROWBY;
425 else if(grp->vars.nelems +1 > grp->vars.nalloc) {
426 vp = (NC_VAR_INFO_T **) realloc(grp->vars.value,
427 (grp->vars.nalloc + NC_ARRAY_GROWBY) *
sizeof(NC_VAR_INFO_T *));
430 grp->vars.value = vp;
431 grp->vars.nalloc += NC_ARRAY_GROWBY;
435 assert(var->varid == grp->vars.nelems);
436 grp->vars.value[grp->vars.nelems] = var;
474 NC4_def_var(
int ncid,
const char *name,
nc_type xtype,
475 int ndims,
const int *dimidsp,
int *varidp)
480 NC_HDF5_FILE_INFO_T *h5;
481 NC_TYPE_INFO_T *type_info = NULL;
487 if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
494 if (!(h5->flags & NC_INDEF))
498 if ((retval = NC4_redef(ncid)))
501 assert(!h5->no_write);
504 if ((retval = nc4_check_name(name, norm_name)))
520 if((
unsigned long) ndims > X_INT_MAX)
524 if ((retval = nc4_check_dup_name(grp, norm_name)))
528 if (ndims && !dimidsp)
532 for (d = 0; d < ndims; d++)
533 if ((retval = nc4_find_dim(grp, dimidsp[d], &dim, NULL)))
537 LOG((2,
"%s: name %s type %d ndims %d", __func__, norm_name, xtype, ndims));
541 for (dd = 0; dd < ndims; dd++)
542 LOG((4,
"dimid[%d] %d", dd, dimidsp[dd]));
551 if (!(type_info = calloc(1,
sizeof(NC_TYPE_INFO_T))))
553 type_info->nc_typeid = xtype;
555 if ((retval = nc4_get_hdf_typeid(h5, xtype, &type_info->hdf_typeid,
556 type_info->endianness)))
558 if ((type_info->native_hdf_typeid = H5Tget_native_type(type_info->hdf_typeid,
559 H5T_DIR_DEFAULT)) < 0)
561 if ((retval = nc4_get_typelen_mem(h5, type_info->nc_typeid, 0,
567 type_info->nc_type_class =
NC_CHAR;
572 if ((
class = H5Tget_class(type_info->hdf_typeid)) < 0)
581 type_info->nc_type_class =
NC_INT;
585 type_info->nc_type_class =
NC_FLOAT;
596 if (nc4_find_type(grp->nc4_info, xtype, &type_info))
601 if ((retval = nc4_var_add(&var)))
605 if (!(var->name = malloc((strlen(norm_name) + 1) *
sizeof(
char))))
607 strcpy(var->name, norm_name);
608 var->hash = hash_fast(norm_name, strlen(norm_name));
609 var->varid = grp->nvars++;
611 var->is_new_var = NC_TRUE;
614 if ((retval = nc4_vararray_add(grp, var)))
618 var->type_info = type_info;
619 var->type_info->rc++;
625 if (!(var->dim = calloc(ndims,
sizeof(NC_DIM_INFO_T *))))
627 if (!(var->dimids = calloc(ndims,
sizeof(
int))))
635 if (var->type_info->nc_type_class <
NC_STRING)
636 var->no_fill = h5->fill_mode;
644 var->contiguous = NC_TRUE;
645 for (d = 0; d < ndims; d++)
647 NC_GRP_INFO_T *dim_grp;
650 if ((retval = nc4_find_dim(grp, dimidsp[d], &dim, &dim_grp)))
654 if (d == 0 && dim_grp == grp && dim->hash == var->hash && strcmp(dim->name, norm_name) == 0)
656 var->dimscale = NC_TRUE;
657 dim->coord_var = var;
662 if (dim->hdf_dimscaleid)
665 if ((retval = rec_detach_scales(grp, dimidsp[d], dim->hdf_dimscaleid)) < 0)
669 if (H5Dclose(dim->hdf_dimscaleid) < 0)
671 dim->hdf_dimscaleid = 0;
675 if (H5Gunlink(grp->hdf_grpid, dim->name) < 0)
682 var->contiguous = NC_FALSE;
685 var->dimids[d] = dimidsp[d];
691 LOG((4,
"allocating array of %d size_t to hold chunksizes for var %s",
692 var->ndims, var->name));
694 if (!(var->chunksizes = calloc(var->ndims,
sizeof(
size_t))))
697 if ((retval = nc4_find_default_chunksizes2(grp, var)))
702 if ((retval = nc4_adjust_var_cache(grp, var)))
710 for (dim = grp->dim; dim; dim = dim->l.next)
711 if (dim->hash == var->hash && !strcmp(dim->name, norm_name) &&
712 (!var->ndims || dimidsp[0] != dim->dimid))
716 if (strlen(norm_name) + strlen(NON_COORD_PREPEND) >
NC_MAX_NAME)
718 if (!(var->hdf5_name = malloc((strlen(NON_COORD_PREPEND) +
719 strlen(norm_name) + 1) *
sizeof(
char))))
722 sprintf(var->hdf5_name,
"%s%s", NON_COORD_PREPEND, norm_name);
729 if (!var->dimscale && ndims)
730 if (ndims && !(var->dimscale_attached = calloc(ndims,
sizeof(nc_bool_t))))
735 *varidp = var->varid;
736 LOG((4,
"new varid %d", var->varid));
740 if ((retval = nc4_type_free(type_info)))
784 NC4_inq_var_all(
int ncid,
int varid,
char *name,
nc_type *xtypep,
785 int *ndimsp,
int *dimidsp,
int *nattsp,
786 int *shufflep,
int *deflatep,
int *deflate_levelp,
787 int *fletcher32p,
int *contiguousp,
size_t *chunksizesp,
788 int *no_fill,
void *fill_valuep,
int *endiannessp,
789 unsigned int* idp,
size_t* nparamsp,
unsigned int* params
794 NC_HDF5_FILE_INFO_T *h5;
801 LOG((2,
"%s: ncid 0x%x varid %d", __func__, ncid, varid));
804 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
817 for (att = grp->att; att; att = att->l.next)
825 if (varid < 0 || varid >= grp->vars.nelems)
827 var = grp->vars.value[varid];
828 assert(var && var->varid == varid);
832 strcpy(name, var->name);
834 *xtypep = var->type_info->nc_typeid;
836 *ndimsp = var->ndims;
838 for (d = 0; d < var->ndims; d++)
839 dimidsp[d] = var->dimids[d];
842 for (att = var->att; att; att = att->l.next)
848 if (!var->contiguous && chunksizesp)
849 for (d = 0; d < var->ndims; d++)
851 chunksizesp[d] = var->chunksizes[d];
852 LOG((4,
"chunksizesp[%d]=%d", d, chunksizesp[d]));
860 *deflatep = (int)var->deflate;
862 *deflate_levelp = var->deflate_level;
864 *shufflep = (int)var->shuffle;
866 *fletcher32p = (int)var->fletcher32;
869 *idp = var->filterid;
871 *nparamsp = (var->params == NULL ? 0 : var->nparams);
872 if (params && var->params != NULL)
873 memcpy(params,var->params,var->nparams*
sizeof(
unsigned int));
877 *no_fill = (int)var->no_fill;
881 if (!var->no_fill && fill_valuep)
886 if (var->type_info->nc_type_class ==
NC_STRING)
888 if (*(
char **)var->fill_value) {
890 if (!(fill_valuep = calloc(1,
sizeof(
char *))))
893 if (!(*(
char **)fill_valuep = strdup(*(
char **)var->fill_value)))
901 assert(var->type_info->size);
902 memcpy(fill_valuep, var->fill_value, var->type_info->size);
907 if (var->type_info->nc_type_class ==
NC_STRING)
909 if (!(fill_valuep = calloc(1,
sizeof(
char *))))
912 if ((retval = nc4_get_default_fill_value(var->type_info, (
char **)fill_valuep)))
922 if ((retval = nc4_get_default_fill_value(var->type_info, fill_valuep)))
930 *endiannessp = var->type_info->endianness;
967 nc_def_var_extra(
int ncid,
int varid,
int *shuffle,
int *deflate,
968 int *deflate_level,
int *fletcher32,
int *contiguous,
969 const size_t *chunksizes,
int *no_fill,
970 const void *fill_value,
int *endianness)
974 NC_HDF5_FILE_INFO_T *h5;
980 assert((deflate && deflate_level && shuffle) ||
981 (!deflate && !deflate_level && !shuffle));
983 LOG((2,
"%s: ncid 0x%x varid %d", __func__, ncid, varid));
986 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
988 assert(nc && grp && h5);
995 if (varid < 0 || varid >= grp->vars.nelems)
997 var = grp->vars.value[varid];
998 assert(var && var->varid == varid);
1002 if (deflate || fletcher32 || shuffle)
1012 if (deflate && !deflate_level)
1016 if (deflate && deflate_level)
1029 var->contiguous = NC_FALSE;
1030 var->deflate = *deflate;
1032 var->deflate_level = *deflate_level;
1033 LOG((3,
"%s: *deflate_level %d", __func__, *deflate_level));
1039 var->shuffle = *shuffle;
1040 var->contiguous = NC_FALSE;
1046 var->fletcher32 = *fletcher32;
1047 var->contiguous = NC_FALSE;
1053 if (contiguous && *contiguous)
1055 if (var->deflate || var->fletcher32 || var->shuffle)
1058 for (d = 0; d < var->ndims; d++)
1059 if (var->dim[d]->unlimited)
1061 var->contiguous = NC_TRUE;
1067 var->contiguous = NC_FALSE;
1074 if ((retval = check_chunksizes(grp, var, chunksizes)))
1078 for (d = 0; d < var->ndims; d++)
1079 if(!var->dim[d]->unlimited && var->dim[d]->len > 0 && chunksizes[d] > var->dim[d]->len)
1083 for (d = 0; d < var->ndims; d++)
1084 var->chunksizes[d] = chunksizes[d];
1090 if (!var->contiguous && (deflate || contiguous))
1094 if (var->chunksizes && !var->chunksizes[0])
1095 if ((retval = nc4_find_default_chunksizes2(grp, var)))
1099 if ((retval = nc4_adjust_var_cache(grp, var)))
1107 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)))
1319 if ((retval = nc4_find_g_var_nc(nc, ncid, varid, &grp, &var)))
1324 if (!(cs = malloc(var->ndims *
sizeof(
size_t))))
1328 for (i = 0; i < var->ndims; i++)
1329 cs[i] = chunksizesp[i];
1331 retval = nc_def_var_extra(ncid, varid, NULL, NULL, NULL, NULL,
1332 &contiguous, cs, NULL, NULL, NULL);
1363 NC4_def_var_fill(
int ncid,
int varid,
int no_fill,
const void *fill_value)
1365 return nc_def_var_extra(ncid, varid, NULL, NULL, NULL, NULL, NULL,
1366 NULL, &no_fill, fill_value, NULL);
1392 NC4_def_var_endian(
int ncid,
int varid,
int endianness)
1394 return nc_def_var_extra(ncid, varid, NULL, NULL, NULL, NULL, NULL,
1395 NULL, NULL, NULL, &endianness);
1419 const unsigned int* parms)
1424 NC_HDF5_FILE_INFO_T *h5;
1427 LOG((2,
"%s: ncid 0x%x varid %d", __func__, ncid, varid));
1430 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
1433 assert(nc && grp && h5);
1436 if (varid < 0 || varid >= grp->vars.nelems)
1438 var = grp->vars.value[varid];
1440 assert(var->varid == varid);
1452 #ifdef HAVE_H5Z_SZIP 1458 if(id == H5Z_FILTER_SZIP) 1464 unsigned int fcfg = 0;
1465 herr_t herr = H5Zget_filter_info(
id,&fcfg);
1468 if((H5Z_FILTER_CONFIG_ENCODE_ENABLED & fcfg) == 0
1469 || (H5Z_FILTER_CONFIG_DECODE_ENABLED & fcfg) == 0)
1475 var->nparams = nparams;
1478 var->params = (
unsigned int*)calloc(nparams,
sizeof(
unsigned int));
1479 if(var->params == NULL)
return NC_ENOMEM;
1480 memcpy(var->params,parms,
sizeof(
unsigned int)*var->nparams);
1498 NC4_inq_varid(
int ncid,
const char *name,
int *varidp)
1513 LOG((2,
"%s: ncid 0x%x name %s", __func__, ncid, name));
1516 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, NULL)))
1520 if ((retval = nc4_normalize_name(name, norm_name)))
1523 nn_hash = hash_fast(norm_name, strlen(norm_name));
1526 for (i=0; i < grp->vars.nelems; i++)
1528 var = grp->vars.value[i];
1530 if (nn_hash == var->hash && !(strcmp(var->name, norm_name)))
1532 *varidp = var->varid;
1557 NC4_rename_var(
int ncid,
int varid,
const char *name)
1561 NC_HDF5_FILE_INFO_T *h5;
1562 NC_VAR_INFO_T *var, *tmp_var;
1570 LOG((2,
"%s: ncid 0x%x varid %d name %s", __func__, ncid, varid,
1574 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
1576 assert(h5 && grp && h5);
1588 if ((retval = NC_check_name(name)))
1592 nn_hash = hash_fast(name, strlen(name));
1594 for (i=0; i < grp->vars.nelems; i++)
1596 var = grp->vars.value[i];
1598 if (nn_hash == var->hash && !strncmp(var->name, name,
NC_MAX_NAME))
1600 if (var->varid == varid)
1609 if (!(h5->flags & NC_INDEF) && strlen(name) > strlen(var->name) &&
1620 if (var->ndims && var->dim[0]->hdf_dimscaleid)
1622 if ((retval = delete_existing_dimscale_dataset(grp, var->dim[0]->dimid, var->dim[0])))
1626 LOG((3,
"Moving dataset %s to %s", var->name, name));
1627 if (H5Gmove(grp->hdf_grpid, var->name, name) < 0)
1633 if (!(var->name = malloc((strlen(name) + 1) *
sizeof(
char))))
1635 strcpy(var->name, name);
1636 var->hash = nn_hash;
1637 LOG((3,
"var is now %s", var->name));
1640 if (var->dimscale && strcmp(var->name, var->dim[0]->name))
1643 if ((retval = nc4_break_coord_var(grp, var, var->dim[0])))
1653 NC_GRP_INFO_T *dim_grp;
1660 if ((retval = nc4_find_dim(grp, var->dimids[0], &dim, &dim_grp)))
1662 if (strcmp(dim->name, name) == 0 && dim_grp == grp)
1665 if ((retval = nc4_reform_coord_var(grp, var, dim)))
1694 NC4_var_par_access(
int ncid,
int varid,
int par_access)
1696 #ifndef USE_PARALLEL4 1701 NC_HDF5_FILE_INFO_T *h5;
1705 LOG((1,
"%s: ncid 0x%x varid %d par_access %d", __func__, ncid,
1706 varid, par_access));
1712 if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))
1720 if (varid < 0 || varid >= grp->vars.nelems)
1722 var = grp->vars.value[varid];
1724 assert(var->varid == varid);
1749 nc4_get_hdf4_vara(NC *nc,
int ncid,
int varid,
const size_t *startp,
1750 const size_t *countp,
nc_type mem_nc_type,
int is_long,
void *data)
1753 NC_HDF5_FILE_INFO_T *h5;
1760 if ((retval = nc4_find_g_var_nc(nc, ncid, varid, &grp, &var)))
1763 assert(grp && h5 && var && var->name);
1765 for (d = 0; d < var->ndims; d++)
1767 start32[d] = startp[d];
1768 edge32[d] = countp[d];
1771 if (SDreaddata(var->sdsid, start32, NULL, edge32, data))
1794 NC4_put_vara(
int ncid,
int varid,
const size_t *startp,
1795 const size_t *countp,
const void *op,
int memtype)
1799 if (!(nc = nc4_find_nc_file(ncid, NULL)))
1802 return nc4_put_vara(nc, ncid, varid, startp, countp, memtype, 0, (
void *)op);
1822 const size_t *countp,
void *ip,
int memtype)
1825 NC_HDF5_FILE_INFO_T* h5;
1827 LOG((2,
"%s: ncid 0x%x varid %d memtype %d", __func__, ncid, varid,
1830 if (!(nc = nc4_find_nc_file(ncid, &h5)))
1836 return nc4_get_hdf4_vara(nc, ncid, varid, startp, countp, memtype,
1841 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.