int /* [enm] Return status */
nco_get_dmn_info
(int nc_id,
int var_id,
char dmn_nm[],
int *dimid,
long *dmn_sz)
{
/* Purpose: Get dimension information associated with specified variable
In our case, this is lat or lon---they are presumed to be identical */
int rcd=NC_NOERR;
nc_type var_typ; /* variable type */
int var_dimid[NC_MAX_VAR_DIMS]; /* dimension ids */
int var_att_nbr; /* number of attributes */
int var_dmn_nbr; /* number of dims */
/* Get dimension information */
rcd=nco_inq_var(nc_id,var_id,0,&var_typ,&var_dmn_nbr,var_dimid,&var_att_nbr);
if(rcd == NC_NOERR){
*dimid=var_dimid[0];
rcd=nco_inq_dimlen(nc_id,var_dimid[0],dmn_sz);
rcd=nco_inq_dimname(nc_id,var_dimid[0],dmn_nm);
} /* endif */
if(rcd != NC_NOERR) nco_err_exit(rcd,"nco_get_dmn_info() unable to get dimension information");
return rcd;
} /* end nco_get_dmn_info() */
nm_id_sct * /* O [sct] List of dimensions associated with input variable list */
nco_dmn_lst_ass_var /* [fnc] Create list of all dimensions associated with input variable list */
(const int nc_id, /* I [id] netCDF input-file ID */
const nm_id_sct * const var, /* I [sct] Variable list */
const int nbr_var, /* I [nbr] Number of variables in list */
int * const nbr_dmn) /* O [nbr] Number of dimensions associated with input variable list */
{
/* Purpose: Create list of all dimensions associated with input variable list */
nco_bool dmn_has_been_placed_on_list;
char dmn_nm[NC_MAX_NAME];
int dmn_id[NC_MAX_DIMS];
int idx_dmn_in;
int idx_var;
int idx_var_dmn;
int idx_dmn_lst;
int nbr_dmn_in;
int nbr_var_dmn;
nm_id_sct *dmn;
*nbr_dmn=0;
/* Get number of dimensions */
(void)nco_inq(nc_id,&nbr_dmn_in,(int *)NULL,(int *)NULL,(int *)NULL);
/* Number of input dimensions is upper bound on number of output dimensions */
dmn=(nm_id_sct *)nco_malloc(nbr_dmn_in*sizeof(nm_id_sct));
/* ...For each dimension in file... */
for(idx_dmn_in=0;idx_dmn_in<nbr_dmn_in;idx_dmn_in++){
/* ...begin search for dimension in dimension list by... */
dmn_has_been_placed_on_list=False;
/* ...looking through the set of output variables... */
for(idx_var=0;idx_var<nbr_var;idx_var++){
/* ...and searching each dimension of each output variable... */
(void)nco_inq_var(nc_id,var[idx_var].id,(char *)NULL,(nc_type *)NULL,&nbr_var_dmn,dmn_id,(int *)NULL);
for(idx_var_dmn=0;idx_var_dmn<nbr_var_dmn;idx_var_dmn++){
/* ...until output variable is found which contains input dimension... */
if(idx_dmn_in == dmn_id[idx_var_dmn]){
/* ...then search each member of output dimension list... */
for(idx_dmn_lst=0;idx_dmn_lst<*nbr_dmn;idx_dmn_lst++){
/* ...until input dimension is found... */
if(idx_dmn_in == dmn[idx_dmn_lst].id) break; /* ...then search no further... */
} /* end loop over idx_dmn_lst */
/* ...and if dimension was not found on output dimension list... */
if(idx_dmn_lst == *nbr_dmn){
/* ...then add dimension to output dimension list... */
(void)nco_inq_dimname(nc_id,idx_dmn_in,dmn_nm);
dmn[*nbr_dmn].id=idx_dmn_in;
dmn[*nbr_dmn].nm=(char *)strdup(dmn_nm);
(*nbr_dmn)++;
} /* end if dimension was not found in current output dimension list */
/* ...call off the dogs for this input dimension... */
dmn_has_been_placed_on_list=True;
} /* end if input dimension belongs to this output variable */
if(dmn_has_been_placed_on_list) break; /* break out of idx_var_dmn to idx_var */
} /* end loop over idx_var_dmn */
if(dmn_has_been_placed_on_list) break; /* break out of idx_var to idx_dmn_in */
} /* end loop over idx_var */
} /* end loop over idx_dmn_in */
/* We now have final list of dimensions to extract. Phew. */
/* Free unused space in output dimension list */
dmn=(nm_id_sct *)nco_realloc((void *)dmn,*nbr_dmn*sizeof(nm_id_sct));
return dmn;
} /* end nco_dmn_lst_ass_var() */
int /* O [flg] Dimension exists in scope of group (if rcd != NC_NOERR) */
nco_inq_dmn_grp_id /* [fnc] Return location and ID of named dimension in specified group */
(const int nc_id, /* I [id] netCDF group ID */
const char * const dmn_nm, /* I [sng] Dimension name */
int * const dmn_id, /* O [id] Dimension ID in specified group */
int * const grp_id_dmn) /* O [id] Group ID where dimension visible to specified group is defined */
{
/* Purpose: Return location and ID of named dimension in specified group
ncks -O -D 1 -v two_dmn_rec_var ~/nco/data/in_grp.nc ~/foo.nc */
const char fnc_nm[]="nco_inq_dmn_grp_id()"; /* [sng] Function name */
const int flg_prn=1; /* [flg] Retrieve all dimensions in all parent groups */
int dmn_ids[NC_MAX_DIMS]; /* [nbr] Dimensions IDs array */
int dmn_idx; /* [idx] Dimension index */
int dmn_nbr; /* [nbr] Number of dimensions for group */
int rcd; /* [rcd] Return code */
nco_bool grp_dfn_fnd=False; /* [flg] Group of definition has been found */
/* Initialize search to start with specified group */
*grp_id_dmn=nc_id;
rcd=nco_inq_dimid_flg(*grp_id_dmn,dmn_nm,dmn_id);
if(nco_dbg_lvl_get() >= nco_dbg_std){
char *grp_nm_fll; /* [sng] Group name */
char dmn_nm_lcl[NC_MAX_NAME]; /* [sng] Dimension name */
size_t grp_nm_fll_lng; /* [nbr] Length of group name */
(void)nco_inq_grpname_full(*grp_id_dmn,&grp_nm_fll_lng,(char *)NULL);
grp_nm_fll=(char *)nco_malloc((grp_nm_fll_lng+1L)*sizeof(char));
(void)nco_inq_grpname_full(*grp_id_dmn,(size_t *)NULL,grp_nm_fll);
(void)nco_inq_dimids(*grp_id_dmn,&dmn_nbr,dmn_ids,flg_prn);
(void)fprintf(stdout,"%s: %s nco_inq_dimids() reports following dimensions/IDs are visible to group %s:\n",nco_prg_nm_get(),fnc_nm,grp_nm_fll);
for(dmn_idx=0;dmn_idx<dmn_nbr;dmn_idx++){
(void)nco_inq_dimname(*grp_id_dmn,dmn_ids[dmn_idx],dmn_nm_lcl);
(void)fprintf(stdout,"%s/%d,%s",dmn_nm_lcl,dmn_ids[dmn_idx],(dmn_idx == dmn_nbr-1) ? "\n" : ", ");
} /* end loop over dmn */
if(rcd == NC_NOERR) (void)fprintf(stdout,"%s: %s nco_inq_dimid() reports group %s sees dimension %s with ID = %d:\n",nco_prg_nm_get(),fnc_nm,grp_nm_fll,dmn_nm,*dmn_id); else (void)fprintf(stdout,"%s: %s reports group %s does not see dimension %s\n",nco_prg_nm_get(),fnc_nm,grp_nm_fll,dmn_nm);
if(grp_nm_fll) grp_nm_fll=(char *)nco_free(grp_nm_fll);
} /* endif dbg */
/* If dimension is visible to output group, find exactly where it is defined
Search ancestors until group of definition is found ... */
while(!grp_dfn_fnd && (rcd == NC_NOERR)){
/* ... obtain all dimension IDs in current group (_NOT_ in ancestor groups) ... */
(void)nco_inq_dimids(*grp_id_dmn,&dmn_nbr,dmn_ids,0);
/* ... and check each against ID of target dimension */
for(dmn_idx=0;dmn_idx<dmn_nbr;dmn_idx++)
if(dmn_ids[dmn_idx] == *dmn_id) break;
if(nco_dbg_lvl_get() >= nco_dbg_std){
char *grp_nm_fll; /* [sng] Group name */
size_t grp_nm_fll_lng; /* [nbr] Length of group name */
(void)nco_inq_grpname_full(*grp_id_dmn,&grp_nm_fll_lng,(char *)NULL);
grp_nm_fll=(char *)nco_malloc((grp_nm_fll_lng+1L)*sizeof(char));
(void)nco_inq_grpname_full(*grp_id_dmn,(size_t *)NULL,grp_nm_fll);
(void)fprintf(stdout,"%s: %s reports dimension %s was%s defined in group %s\n",nco_prg_nm_get(),fnc_nm,dmn_nm,(dmn_idx < dmn_nbr) ? "" : " not",grp_nm_fll);
if(grp_nm_fll) grp_nm_fll=(char *)nco_free(grp_nm_fll);
} /* endif dbg */
if(dmn_idx < dmn_nbr){
grp_dfn_fnd=True;
}else{
/* Overwrite current group ID with parent group ID */
rcd=nco_inq_grp_parent_flg(*grp_id_dmn,grp_id_dmn);
} /* end else */
} /* end while */
return rcd;
} /* end nco_inq_dmn_grp_id */
void
nco_cnk_sz_set /* [fnc] Set chunksize parameters */
(const int nc_id, /* I [id] netCDF file ID */
CST_X_PTR_CST_PTR_CST_Y(lmt_all_sct,lmt_all_lst), /* I [sct] Hyperslab limits */
const int lmt_all_lst_nbr, /* I [nbr] Number of hyperslab limits */
int * const cnk_map_ptr, /* I/O [enm] Chunking map */
int * const cnk_plc_ptr, /* I/O [enm] Chunking policy */
const size_t cnk_sz_scl, /* I [nbr] Chunk size scalar */
CST_X_PTR_CST_PTR_CST_Y(cnk_sct,cnk), /* I [sct] Chunking information */
const int cnk_nbr) /* I [nbr] Number of dimensions with user-specified chunking */
{
/* Purpose: Use chunking map and policy to determine chunksize list */
const char fnc_nm[]="nco_cnk_sz_set()"; /* [sng] Function name */
char dmn_nm[NC_MAX_NAME];
char var_nm[NC_MAX_NAME];
int *dmn_id;
int cnk_idx;
int dmn_idx;
int cnk_map; /* [enm] Chunking map */
int cnk_plc; /* [enm] Chunking policy */
int chk_typ; /* [enm] Checksum type */
int deflate; /* [enm] Deflate filter is on */
int dmn_nbr; /* [nbr] Number of dimensions in variable */
int fl_fmt; /* [enm] Input file format */
int lmt_idx;
int lmt_idx_rec=int_CEWI;
int nbr_dmn_fl; /* [nbr] Number of dimensions in file */
int rcd_dmn_id;
int srg_typ; /* [enm] Storage type */
int var_idx;
int var_nbr;
long dmn_sz;
nco_bool flg_cnk=False; /* [flg] Chunking requested */
nco_bool is_rec_var; /* [flg] Record variable */
nco_bool is_chk_var; /* [flg] Checksummed variable */
nco_bool is_cmp_var; /* [flg] Compressed variable */
nco_bool is_chunked; /* [flg] Chunked variable */
nco_bool must_be_chunked; /* [flg] Variable must be chunked */
nc_type var_typ_dsk;
size_t *cnk_sz; /* [nbr] Chunksize list */
size_t cnk_sz_dfl; /* [nbr] Chunksize default */
/* Did user explicitly request chunking? */
if(cnk_nbr > 0 || cnk_sz_scl > 0UL || *cnk_map_ptr != nco_cnk_map_nil || *cnk_plc_ptr != nco_cnk_plc_nil) flg_cnk=True;
if(!flg_cnk) return;
/* Set actual chunk policy and map to defaults as necessary
This rather arcane procedure saves a few lines of code in calling program
(because defaults not set there) while maintaining correctness of arguments */
if(*cnk_map_ptr == nco_cnk_map_nil) *cnk_map_ptr=nco_cnk_map_get((char *)NULL);
if(*cnk_plc_ptr == nco_cnk_plc_nil) *cnk_plc_ptr=nco_cnk_plc_get((char *)NULL);
cnk_map=*cnk_map_ptr;
cnk_plc=*cnk_plc_ptr;
/* Bail on unsupported options */
if(cnk_plc == nco_cnk_plc_xpl){
(void)fprintf(stderr,"%s: ERROR cnk_plc = %s not yet supported\n",prg_nm_get(),nco_cnk_plc_sng_get(cnk_plc));
nco_exit(EXIT_FAILURE);
} /* endif */
/* Does output file support chunking? */
(void)nco_inq_format(nc_id,&fl_fmt);
if(fl_fmt != NC_FORMAT_NETCDF4 && fl_fmt != NC_FORMAT_NETCDF4_CLASSIC){
(void)fprintf(stderr,"%s: WARNING Output file format is %s so chunking request will be ignored\n",prg_nm_get(),nco_fmt_sng(fl_fmt));
return;
} /* endif dbg */
/* Vet input */
if(cnk_map == nco_cnk_map_scl && cnk_sz_scl <= 0){
(void)fprintf(stderr,"%s: ERROR cnk_sz_scl = %lu must be greater than 0\n",prg_nm_get(),(unsigned long)cnk_sz_scl);
nco_exit(EXIT_FAILURE);
} /* endif cnk_sz_scl */
if(dbg_lvl_get() >= nco_dbg_fl) (void)fprintf(stderr,"%s: INFO Requested chunking or unchunking\n",prg_nm_get());
if(dbg_lvl_get() >= nco_dbg_scl){
(void)fprintf(stderr,"cnk_plc: %s\n",nco_cnk_plc_sng_get(cnk_plc));
(void)fprintf(stderr,"cnk_map: %s\n",nco_cnk_map_sng_get(cnk_map));
(void)fprintf(stderr,"cnk_sz_scl: %lu\n",(unsigned long)cnk_sz_scl);
if(cnk_nbr > 0){
(void)fprintf(stderr,"idx dmn_nm\tcnk_sz:\n");
for(cnk_idx=0;cnk_idx<cnk_nbr;cnk_idx++) (void)fprintf(stderr,"%2d %s\t%lu\n",cnk_idx,cnk[cnk_idx]->nm,(unsigned long)cnk[cnk_idx]->sz);
} /* cnk_nbr == 0 */
} /* endif dbg */
/* Get record dimension ID */
(void)nco_inq(nc_id,&nbr_dmn_fl,&var_nbr,(int *)NULL,&rcd_dmn_id);
/* Find record dimension, if any, in limit structure list first
This information may be needed below */
if(rcd_dmn_id != NCO_REC_DMN_UNDEFINED){
(void)nco_inq_dimname(nc_id,rcd_dmn_id,dmn_nm);
for(lmt_idx=0;lmt_idx<lmt_all_lst_nbr;lmt_idx++){
if(!strcmp(dmn_nm,lmt_all_lst[lmt_idx]->dmn_nm)){
lmt_idx_rec=lmt_idx;
break;
} /* end if */
} /* end loop over limit */
} /* NCO_REC_DMN_UNDEFINED */
/* NB: Assumes variable IDs range from [0..var_nbr-1] */
for(var_idx=0;var_idx<var_nbr;var_idx++){
/* Initialize storage type for this variable */
srg_typ=NC_CONTIGUOUS; /* [enm] Storage type */
cnk_sz=(size_t *)NULL; /* [nbr] Chunksize list */
is_rec_var=False; /* [flg] Record variable */
is_chk_var=False; /* [flg] Checksummed variable */
is_cmp_var=False; /* [flg] Compressed variable */
is_chunked=False; /* [flg] Chunked variable */
/* Get type and number of dimensions for variable */
(void)nco_inq_var(nc_id,var_idx,var_nm,&var_typ_dsk,&dmn_nbr,(int *)NULL,(int *)NULL);
if(dmn_nbr == 0) continue; /* Skip chunking calls for scalars */
/* Allocate space to hold dimension IDs */
dmn_id=(int *)nco_malloc(dmn_nbr*sizeof(int));
/* Get dimension IDs */
(void)nco_inq_vardimid(nc_id,var_idx,dmn_id);
/* Is this a record variable? */
if(rcd_dmn_id != NCO_REC_DMN_UNDEFINED){
for(dmn_idx=0;dmn_idx<dmn_nbr;dmn_idx++){
/* Is this the record dimension? */
if(dmn_id[dmn_idx] == rcd_dmn_id) break; /* ...then search no further */
} /* end loop over dmn */
if(dmn_idx < dmn_nbr) is_rec_var=True; /* [flg] Record variable */
} /* NCO_REC_DMN_UNDEFINED */
/* Is variable compressed? */
(void)nco_inq_var_deflate(nc_id,var_idx,NULL,&deflate,NULL);
if(deflate) is_cmp_var=True;
/* Is variable checksummed? */
(void)nco_inq_var_fletcher32(nc_id,var_idx,&chk_typ);
if(chk_typ != NC_NOCHECKSUM) is_chk_var=True;
/* Must variable be chunked? */
if(is_rec_var || is_chk_var || is_cmp_var) must_be_chunked=True; else must_be_chunked=False;
/* Is variable currently chunked? */
is_chunked=nco_cnk_dsk_inq(nc_id,var_idx);
/* Explicitly turn off chunking for arrays that are... */
if((cnk_plc == nco_cnk_plc_g2d && dmn_nbr < 2) || /* ...much too small... */
(cnk_plc == nco_cnk_plc_g3d && dmn_nbr < 3) || /* ...too small... */
(cnk_plc == nco_cnk_plc_uck) || /* ...intentionally unchunked... */
False){
/* If variable is chunked */
if(is_chunked){
if(must_be_chunked){
if(dbg_lvl_get() >= nco_dbg_var) (void)fprintf(stderr,"%s: INFO %s %s must be chunked (record, compressed, or checksummed variable)\n",prg_nm_get(),fnc_nm,var_nm);
}else{
/* Turn off chunking for this variable */
if(dbg_lvl_get() >= nco_dbg_var) (void)fprintf(stderr,"%s: INFO %s unchunking %s\n",prg_nm_get(),fnc_nm,var_nm);
(void)nco_def_var_chunking(nc_id,var_idx,srg_typ,cnk_sz);
} /* !must_be_chunked */
}else{ /* !chunked */
if(dbg_lvl_get() >= nco_dbg_var) (void)fprintf(stderr,"%s: INFO %s not unchunking %s because it is not chunked\n",prg_nm_get(),fnc_nm,var_nm);
} /* !chunked */
/* Free space holding dimension IDs before skipping to next variable */
dmn_id=(int *)nco_free(dmn_id);
/* Skip to next variable in loop */
continue;
} /* end if */
/* Variable will definitely be chunked */
srg_typ=NC_CHUNKED; /* [enm] Storage type */
if(dbg_lvl_get() >= nco_dbg_var) (void)fprintf(stderr,"%s: INFO %s %schunking %s\n",prg_nm_get(),fnc_nm,(is_chunked ? "re-" : "" ),var_nm);
/* Allocate space to hold chunksizes */
cnk_sz=(size_t *)nco_malloc(dmn_nbr*sizeof(size_t));
/* Default "equal" chunksize for each dimension */
cnk_sz_dfl=cnk_sz_scl;
if(cnk_map == nco_cnk_map_prd){
double cnk_sz_prd_dbl; /* [nbr] Chunksize product, double precision */
double cnk_sz_eql_dbl; /* [nbr] Chunksize equal, double precision */
double cnk_sz_dfl_dbl; /* [nbr] Chunksize default, double precision */
cnk_sz_prd_dbl=cnk_sz_scl;
cnk_sz_eql_dbl=pow(cnk_sz_prd_dbl,1.0/dmn_nbr);
cnk_sz_dfl_dbl=ceil(cnk_sz_eql_dbl);
cnk_sz_dfl=(size_t)cnk_sz_dfl_dbl;
} /* endif map_prd */
for(dmn_idx=0;dmn_idx<dmn_nbr;dmn_idx++){
/* Get dimension name and size */
(void)nco_inq_dim(nc_id,dmn_id[dmn_idx],dmn_nm,&dmn_sz);
/* Is this the record dimension? */
if(dmn_id[dmn_idx] == rcd_dmn_id){
/* Does policy specify record dimension treatment? */
if(cnk_map == nco_cnk_map_rd1){
cnk_sz[dmn_idx]=1UL;
/* This may still be over-ridden by explicitly specified chunksize */
goto cnk_xpl_override;
} /* !nco_cnk_map_rd1 */
/* Record dimension size in output file is zero until first write
Obtain record dimension size from lmt_all structure */
if(lmt_all_lst[lmt_idx_rec]->BASIC_DMN){
/* When not hyperslabbed, use input record dimension size ... */
cnk_sz[dmn_idx]=lmt_all_lst[lmt_idx_rec]->dmn_sz_org;
}else{ /* !BASIC_DMN */
/* ... and when hyperslabbed, use user-specified count */
cnk_sz[dmn_idx]=lmt_all_lst[lmt_idx_rec]->dmn_cnt;
} /* !BASIC_DMN */
}else{ /* !record dimension */
/* Set non-record dimensions to default, possibly over-ride later */
cnk_sz[dmn_idx]=dmn_sz;
if(dmn_sz == 0L){
(void)fprintf(stderr,"%s: ERROR %s reports variable %s has dim_sz == 0L for non-record dimension %s. This should not occur and it will cause chunking to fail...\n",prg_nm_get(),fnc_nm,var_nm,dmn_nm);
} /* endif err */
} /* !record dimension */
/* Propagate scalar chunksize, if specified */
if(cnk_sz_dfl > 0UL){
if(dmn_id[dmn_idx] == rcd_dmn_id){
if(lmt_all_lst[lmt_idx_rec]->BASIC_DMN){
/* When not hyperslabbed, use input record dimension size ... */
cnk_sz[dmn_idx]=(cnk_sz_dfl <= (size_t)lmt_all_lst[lmt_idx_rec]->dmn_sz_org) ? cnk_sz_dfl : (size_t)lmt_all_lst[lmt_idx_rec]->dmn_sz_org;
}else{ /* !BASIC_DMN */
/* ... and when hyperslabbed, use user-specified count */
cnk_sz[dmn_idx]=(cnk_sz_dfl <= (size_t)lmt_all_lst[lmt_idx_rec]->dmn_cnt) ? cnk_sz_dfl : (size_t)lmt_all_lst[lmt_idx_rec]->dmn_cnt;
} /* !BASIC_DMN */
}else{ /* !rcd_dmn_id */
/* Non-record sizes default to cnk_sz_dfl or to dimension size */
cnk_sz[dmn_idx]=(cnk_sz_dfl <= (size_t)dmn_sz) ? cnk_sz_dfl : (size_t)dmn_sz;
} /* !rcd_dmn_id */
} /* !cnk_sz_dfl */
cnk_xpl_override: /* end goto */
/* Explicit chunk specifications override all else */
for(cnk_idx=0;cnk_idx<cnk_nbr;cnk_idx++){
/* Match on name not ID */
if(!strcmp(cnk[cnk_idx]->nm,dmn_nm)){
cnk_sz[dmn_idx]=cnk[cnk_idx]->sz;
if(dmn_id[dmn_idx] == rcd_dmn_id){
if(lmt_all_lst[lmt_idx_rec]->BASIC_DMN){
if(cnk_sz[dmn_idx] > (size_t)lmt_all_lst[lmt_idx_rec]->dmn_sz_org){
(void)fprintf(stderr,"%s: WARNING %s allowing user-specified record dimension chunksize = %lu for %s to exceed record dimension size in input file = %lu. May fail if output file is not concatenated from multiple inputs.\n",prg_nm_get(),fnc_nm,(unsigned long)cnk[cnk_idx]->sz,dmn_nm,lmt_all_lst[lmt_idx_rec]->dmn_sz_org);
} /* endif too big */
}else{ /* !BASIC_DMN */
if(cnk_sz[dmn_idx] > (size_t)lmt_all_lst[lmt_idx_rec]->dmn_cnt){
(void)fprintf(stderr,"%s: WARNING %s allowing user-specified record dimension chunksize = %lu for %s to exceed user-specified record dimension hyperslab size in input file = %lu. May fail if output file is not concatenated from multiple inputs.\n",prg_nm_get(),fnc_nm,(unsigned long)cnk[cnk_idx]->sz,dmn_nm,lmt_all_lst[lmt_idx_rec]->dmn_cnt);
} /* endif too big */
} /* !BASIC_DMN */
}else{ /* !rcd_dmn_id */
if(cnk_sz[dmn_idx] > (size_t)dmn_sz){
/* dmn_sz of record dimension may (will) be zero in output file
Non-record dimensions, though, must have cnk_sz <= dmn_sz */
(void)fprintf(stderr,"%s: WARNING %s trimming user-specified chunksize = %lu to %s size = %lu\n",prg_nm_get(),fnc_nm,(unsigned long)cnk[cnk_idx]->sz,dmn_nm,dmn_sz);
/* Trim else out-of-bounds sizes will fail in HDF library in nc_enddef() */
cnk_sz[dmn_idx]=(size_t)dmn_sz;
} /* endif */
} /* !rcd_dmn_id */
break;
} /* cnk_nm != dmn_nm */
} /* end loop over cnk */
} /* end loop over dmn */
if(dbg_lvl_get() >= nco_dbg_scl){
(void)fprintf(stderr,"idx nm\tdmn_sz\tcnk_sz for %s:\n",var_nm);
for(dmn_idx=0;dmn_idx<dmn_nbr;dmn_idx++){
(void)nco_inq_dimlen(nc_id,dmn_id[dmn_idx],&dmn_sz);
(void)nco_inq_dimname(nc_id,dmn_id[dmn_idx],dmn_nm);
(void)fprintf(stderr,"%2d %s\t%lu\t%lu\n",dmn_idx,dmn_nm,dmn_sz,(unsigned long)cnk_sz[dmn_idx]);
} /* end loop over dmn */
} /* endif dbg */
/* Turn chunking on for this variable */
(void)nco_def_var_chunking(nc_id,var_idx,srg_typ,cnk_sz);
/* Free space holding dimension IDs and chunksizes */
dmn_id=(int *)nco_free(dmn_id);
cnk_sz=(size_t *)nco_free(cnk_sz);
} /* end loop over var */
return;
} /* end nco_cnk_sz_set() */
