/* NB: Following routines are placeholders, currently not used */
size_t * /* O [nbr] Chunksize array for variable */
nco_cnk_sz_get /* [fnc] Determine chunksize array */
(const int nc_id, /* I [id] netCDF file ID */
const char * const var_nm, /* I [sng] Variable name */
const int cnk_map, /* I [enm] Chunking map */
const int cnk_plc, /* I [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 */
int dmn_nbr; /* [nbr] Number of dimensions in variable */
int dmn_idx;
int idx;
int rec_dmn_id;
size_t *cnk_sz; /* [nbr] Chunksize list */
/* Get record dimension ID */
(void)nco_inq(nc_id,(int *)NULL,(int *)NULL,(int *)NULL,&rec_dmn_id);
/* Get type and number of dimensions and attributes for variable */
cnk_sz=(size_t *)nco_malloc(dmn_nbr*sizeof(size_t));
return cnk_sz;
} /* end nco_cnk_sz_get() */
dmn_sct * /* O [sct] Output dimension structure */
nco_dmn_fll /* [fnc] Create and return completed dmn_sct */
(const int nc_id, /* I [id] netCDF input file ID */
const int dmn_id, /* I [id] Dimension ID */
const char * const dmn_nm) /* I [sng] Dimension name */
{
/* Purpose: nco_malloc() and return a completed dmn_sct */
dmn_sct *dmn;
int rcd=NC_NOERR; /* [rcd] Return code */
int rec_dmn_id;
dmn=(dmn_sct *)nco_malloc(sizeof(dmn_sct));
dmn->nm=(char *)strdup(dmn_nm);
dmn->nm_fll=NULL;
dmn->id=dmn_id;
dmn->nc_id=nc_id;
dmn->xrf=NULL;
dmn->val.vp=NULL;
dmn->is_crd_dmn=False;
dmn->cid=-1; /* [id] Variable ID of associated coordinate, if any */
(void)nco_inq_dimlen(dmn->nc_id,dmn_id,&dmn->sz);
/* Get record dimension ID */
(void)nco_inq(dmn->nc_id,(int *)NULL,(int *)NULL,(int *)NULL,&rec_dmn_id);
if(dmn->id == rec_dmn_id){
dmn->is_rec_dmn=True;
}else{
dmn->is_rec_dmn=False;
} /* end if */
rcd=nco_inq_varid_flg(dmn->nc_id,dmn_nm,&dmn->cid);
if(rcd == NC_NOERR){
dmn->is_crd_dmn=True;
/* What type is coordinate? */
(void)nco_inq_vartype(dmn->nc_id,dmn->cid,&dmn->type);
} /* end if */
dmn->cnk_sz=0L;
dmn->cnt=dmn->sz;
dmn->srt=0L;
dmn->end=dmn->sz-1L;
dmn->srd=1L;
return dmn;
} /* end nco_dmn_fll() */
void
rec_var_dbg /* [fnc] Aid in debugging problems with record dimension */
(const int nc_id, /* I [id] netCDF file ID */
const char * const dbg_sng) /* I [sng] Debugging message to print */
{
/* Purpose: Aid in debugging problems with record dimension */
/* Usage: if(dbg_lvl == 73) rec_var_dbg(out_id,"After ncvarput()"); */
int nbr_dmn_fl;
int nbr_var_fl;
int rec_dmn_id=NCO_REC_DMN_UNDEFINED;
long dmn_sz;
(void)fprintf(stderr,"%s: DBG %s\n",prg_nm_get(),dbg_sng);
(void)nco_inq(nc_id,&nbr_dmn_fl,&nbr_var_fl,(int *)NULL,&rec_dmn_id);
if(rec_dmn_id == NCO_REC_DMN_UNDEFINED){
(void)fprintf(stderr,"%s: DBG %d dimensions, %d variables, no record dimension\n",prg_nm_get(),nbr_dmn_fl,nbr_var_fl);
}else{
(void)nco_inq_dimlen(nc_id,rec_dmn_id,&dmn_sz);
(void)fprintf(stderr,"%s: DBG %d dimensions, %d variables, record dimension size is %li\n",prg_nm_get(),nbr_dmn_fl,nbr_var_fl,dmn_sz);
} /* end else */
(void)fflush(stderr);
} /* end rec_var_dbg() */
int
main(int argc,char **argv)
{
aed_sct *aed_lst=NULL_CEWI;
char **fl_lst_abb=NULL; /* Option n */
char **fl_lst_in;
char **gaa_arg=NULL; /* [sng] Global attribute arguments */
char *aed_arg[NC_MAX_ATTRS];
char *cmd_ln;
char *fl_in=NULL;
char *fl_out=NULL; /* Option o */
char *fl_pth=NULL; /* Option p */
char *fl_pth_lcl=NULL; /* Option l */
char *opt_crr=NULL; /* [sng] String representation of current long-option name */
char *sng_cnv_rcd=NULL_CEWI; /* [sng] strtol()/strtoul() return code */
char trv_pth[]="/"; /* [sng] Root path of traversal tree */
const char * const CVS_Id="$Id$";
const char * const CVS_Revision="$Revision$";
const char * const opt_sht_lst="Aa:D:hl:Oo:p:Rr-:";
#if defined(__cplusplus) || defined(PGI_CC)
ddra_info_sct ddra_info;
ddra_info.flg_ddra=False;
#else /* !__cplusplus */
ddra_info_sct ddra_info={.flg_ddra=False};
#endif /* !__cplusplus */
extern char *optarg;
extern int optind;
int abb_arg_nbr=0;
int fl_nbr=0;
int gaa_nbr=0; /* [nbr] Number of global attributes to add */
int nbr_aed=0; /* Option a. NB: nbr_var_aed gets incremented */
int nbr_var_fl;
int nc_id;
int md_open; /* [enm] Mode flag for nc_open() call */
int opt;
int rcd=NC_NOERR; /* [rcd] Return code */
nco_bool FL_RTR_RMT_LCN;
nco_bool FL_LST_IN_FROM_STDIN=False; /* [flg] fl_lst_in comes from stdin */
nco_bool FORCE_APPEND=False; /* Option A */
nco_bool FORCE_OVERWRITE=False; /* Option O */
nco_bool HISTORY_APPEND=True; /* Option h */
nco_bool FL_OUT_NEW=False;
nco_bool RAM_OPEN=False; /* [flg] Open (netCDF3-only) file(s) in RAM */
nco_bool RM_RMT_FL_PST_PRC=True; /* Option R */
nco_bool flg_cln=False; /* [flg] Clean memory prior to exit */
size_t bfr_sz_hnt=NC_SIZEHINT_DEFAULT; /* [B] Buffer size hint */
size_t hdr_pad=0UL; /* [B] Pad at end of header section */
trv_tbl_sct *trv_tbl=NULL; /* [lst] Traversal table */
nco_dmn_dne_t *flg_dne=NULL; /* [lst] Flag to check if input dimension -d "does not exist" */
#ifdef ENABLE_MPI
/* Declare all MPI-specific variables here */
MPI_Comm mpi_cmm=MPI_COMM_WORLD; /* [prc] Communicator */
int prc_rnk; /* [idx] Process rank */
int prc_nbr=0; /* [nbr] Number of MPI processes */
#endif /* !ENABLE_MPI */
static struct option opt_lng[]={ /* Structure ordered by short option key if possible */
/* Long options with no argument, no short option counterpart */
{"cln",no_argument,0,0}, /* [flg] Clean memory prior to exit */
{"clean",no_argument,0,0}, /* [flg] Clean memory prior to exit */
{"mmr_cln",no_argument,0,0}, /* [flg] Clean memory prior to exit */
{"drt",no_argument,0,0}, /* [flg] Allow dirty memory on exit */
{"dirty",no_argument,0,0}, /* [flg] Allow dirty memory on exit */
{"mmr_drt",no_argument,0,0}, /* [flg] Allow dirty memory on exit */
{"hdf4",no_argument,0,0}, /* [flg] Treat file as HDF4 */
{"ram_all",no_argument,0,0}, /* [flg] Open (netCDF3) and create file(s) in RAM */
{"create_ram",no_argument,0,0}, /* [flg] Create file in RAM */
{"open_ram",no_argument,0,0}, /* [flg] Open (netCDF3) file(s) in RAM */
{"diskless_all",no_argument,0,0}, /* [flg] Open (netCDF3) and create file(s) in RAM */
{"version",no_argument,0,0},
{"vrs",no_argument,0,0},
/* Long options with argument, no short option counterpart */
{"bfr_sz_hnt",required_argument,0,0}, /* [B] Buffer size hint */
{"buffer_size_hint",required_argument,0,0}, /* [B] Buffer size hint */
{"gaa",required_argument,0,0}, /* [sng] Global attribute add */
{"glb_att_add",required_argument,0,0}, /* [sng] Global attribute add */
{"hdr_pad",required_argument,0,0},
{"header_pad",required_argument,0,0},
/* Long options with short counterparts */
{"append",no_argument,0,'A'},
{"attribute",required_argument,0,'a'},
{"debug",required_argument,0,'D'},
{"nco_dbg_lvl",required_argument,0,'D'},
{"history",no_argument,0,'h'},
{"hst",no_argument,0,'h'},
{"local",required_argument,0,'l'},
{"lcl",required_argument,0,'l'},
{"overwrite",no_argument,0,'O'},
{"ovr",no_argument,0,'O'},
{"output",required_argument,0,'o'},
{"fl_out",required_argument,0,'o'},
{"path",required_argument,0,'p'},
{"retain",no_argument,0,'R'},
{"rtn",no_argument,0,'R'},
{"help",no_argument,0,'?'},
{"hlp",no_argument,0,'?'},
{0,0,0,0}
}; /* end opt_lng */
int opt_idx=0; /* Index of current long option into opt_lng array */
/* Start timer and save command line */
ddra_info.tmr_flg=nco_tmr_srt;
rcd+=nco_ddra((char *)NULL,(char *)NULL,&ddra_info);
ddra_info.tmr_flg=nco_tmr_mtd;
cmd_ln=nco_cmd_ln_sng(argc,argv);
/* Get program name and set program enum (e.g., nco_prg_id=ncra) */
nco_prg_nm=nco_prg_prs(argv[0],&nco_prg_id);
#ifdef ENABLE_MPI
/* MPI Initialization */
if(False) (void)fprintf(stdout,gettext("%s: WARNING Compiled with MPI\n"),nco_prg_nm);
MPI_Init(&argc,&argv);
MPI_Comm_size(mpi_cmm,&prc_nbr);
MPI_Comm_rank(mpi_cmm,&prc_rnk);
#endif /* !ENABLE_MPI */
/* Parse command line arguments */
while(1){
/* getopt_long_only() allows one dash to prefix long options */
opt=getopt_long(argc,argv,opt_sht_lst,opt_lng,&opt_idx);
/* NB: access to opt_crr is only valid when long_opt is detected */
if(opt == EOF) break; /* Parse positional arguments once getopt_long() returns EOF */
opt_crr=(char *)strdup(opt_lng[opt_idx].name);
/* Process long options without short option counterparts */
if(opt == 0){
if(!strcmp(opt_crr,"bfr_sz_hnt") || !strcmp(opt_crr,"buffer_size_hint")){
bfr_sz_hnt=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10);
if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd);
} /* endif cnk */
if(!strcmp(opt_crr,"cln") || !strcmp(opt_crr,"mmr_cln") || !strcmp(opt_crr,"clean")) flg_cln=True; /* [flg] Clean memory prior to exit */
if(!strcmp(opt_crr,"drt") || !strcmp(opt_crr,"mmr_drt") || !strcmp(opt_crr,"dirty")) flg_cln=False; /* [flg] Clean memory prior to exit */
if(!strcmp(opt_crr,"gaa") || !strcmp(opt_crr,"glb_att_add")){
gaa_arg=(char **)nco_realloc(gaa_arg,(gaa_nbr+1)*sizeof(char *));
gaa_arg[gaa_nbr++]=(char *)strdup(optarg);
} /* endif gaa */
if(!strcmp(opt_crr,"hdf4")) nco_fmt_xtn=nco_fmt_xtn_hdf4; /* [enm] Treat file as HDF4 */
if(!strcmp(opt_crr,"hdr_pad") || !strcmp(opt_crr,"header_pad")){
hdr_pad=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10);
if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd);
} /* endif "hdr_pad" */
if(!strcmp(opt_crr,"ram_all") || !strcmp(opt_crr,"open_ram") || !strcmp(opt_crr,"diskless_all")) RAM_OPEN=True; /* [flg] Create file in RAM */
if(!strcmp(opt_crr,"vrs") || !strcmp(opt_crr,"version")){
(void)nco_vrs_prn(CVS_Id,CVS_Revision);
nco_exit(EXIT_SUCCESS);
} /* endif "vrs" */
} /* opt != 0 */
/* Process short options */
switch(opt){
case 0: /* Long options have already been processed, return */
break;
case 'A': /* Toggle FORCE_APPEND */
FORCE_APPEND=!FORCE_APPEND;
break;
case 'a': /* Copy argument for later processing */
aed_arg[nbr_aed]=(char *)strdup(optarg);
nbr_aed++;
break;
case 'D': /* Debugging level. Default is 0. */
nco_dbg_lvl=(unsigned short int)strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10);
if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd);
nc_set_log_level(nco_dbg_lvl);
break;
case 'h': /* Toggle appending to history global attribute */
HISTORY_APPEND=!HISTORY_APPEND;
break;
case 'l': /* Local path prefix for files retrieved from remote file system */
fl_pth_lcl=(char *)strdup(optarg);
break;
case 'O': /* Toggle FORCE_OVERWRITE */
FORCE_OVERWRITE=!FORCE_OVERWRITE;
break;
case 'o': /* Name of output file */
fl_out=(char *)strdup(optarg);
break;
case 'p': /* Common file path */
fl_pth=(char *)strdup(optarg);
break;
case 'R': /* Toggle removal of remotely-retrieved-files. Default is True. */
RM_RMT_FL_PST_PRC=!RM_RMT_FL_PST_PRC;
break;
case 'r': /* Print CVS program information and copyright notice */
(void)nco_vrs_prn(CVS_Id,CVS_Revision);
(void)nco_lbr_vrs_prn();
(void)nco_cpy_prn();
(void)nco_cnf_prn();
nco_exit(EXIT_SUCCESS);
break;
case '?': /* Print proper usage */
(void)nco_usg_prn();
nco_exit(EXIT_SUCCESS);
break;
case '-': /* Long options are not allowed */
(void)fprintf(stderr,"%s: ERROR Long options are not available in this build. Use single letter options instead.\n",nco_prg_nm_get());
nco_exit(EXIT_FAILURE);
break;
default: /* Print proper usage */
(void)fprintf(stdout,"%s ERROR in command-line syntax/options. Please reformulate command accordingly.\n",nco_prg_nm_get());
(void)nco_usg_prn();
nco_exit(EXIT_FAILURE);
} /* end switch */
if(opt_crr) opt_crr=(char *)nco_free(opt_crr);
} /* end while loop */
/* Process positional arguments and fill in filenames */
fl_lst_in=nco_fl_lst_mk(argv,argc,optind,&fl_nbr,&fl_out,&FL_LST_IN_FROM_STDIN);
if(fl_out) FL_OUT_NEW=True; else fl_out=(char *)strdup(fl_lst_in[0]);
if(nbr_aed == 0){
(void)fprintf(stdout,"%s: ERROR must specify an attribute to edit\n",nco_prg_nm);
nco_usg_prn();
nco_exit(EXIT_FAILURE);
} /* end if */
if(nco_dbg_lvl_get() >= nco_dbg_var) (void)fprintf(stdout,"%s: DEBUG attribute assumed to hold missing data is named \"%s\"\n",nco_prg_nm_get(),nco_mss_val_sng_get());
/* Make uniform list of user-specified attribute edit structures */
if(nbr_aed > 0) aed_lst=nco_prs_aed_lst(nbr_aed,aed_arg);
/* We now have final list of attributes to edit */
/* Parse filename */
fl_in=nco_fl_nm_prs(fl_in,0,&fl_nbr,fl_lst_in,abb_arg_nbr,fl_lst_abb,fl_pth);
/* Make sure file is on local system and is readable or die trying */
fl_in=nco_fl_mk_lcl(fl_in,fl_pth_lcl,&FL_RTR_RMT_LCN);
if(FL_OUT_NEW){
/* Obtain user consent, if needed, to overwrite output file (or die trying) */
if(!FORCE_OVERWRITE) nco_fl_overwrite_prm(fl_out);
/* Copy input file to output file and then search through output,
changing names on the fly. This avoids possible XDR translation
performance penalty of copying each variable with netCDF. */
(void)nco_fl_cp(fl_in,fl_out);
/* Ensure output file is user/owner-writable */
(void)nco_fl_chmod(fl_out);
} /* end if FL_OUT_NEW */
/* Open file. Writing must be enabled and file should be in define mode for renaming */
/* if(nco_dbg_lvl == 8) md_open|=NC_SHARE;*/
if(RAM_OPEN) md_open=NC_WRITE|NC_DISKLESS; else md_open=NC_WRITE;
rcd+=nco_fl_open(fl_out,md_open,&bfr_sz_hnt,&nc_id);
(void)nco_redef(nc_id);
/* Get number of variables in file */
(void)nco_inq(nc_id,(int *)NULL,&nbr_var_fl,(int *)NULL,(int *)NULL);
/* Initialize traversal table */
trv_tbl_init(&trv_tbl);
/* Construct GTT (Group Traversal Table) */
(void)nco_bld_trv_tbl(nc_id,trv_pth,(int)0,NULL,(int)0,NULL,False,False,NULL,(int)0,NULL,(int) 0,False,False,False,False,True,nco_pck_plc_nil,&flg_dne,trv_tbl);
/* Timestamp end of metadata setup and disk layout */
rcd+=nco_ddra((char *)NULL,(char *)NULL,&ddra_info);
ddra_info.tmr_flg=nco_tmr_rgl;
for(int idx_aed=0;idx_aed<nbr_aed;idx_aed++){
if(!aed_lst[idx_aed].var_nm){
/* Variable name is blank so edit same attribute for all variables */
(void)nco_aed_prc_var_all(nc_id,aed_lst[idx_aed],trv_tbl);
}else if(strpbrk(aed_lst[idx_aed].var_nm,".*^$\\[]()<>+?|{}")){
/* Variable name contains a "regular expression" (rx) */
trv_tbl_sct *trv_tbl_rx;
char **var_lst_in; /* I [sng] User-specified list of variables */
int var_lst_in_nbr; /* I [nbr] Number of variables in list */
var_lst_in=nco_lst_prs_2D(aed_lst[idx_aed].var_nm,",",&var_lst_in_nbr);
trv_tbl_init(&trv_tbl_rx);
/* Use regular expressions in aed structure to construct traversal table
Variables marked for extraction will then have the attributes edited */
(void)nco_bld_trv_tbl(nc_id,trv_pth,(int)0,NULL,(int)0,NULL,False,False,NULL,(int)0,var_lst_in,var_lst_in_nbr,False,False,False,False,False,nco_pck_plc_nil,&flg_dne,trv_tbl_rx);
/* Edit same attribute for all variables marked for extraction */
(void)nco_aed_prc_var_xtr(nc_id,aed_lst[idx_aed],trv_tbl_rx);
trv_tbl_free(trv_tbl_rx);
var_lst_in=nco_sng_lst_free(var_lst_in,var_lst_in_nbr);
}else if(!strcasecmp(aed_lst[idx_aed].var_nm,"group")){
/* Variable name of "group" means edit group attributes */
(void)nco_aed_prc_grp(nc_id,aed_lst[idx_aed],trv_tbl);
}else if(!strcasecmp(aed_lst[idx_aed].var_nm,"global")){
/* Variable name of "global" means edit global attributes */
(void)nco_aed_prc_glb(nc_id,aed_lst[idx_aed],trv_tbl);
}else{
/* Regular ole' variable name means edits attributes that match absoluted and relative names */
(void)nco_aed_prc_var_nm(nc_id,aed_lst[idx_aed],trv_tbl);
} /* end var_nm */
} /* end loop over aed structures */
/* Catenate the time-stamped command line to the "history" global attribute */
if(HISTORY_APPEND) (void)nco_hst_att_cat(nc_id,cmd_ln);
/* Take output file out of define mode */
if(hdr_pad == 0UL){
(void)nco_enddef(nc_id);
}else{
(void)nco__enddef(nc_id,hdr_pad);
if(nco_dbg_lvl >= nco_dbg_scl) (void)fprintf(stderr,"%s: INFO Padding header with %lu extra bytes\n",nco_prg_nm_get(),(unsigned long)hdr_pad);
} /* hdr_pad */
/* Close the open netCDF file */
nco_close(nc_id);
/* Remove local copy of file */
if(FL_RTR_RMT_LCN && RM_RMT_FL_PST_PRC) (void)nco_fl_rm(fl_in);
/* Clean memory unless dirty memory allowed */
if(flg_cln){
/* ncatted-specific memory */
for(int idx=0;idx<nbr_aed;idx++) aed_arg[idx]=(char *)nco_free(aed_arg[idx]);
for(int idx=0;idx<nbr_aed;idx++){
if(aed_lst[idx].att_nm) aed_lst[idx].att_nm=(char *)nco_free(aed_lst[idx].att_nm);
if(aed_lst[idx].var_nm) aed_lst[idx].var_nm=(char *)nco_free(aed_lst[idx].var_nm);
aed_lst[idx].val.vp=(void *)nco_free(aed_lst[idx].val.vp);
} /* end for */
if(nbr_aed > 0) aed_lst=(aed_sct *)nco_free(aed_lst);
/* NCO-generic clean-up */
/* Free individual strings/arrays */
if(cmd_ln) cmd_ln=(char *)nco_free(cmd_ln);
if(fl_in) fl_in=(char *)nco_free(fl_in);
if(fl_out) fl_out=(char *)nco_free(fl_out);
if(fl_pth) fl_pth=(char *)nco_free(fl_pth);
if(fl_pth_lcl) fl_pth_lcl=(char *)nco_free(fl_pth_lcl);
/* Free lists of strings */
if(fl_lst_in && fl_lst_abb == NULL) fl_lst_in=nco_sng_lst_free(fl_lst_in,fl_nbr);
if(fl_lst_in && fl_lst_abb) fl_lst_in=nco_sng_lst_free(fl_lst_in,1);
if(fl_lst_abb) fl_lst_abb=nco_sng_lst_free(fl_lst_abb,abb_arg_nbr);
if(gaa_nbr > 0) gaa_arg=nco_sng_lst_free(gaa_arg,gaa_nbr);
trv_tbl_free(trv_tbl);
} /* !flg_cln */
#ifdef ENABLE_MPI
MPI_Finalize();
#endif /* !ENABLE_MPI */
/* End timer */
ddra_info.tmr_flg=nco_tmr_end; /* [enm] Timer flag */
rcd+=nco_ddra((char *)NULL,(char *)NULL,&ddra_info);
if(rcd != NC_NOERR) nco_err_exit(rcd,"main");
nco_exit_gracefully();
return EXIT_SUCCESS;
} /* end main() */
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() */
void
nco_hst_att_cat /* [fnc] Add command line, date stamp to history attribute */
(const int out_id, /* I [id] netCDF output-file ID */
const char * const hst_sng) /* I [sng] String to add to history attribute */
{
/* Purpose: Add command line and date stamp to existing history attribute, if any,
and write them to specified output file */
/* Length of string + NUL required to hold output of ctime() */
#define TIME_STAMP_SNG_LNG 25
char att_nm[NC_MAX_NAME];
char *ctime_sng;
char *history_crr=NULL;
char *history_new;
char time_stamp_sng[TIME_STAMP_SNG_LNG];
const char sng_history[]="history"; /* [sng] Possible name of history attribute */
int idx;
int glb_att_nbr;
long att_sz=0;
nc_type att_typ;
time_t time_crr_time_t;
/* Create timestamp string */
time_crr_time_t=time((time_t *)NULL);
ctime_sng=ctime(&time_crr_time_t);
/* NUL-terminate time_stamp_sng */
time_stamp_sng[TIME_STAMP_SNG_LNG-1]='\0';
/* Get rid of carriage return in ctime_sng */
(void)strncpy(time_stamp_sng,ctime_sng,TIME_STAMP_SNG_LNG-1);
/* Get number of global attributes in file */
(void)nco_inq(out_id,(int *)NULL,(int *)NULL,&glb_att_nbr,(int *)NULL);
for(idx=0;idx<glb_att_nbr;idx++){
(void)nco_inq_attname(out_id,NC_GLOBAL,idx,att_nm);
if(!strcasecmp(att_nm,sng_history)) break;
} /* end loop over att */
/* Fill in history string */
if(idx == glb_att_nbr){
/* Global attribute "[hH]istory" does not yet exist */
/* Add 3 for formatting characters */
history_new=(char *)nco_malloc((strlen(hst_sng)+strlen(time_stamp_sng)+3)*sizeof(char));
(void)sprintf(history_new,"%s: %s",time_stamp_sng,hst_sng);
/* Set attribute name to default */
(void)strcpy(att_nm,sng_history);
}else{
/* Global attribute "[hH]istory" currently exists */
/* NB: ncattinq(), unlike strlen(), counts terminating NUL for stored NC_CHAR arrays */
(void)nco_inq_att(out_id,NC_GLOBAL,att_nm,&att_typ,&att_sz);
if(att_typ != NC_CHAR){
if(dbg_lvl_get() >= nco_dbg_std) (void)fprintf(stderr,"%s: WARNING the \"%s\" global attribute is type %s, not %s. Therefore current command line will not be appended to %s in output file.\n",prg_nm_get(),att_nm,nco_typ_sng(att_typ),nco_typ_sng(NC_CHAR),att_nm);
return;
} /* end if */
/* Allocate and NUL-terminate space for current history attribute
If history attribute is of size zero then ensure strlen(history_crr) = 0 */
history_crr=(char *)nco_malloc((att_sz+1)*sizeof(char));
history_crr[att_sz]='\0';
if(att_sz > 0) (void)nco_get_att(out_id,NC_GLOBAL,att_nm,(void *)history_crr,NC_CHAR);
/* Add 4 for formatting characters */
history_new=(char *)nco_malloc((strlen(history_crr)+strlen(hst_sng)+strlen(time_stamp_sng)+4)*sizeof(char));
(void)sprintf(history_new,"%s: %s\n%s",time_stamp_sng,hst_sng,history_crr);
} /* endif history global attribute currently exists */
(void)nco_put_att(out_id,NC_GLOBAL,att_nm,NC_CHAR,(long)(strlen(history_new)+1UL),(void *)history_new);
history_crr=(char *)nco_free(history_crr);
history_new=(char *)nco_free(history_new);
return; /* 20050109: fxm added return to void function to squelch erroneous gcc-3.4.2 warning */
} /* end nco_hst_att_cat() */
void
nco_aed_prc /* [fnc] Process single attribute edit for single variable */
(const int nc_id, /* I [id] Input netCDF file ID */
const int var_id, /* I [id] ID of variable on which to perform attribute editing */
const aed_sct aed) /* I [sct] Structure containing information necessary to edit */
{
/* Purpose: Process single attribute edit for single variable */
/* If var_id == NC_GLOBAL ( = -1) then global attribute will be edited */
#ifdef NCO_NETCDF4_AND_FILLVALUE
char att_nm_tmp[]="eulaVlliF_"; /* String of same length as "_FillValue" for name hack with netCDF4 */
nco_bool flg_netCDF4=False; /* [flg] File format is netCDF4 */
#endif /* !NCO_NETCDF4_AND_FILLVALUE */
char att_nm[NC_MAX_NAME];
char var_nm[NC_MAX_NAME];
/* NB: netCDF2 specifies att_sz is type int, netCDF3 and netCDF4 use size_t */
int nbr_att; /* [nbr] Number of attributes */
int rcd=NC_NOERR; /* [rcd] Return code */
long att_sz;
nc_type att_typ;
void *att_val_new=NULL;
if(var_id == NC_GLOBAL){
/* Get number of global attributes in file */
(void)nco_inq(nc_id,(int *)NULL,(int *)NULL,&nbr_att,(int *)NULL);
(void)strcpy(var_nm,"Global");
}else{
/* Get name and number of attributes for variable */
(void)nco_inq_var(nc_id,var_id,var_nm,(nc_type *)NULL,(int *)NULL,(int *)NULL,&nbr_att);
} /* end else */
/* Query attribute metadata when attribute name was specified */
if(aed.att_nm) rcd=nco_inq_att_flg(nc_id,var_id,aed.att_nm,&att_typ,&att_sz);
/* Before changing metadata, change missing values to new missing value if warranted
This capability is add-on feature not implemented too cleanly or efficiently
If every variable has "_FillValue" attribute and "_FillValue" is changed
globally, then algorithm goes into and out of define mode for each variable,
rather than collecting all information in first pass and replacing all data in second pass.
This is because ncatted was originally designed to change only metadata and so was
architected differently from other NCO operators. */
if(
aed.att_nm /* Linux strcmp() dumps core if attribute name is blank */
&& strcmp(aed.att_nm,nco_mss_val_sng_get()) == 0 /* Current attribute is "_FillValue" */
&& var_id != NC_GLOBAL /* Current attribute is not global */
&& (aed.mode == aed_modify || aed.mode == aed_overwrite) /* Modifying or overwriting existing value */
&& rcd == NC_NOERR /* Only when existing _FillValue attribute is modified */
&& att_sz == 1L /* Old _FillValue attribute must be of size 1 */
&& aed.sz == 1L /* New _FillValue attribute must be of size 1 */
){
int *dmn_id;
long *dmn_sz;
long *dmn_srt;
long idx;
long var_sz=long_CEWI;
ptr_unn mss_val_crr;
ptr_unn mss_val_new;
ptr_unn var_val;
var_sct *var=NULL_CEWI;
if(dbg_lvl_get() >= nco_dbg_std) (void)fprintf(stdout,"%s: INFO Replacing missing value data in variable %s\n",prg_nm_get(),var_nm);
/* Take file out of define mode */
(void)nco_enddef(nc_id);
/* Initialize (partially) variable structure */
var=(var_sct *)nco_malloc(sizeof(var_sct));
var->nc_id=nc_id;
var->id=var_id;
var->sz=1L;
/* Get type of variable and number of dimensions */
(void)nco_inq_var(nc_id,var_id,(char *)NULL,&var->type,&var->nbr_dim,(int *)NULL,(int *)NULL);
dmn_id=(int *)nco_malloc(var->nbr_dim*sizeof(int));
dmn_sz=(long *)nco_malloc(var->nbr_dim*sizeof(long));
dmn_srt=(long *)nco_malloc(var->nbr_dim*sizeof(long));
(void)nco_inq_vardimid(nc_id,var_id,dmn_id);
/* Get dimension sizes and construct variable size */
for(idx=0;idx<var->nbr_dim;idx++){
(void)nco_inq_dimlen(nc_id,dmn_id[idx],dmn_sz+idx);
var->sz*=dmn_sz[idx];
dmn_srt[idx]=0L;
} /* end loop over dim */
var->dmn_id=dmn_id;
var->cnt=dmn_sz;
var->srt=dmn_srt;
/* Place nco_var_get() code inline since var struct is not truly complete */
if((var->val.vp=(void *)nco_malloc_flg(var->sz*nco_typ_lng(var->type))) == NULL){
(void)fprintf(stdout,"%s: ERROR Unable to malloc() %ld*%lu bytes in nco_aed_prc()\n",prg_nm_get(),var->sz,(unsigned long)nco_typ_lng(var->type));
nco_exit(EXIT_FAILURE);
} /* end if */
if(var->sz > 1L){
(void)nco_get_vara(nc_id,var_id,var->srt,var->cnt,var->val.vp,var->type);
}else{
(void)nco_get_var1(nc_id,var_id,var->srt,var->val.vp,var->type);
} /* end else */
/* Get current missing value attribute */
var->mss_val.vp=NULL;
var->has_mss_val=nco_mss_val_get(nc_id,var);
/* Sanity check */
if(var->has_mss_val == False){
(void)fprintf(stdout,"%s: ERROR variable %s does not have \"%s\" attribute in nco_aed_prc()\n",prg_nm_get(),var_nm,nco_mss_val_sng_get());
nco_exit(EXIT_FAILURE);
} /* end if */
/* Shortcuts to avoid indirection */
var_val=var->val;
var_sz=var->sz;
/* Get new and old missing values in same type as variable */
mss_val_crr.vp=(void *)nco_malloc(att_sz*nco_typ_lng(var->type));
mss_val_new.vp=(void *)nco_malloc(aed.sz*nco_typ_lng(var->type));
(void)nco_val_cnf_typ(var->type,var->mss_val,var->type,mss_val_crr);
(void)nco_val_cnf_typ(aed.type,aed.val,var->type,mss_val_new);
/* Typecast pointer to values before access */
(void)cast_void_nctype(var->type,&var_val);
(void)cast_void_nctype(var->type,&mss_val_crr);
(void)cast_void_nctype(var->type,&mss_val_new);
switch(var->type){
case NC_FLOAT: for(idx=0L;idx<var_sz;idx++) {if(var_val.fp[idx] == *mss_val_crr.fp) var_val.fp[idx]=*mss_val_new.fp;} break;
case NC_DOUBLE: for(idx=0L;idx<var_sz;idx++) {if(var_val.dp[idx] == *mss_val_crr.dp) var_val.dp[idx]=*mss_val_new.dp;} break;
case NC_INT: for(idx=0L;idx<var_sz;idx++) {if(var_val.ip[idx] == *mss_val_crr.ip) var_val.ip[idx]=*mss_val_new.ip;} break;
case NC_SHORT: for(idx=0L;idx<var_sz;idx++) {if(var_val.sp[idx] == *mss_val_crr.sp) var_val.sp[idx]=*mss_val_new.sp;} break;
case NC_CHAR: for(idx=0L;idx<var_sz;idx++) {if(var_val.cp[idx] == *mss_val_crr.cp) var_val.cp[idx]=*mss_val_new.cp;} break;
case NC_BYTE: for(idx=0L;idx<var_sz;idx++) {if(var_val.bp[idx] == *mss_val_crr.bp) var_val.bp[idx]=*mss_val_new.bp;} break;
case NC_UBYTE: for(idx=0L;idx<var_sz;idx++) {if(var_val.ubp[idx] == *mss_val_crr.ubp) var_val.ubp[idx]=*mss_val_new.ubp;} break;
case NC_USHORT: for(idx=0L;idx<var_sz;idx++) {if(var_val.usp[idx] == *mss_val_crr.usp) var_val.usp[idx]=*mss_val_new.usp;} break;
case NC_UINT: for(idx=0L;idx<var_sz;idx++) {if(var_val.uip[idx] == *mss_val_crr.uip) var_val.uip[idx]=*mss_val_new.uip;} break;
case NC_INT64: for(idx=0L;idx<var_sz;idx++) {if(var_val.i64p[idx] == *mss_val_crr.i64p) var_val.i64p[idx]=*mss_val_new.i64p;} break;
case NC_UINT64: for(idx=0L;idx<var_sz;idx++) {if(var_val.ui64p[idx] == *mss_val_crr.ui64p) var_val.ui64p[idx]=*mss_val_new.ui64p;} break;
case NC_STRING: for(idx=0L;idx<var_sz;idx++) {if(var_val.sngp[idx] == *mss_val_crr.sngp) var_val.sngp[idx]=*mss_val_new.sngp;} break;
default: nco_dfl_case_nc_type_err(); break;
} /* end switch */
/* Un-typecast the pointer to values after access */
(void)cast_nctype_void(var->type,&var_val);
(void)cast_nctype_void(var->type,&mss_val_crr);
(void)cast_nctype_void(var->type,&mss_val_new);
/* Write to disk */
if(var->nbr_dim == 0){
(void)nco_put_var1(nc_id,var_id,var->srt,var->val.vp,var->type);
}else{ /* end if variable is scalar */
(void)nco_put_vara(nc_id,var_id,var->srt,var->cnt,var->val.vp,var->type);
} /* end else */
/* Free memory */
mss_val_crr.vp=nco_free(mss_val_crr.vp);
mss_val_new.vp=nco_free(mss_val_new.vp);
var->mss_val.vp=nco_free(var->mss_val.vp);
var->val.vp=nco_free(var->val.vp);
var->dmn_id=(int *)nco_free(var->dmn_id);
var->srt=(long *)nco_free(var->srt);
var->cnt=(long *)nco_free(var->cnt);
/* 20050704 try and use nco_free() to avoid valgrind error message */
var=(var_sct *)nco_free(var);
/* Put file back in define mode */
(void)nco_redef(nc_id);
} /* end if replacing missing value data */
/* Change metadata (as written, this must be done after _FillValue data is replaced) */
#ifdef NCO_NETCDF4_AND_FILLVALUE
/* Bold hack which gets around problem of modifying netCDF4 "_FillValue" attributes
netCDF4 does not allow this by default, though netCDF3 does
Change attribute name to att_nm_tmp, modify value, then restore name */
/* Check if file is netCDF3 classic with netCDF4 library
If so, do not kludge. NB: create global variable for output file format? */
{ /* scope for fl_fmt temporary */
int fl_fmt;
(void)nco_inq_format(nc_id,&fl_fmt);
flg_netCDF4=(fl_fmt==NC_FORMAT_NETCDF4 || fl_fmt==NC_FORMAT_NETCDF4_CLASSIC);
} /* end scope */
if(flg_netCDF4 && !strcmp(aed.att_nm,nco_mss_val_sng_get()) && aed.mode != aed_delete){
if(aed.mode != aed_create) (void)nco_rename_att(nc_id,var_id,aed.att_nm,att_nm_tmp);
strcpy(aed.att_nm,att_nm_tmp);
} /* endif libnetCDF may have netCDF4 restrictions */
#endif /* !NCO_NETCDF4_AND_FILLVALUE */
switch(aed.mode){
case aed_append:
if(rcd == NC_NOERR){
/* Append to existing attribute value */
if(aed.type != att_typ){
(void)fprintf(stdout,"%s: ERROR %s attribute %s is of type %s not %s, unable to append\n",prg_nm_get(),var_nm,aed.att_nm,nco_typ_sng(att_typ),nco_typ_sng(aed.type));
nco_exit(EXIT_FAILURE);
} /* end if */
att_val_new=(void *)nco_malloc((att_sz+aed.sz)*nco_typ_lng(aed.type));
(void)nco_get_att(nc_id,var_id,aed.att_nm,(void *)att_val_new,aed.type);
/* NB: Following assumes sizeof(char) = 1 byte */
(void)memcpy((void *)((char *)att_val_new+att_sz*nco_typ_lng(aed.type)),
(void *)aed.val.vp,
aed.sz*nco_typ_lng(aed.type));
(void)nco_put_att(nc_id,var_id,aed.att_nm,aed.type,att_sz+aed.sz,att_val_new);
att_val_new=nco_free(att_val_new);
}else{
/* Create new attribute */
(void)nco_put_att(nc_id,var_id,aed.att_nm,aed.type,aed.sz,aed.val.vp);
} /* end else */
break;
case aed_create:
if(rcd != NC_NOERR) (void)nco_put_att(nc_id,var_id,aed.att_nm,aed.type,aed.sz,aed.val.vp);
break;
case aed_delete:
/* Delete specified attribute if attribute name was specified... */
if(aed.att_nm){
/* ...and if attribute is known to exist from previous inquire call... */
if(rcd == NC_NOERR) (void)nco_del_att(nc_id,var_id,aed.att_nm);
}else{
/* ...else delete all attributes for this variable... */
while(nbr_att){
(void)nco_inq_attname(nc_id,var_id,nbr_att-1,att_nm);
(void)nco_del_att(nc_id,var_id,att_nm);
nbr_att--;
} /* end while */
} /* end else */
break;
case aed_modify:
if(rcd == NC_NOERR) (void)nco_put_att(nc_id,var_id,aed.att_nm,aed.type,aed.sz,aed.val.vp);
break;
case aed_overwrite:
(void)nco_put_att(nc_id,var_id,aed.att_nm,aed.type,aed.sz,aed.val.vp);
break;
default:
break;
} /* end switch */
#ifdef NCO_NETCDF4_AND_FILLVALUE
if(flg_netCDF4 && !strcmp(aed.att_nm,att_nm_tmp) && aed.mode != aed_delete){
(void)nco_rename_att(nc_id,var_id,att_nm_tmp,nco_mss_val_sng_get());
/* Restore original name (space already allocated) */
strcpy(aed.att_nm,nco_mss_val_sng_get());
} /* !flg_netCDF4 */
#endif /* !NCO_NETCDF4_AND_FILLVALUE */
} /* end nco_aed_prc() */
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() */
int
main(int argc,char **argv)
{
char **fl_lst_abb=NULL; /* Option a */
char **fl_lst_in;
char **gaa_arg=NULL; /* [sng] Global attribute arguments */
char **var_lst_in=NULL_CEWI;
char *aux_arg[NC_MAX_DIMS];
char *cmd_ln;
char *cnk_arg[NC_MAX_DIMS];
char *cnk_map_sng=NULL_CEWI; /* [sng] Chunking map */
char *cnk_plc_sng=NULL_CEWI; /* [sng] Chunking policy */
char *fl_in=NULL;
char *fl_out=NULL; /* Option o */
char *fl_out_tmp=NULL; /* MPI CEWI */
char *fl_pth=NULL; /* Option p */
char *fl_pth_lcl=NULL; /* Option l */
char *lmt_arg[NC_MAX_DIMS];
char *opt_crr=NULL; /* [sng] String representation of current long-option name */
char *optarg_lcl=NULL; /* [sng] Local copy of system optarg */
char *rec_dmn_nm=NULL; /* [sng] New record dimension name */
char *sng_cnv_rcd=NULL_CEWI; /* [sng] strtol()/strtoul() return code */
const char * const CVS_Id="$Id$";
const char * const CVS_Revision="$Revision$";
const char * const opt_sht_lst="3467ACcD:d:FHhL:l:n:Oo:p:rRSt:u:v:X:x-:";
cnk_dmn_sct **cnk_dmn=NULL_CEWI;
dmn_sct *rec_dmn;
dmn_sct **dim;
dmn_sct **dmn_out;
extern char *optarg;
extern int optind;
/* Using naked stdin/stdout/stderr in parallel region generates warning
Copy appropriate filehandle to variable scoped shared in parallel clause */
FILE * const fp_stderr=stderr; /* [fl] stderr filehandle CEWI */
FILE * const fp_stdout=stdout; /* [fl] stdout filehandle CEWI */
int *in_id_arr;
int abb_arg_nbr=0;
int aux_nbr=0; /* [nbr] Number of auxiliary coordinate hyperslabs specified */
int cnk_map=nco_cnk_map_nil; /* [enm] Chunking map */
int cnk_nbr=0; /* [nbr] Number of chunk sizes */
int cnk_plc=nco_cnk_plc_nil; /* [enm] Chunking policy */
int dfl_lvl=NCO_DFL_LVL_UNDEFINED; /* [enm] Deflate level */
int fl_idx;
int fl_nbr=0;
int fl_in_fmt; /* [enm] Input file format */
int fl_out_fmt=NCO_FORMAT_UNDEFINED; /* [enm] Output file format */
int fll_md_old; /* [enm] Old fill mode */
int gaa_nbr=0; /* [nbr] Number of global attributes to add */
int idx;
int jdx;
int in_id;
int lmt_nbr=0; /* Option d. NB: lmt_nbr gets incremented */
int md_open; /* [enm] Mode flag for nc_open() call */
int nbr_dmn_fl;
int nbr_dmn_xtr;
int nbr_var_fix; /* nbr_var_fix gets incremented */
int nbr_var_fl;
int nbr_var_prc; /* nbr_var_prc gets incremented */
int xtr_nbr=0; /* xtr_nbr won't otherwise be set for -c with no -v */
int opt;
int out_id;
int rcd=NC_NOERR; /* [rcd] Return code */
int rec_dmn_id=NCO_REC_DMN_UNDEFINED;
int thr_idx; /* [idx] Index of current thread */
int thr_nbr=int_CEWI; /* [nbr] Thread number Option t */
int var_lst_in_nbr=0;
lmt_sct **aux=NULL_CEWI; /* Auxiliary coordinate limits */
lmt_sct **lmt;
lmt_all_sct **lmt_all_lst; /* List of *lmt_all structures */
long idx_rec_out=0L; /* idx_rec_out gets incremented */
nco_bool CNV_CCM_CCSM_CF;
nco_bool EXCLUDE_INPUT_LIST=False; /* Option c */
nco_bool EXTRACT_ALL_COORDINATES=False; /* Option c */
nco_bool EXTRACT_ASSOCIATED_COORDINATES=True; /* Option C */
nco_bool FL_RTR_RMT_LCN;
nco_bool FL_LST_IN_APPEND=True; /* Option H */
nco_bool FL_LST_IN_FROM_STDIN=False; /* [flg] fl_lst_in comes from stdin */
nco_bool FORCE_APPEND=False; /* Option A */
nco_bool FORCE_OVERWRITE=False; /* Option O */
nco_bool FORTRAN_IDX_CNV=False; /* Option F */
nco_bool HISTORY_APPEND=True; /* Option h */
nco_bool MSA_USR_RDR=False; /* [flg] Multi-Slab Algorithm returns hyperslabs in user-specified order */
nco_bool RAM_CREATE=False; /* [flg] Create file in RAM */
nco_bool RAM_OPEN=False; /* [flg] Open (netCDF3-only) file(s) in RAM */
nco_bool RM_RMT_FL_PST_PRC=True; /* Option R */
nco_bool WRT_TMP_FL=True; /* [flg] Write output to temporary file */
nco_bool flg_cln=False; /* [flg] Clean memory prior to exit */
nm_id_sct *dmn_lst;
nm_id_sct *xtr_lst=NULL; /* xtr_lst may be alloc()'d from NULL with -c option */
size_t bfr_sz_hnt=NC_SIZEHINT_DEFAULT; /* [B] Buffer size hint */
size_t cnk_min_byt=NCO_CNK_SZ_MIN_BYT_DFL; /* [B] Minimize size of variable to chunk */
size_t cnk_sz_byt=0UL; /* [B] Chunk size in bytes */
size_t cnk_sz_scl=0UL; /* [nbr] Chunk size scalar */
size_t hdr_pad=0UL; /* [B] Pad at end of header section */
var_sct **var;
var_sct **var_fix;
var_sct **var_fix_out;
var_sct **var_out;
var_sct **var_prc;
var_sct **var_prc_out;
#ifdef ENABLE_MPI
/* Declare all MPI-specific variables here */
MPI_Comm mpi_cmm=MPI_COMM_WORLD; /* [prc] Communicator */
MPI_Info mpi_nfo=MPI_INFO_NULL; /* [sct] File geometry hints */
MPI_Status mpi_stt; /* [enm] Status check to decode msg_tag_typ */
nco_bool TKN_WRT_FREE=True; /* [flg] Write-access to output file is available */
int fl_nm_lng; /* [nbr] Output file name length */
int msg_bfr[msg_bfr_lng]; /* [bfr] Buffer containing var, idx, tkn_wrt_rsp */
int msg_tag_typ; /* [enm] MPI message tag type */
int prc_rnk; /* [idx] Process rank */
int prc_nbr=0; /* [nbr] Number of MPI processes */
int tkn_wrt_rsp; /* [enm] Response to request for write token */
int var_wrt_nbr=0; /* [nbr] Variables written to output file until now */
int rnk_wrk; /* [idx] Worker rank */
int wrk_id_bfr[wrk_id_bfr_lng]; /* [bfr] Buffer for rnk_wrk */
#endif /* !ENABLE_MPI */
static struct option opt_lng[]={ /* Structure ordered by short option key if possible */
/* Long options with no argument, no short option counterpart */
{"cln",no_argument,0,0}, /* [flg] Clean memory prior to exit */
{"clean",no_argument,0,0}, /* [flg] Clean memory prior to exit */
{"mmr_cln",no_argument,0,0}, /* [flg] Clean memory prior to exit */
{"drt",no_argument,0,0}, /* [flg] Allow dirty memory on exit */
{"dirty",no_argument,0,0}, /* [flg] Allow dirty memory on exit */
{"mmr_drt",no_argument,0,0}, /* [flg] Allow dirty memory on exit */
{"msa_usr_rdr",no_argument,0,0}, /* [flg] Multi-Slab Algorithm returns hyperslabs in user-specified order */
{"msa_user_order",no_argument,0,0}, /* [flg] Multi-Slab Algorithm returns hyperslabs in user-specified order */
{"ram_all",no_argument,0,0}, /* [flg] Open (netCDF3) and create file(s) in RAM */
{"create_ram",no_argument,0,0}, /* [flg] Create file in RAM */
{"open_ram",no_argument,0,0}, /* [flg] Open (netCDF3) file(s) in RAM */
{"diskless_all",no_argument,0,0}, /* [flg] Open (netCDF3) and create file(s) in RAM */
{"wrt_tmp_fl",no_argument,0,0}, /* [flg] Write output to temporary file */
{"write_tmp_fl",no_argument,0,0}, /* [flg] Write output to temporary file */
{"no_tmp_fl",no_argument,0,0}, /* [flg] Do not write output to temporary file */
{"version",no_argument,0,0},
{"vrs",no_argument,0,0},
/* Long options with argument, no short option counterpart */
{"bfr_sz_hnt",required_argument,0,0}, /* [B] Buffer size hint */
{"buffer_size_hint",required_argument,0,0}, /* [B] Buffer size hint */
{"cnk_byt",required_argument,0,0}, /* [B] Chunk size in bytes */
{"chunk_byte",required_argument,0,0}, /* [B] Chunk size in bytes */
{"cnk_dmn",required_argument,0,0}, /* [nbr] Chunk size */
{"chunk_dimension",required_argument,0,0}, /* [nbr] Chunk size */
{"cnk_map",required_argument,0,0}, /* [nbr] Chunking map */
{"chunk_map",required_argument,0,0}, /* [nbr] Chunking map */
{"cnk_min",required_argument,0,0}, /* [B] Minimize size of variable to chunk */
{"chunk_min",required_argument,0,0}, /* [B] Minimize size of variable to chunk */
{"cnk_plc",required_argument,0,0}, /* [nbr] Chunking policy */
{"chunk_policy",required_argument,0,0}, /* [nbr] Chunking policy */
{"cnk_scl",required_argument,0,0}, /* [nbr] Chunk size scalar */
{"chunk_scalar",required_argument,0,0}, /* [nbr] Chunk size scalar */
{"fl_fmt",required_argument,0,0},
{"file_format",required_argument,0,0},
{"gaa",required_argument,0,0}, /* [sng] Global attribute add */
{"glb_att_add",required_argument,0,0}, /* [sng] Global attribute add */
{"hdr_pad",required_argument,0,0},
{"header_pad",required_argument,0,0},
/* Long options with short counterparts */
{"3",no_argument,0,'3'},
{"4",no_argument,0,'4'},
{"64bit",no_argument,0,'4'},
{"netcdf4",no_argument,0,'4'},
{"7",no_argument,0,'7'},
{"append",no_argument,0,'A'},
{"coords",no_argument,0,'c'},
{"crd",no_argument,0,'c'},
{"no-coords",no_argument,0,'C'},
{"no-crd",no_argument,0,'C'},
{"debug",required_argument,0,'D'},
{"nco_dbg_lvl",required_argument,0,'D'},
{"dimension",required_argument,0,'d'},
{"dmn",required_argument,0,'d'},
{"fortran",no_argument,0,'F'},
{"ftn",no_argument,0,'F'},
{"fl_lst_in",no_argument,0,'H'},
{"file_list",no_argument,0,'H'},
{"history",no_argument,0,'h'},
{"hst",no_argument,0,'h'},
{"dfl_lvl",required_argument,0,'L'}, /* [enm] Deflate level */
{"deflate",required_argument,0,'L'}, /* [enm] Deflate level */
{"local",required_argument,0,'l'},
{"lcl",required_argument,0,'l'},
{"nintap",required_argument,0,'n'},
{"overwrite",no_argument,0,'O'},
{"ovr",no_argument,0,'O'},
{"output",required_argument,0,'o'},
{"fl_out",required_argument,0,'o'},
{"path",required_argument,0,'p'},
{"retain",no_argument,0,'R'},
{"rtn",no_argument,0,'R'},
{"revision",no_argument,0,'r'},
{"suspend", no_argument,0,'S'},
{"thr_nbr",required_argument,0,'t'},
{"threads",required_argument,0,'t'},
{"omp_num_threads",required_argument,0,'t'},
{"ulm_nm",required_argument,0,'u'},
{"rcd_nm",required_argument,0,'u'},
{"variable",required_argument,0,'v'},
{"auxiliary",required_argument,0,'X'},
{"exclude",no_argument,0,'x'},
{"xcl",no_argument,0,'x'},
{"help",no_argument,0,'?'},
{"hlp",no_argument,0,'?'},
{0,0,0,0}
}; /* end opt_lng */
int opt_idx=0; /* Index of current long option into opt_lng array */
#ifdef ENABLE_MPI
/* MPI Initialization */
MPI_Init(&argc,&argv);
MPI_Comm_size(mpi_cmm,&prc_nbr);
MPI_Comm_rank(mpi_cmm,&prc_rnk);
#endif /* !ENABLE_MPI */
/* Start clock and save command line */
cmd_ln=nco_cmd_ln_sng(argc,argv);
/* Get program name and set program enum (e.g., nco_prg_id=ncra) */
nco_prg_nm=nco_prg_prs(argv[0],&nco_prg_id);
/* Parse command line arguments */
while(1){
/* getopt_long_only() allows one dash to prefix long options */
opt=getopt_long(argc,argv,opt_sht_lst,opt_lng,&opt_idx);
/* NB: access to opt_crr is only valid when long_opt is detected */
if(opt == EOF) break; /* Parse positional arguments once getopt_long() returns EOF */
opt_crr=(char *)strdup(opt_lng[opt_idx].name);
/* Process long options without short option counterparts */
if(opt == 0){
if(!strcmp(opt_crr,"bfr_sz_hnt") || !strcmp(opt_crr,"buffer_size_hint")){
bfr_sz_hnt=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10);
if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd);
} /* endif cnk */
if(!strcmp(opt_crr,"cnk_byt") || !strcmp(opt_crr,"chunk_byte")){
cnk_sz_byt=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10);
if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd);
} /* endif cnk_byt */
if(!strcmp(opt_crr,"cnk_min") || !strcmp(opt_crr,"chunk_min")){
cnk_min_byt=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10);
if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd);
} /* endif cnk_min */
if(!strcmp(opt_crr,"cnk_dmn") || !strcmp(opt_crr,"chunk_dimension")){
/* Copy limit argument for later processing */
cnk_arg[cnk_nbr]=(char *)strdup(optarg);
cnk_nbr++;
} /* endif cnk */
if(!strcmp(opt_crr,"cnk_scl") || !strcmp(opt_crr,"chunk_scalar")){
cnk_sz_scl=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10);
if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd);
} /* endif cnk */
if(!strcmp(opt_crr,"cnk_map") || !strcmp(opt_crr,"chunk_map")){
/* Chunking map */
cnk_map_sng=(char *)strdup(optarg);
cnk_map=nco_cnk_map_get(cnk_map_sng);
} /* endif cnk */
if(!strcmp(opt_crr,"cnk_plc") || !strcmp(opt_crr,"chunk_policy")){
/* Chunking policy */
cnk_plc_sng=(char *)strdup(optarg);
cnk_plc=nco_cnk_plc_get(cnk_plc_sng);
} /* endif cnk */
if(!strcmp(opt_crr,"cln") || !strcmp(opt_crr,"mmr_cln") || !strcmp(opt_crr,"clean")) flg_cln=True; /* [flg] Clean memory prior to exit */
if(!strcmp(opt_crr,"drt") || !strcmp(opt_crr,"mmr_drt") || !strcmp(opt_crr,"dirty")) flg_cln=False; /* [flg] Clean memory prior to exit */
if(!strcmp(opt_crr,"fl_fmt") || !strcmp(opt_crr,"file_format")) rcd=nco_create_mode_prs(optarg,&fl_out_fmt);
if(!strcmp(opt_crr,"gaa") || !strcmp(opt_crr,"glb_att_add")){
gaa_arg=(char **)nco_realloc(gaa_arg,(gaa_nbr+1)*sizeof(char *));
gaa_arg[gaa_nbr++]=(char *)strdup(optarg);
} /* endif gaa */
if(!strcmp(opt_crr,"hdr_pad") || !strcmp(opt_crr,"header_pad")){
hdr_pad=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10);
if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd);
} /* endif "hdr_pad" */
if(!strcmp(opt_crr,"msa_usr_rdr") || !strcmp(opt_crr,"msa_user_order")) MSA_USR_RDR=True; /* [flg] Multi-Slab Algorithm returns hyperslabs in user-specified order */
if(!strcmp(opt_crr,"ram_all") || !strcmp(opt_crr,"create_ram") || !strcmp(opt_crr,"diskless_all")) RAM_CREATE=True; /* [flg] Open (netCDF3) file(s) in RAM */
if(!strcmp(opt_crr,"ram_all") || !strcmp(opt_crr,"open_ram") || !strcmp(opt_crr,"diskless_all")) RAM_OPEN=True; /* [flg] Create file in RAM */
if(!strcmp(opt_crr,"vrs") || !strcmp(opt_crr,"version")){
(void)nco_vrs_prn(CVS_Id,CVS_Revision);
nco_exit(EXIT_SUCCESS);
} /* endif "vrs" */
if(!strcmp(opt_crr,"wrt_tmp_fl") || !strcmp(opt_crr,"write_tmp_fl")) WRT_TMP_FL=True;
if(!strcmp(opt_crr,"no_tmp_fl")) WRT_TMP_FL=False;
} /* opt != 0 */
/* Process short options */
switch(opt){
case 0: /* Long options have already been processed, return */
break;
case '3': /* Request netCDF3 output storage format */
fl_out_fmt=NC_FORMAT_CLASSIC;
break;
case '4': /* Catch-all to prescribe output storage format */
if(!strcmp(opt_crr,"64bit")) fl_out_fmt=NC_FORMAT_64BIT; else fl_out_fmt=NC_FORMAT_NETCDF4;
break;
case '6': /* Request netCDF3 64-bit offset output storage format */
fl_out_fmt=NC_FORMAT_64BIT;
break;
case '7': /* Request netCDF4-classic output storage format */
fl_out_fmt=NC_FORMAT_NETCDF4_CLASSIC;
break;
case 'A': /* Toggle FORCE_APPEND */
FORCE_APPEND=!FORCE_APPEND;
break;
case 'C': /* Extract all coordinates associated with extracted variables? */
EXTRACT_ASSOCIATED_COORDINATES=False;
break;
case 'c':
EXTRACT_ALL_COORDINATES=True;
break;
case 'D': /* Debugging level. Default is 0. */
nco_dbg_lvl=(unsigned short int)strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10);
if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd);
nc_set_log_level(nco_dbg_lvl);
break;
case 'd': /* Copy limit argument for later processing */
lmt_arg[lmt_nbr]=(char *)strdup(optarg);
lmt_nbr++;
break;
case 'F': /* Toggle index convention. Default is 0-based arrays (C-style). */
FORTRAN_IDX_CNV=!FORTRAN_IDX_CNV;
break;
case 'H': /* Toggle writing input file list attribute */
FL_LST_IN_APPEND=!FL_LST_IN_APPEND;
break;
case 'h': /* Toggle appending to history global attribute */
HISTORY_APPEND=!HISTORY_APPEND;
break;
case 'L': /* [enm] Deflate level. Default is 0. */
dfl_lvl=(int)strtol(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10);
if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtol",sng_cnv_rcd);
break;
case 'l': /* Local path prefix for files retrieved from remote file system */
fl_pth_lcl=(char *)strdup(optarg);
break;
case 'n': /* NINTAP-style abbreviation of files to process */
fl_lst_abb=nco_lst_prs_2D(optarg,",",&abb_arg_nbr);
if(abb_arg_nbr < 1 || abb_arg_nbr > 6){
(void)fprintf(stdout,"%s: ERROR Incorrect abbreviation for file list\n",nco_prg_nm);
(void)nco_usg_prn();
nco_exit(EXIT_FAILURE);
} /* end if */
break;
case 'O': /* Toggle FORCE_OVERWRITE */
FORCE_OVERWRITE=!FORCE_OVERWRITE;
break;
case 'o': /* Name of output file */
fl_out=(char *)strdup(optarg);
break;
case 'p': /* Common file path */
fl_pth=(char *)strdup(optarg);
break;
case 'R': /* Toggle removal of remotely-retrieved-files. Default is True. */
RM_RMT_FL_PST_PRC=!RM_RMT_FL_PST_PRC;
break;
case 'r': /* Print CVS program information and copyright notice */
(void)nco_vrs_prn(CVS_Id,CVS_Revision);
(void)nco_lbr_vrs_prn();
(void)nco_cpy_prn();
(void)nco_cnf_prn();
nco_exit(EXIT_SUCCESS);
break;
#ifdef ENABLE_MPI
case 'S': /* Suspend with signal handler to facilitate debugging */
if(signal(SIGUSR1,nco_cnt_run) == SIG_ERR) (void)fprintf(fp_stdout,"%s: ERROR Could not install suspend handler.\n",nco_prg_nm);
while(!nco_spn_lck_brk) usleep(nco_spn_lck_us); /* Spinlock. fxm: should probably insert a sched_yield */
break;
#endif /* !ENABLE_MPI */
case 't': /* Thread number */
thr_nbr=(int)strtol(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10);
if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtol",sng_cnv_rcd);
break;
case 'u': /* New record dimension name */
rec_dmn_nm=(char *)strdup(optarg);
break;
case 'v': /* Variables to extract/exclude */
/* Replace commas with hashes when within braces (convert back later) */
optarg_lcl=(char *)strdup(optarg);
(void)nco_rx_comma2hash(optarg_lcl);
var_lst_in=nco_lst_prs_2D(optarg_lcl,",",&var_lst_in_nbr);
optarg_lcl=(char *)nco_free(optarg_lcl);
xtr_nbr=var_lst_in_nbr;
break;
case 'X': /* Copy auxiliary coordinate argument for later processing */
aux_arg[aux_nbr]=(char *)strdup(optarg);
aux_nbr++;
MSA_USR_RDR=True; /* [flg] Multi-Slab Algorithm returns hyperslabs in user-specified order */
break;
case 'x': /* Exclude rather than extract variables specified with -v */
EXCLUDE_INPUT_LIST=True;
break;
case '?': /* Print proper usage */
(void)nco_usg_prn();
nco_exit(EXIT_SUCCESS);
break;
case '-': /* Long options are not allowed */
(void)fprintf(stderr,"%s: ERROR Long options are not available in this build. Use single letter options instead.\n",nco_prg_nm_get());
nco_exit(EXIT_FAILURE);
break;
default: /* Print proper usage */
(void)fprintf(stdout,"%s ERROR in command-line syntax/options. Please reformulate command accordingly.\n",nco_prg_nm_get());
(void)nco_usg_prn();
nco_exit(EXIT_FAILURE);
break;
} /* end switch */
if(opt_crr) opt_crr=(char *)nco_free(opt_crr);
} /* end while loop */
/* Process positional arguments and fill in filenames */
fl_lst_in=nco_fl_lst_mk(argv,argc,optind,&fl_nbr,&fl_out,&FL_LST_IN_FROM_STDIN);
/* Make uniform list of user-specified chunksizes */
if(cnk_nbr > 0) cnk_dmn=nco_cnk_prs(cnk_nbr,cnk_arg);
/* Make uniform list of user-specified dimension limits */
lmt=nco_lmt_prs(lmt_nbr,lmt_arg);
/* Initialize thread information */
thr_nbr=nco_openmp_ini(thr_nbr);
in_id_arr=(int *)nco_malloc(thr_nbr*sizeof(int));
/* Parse filename */
fl_in=nco_fl_nm_prs(fl_in,0,&fl_nbr,fl_lst_in,abb_arg_nbr,fl_lst_abb,fl_pth);
/* Make sure file is on local system and is readable or die trying */
fl_in=nco_fl_mk_lcl(fl_in,fl_pth_lcl,&FL_RTR_RMT_LCN);
/* Open file using appropriate buffer size hints and verbosity */
if(RAM_OPEN) md_open=NC_NOWRITE|NC_DISKLESS; else md_open=NC_NOWRITE;
rcd+=nco_fl_open(fl_in,md_open,&bfr_sz_hnt,&in_id);
/* Parse auxiliary coordinates */
if(aux_nbr > 0){
int aux_idx_nbr;
aux=nco_aux_evl(in_id,aux_nbr,aux_arg,&aux_idx_nbr);
if(aux_idx_nbr > 0){
lmt=(lmt_sct **)nco_realloc(lmt,(lmt_nbr+aux_idx_nbr)*sizeof(lmt_sct *));
int lmt_nbr_new=lmt_nbr+aux_idx_nbr;
int aux_idx=0;
for(int lmt_idx=lmt_nbr;lmt_idx<lmt_nbr_new;lmt_idx++) lmt[lmt_idx]=aux[aux_idx++];
lmt_nbr=lmt_nbr_new;
} /* endif aux */
} /* endif aux_nbr */
/* Get number of variables, dimensions, and record dimension ID of input file */
(void)nco_inq(in_id,&nbr_dmn_fl,&nbr_var_fl,(int *)NULL,&rec_dmn_id);
(void)nco_inq_format(in_id,&fl_in_fmt);
/* Form initial extraction list which may include extended regular expressions */
xtr_lst=nco_var_lst_mk(in_id,nbr_var_fl,var_lst_in,EXCLUDE_INPUT_LIST,EXTRACT_ALL_COORDINATES,&xtr_nbr);
/* Change included variables to excluded variables */
if(EXCLUDE_INPUT_LIST) xtr_lst=nco_var_lst_xcl(in_id,nbr_var_fl,xtr_lst,&xtr_nbr);
/* Is this a CCM/CCSM/CF-format history tape? */
CNV_CCM_CCSM_CF=nco_cnv_ccm_ccsm_cf_inq(in_id);
/* Add all coordinate variables to extraction list */
if(EXTRACT_ALL_COORDINATES) xtr_lst=nco_var_lst_crd_add(in_id,nbr_dmn_fl,nbr_var_fl,xtr_lst,&xtr_nbr,CNV_CCM_CCSM_CF);
/* Extract coordinates associated with extracted variables */
if(EXTRACT_ASSOCIATED_COORDINATES) xtr_lst=nco_var_lst_crd_ass_add(in_id,xtr_lst,&xtr_nbr,CNV_CCM_CCSM_CF);
/* Sort extraction list by variable ID for fastest I/O */
if(xtr_nbr > 1) xtr_lst=nco_lst_srt_nm_id(xtr_lst,xtr_nbr,False);
/* We now have final list of variables to extract. Phew. */
/* Find coordinate/dimension values associated with user-specified limits
NB: nco_lmt_evl() with same nc_id contains OpenMP critical region */
for(idx=0;idx<lmt_nbr;idx++) (void)nco_lmt_evl(in_id,lmt[idx],0L,FORTRAN_IDX_CNV);
/* Place all dimensions in lmt_all_lst */
lmt_all_lst=(lmt_all_sct **)nco_malloc(nbr_dmn_fl*sizeof(lmt_all_sct *));
/* Initialize lmt_all_sct's */
(void)nco_msa_lmt_all_ntl(in_id,MSA_USR_RDR,lmt_all_lst,nbr_dmn_fl,lmt,lmt_nbr);
/* Find dimensions associated with variables to be extracted */
dmn_lst=nco_dmn_lst_ass_var(in_id,xtr_lst,xtr_nbr,&nbr_dmn_xtr);
/* Fill-in dimension structure for all extracted dimensions */
dim=(dmn_sct **)nco_malloc(nbr_dmn_xtr*sizeof(dmn_sct *));
for(idx=0;idx<nbr_dmn_xtr;idx++) dim[idx]=nco_dmn_fll(in_id,dmn_lst[idx].id,dmn_lst[idx].nm);
/* Dimension list no longer needed */
dmn_lst=nco_nm_id_lst_free(dmn_lst,nbr_dmn_xtr);
/* Merge hyperslab limit information into dimension structures */
if(lmt_nbr > 0) (void)nco_dmn_lmt_mrg(dim,nbr_dmn_xtr,lmt,lmt_nbr);
/* Duplicate input dimension structures for output dimension structures */
dmn_out=(dmn_sct **)nco_malloc(nbr_dmn_xtr*sizeof(dmn_sct *));
for(idx=0;idx<nbr_dmn_xtr;idx++){
dmn_out[idx]=nco_dmn_dpl(dim[idx]);
(void)nco_dmn_xrf(dim[idx],dmn_out[idx]);
} /* end loop over idx */
/* Fill-in variable structure list for all extracted variables */
var=(var_sct **)nco_malloc(xtr_nbr*sizeof(var_sct *));
var_out=(var_sct **)nco_malloc(xtr_nbr*sizeof(var_sct *));
for(idx=0;idx<xtr_nbr;idx++){
var[idx]=nco_var_fll(in_id,xtr_lst[idx].id,xtr_lst[idx].nm,dim,nbr_dmn_xtr);
var_out[idx]=nco_var_dpl(var[idx]);
(void)nco_xrf_var(var[idx],var_out[idx]);
(void)nco_xrf_dmn(var_out[idx]);
} /* end loop over idx */
/* Extraction list no longer needed */
xtr_lst=nco_nm_id_lst_free(xtr_lst,xtr_nbr);
/* Divide variable lists into lists of fixed variables and variables to be processed */
(void)nco_var_lst_dvd(var,var_out,xtr_nbr,CNV_CCM_CCSM_CF,True,nco_pck_plc_nil,nco_pck_map_nil,(dmn_sct **)NULL,0,&var_fix,&var_fix_out,&nbr_var_fix,&var_prc,&var_prc_out,&nbr_var_prc);
#ifdef ENABLE_MPI
if(prc_rnk == rnk_mgr){ /* MPI manager code */
#endif /* !ENABLE_MPI */
/* Make output and input files consanguinous */
if(fl_out_fmt == NCO_FORMAT_UNDEFINED) fl_out_fmt=fl_in_fmt;
/* Verify output file format supports requested actions */
(void)nco_fl_fmt_vet(fl_out_fmt,cnk_nbr,dfl_lvl);
/* Open output file */
fl_out_tmp=nco_fl_out_open(fl_out,FORCE_APPEND,FORCE_OVERWRITE,fl_out_fmt,&bfr_sz_hnt,RAM_CREATE,RAM_OPEN,WRT_TMP_FL,&out_id);
/* Copy global attributes */
(void)nco_att_cpy(in_id,out_id,NC_GLOBAL,NC_GLOBAL,(nco_bool)True);
/* Catenate time-stamped command line to "history" global attribute */
if(HISTORY_APPEND) (void)nco_hst_att_cat(out_id,cmd_ln);
if(HISTORY_APPEND && FORCE_APPEND) (void)nco_prv_att_cat(fl_in,in_id,out_id);
if(gaa_nbr > 0) (void)nco_glb_att_add(out_id,gaa_arg,gaa_nbr);
if(HISTORY_APPEND) (void)nco_vrs_att_cat(out_id);
if(thr_nbr > 0 && HISTORY_APPEND) (void)nco_thr_att_cat(out_id,thr_nbr);
#ifdef ENABLE_MPI
/* Initialize MPI task information */
if(prc_nbr > 0 && HISTORY_APPEND) (void)nco_mpi_att_cat(out_id,prc_nbr);
#endif /* !ENABLE_MPI */
/* Add input file list global attribute */
if(FL_LST_IN_APPEND && HISTORY_APPEND && FL_LST_IN_FROM_STDIN) (void)nco_fl_lst_att_cat(out_id,fl_lst_in,fl_nbr);
#ifdef ENABLE_MPI
} /* prc_rnk != rnk_mgr */
#endif /* !ENABLE_MPI */
/* ncecat-specific operations */
if(True){
/* Always construct new "record" dimension from scratch */
rec_dmn=(dmn_sct *)nco_malloc(sizeof(dmn_sct));
if(rec_dmn_nm == NULL) rec_dmn->nm=rec_dmn_nm=(char *)strdup("record"); else rec_dmn->nm=rec_dmn_nm;
rec_dmn->id=-1;
rec_dmn->nc_id=-1;
rec_dmn->xrf=NULL;
rec_dmn->val.vp=NULL;
rec_dmn->is_crd_dmn=False;
rec_dmn->is_rec_dmn=True;
rec_dmn->sz=0L;
rec_dmn->cnt=0L;
rec_dmn->srd=0L;
rec_dmn->srt=0L;
rec_dmn->end=rec_dmn->sz-1L;
/* Change existing record dimension, if any, to regular dimension */
for(idx=0;idx<nbr_dmn_xtr;idx++){
/* Is any input dimension a record dimension? */
if(dmn_out[idx]->is_rec_dmn){
dmn_out[idx]->is_rec_dmn=False;
break;
} /* end if */
} /* end loop over idx */
/* Add record dimension to end of dimension list */
nbr_dmn_xtr++;
dmn_out=(dmn_sct **)nco_realloc(dmn_out,nbr_dmn_xtr*sizeof(dmn_sct **));
dmn_out[nbr_dmn_xtr-1]=rec_dmn;
} /* end if */
#ifdef ENABLE_MPI
if(prc_rnk == rnk_mgr){ /* MPI manager code */
#endif /* !ENABLE_MPI */
/* Define dimensions in output file */
(void)nco_dmn_dfn(fl_out,out_id,dmn_out,nbr_dmn_xtr);
#ifdef ENABLE_MPI
} /* prc_rnk != rnk_mgr */
#endif /* !ENABLE_MPI */
if(True){
/* Prepend record dimension to beginning of all vectors for processed variables */
for(idx=0;idx<nbr_var_prc;idx++){
var_prc_out[idx]->nbr_dim++;
var_prc_out[idx]->is_rec_var=True;
var_prc_out[idx]->sz_rec=var_prc_out[idx]->sz;
/* Allocate space to hold dimension IDs */
var_prc_out[idx]->dim=(dmn_sct **)nco_realloc(var_prc_out[idx]->dim,var_prc_out[idx]->nbr_dim*sizeof(dmn_sct *));
var_prc_out[idx]->dmn_id=(int *)nco_realloc(var_prc_out[idx]->dmn_id,var_prc_out[idx]->nbr_dim*sizeof(int));
var_prc_out[idx]->cnt=(long *)nco_realloc(var_prc_out[idx]->cnt,var_prc_out[idx]->nbr_dim*sizeof(long int));
var_prc_out[idx]->end=(long *)nco_realloc(var_prc_out[idx]->end,var_prc_out[idx]->nbr_dim*sizeof(long int));
var_prc_out[idx]->srd=(long *)nco_realloc(var_prc_out[idx]->srd,var_prc_out[idx]->nbr_dim*sizeof(long int));
var_prc_out[idx]->srt=(long *)nco_realloc(var_prc_out[idx]->srt,var_prc_out[idx]->nbr_dim*sizeof(long int));
/* Move current array by one to make room for new record dimension info */
(void)memmove((void *)(var_prc_out[idx]->dim+1),(void *)(var_prc_out[idx]->dim),(var_prc_out[idx]->nbr_dim-1)*sizeof(dmn_sct *));
(void)memmove((void *)(var_prc_out[idx]->dmn_id+1),(void *)(var_prc_out[idx]->dmn_id),(var_prc_out[idx]->nbr_dim-1)*sizeof(int));
(void)memmove((void *)(var_prc_out[idx]->cnt+1),(void *)(var_prc_out[idx]->cnt),(var_prc_out[idx]->nbr_dim-1)*sizeof(long int));
(void)memmove((void *)(var_prc_out[idx]->end+1),(void *)(var_prc_out[idx]->end),(var_prc_out[idx]->nbr_dim-1)*sizeof(long int));
(void)memmove((void *)(var_prc_out[idx]->srd+1),(void *)(var_prc_out[idx]->srd),(var_prc_out[idx]->nbr_dim-1)*sizeof(long int));
(void)memmove((void *)(var_prc_out[idx]->srt+1),(void *)(var_prc_out[idx]->srt),(var_prc_out[idx]->nbr_dim-1)*sizeof(long int));
/* Insert value for new record dimension */
var_prc_out[idx]->dim[0]=rec_dmn;
var_prc_out[idx]->dmn_id[0]=rec_dmn->id;
var_prc_out[idx]->cnt[0]=1L;
var_prc_out[idx]->end[0]=-1L;
var_prc_out[idx]->srd[0]=-1L;
var_prc_out[idx]->srt[0]=-1L;
} /* end loop over idx */
} /* end if */
#ifdef ENABLE_MPI
if(prc_rnk == rnk_mgr){ /* MPI manager code */
#endif /* !ENABLE_MPI */
/* Define variables in output file, copy their attributes */
(void)nco_var_dfn(in_id,fl_out,out_id,var_out,xtr_nbr,(dmn_sct **)NULL,(int)0,nco_pck_plc_nil,nco_pck_map_nil,dfl_lvl);
#ifdef ENABLE_MPI
} /* prc_rnk != rnk_mgr */
#endif /* !ENABLE_MPI */
/* Assign zero to start and unity to stride vectors in output variables */
(void)nco_var_srd_srt_set(var_out,xtr_nbr);
#ifdef ENABLE_MPI
if(prc_rnk == rnk_mgr){ /* prc_rnk != rnk_mgr */
#endif /* !ENABLE_MPI */
/* Set chunksize parameters */
if(fl_out_fmt == NC_FORMAT_NETCDF4 || fl_out_fmt == NC_FORMAT_NETCDF4_CLASSIC) (void)nco_cnk_sz_set(out_id,lmt_all_lst,nbr_dmn_fl,&cnk_map,&cnk_plc,cnk_sz_scl,cnk_dmn,cnk_nbr);
/* Turn-off default filling behavior to enhance efficiency */
nco_set_fill(out_id,NC_NOFILL,&fll_md_old);
/* Take output file out of define mode */
if(hdr_pad == 0UL){
(void)nco_enddef(out_id);
}else{
(void)nco__enddef(out_id,hdr_pad);
if(nco_dbg_lvl >= nco_dbg_scl) (void)fprintf(stderr,"%s: INFO Padding header with %lu extra bytes\n",nco_prg_nm_get(),(unsigned long)hdr_pad);
} /* hdr_pad */
#ifdef ENABLE_MPI
} /* prc_rnk != rnk_mgr */
/* Manager obtains output filename and broadcasts to workers */
if(prc_rnk == rnk_mgr) fl_nm_lng=(int)strlen(fl_out_tmp);
MPI_Bcast(&fl_nm_lng,1,MPI_INT,0,mpi_cmm);
if(prc_rnk != rnk_mgr) fl_out_tmp=(char *)nco_malloc((fl_nm_lng+1)*sizeof(char));
MPI_Bcast(fl_out_tmp,fl_nm_lng+1,MPI_CHAR,0,mpi_cmm);
if(prc_rnk == rnk_mgr){ /* MPI manager code */
TKN_WRT_FREE=False;
#endif /* !ENABLE_MPI */
/* Copy variable data for non-processed variables */
(void)nco_var_val_cpy(in_id,out_id,var_fix,nbr_var_fix);
#ifdef ENABLE_MPI
/* Close output file so workers can open it */
nco_close(out_id);
TKN_WRT_FREE=True;
} /* prc_rnk != rnk_mgr */
#endif /* !ENABLE_MPI */
/* Close first input netCDF file */
(void)nco_close(in_id);
/* Loop over input files */
for(fl_idx=0;fl_idx<fl_nbr;fl_idx++){
#ifdef ENABLE_MPI
MPI_Barrier(mpi_cmm);
#endif /* !ENABLE_MPI */
/* Parse filename */
if(fl_idx != 0) fl_in=nco_fl_nm_prs(fl_in,fl_idx,(int *)NULL,fl_lst_in,abb_arg_nbr,fl_lst_abb,fl_pth);
if(nco_dbg_lvl >= nco_dbg_fl) (void)fprintf(fp_stderr,"\nInput file %d is %s; ",fl_idx,fl_in);
/* Make sure file is on local system and is readable or die trying */
if(fl_idx != 0) fl_in=nco_fl_mk_lcl(fl_in,fl_pth_lcl,&FL_RTR_RMT_LCN);
if(nco_dbg_lvl >= nco_dbg_fl) (void)fprintf(fp_stderr,"local file %s:\n",fl_in);
/* Open file once per thread to improve caching */
for(thr_idx=0;thr_idx<thr_nbr;thr_idx++) rcd=nco_fl_open(fl_in,md_open,&bfr_sz_hnt,in_id_arr+thr_idx);
#if 0
/* fxm: netCDF4: Change to independent variable reads? */
#ifdef ENABLE_NETCDF4
rcd=nco_open_par(fl_in,NC_MPIIO|NC_NETCDF4,mpi_cmm,mpi_nfo,&in_id);
#endif /* !ENABLE_NETCDF4 */
#endif /* !0 */
/* Perform various error-checks on input file */
if(False) (void)nco_fl_cmp_err_chk();
#ifdef ENABLE_MPI
if(prc_rnk == rnk_mgr){ /* MPI manager code */
/* Compensate for incrementing on each worker's first message */
var_wrt_nbr=-prc_nbr+1;
idx=0;
/* While variables remain to be processed or written... */
while(var_wrt_nbr < nbr_var_prc){
/* Receive message from any worker */
MPI_Recv(wrk_id_bfr,wrk_id_bfr_lng,MPI_INT,MPI_ANY_SOURCE,MPI_ANY_TAG,mpi_cmm,&mpi_stt);
/* Obtain MPI message tag type */
msg_tag_typ=mpi_stt.MPI_TAG;
/* Get sender's prc_rnk */
rnk_wrk=wrk_id_bfr[0];
/* Allocate next variable, if any, to worker */
if(msg_tag_typ == msg_tag_wrk_rqs){
var_wrt_nbr++; /* [nbr] Number of variables written */
/* Worker closed output file before sending msg_tag_wrk_rqs */
TKN_WRT_FREE=True;
if(idx > nbr_var_prc-1){
msg_bfr[0]=idx_all_wrk_ass; /* [enm] All variables already assigned */
msg_bfr[1]=out_id; /* Output file ID */
}else{
/* Tell requesting worker to allocate space for next variable */
msg_bfr[0]=idx; /* [idx] Variable to be processed */
msg_bfr[1]=out_id; /* Output file ID */
msg_bfr[2]=var_prc_out[idx]->id; /* [id] Variable ID in output file */
/* Point to next variable on list */
idx++;
} /* endif idx */
MPI_Send(msg_bfr,msg_bfr_lng,MPI_INT,rnk_wrk,msg_tag_wrk_rsp,mpi_cmm);
/* msg_tag_typ != msg_tag_wrk_rqs */
}else if(msg_tag_typ == msg_tag_tkn_wrt_rqs){
/* Allocate token if free, else ask worker to try later */
if(TKN_WRT_FREE){
TKN_WRT_FREE=False;
msg_bfr[0]=tkn_wrt_rqs_xcp; /* Accept request for write token */
}else{
msg_bfr[0]=tkn_wrt_rqs_dny; /* Deny request for write token */
} /* !TKN_WRT_FREE */
MPI_Send(msg_bfr,msg_bfr_lng,MPI_INT,rnk_wrk,msg_tag_tkn_wrt_rsp,mpi_cmm);
} /* msg_tag_typ != msg_tag_tkn_wrt_rqs */
} /* end while var_wrt_nbr < nbr_var_prc */
}else{ /* prc_rnk != rnk_mgr, end Manager code begin Worker code */
wrk_id_bfr[0]=prc_rnk;
while(1){ /* While work remains... */
/* Send msg_tag_wrk_rqs */
wrk_id_bfr[0]=prc_rnk;
MPI_Send(wrk_id_bfr,wrk_id_bfr_lng,MPI_INT,rnk_mgr,msg_tag_wrk_rqs,mpi_cmm);
/* Receive msg_tag_wrk_rsp */
MPI_Recv(msg_bfr,msg_bfr_lng,MPI_INT,0,msg_tag_wrk_rsp,mpi_cmm,&mpi_stt);
idx=msg_bfr[0];
out_id=msg_bfr[1];
if(idx == idx_all_wrk_ass) break;
else{
var_prc_out[idx]->id=msg_bfr[2];
/* Process this variable same as UP code */
#else /* !ENABLE_MPI */
/* OpenMP with threading over variables, not files */
#ifdef _OPENMP
#pragma omp parallel for default(none) private(idx,in_id) shared(nco_dbg_lvl,fl_nbr,idx_rec_out,in_id_arr,nbr_var_prc,out_id,var_prc,var_prc_out,lmt_all_lst,nbr_dmn_fl,jdx)
#endif /* !_OPENMP */
/* Process all variables in current file */
for(idx=0;idx<nbr_var_prc;idx++){
#endif /* !ENABLE_MPI */
/* Common code for UP and MPI */ /* fxm: requires C99 as is? */
in_id=in_id_arr[omp_get_thread_num()];
if(nco_dbg_lvl >= nco_dbg_var) (void)fprintf(fp_stderr,"%s, ",var_prc[idx]->nm);
if(nco_dbg_lvl >= nco_dbg_var) (void)fflush(fp_stderr);
/* Variables may have different ID, missing_value, type, in each file */
(void)nco_var_mtd_refresh(in_id,var_prc[idx]);
/* Retrieve variable from disk into memory */
/* NB: nco_var_get() with same nc_id contains OpenMP critical region */
(void)nco_var_get(in_id,var_prc[idx]);
/* Size of record dimension is 1 in output file */
var_prc_out[idx]->cnt[0]=1L;
var_prc_out[idx]->srt[0]=idx_rec_out;
#ifdef ENABLE_MPI
/* Obtain token and prepare to write */
while(1){ /* Send msg_tag_tkn_wrt_rqs repeatedly until token obtained */
wrk_id_bfr[0]=prc_rnk;
MPI_Send(wrk_id_bfr,wrk_id_bfr_lng,MPI_INT,rnk_mgr,msg_tag_tkn_wrt_rqs,mpi_cmm);
MPI_Recv(msg_bfr,msg_bfr_lng,MPI_INT,rnk_mgr,msg_tag_tkn_wrt_rsp,mpi_cmm,&mpi_stt);
tkn_wrt_rsp=msg_bfr[0];
/* Wait then re-send request */
if(tkn_wrt_rsp == tkn_wrt_rqs_dny) sleep(tkn_wrt_rqs_ntv); else break;
} /* end while loop waiting for write token */
/* Worker has token---prepare to write */
if(tkn_wrt_rsp == tkn_wrt_rqs_xcp){
if(RAM_OPEN) md_open=NC_WRITE|NC_SHARE|NC_DISKLESS; else md_open=NC_WRITE|NC_SHARE;
rcd=nco_fl_open(fl_out_tmp,md_open,&bfr_sz_hnt,&out_id);
/* Set chunksize parameters */
if(fl_out_fmt == NC_FORMAT_NETCDF4 || fl_out_fmt == NC_FORMAT_NETCDF4_CLASSIC) (void)nco_cnk_sz_set(out_id,lmt_all_lst,nbr_dmn_fl,&cnk_map,&cnk_plc,cnk_sz_scl,cnk_dmn,cnk_nbr);
/* Turn-off default filling behavior to enhance efficiency */
nco_set_fill(out_id,NC_NOFILL,&fll_md_old);
#else /* !ENABLE_MPI */
#ifdef _OPENMP
#pragma omp critical
#endif /* _OPENMP */
#endif /* !ENABLE_MPI */
{ /* begin OpenMP critical */
/* Write variable into current record in output file */
if(var_prc[idx]->nbr_dim == 0){
(void)nco_put_var1(out_id,var_prc_out[idx]->id,var_prc_out[idx]->srt,var_prc[idx]->val.vp,var_prc[idx]->type);
}else{ /* end if variable is scalar */
(void)nco_put_vara(out_id,var_prc_out[idx]->id,var_prc_out[idx]->srt,var_prc_out[idx]->cnt,var_prc[idx]->val.vp,var_prc[idx]->type);
} /* end if variable is array */
/* Free current input buffer */
var_prc[idx]->val.vp=nco_free(var_prc[idx]->val.vp);
} /* end OpenMP critical */
#ifdef ENABLE_MPI
/* Close output file and increment written counter */
nco_close(out_id);
var_wrt_nbr++;
} /* endif tkn_wrt_rqs_xcp */
} /* end else !idx_all_wrk_ass */
} /* end while loop requesting work/token */
} /* endif Worker */
#else /* !ENABLE_MPI */
} /* end (OpenMP parallel for) loop over idx */
#endif /* !ENABLE_MPI */
idx_rec_out++; /* [idx] Index of current record in output file (0 is first, ...) */
if(nco_dbg_lvl > nco_dbg_scl) (void)fprintf(stderr,"\n");
/* Close input netCDF file */
for(thr_idx=0;thr_idx<thr_nbr;thr_idx++) nco_close(in_id_arr[thr_idx]);
/* Remove local copy of file */
if(FL_RTR_RMT_LCN && RM_RMT_FL_PST_PRC) (void)nco_fl_rm(fl_in);
#ifdef ENABLE_MPI
MPI_Barrier(mpi_cmm);
#endif /* !ENABLE_MPI */
} /* end loop over fl_idx */
#ifdef ENABLE_MPI
/* Manager moves output file (closed by workers) from temporary to permanent location */
if(prc_rnk == rnk_mgr) (void)nco_fl_mv(fl_out_tmp,fl_out);
#else /* !ENABLE_MPI */
/* Close output file and move it from temporary to permanent location */
(void)nco_fl_out_cls(fl_out,fl_out_tmp,out_id);
#endif /* end !ENABLE_MPI */
/* Clean memory unless dirty memory allowed */
if(flg_cln){
/* ncecat-specific memory cleanup */
if(rec_dmn_nm) rec_dmn_nm=(char *)nco_free(rec_dmn_nm);
/* NB: free lmt[] is now referenced within lmt_all_lst[idx] */
for(idx=0;idx<nbr_dmn_fl;idx++)
for(jdx=0;jdx<lmt_all_lst[idx]->lmt_dmn_nbr;jdx++)
lmt_all_lst[idx]->lmt_dmn[jdx]=nco_lmt_free(lmt_all_lst[idx]->lmt_dmn[jdx]);
lmt=(lmt_sct**)nco_free(lmt);
if(nbr_dmn_fl > 0) lmt_all_lst=nco_lmt_all_lst_free(lmt_all_lst,nbr_dmn_fl);
/* NCO-generic clean-up */
/* Free individual strings/arrays */
if(cmd_ln) cmd_ln=(char *)nco_free(cmd_ln);
if(cnk_map_sng) cnk_map_sng=(char *)nco_free(cnk_map_sng);
if(cnk_plc_sng) cnk_plc_sng=(char *)nco_free(cnk_plc_sng);
if(fl_in) fl_in=(char *)nco_free(fl_in);
if(fl_out) fl_out=(char *)nco_free(fl_out);
if(fl_out_tmp) fl_out_tmp=(char *)nco_free(fl_out_tmp);
if(fl_pth) fl_pth=(char *)nco_free(fl_pth);
if(fl_pth_lcl) fl_pth_lcl=(char *)nco_free(fl_pth_lcl);
if(in_id_arr) in_id_arr=(int *)nco_free(in_id_arr);
/* Free lists of strings */
if(fl_lst_in && fl_lst_abb == NULL) fl_lst_in=nco_sng_lst_free(fl_lst_in,fl_nbr);
if(fl_lst_in && fl_lst_abb) fl_lst_in=nco_sng_lst_free(fl_lst_in,1);
if(fl_lst_abb) fl_lst_abb=nco_sng_lst_free(fl_lst_abb,abb_arg_nbr);
if(gaa_nbr > 0) gaa_arg=nco_sng_lst_free(gaa_arg,gaa_nbr);
if(var_lst_in_nbr > 0) var_lst_in=nco_sng_lst_free(var_lst_in,var_lst_in_nbr);
/* Free limits */
for(idx=0;idx<lmt_nbr;idx++) lmt_arg[idx]=(char *)nco_free(lmt_arg[idx]);
for(idx=0;idx<aux_nbr;idx++) aux_arg[idx]=(char *)nco_free(aux_arg[idx]);
if(aux_nbr > 0) aux=(lmt_sct **)nco_free(aux);
/* Free chunking information */
for(idx=0;idx<cnk_nbr;idx++) cnk_arg[idx]=(char *)nco_free(cnk_arg[idx]);
if(cnk_nbr > 0) cnk_dmn=nco_cnk_lst_free(cnk_dmn,cnk_nbr);
/* Free dimension lists */
if(nbr_dmn_xtr > 0) dim=nco_dmn_lst_free(dim,nbr_dmn_xtr-1); /* NB: ncecat has one fewer input than output dimension */
if(nbr_dmn_xtr > 0) dmn_out=nco_dmn_lst_free(dmn_out,nbr_dmn_xtr);
/* Free variable lists */
if(xtr_nbr > 0) var=nco_var_lst_free(var,xtr_nbr);
if(xtr_nbr > 0) var_out=nco_var_lst_free(var_out,xtr_nbr);
var_prc=(var_sct **)nco_free(var_prc);
var_prc_out=(var_sct **)nco_free(var_prc_out);
var_fix=(var_sct **)nco_free(var_fix);
var_fix_out=(var_sct **)nco_free(var_fix_out);
} /* !flg_cln */
#ifdef ENABLE_MPI
MPI_Finalize();
#endif /* !ENABLE_MPI */
if(rcd != NC_NOERR) nco_err_exit(rcd,"main");
nco_exit_gracefully();
return EXIT_SUCCESS;
} /* end main() */
