[cmor] 58/190: 2010-09-29 : Cleaned up error messages, now tries to output var/axis it was working on as well as table used. 2010-09-29 : When value that exceeds valid_min/max is found, now returns location of extreme point instead of first point encountered, as well as actuall coordinates values (not just indices)
Alastair McKinstry
mckinstry at moszumanska.debian.org
Tue Jul 21 12:54:37 UTC 2015
This is an automated email from the git hooks/post-receive script.
mckinstry pushed a commit to branch debian/master
in repository cmor.
commit 230a82302a871769ae849002e6aafc8d084aa110
Author: Charles Doutriaux <doutriaux1 at llnl.gov>
Date: Wed Sep 29 14:21:02 2010 -0700
2010-09-29 : Cleaned up error messages, now tries to output var/axis it was working on as well as table used.
2010-09-29 : When value that exceeds valid_min/max is found, now returns location of extreme point instead of first point encountered, as well as actuall coordinates values (not just indices)
---
RELEASE-NOTES | 2 +
Src/cmor.c | 236 ++++++++++++++++++-------------------
Src/cmor_axes.c | 128 ++++++++++----------
Src/cmor_grids.c | 2 +-
Src/cmor_tables.c | 30 +++--
Src/cmor_variables.c | 205 +++++++++++++++++---------------
Test/cmor_speed_and_compression.py | 1 +
7 files changed, 314 insertions(+), 290 deletions(-)
diff --git a/RELEASE-NOTES b/RELEASE-NOTES
index ae2c39f..ddd772d 100644
--- a/RELEASE-NOTES
+++ b/RELEASE-NOTES
@@ -1,3 +1,5 @@
+2010-09-29 : Cleaned up error messages, now tries to output var/axis it was working on as well as table used.
+2010-09-29 : When value that exceeds valid_min/max is found, now returns location of extreme point instead of first point encountered, as well as actuall coordinates values (not just indices)
2010-09-22 : Joerg found a bug that was due to checking only the refvar.dimension w/o checking the actual tables as well
2010-09-01 : fixed a bug on mac 32bit when reading in net3 version string
2010-09-01 : some vars with grid and singleton dims were wrongly analyzed by cmor_variable has not being defined with the right number of dimmensions.
diff --git a/Src/cmor.c b/Src/cmor.c
index d3e9cc6..46eaefc 100644
--- a/Src/cmor.c
+++ b/Src/cmor.c
@@ -82,7 +82,7 @@ void cmor_check_forcing_validity(int table_id,char *value) {
}
}
if (found==0) {
- sprintf(msg,"forcing attribute elt %i (%s) is not valid, valid values are:",i,bstr[i]);
+ sprintf(msg,"forcing attribute elt %i (%s) is not valid for table %s, valid values are:",i,bstr[i],cmor_tables[table_id].table_id);
for(j=0;j<cmor_tables[table_id].nforcings;j++) {
strncat(msg," ",CMOR_MAX_STRING);
strncat(msg,cmor_tables[table_id].forcings[j],CMOR_MAX_STRING);
@@ -242,7 +242,7 @@ void cmor_is_setup(void){
extern void cmor_handle_error(char error_msg[CMOR_MAX_STRING],int level);
cmor_add_traceback("cmor_is_setup");
if (CMOR_HAS_BEEN_SETUP==0) {
- snprintf(msg,CMOR_MAX_STRING,"Error you need to run cmor_setup before calling any cmor_function");
+ snprintf(msg,CMOR_MAX_STRING,"You need to run cmor_setup before calling any cmor_function");
cmor_handle_error(msg,CMOR_CRITICAL);
}
cmor_pop_traceback();
@@ -347,7 +347,7 @@ int cmor_have_NetCDF3(void) {
strncpy(version,nc_inq_libvers(),50);
if (version[0]!='"') return 1;
sscanf(version,"%*c%1d%*s",&major);
- if (major!=3) { printf("not nc3 returned\n");return 1;}
+ if (major!=3) return 1;
return 0;
}
int cmor_have_NetCDF363(void) {
@@ -809,7 +809,7 @@ int cmor_put_nc_num_attribute(int ncid,int nc_var_id,char *name, char type, doub
ierr = nc_put_att_double(ncid,nc_var_id,name,NC_DOUBLE,1,&value);
}
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) setting numerical attribute %s on variable (%s)",ierr,name,var_name);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) setting numerical attribute %s on variable %s",ierr,nc_strerror(ierr),name,var_name);
cmor_handle_error(msg,CMOR_CRITICAL);
}
cmor_pop_traceback();
@@ -825,7 +825,7 @@ int cmor_put_nc_char_attribute(int ncid,int nc_var_id,char *name,char *value,cha
value[k]='\0';
ierr = nc_put_att_text(ncid,nc_var_id,name,k+1,value);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) setting attribute: '%s' on variable (%s)",ierr,name,var_name);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) setting attribute: '%s' on variable (%s)",ierr,nc_strerror(ierr),name,var_name);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -840,8 +840,8 @@ int cmor_set_cur_dataset_attribute(char *name, char *value, int optional) {
cmor_add_traceback("cmor_set_cur_dataset_attribute");
cmor_is_setup();
cmor_trim_string(value,msg);
- if (strlen(name)>CMOR_MAX_STRING) {
- snprintf(msg,CMOR_MAX_STRING,"CMOR Dataset error, %s length is greater than limit: %i", name, CMOR_MAX_STRING);
+ if ((int)strlen(name)>CMOR_MAX_STRING) {
+ snprintf(msg,CMOR_MAX_STRING,"CMOR Dataset error, attribute name: %s; length (%i) is greater than limit: %i", name, (int)strlen(name),CMOR_MAX_STRING);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -868,7 +868,7 @@ int cmor_set_cur_dataset_attribute(char *name, char *value, int optional) {
}
}
if (n>=CMOR_MAX_ATTRIBUTES) {
- sprintf(msg,"Setting dataset attribute: %s, we already have %i elts set which is the max, won't be set",name,CMOR_MAX_ELEMENTS);
+ sprintf(msg,"Setting dataset attribute: %s, we already have %i elements set which is the max, this element won't be set",name,CMOR_MAX_ELEMENTS);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -970,7 +970,7 @@ void cmor_has_required_global_attributes(int table_id) {
/* } */
/* } */
if (found == 0) {
- snprintf(ctmp,CMOR_MAX_STRING,"Required global attribute %s is missing please check call to cmor_dataset",msg);
+ snprintf(ctmp,CMOR_MAX_STRING,"Required global attribute %s is missing please check call(s) to cmor_dataset and/or cmor_set_cur_dataset_attribute",msg);
cmor_handle_error(ctmp,CMOR_CRITICAL);
}
strncpy(msg2,msg,CMOR_MAX_STRING);
@@ -1019,8 +1019,8 @@ int cmor_has_cur_dataset_attribute(char *name) {
extern cmor_dataset_def cmor_current_dataset;
cmor_add_traceback("cmor_has_cur_dataset_attribute");
cmor_is_setup();
- if (strlen(name)>CMOR_MAX_STRING) {
- snprintf(msg,CMOR_MAX_STRING,"CMOR Dataset: %s length is greater than limit: %i", name, CMOR_MAX_STRING);
+ if ((int)strlen(name)>CMOR_MAX_STRING) {
+ snprintf(msg,CMOR_MAX_STRING,"CMOR Dataset: attribute name (%s) length (%i) is greater than limit: %i", name, (int)strlen(name), CMOR_MAX_STRING);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -1407,7 +1407,7 @@ int cmor_define_zfactors_vars(int var_id,int ncid, int *nc_dim,char *formula_ter
}
}
if (found==0) {
- snprintf(msg,CMOR_MAX_STRING,"could not find the zfactor variable: %s, please define it first",ctmp);
+ snprintf(msg,CMOR_MAX_STRING,"could not find the zfactor variable: %s, please define it first, while defining zfactors for variable %s (table %s)",ctmp,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
@@ -1444,7 +1444,7 @@ int cmor_define_zfactors_vars(int var_id,int ncid, int *nc_dim,char *formula_ter
}
}
if (found==0) {
- snprintf(msg,CMOR_MAX_STRING,"variable \"%s\" has axis \"%s\" defined with formula terms, but term \"%s\" depends on axis \"%s\" which is not part of the variable",cmor_vars[var_id].id,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,ctmp,cmor_axes[cmor_vars[l].axes_ids[k]].id);
+ snprintf(msg,CMOR_MAX_STRING,"variable \"%s\" (table: %s) has axis \"%s\" defined with formula terms, but term \"%s\" depends on axis \"%s\" which is not part of the variable",cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,ctmp,cmor_axes[cmor_vars[l].axes_ids[k]].id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -1455,7 +1455,7 @@ int cmor_define_zfactors_vars(int var_id,int ncid, int *nc_dim,char *formula_ter
else if (cmor_vars[l].type == 'l') ierr = nc_def_var(ncid,cmor_vars[l].id,NC_INT,cmor_vars[l].ndims,&dim_holder[0],&nc_zfactors[lnzfactors]);
else if (cmor_vars[l].type == 'i') ierr = nc_def_var(ncid,cmor_vars[l].id,NC_INT,cmor_vars[l].ndims,&dim_holder[0],&nc_zfactors[lnzfactors]);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING, "NC Error (%i) for variable %s error defining zfactor var: %i (%s)",ierr,cmor_vars[var_id].id,lnzfactors,cmor_vars[l].id);
+ snprintf(msg,CMOR_MAX_STRING, "NC Error (%i: %s) for variable %s (table %s) error defining zfactor var: %i (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,lnzfactors,cmor_vars[l].id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
@@ -1467,7 +1467,7 @@ int cmor_define_zfactors_vars(int var_id,int ncid, int *nc_dim,char *formula_ter
icdl = cmor_tables[cmor_vars[l].ref_table_id].vars[cmor_vars[l].ref_var_id].deflate_level;
ierr = nc_def_var_deflate(ncid,nc_zfactors[lnzfactors],ics,icd,icdl);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) defining compression parameters for zfactor variable %s for variable '%s'",ierr,cmor_vars[l].id,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NCError (%i: %s) defining compression parameters for zfactor variable %s for variable '%s' (table %s)",ierr,nc_strerror(ierr),cmor_vars[l].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -1482,7 +1482,7 @@ int cmor_define_zfactors_vars(int var_id,int ncid, int *nc_dim,char *formula_ter
ierr = cmor_convert_string_to_list(cmor_vars[l].attributes_values_char[k],'i',(void *)&int_list,&nelts);
ierr = nc_put_att_int(ncid,nc_zfactors[lnzfactors] ,"flag_values",NC_INT,nelts,int_list);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) setting flags numerical attribute on variable",ierr);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) setting flags numerical attribute on zfactor variable %s for variable %s (table %s)",ierr,nc_strerror(ierr),cmor_vars[l].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
free(int_list);
@@ -1505,7 +1505,7 @@ int cmor_define_zfactors_vars(int var_id,int ncid, int *nc_dim,char *formula_ter
else if (cmor_vars[l].type == 'f') ierr = nc_def_var(ncid,cmor_vars[l].id,NC_FLOAT,cmor_vars[l].ndims+1,&dim_holder[0],&nc_zfactors[lnzfactors]);
else if (cmor_vars[l].type == 'l') ierr = nc_def_var(ncid,cmor_vars[l].id,NC_INT,cmor_vars[l].ndims+1,&dim_holder[0],&nc_zfactors[lnzfactors]);
else if (cmor_vars[l].type == 'i') ierr = nc_def_var(ncid,cmor_vars[l].id,NC_INT,cmor_vars[l].ndims+1,&dim_holder[0],&nc_zfactors[lnzfactors]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NC Error (%i) for variable %s error defining zfactor var: %i (%s)",ierr,cmor_vars[var_id].id,lnzfactors,cmor_vars[l].id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NC Error (%i: %s) for variable %s (table: %s),error defining zfactor var: %i (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,lnzfactors,cmor_vars[l].id);cmor_handle_error(msg,CMOR_CRITICAL);}
/* Compression stuff */
if ((CMOR_NETCDF_MODE != CMOR_REPLACE_3) && (CMOR_NETCDF_MODE != CMOR_PRESERVE_3) && (CMOR_NETCDF_MODE != CMOR_APPEND_3)) {
@@ -1514,7 +1514,7 @@ int cmor_define_zfactors_vars(int var_id,int ncid, int *nc_dim,char *formula_ter
icdl = cmor_tables[cmor_vars[l].ref_table_id].vars[cmor_vars[l].ref_var_id].deflate_level;
ierr = nc_def_var_deflate(ncid,nc_zfactors[lnzfactors],ics,icd,icdl);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) defining compression parameters for zfactor variable %s for variable '%s'",ierr,cmor_vars[l].id,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NCError (%i: %s) defining compression parameters for zfactor variable %s for variable '%s' (table %s)",ierr,nc_strerror(ierr),cmor_vars[l].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -1526,7 +1526,7 @@ int cmor_define_zfactors_vars(int var_id,int ncid, int *nc_dim,char *formula_ter
ierr = cmor_convert_string_to_list(cmor_vars[l].attributes_values_char[k],'i',(void *)&int_list,&nelts);
ierr = nc_put_att_int(ncid,nc_zfactors[lnzfactors] ,"flag_values",NC_INT,nelts,int_list);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) setting flags numerical attribute on variable",ierr);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) setting flags numerical attribute on zfactor variable %s for variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_vars[l].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
free(int_list);
@@ -1690,13 +1690,13 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
varid=(int) *refvar;
/* printf("ok passing with a refvar: %i\n",varid); */
if (cmor_vars[varid].initialized==-1) {
- snprintf(msg,CMOR_MAX_STRING, "You are trying to write variable \"%s\" in association with variable \"%s\" but you you need to write the associated variable first in order to initialize the file and dimensinos",cmor_vars[varid].id,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING, "You are trying to write variable \"%s\" in association with variable \"%s\" (table %s), but you you need to write the associated variable first in order to initialize the file and dimensinos",cmor_vars[varid].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* ok now we need to scan the netcdf file to figure the ncvarid associated */
ierr = nc_inq_varid(cmor_vars[varid].initialized,cmor_vars[var_id].id,&cmor_vars[var_id].nc_var_id);
if (ierr!=NC_NOERR) {
- sprintf(msg,"Could not find variable: '%s' in file of associated variable: '%s'",cmor_vars[var_id].id,cmor_vars[*refvar].id);
+ sprintf(msg,"Could not find variable: '%s' (table: %s) in file of associated variable: '%s'",cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_vars[*refvar].id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
cmor_vars[var_id].ntimes_written = cmor_vars[varid].ntimes_written - ntimes_passed;
@@ -1705,7 +1705,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
/* Here we check that the types are consitent between the missing value passed and the type passed now */
if (cmor_vars[varid].nomissing==0) {
if (cmor_vars[varid].itype!=type) {
- snprintf(msg,CMOR_MAX_STRING,"You defined variable \"%s\" with a missing value of type \"%c\", but you are now writing data of type: \"%c\" this may lead to some spurious handling of the missing values",cmor_vars[varid].id,cmor_vars[varid].itype,type);
+ snprintf(msg,CMOR_MAX_STRING,"You defined variable \"%s\" (table %s) with a missing value of type \"%c\", but you are now writing data of type: \"%c\" this may lead to some spurious handling of the missing values",cmor_vars[varid].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_vars[varid].itype,type);
cmor_handle_error(msg,CMOR_WARNING);
}
}
@@ -1730,7 +1730,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
cmor_get_cur_dataset_attribute("experiment_id",ctmp2);
/* ok here we check the exptid is ok */
if (cmor_check_expt_id(ctmp2,cmor_vars[var_id].ref_table_id,"experiment","experiment_id")!=0) {
- snprintf(msg,CMOR_MAX_STRING,"Invalid dataset experiment id: %s, check against table: %s",ctmp2,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
+ snprintf(msg,CMOR_MAX_STRING,"Invalid dataset experiment id: %s, while writing variable %s, check against table: %s",ctmp2,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -1749,7 +1749,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
else { /* file does not exists it is a suffix */
/* we need to check if the CMOR table used is not for a cmor 2 */
if (cmor_tables[cmor_vars[var_id].ref_table_id].cmor_version>=2.) {
- sprintf(msg,"You passed '%s' as file_suffix, suffix are not allowed in CMOR2.0 and newer. Were you trying to append to a non-existing file?",appending_to);
+ sprintf(msg,"You passed '%s' as file_suffix while writing variable %s (table %s), suffix are not allowed in CMOR2.0 and newer. Were you trying to append to a non-existing file?",appending_to,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
else {
@@ -1760,7 +1760,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
else {
/* we need to check if the CMOR table used is not for a cmor 2 */
if (cmor_tables[cmor_vars[var_id].ref_table_id].cmor_version>=2.) {
- sprintf(msg,"Suffix are not allowed in CMOR 2.0 and greater");
+ sprintf(msg,"Suffix are not allowed in CMOR 2.0 and greater, suffix %s encountered while writing variable %s (table %s)",suffix,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
else {
@@ -1782,7 +1782,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
strncat(outname,"/",CMOR_MAX_STRING-strlen(outname));
for (i=0;i<strlen(cmor_vars[var_id].id);i++) {
if ((cmor_vars[var_id].id[i]=='_')||(cmor_vars[var_id].id[i]=='-')) {
- snprintf(outname,CMOR_MAX_STRING,"var_id cannot contain %c you passed: %s. Please check your input tables\n",cmor_vars[var_id].id[i],cmor_vars[var_id].id);
+ snprintf(outname,CMOR_MAX_STRING,"var_id cannot contain %c you passed: %s (table: %s). Please check your input tables\n",cmor_vars[var_id].id[i],cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(outname,CMOR_CRITICAL);
}
}
@@ -1794,7 +1794,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
strcpy(ctmp5,msg);
for (i=0;i<strlen(msg);i++) {
if (cmor_convert_char_to_hyphen(msg[i])==1) {
- snprintf(ctmp6,CMOR_MAX_STRING,"model_id (%s) contains the character '%c' it will be replaced with a hyphen\n",msg,msg[i]);
+ snprintf(ctmp6,CMOR_MAX_STRING,"writing variable %s (table %s), model_id (%s) contains the character '%c' it will be replaced with a hyphen in the filename and output directories\n",cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,msg,msg[i]);
cmor_handle_error(ctmp6,CMOR_WARNING);
ctmp5[i]='-';
}
@@ -1896,11 +1896,11 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
for (i=0;i<strlen(msg);i++) {
if (msg[i]=='_') {
if ((CMOR_NETCDF_MODE == CMOR_APPEND_4) ||(CMOR_NETCDF_MODE == CMOR_APPEND_3)) {
- snprintf(ctmp2,CMOR_MAX_STRING,"suffix cannot contain the '_' character, you passed: %s Is it possible you are trying to append to a file and the file is not exactly here?",msg);
+ snprintf(ctmp2,CMOR_MAX_STRING,"While writing variable %s (table %s), suffix cannot contain the '_' character, you passed: %s. Is it possible you are trying to append to a file and the file is not actually here?",cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,msg);
cmor_handle_error(ctmp2,CMOR_CRITICAL);
}
else {
- snprintf(ctmp2,CMOR_MAX_STRING,"suffix cannot contain the '_' character, you passed: %s",msg);
+ snprintf(ctmp2,CMOR_MAX_STRING,"suffix cannot contain the '_' character, you passed: %s, while writing variable %s (table: %s)",msg,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(ctmp2,CMOR_CRITICAL);
}
}
@@ -1960,16 +1960,16 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
ierr = fclose(fperr);
/*cmor_vars[var_id].suffix_has_date=1;*/
ierr = nc_open(outname,NC_WRITE,&ncid);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) opening file: %s",ierr,outname); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) opening file: %s",ierr,nc_strerror(ierr),outname); cmor_handle_error(msg,CMOR_CRITICAL);}
ierr = nc_inq_dimid(ncid,"time",&i);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) looking for time dimension in file: %s",ierr,outname); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) looking for time dimension in file: %s",ierr,nc_strerror(ierr),outname); cmor_handle_error(msg,CMOR_CRITICAL);}
ierr = nc_inq_dimlen(ncid,i,&nctmp);
cmor_vars[var_id].ntimes_written=(int)nctmp;
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) looking for time dimension length in file: %s",ierr,outname); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) looking for time dimension length in file: %s",ierr,nc_strerror(ierr),outname); cmor_handle_error(msg,CMOR_CRITICAL);}
ierr = nc_inq_varid(ncid,cmor_vars[var_id].id,&cmor_vars[var_id].nc_var_id);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) looking for variable '%s' in file: %s",ierr,cmor_vars[var_id].id,outname); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) looking for variable '%s' in file: %s",ierr,nc_strerror(ierr),cmor_vars[var_id].id,outname); cmor_handle_error(msg,CMOR_CRITICAL);}
ierr = nc_inq_varid(ncid,"time",&cmor_vars[var_id].time_nc_id);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) looking for time of variable '%s' in file: %s",ierr,cmor_vars[var_id].id,outname); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) looking for time of variable '%s' in file: %s",ierr,nc_strerror(ierr),cmor_vars[var_id].id,outname); cmor_handle_error(msg,CMOR_CRITICAL);}
/* ok now we need to read the first time in here */
starts[0]=0;
ierr = nc_get_var1_double(ncid,cmor_vars[var_id].time_nc_id,&starts[0],&cmor_vars[var_id].first_time);
@@ -1977,7 +1977,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
ierr = nc_get_var1_double(ncid,cmor_vars[var_id].time_nc_id,&starts[0],&cmor_vars[var_id].last_time);
ierr = nc_inq_varid(ncid,"time_bnds",&i);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) looking for time bounds of variable '%s' in file: %s",ierr,cmor_vars[var_id].id,outname);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) looking for time bounds of variable '%s' in file: %s",ierr,nc_strerror(ierr),cmor_vars[var_id].id,outname);
cmor_handle_error(msg,CMOR_WARNING);
ierr = NC_NOERR;
}
@@ -1991,7 +1991,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
snprintf(msg,CMOR_MAX_STRING,"Unknown CMOR_NETCDF_MODE file mode: %i",CMOR_NETCDF_MODE);
cmor_handle_error(msg,CMOR_CRITICAL);
}
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) creating file: %s",ierr,outname); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) creating file: %s",ierr,nc_strerror(ierr),outname); cmor_handle_error(msg,CMOR_CRITICAL);}
}
/* we closed and reopened the same test, in case we were appending, in which case all decalration have been done if the open loop */
if (cmor_vars[varid].initialized==-1) { /* Variable never been thru cmor_write, we need to define everything */
@@ -2027,7 +2027,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
ncafid = ncid;
/* Ok we need to set the associated_files attributes */
if (strcmp(cmor_tables[cmor_vars[var_id].ref_table_id].URL,"")==0) {
- snprintf(msg,CMOR_MAX_STRING,"Your table does not contain a reference URL, please consider adding it");
+ snprintf(msg,CMOR_MAX_STRING,"Your table (%s) does not contain a reference URL, please consider adding it",cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_WARNING);
strncpy(ctmp,"",CMOR_MAX_STRING);
}
@@ -2107,7 +2107,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
break;
}
}
- if (k!=-1) { /*ok we have this guy, let's figureout the name */
+ if (k!=-1) { /*ok we have this guy, let's figure out the name */
for(i=k;i<strlen(ctmp5);i++) {
if ((ctmp5[i]==' ') || (ctmp5[i]=='\0')) break;
ctmp6[i-k]=ctmp5[i];
@@ -2203,7 +2203,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
/* make sure we are in def mode */
ierr = nc_redef(ncafid);
if (ierr != NC_NOERR && ierr != NC_EINDEFINE) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) putting metadata file (%s) in def mode, nc file id was: %i",ierr,cmor_current_dataset.associated_file_name,ncafid);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) putting metadata file (%s) in def mode, nc file id was: %i, you were writing variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_current_dataset.associated_file_name,ncafid,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
@@ -2257,7 +2257,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
afloat+=d;
if (cmor_tables[cmor_vars[var_id].ref_table_id].cf_version>afloat) {
- snprintf(msg,CMOR_MAX_STRING,"Your table claims to enforce CF version %f but this version of the library is designed for CF up to: %i.%i",cmor_tables[cmor_vars[var_id].ref_table_id].cf_version,CMOR_CF_VERSION_MAJOR,CMOR_CF_VERSION_MINOR);
+ snprintf(msg,CMOR_MAX_STRING,"Your table (%s) claims to enforce CF version %f but this version of the library is designed for CF up to: %i.%i, you were writing variable: %s",cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_tables[cmor_vars[var_id].ref_table_id].cf_version,CMOR_CF_VERSION_MAJOR,CMOR_CF_VERSION_MINOR,cmor_vars[var_id].id);
cmor_handle_error(msg,CMOR_WARNING);
}
@@ -2268,7 +2268,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
if (strcmp(msg,"N/A")!=0) { /* did the user pass an expt */
cmor_get_cur_dataset_attribute("experiment_id",ctmp);
if (strcmp(msg,ctmp)==0) {
- sprintf(ctmp,"Your parent_experiment id matches your current experiment_id, they are both set to: %s",msg);
+ sprintf(ctmp,"Your parent_experiment id matches your current experiment_id, they are both set to: %s; you were writing variable %s (table: %s)",msg,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(ctmp,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -2276,14 +2276,14 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
else {
cmor_get_cur_dataset_attribute("experiment",ctmp);
if (strcmp(msg,ctmp)==0) {
- sprintf(ctmp,"Your parent_experiment id matches your current experiment_id, they are both set to: %s",msg);
+ sprintf(ctmp,"Your parent_experiment id matches your current experiment_id, they are both set to: %s; you were writing variable %s (table: %s)",msg,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(ctmp,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
}
else { /*ok now we can check it is a valid "other" experiment */
if (cmor_check_expt_id(msg,cmor_vars[var_id].ref_table_id,"parent_experiment","parent_experiment_id")!=0) {
- snprintf(ctmp,CMOR_MAX_STRING,"Invalid dataset parent experiment id: %s, check against table: %s",msg,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
+ snprintf(ctmp,CMOR_MAX_STRING,"Invalid dataset parent experiment id: %s, check against table: %s, you were writing variable: %s",msg,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_vars[var_id].id);
cmor_handle_error(ctmp,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -2296,7 +2296,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
cmor_get_cur_dataset_attribute("branch_time",msg);
sscanf(msg,"%lf",&tmps[0]);
if (tmps[0]!=0.) {
- sprintf(msg,"when dataset attribute parent_experiment_id is set to N/A branch_time must be 0. you passed: %lf, we are resetting to 0.",tmps[0]);
+ sprintf(msg,"when dataset attribute parent_experiment_id is set to N/A, branch_time must be 0., you passed: %lf, we are resetting to 0. for variable %s (table: %s)",tmps[0],cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_WARNING);
cmor_set_cur_dataset_attribute("branch_time","0.",1);
}
@@ -2312,7 +2312,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
cmor_get_cur_dataset_attribute("model_id",ctmp5);
cmor_get_cur_dataset_attribute("source",ctmp6);
if (strncmp(ctmp5,ctmp6,strlen(ctmp5))!=0) {
- snprintf(msg,CMOR_MAX_STRING,"source attribute does not start with 'model_id', it should start with: %s",ctmp5);
+ snprintf(msg,CMOR_MAX_STRING,"while writing variable %s (table: %s), source attribute does not start with 'model_id', it should start with: %s",cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,ctmp5);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -2343,20 +2343,20 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
if ((strcmp(cmor_current_dataset.attributes_names[i],"initialization_method")==0) || (strcmp(cmor_current_dataset.attributes_names[i],"physics_version")==0) ) { /* these two are actually int not char */
sscanf(cmor_current_dataset.attributes_values[i],"%i",&itmp2);
ierr = nc_put_att_int(ncid, NC_GLOBAL, cmor_current_dataset.attributes_names[i],NC_INT,1,&itmp2);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) for variable %s writing global att: %s (%s)",ierr,cmor_vars[var_id].id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) for variable %s (table: %s) writing global att: %s (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
if (ncid!=ncafid) {
ierr = nc_put_att_int(ncafid, NC_GLOBAL, cmor_current_dataset.attributes_names[i],NC_INT,1,&itmp2);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) for variable %s writing global att to metafile: %s (%s)",ierr,cmor_vars[var_id].id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) for variable %s (table: %s) writing global att to metafile: %s (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
}
}
else if (strcmp(cmor_current_dataset.attributes_names[i],"branch_time")==0) {
/* double attribute */
sscanf(cmor_current_dataset.attributes_values[i],"%lf",&tmps[0]);
ierr = nc_put_att_double(ncid, NC_GLOBAL, cmor_current_dataset.attributes_names[i],NC_DOUBLE,1,&tmps[0]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) for variable %s writing global att: %s (%s)",ierr,cmor_vars[var_id].id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) for variable %s (table: %s) writing global att: %s (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
if (ncid!=ncafid) {
ierr = nc_put_att_double(ncafid, NC_GLOBAL, cmor_current_dataset.attributes_names[i],NC_DOUBLE,1,&tmps[0]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) for variable %s writing global att to metafile: %s (%s)",ierr,cmor_vars[var_id].id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) for variable %s (table: %s), writing global att to metafile: %s (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
}
}
else {
@@ -2368,29 +2368,29 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
itmp2=CMOR_DEF_ATT_STR_LEN;
}
ierr = nc_put_att_text(ncid, NC_GLOBAL,cmor_current_dataset.attributes_names[i],itmp2,cmor_current_dataset.attributes_values[i]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) for variable %s writing global att: %s (%s)",ierr,cmor_vars[var_id].id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) for variable %s (table: %s) writing global att: %s (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
if (ncid!=ncafid) {
ierr = nc_put_att_text(ncafid, NC_GLOBAL,cmor_current_dataset.attributes_names[i],itmp2,cmor_current_dataset.attributes_values[i]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) for variable %s writing global att to metafile: %s (%s)",ierr,cmor_vars[var_id].id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) for variable %s (table %s), writing global att to metafile: %s (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
}
}
}
}
/* realization */
ierr = nc_put_att_int(ncid, NC_GLOBAL,"realization",NC_INT,1,&cmor_current_dataset.realization);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) writing global att realization (%i)",ierr,cmor_current_dataset.realization); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) writing variable %s (table: %s) global att realization (%i)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_current_dataset.realization); cmor_handle_error(msg,CMOR_CRITICAL);}
/* cmor_ver */
snprintf(msg,CMOR_MAX_STRING,"%i.%i.%i",CMOR_VERSION_MAJOR,CMOR_VERSION_MINOR,CMOR_VERSION_PATCH);
ierr = nc_put_att_text(ncid, NC_GLOBAL,"cmor_version",strlen(msg)+1,msg);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) writing global att cmor_version (%f)",ierr,afloat); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) writing variable %s (table: %s) global att cmor_version (%f)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,afloat); cmor_handle_error(msg,CMOR_CRITICAL);}
if (ncid!=ncafid) {
ierr = nc_put_att_int(ncafid, NC_GLOBAL,"realization",NC_INT,1,&cmor_current_dataset.realization);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) writing global att realization (%i) to metafile",ierr,cmor_current_dataset.realization); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) writing variable %s (table: %s) global att realization (%i) to metafile",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_current_dataset.realization); cmor_handle_error(msg,CMOR_CRITICAL);}
/* cmor_ver */
ierr = nc_put_att_text(ncid, NC_GLOBAL,"cmor_version",strlen(msg)+1,msg);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) writing global att cmor_version (%f)",ierr,afloat); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) writing variable %s (table: %s) global att cmor_version (%f)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,afloat); cmor_handle_error(msg,CMOR_CRITICAL);}
}
if (isfixed==1) cmor_current_dataset.realization = origRealization;
@@ -2419,20 +2419,20 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
}
ierr = nc_def_dim(ncid,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,j,&nc_dim[i]);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) for dimension definition of axis: %s (%i), for variable %i (%s)",ierr,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,i,var_id,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i:%s) for dimension definition of axis: %s (%i), for variable %i (%s, table: %s)",ierr,nc_strerror(ierr),cmor_axes[cmor_vars[var_id].axes_ids[i]].id,i,var_id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
ierr = nc_enddef(ncid);
cmor_handle_error(msg,CMOR_CRITICAL);
}
nc_dim_af[i]=nc_dim[i];
if (ncid!=ncafid) {
ierr = nc_def_dim(ncafid,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,j,&nc_dim_af[i]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) for dimension definition of axis: %s (%i) in metafile",ierr,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,i); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) for dimension definition of axis: %s (%i) in metafile, variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_axes[cmor_vars[var_id].axes_ids[i]].id,i,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id); cmor_handle_error(msg,CMOR_CRITICAL);}
}
}
/* creates the bounds dim (only in metafile?)*/
ierr = nc_def_dim(ncafid,"bnds",2,&dim_bnds);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NC error (%i), %s error creating bnds dimension to metafile",ierr,cmor_vars[var_id].id); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NC error (%i: %s), error creating bnds dimension to metafile, variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id); cmor_handle_error(msg,CMOR_CRITICAL);}
/* Now define the variable corresponding to store the dimensions values */
for (i=0;i<cmor_vars[var_id].ndims;i++) {
@@ -2454,7 +2454,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
break;
}
ierr = nc_def_var(ncid,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,j,1,&nc_dim[i],&nc_vars[i]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i) for variable %s error defining dim var: %i (%s)",ierr,cmor_vars[var_id].id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i: %s) for variable %s (table: %s) error defining dim var: %i (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
/* /\* table are different ? *\/ */
/* if (cmor_axes[cmor_vars[var_id].axes_ids[i]].ref_table_id!=cmor_vars[var_id].ref_table_id) { */
@@ -2475,7 +2475,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
icdl = cmor_tables[cmor_vars[var_id].ref_table_id].vars[cmor_vars[var_id].ref_var_id].deflate_level;
ierr = nc_def_var_deflate(ncid,nc_vars[i],ics,icd,icdl);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) defining compression parameters for dimension %s for variable '%s'",ierr,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NCError (%i: %s) defining compression parameters for dimension %s for variable '%s' (table: %s)",ierr,nc_strerror(ierr),cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -2483,7 +2483,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
nc_vars_af[i]=nc_vars[i];
if (ncid!=ncafid) {
ierr = nc_def_var(ncafid,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,j,1,&nc_dim_af[i],&nc_vars_af[i]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i) for variable %s error defining dim var: %i (%s) in metafile",ierr,cmor_vars[var_id].id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i: %s ) for variable %s (table: %s) error defining dim var: %i (%s) in metafile",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
/* Compression stuff */
if ((CMOR_NETCDF_MODE != CMOR_REPLACE_3) && (CMOR_NETCDF_MODE != CMOR_PRESERVE_3) && (CMOR_NETCDF_MODE != CMOR_APPEND_3)) {
@@ -2492,7 +2492,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
icdl = cmor_tables[cmor_vars[var_id].ref_table_id].vars[cmor_vars[var_id].ref_var_id].deflate_level;
ierr = nc_def_var_deflate(ncafid,nc_vars_af[i],ics,icd,icdl);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) defining compression parameters for dimension %s for variable '%s'",ierr,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NCError (%i: %s) defining compression parameters for dimension %s for variable '%s' (table: %s)",ierr,nc_strerror(ierr),cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -2526,17 +2526,17 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
}
/* ok so now i can create the dummy dim strlen */
ierr = nc_def_dim(ncid,"strlen",l,&tmp_dims[1]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) for dummy 'strlen' dimension definition of axis: %s (%i) in metafile",ierr,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,i); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) for dummy 'strlen' dimension definition of axis: %s (%i) in metafile, while writing variable %s (table: %s)",ierr,nc_strerror(ierr), cmor_axes[cmor_vars[var_id].axes_ids[i]].id,i,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id); cmor_handle_error(msg,CMOR_CRITICAL);}
tmp_dims[0]=nc_dim[i];
ierr = nc_def_var(ncid,ctmp,NC_CHAR,2,&tmp_dims[0],&nc_vars[i]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i) for variable %s error defining dim var: %i (%s)",ierr,cmor_vars[var_id].id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i: %s) for variable %s (table: %s) error defining dim var: %i (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
nc_vars_af[i]=nc_vars[i];
if (ncid!=ncafid) {
ierr = nc_def_dim(ncafid,"strlen",l,&tmp_dims[1]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) for dummy 'strlen' dimension definition of axis: %s (%i) in metafile",ierr,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,i); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) for dummy 'strlen' dimension definition of axis: %s (%i) in metafile, while writing variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_axes[cmor_vars[var_id].axes_ids[i]].id,i,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id); cmor_handle_error(msg,CMOR_CRITICAL);}
tmp_dims[0]=nc_dim_af[i];
ierr = nc_def_var(ncafid,ctmp,NC_CHAR,1,&tmp_dims[0],&nc_vars_af[i]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i) for variable %s error defining dim var: %i (%s) in metafile",ierr,cmor_vars[var_id].id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i: %s) for variable %s (table: %s) error defining dim var: %i (%s) in metafile",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
}
}
/* ok do we have bounds on this axis? */
@@ -2569,7 +2569,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
break;
}
ierr = nc_def_var(ncafid,ctmp,j,2,&dims_bnds_ids[0],&nc_bnds_vars[i]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i) for variable %s error defining bounds dim var: %i (%s)",ierr,cmor_vars[var_id].id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i: %s) for variable %s (table: %s) error defining bounds dim var: %i (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
/* Compression stuff */
if ((CMOR_NETCDF_MODE != CMOR_REPLACE_3) && (CMOR_NETCDF_MODE != CMOR_PRESERVE_3) && (CMOR_NETCDF_MODE != CMOR_APPEND_3)) {
@@ -2578,14 +2578,14 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
icdl = cmor_tables[cmor_vars[var_id].ref_table_id].vars[cmor_vars[var_id].ref_var_id].deflate_level;
ierr = nc_def_var_deflate(ncafid,nc_bnds_vars[i],ics,icd,icdl);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) defining compression parameters for bounds variable %s for variable '%s'",ierr,ctmp,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NCError (%i: %s) defining compression parameters for bounds variable %s for variable '%s' (table: %s)",ierr,nc_strerror(ierr),ctmp,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
/* sets the bounds attribute of parent var */
if (i==0) cmor_vars[var_id].time_bnds_nc_id = nc_bnds_vars[i];
ierr = nc_put_att_text(ncafid,nc_vars[i],msg,strlen(ctmp)+1,ctmp);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i) for variable %s error defining bounds attribute var: %i (%s)",ierr,cmor_vars[var_id].id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING, "NetCDF Error (%i: %s) for variable %s (table: %s) error defining bounds attribute var: %i (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
}
/* Creates attribute related to that axis */
for (j=0;j<cmor_axes[cmor_vars[var_id].axes_ids[i]].nattributes;j++){
@@ -2595,11 +2595,11 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
strncpy(msg,cmor_axes[cmor_vars[var_id].axes_ids[i]].attributes_values_char[j],CMOR_MAX_STRING);
n=strlen(msg)+1;
ierr = nc_put_att_text(ncid,nc_vars[i],"formula_terms",n,msg);
- if (ierr != NC_NOERR) {snprintf(ctmp,CMOR_MAX_STRING,"NetCDF error (%i) writing formula term att (%s) for axis %i (%s)",ierr,msg,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(ctmp,CMOR_MAX_STRING,"NetCDF error (%i: %s) writing formula term att (%s) for axis %i (%s), variable %s (table: %s)",ierr,nc_strerror(ierr),msg,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);cmor_handle_error(msg,CMOR_CRITICAL);}
/* printf("doing formula for: %s\n",msg); */
if (ncid!=ncafid) {
ierr = nc_put_att_text(ncafid,nc_vars_af[i],"formula_terms",n,msg);
- if (ierr != NC_NOERR) {snprintf(ctmp,CMOR_MAX_STRING,"NetCDF error (%i) writing formula term att (%s) for axis %i (%s)",ierr,msg,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);cmor_handle_error(ctmp,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(ctmp,CMOR_MAX_STRING,"NetCDF error (%i: %s) writing formula term att (%s) for axis %i (%s), variable %s (table: %s)",ierr,nc_strerror(ierr),msg,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);cmor_handle_error(ctmp,CMOR_CRITICAL);}
}
ierr = cmor_define_zfactors_vars(var_id,ncafid, &nc_dim_af[0],msg,&nzfactors, &zfactors[0],&nc_zfactors[0],i,-1);
}
@@ -2693,7 +2693,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
cmor_set_variable_attribute(var_id,"grid_mapping",'c',cmor_grids[cmor_vars[var_id].grid_id].mapping);
ierr = nc_def_var(ncafid,cmor_grids[cmor_vars[var_id].grid_id].mapping,NC_INT,0,&nc_dims_associated[0],&m);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF error %i while defining associated grid mapping variable %s",ierr,cmor_grids[cmor_vars[var_id].grid_id].mapping);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) while defining associated grid mapping variable %s for variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_grids[cmor_vars[var_id].grid_id].mapping,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* Creates attributes related to that variable */
@@ -2715,7 +2715,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
ierr = nc_put_att_double(ncafid,m,"standard_parallel",NC_DOUBLE,1,&tmps[0]);
}
if (ierr!=NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) writing standard_parallel to file",ierr);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) writing standard_parallel to file, varialbe: %s (table: %s)",ierr, nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -2761,7 +2761,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
if (((i==2) || (i==3)) && (m==0)) { /*vertices need to be added */
m=1; /* ok now it has been defined */
ierr = nc_def_dim(ncafid,"vertices",cmor_axes[cmor_vars[j].axes_ids[cmor_vars[j].ndims-1]].length,&nc_dims_associated[l]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error %i while defining vertices dimension",ierr);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) while defining vertices dimension, variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);cmor_handle_error(msg,CMOR_CRITICAL);}
}
mtype = cmor_vars[j].type;
/* printf("type, ndims: %c, %i\n",mtype,cmor_vars[j].ndims); */
@@ -2772,7 +2772,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
else if (mtype=='f' ) ierr = nc_def_var(ncafid,cmor_vars[j].id,NC_FLOAT,cmor_vars[j].ndims,&nc_dims_associated[0],&nc_associated_vars[i]);
else if (mtype=='l' ) ierr = nc_def_var(ncafid,cmor_vars[j].id,NC_INT,cmor_vars[j].ndims,&nc_dims_associated[0],&nc_associated_vars[i]);
else if (mtype=='i' ) ierr = nc_def_var(ncafid,cmor_vars[j].id,NC_INT,cmor_vars[j].ndims,&nc_dims_associated[0],&nc_associated_vars[i]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error %i while defining associated variable %s",ierr,cmor_vars[j].id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) while defining associated variable %s, of variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_vars[j].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);cmor_handle_error(msg,CMOR_CRITICAL);}
/* /\* at this point we check if tables match *\/ */
/* if (cmor_vars[j].ref_table_id!=cmor_vars[var_id].ref_table_id) { */
/* snprintf(msg,CMOR_MAX_STRING,"Table %s (%s) ",cmor_tables[cmor_vars[j].ref_table_id].table_id,cmor_tables[cmor_vars[j].ref_table_id].date); */
@@ -2792,7 +2792,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
ierr = cmor_convert_string_to_list(cmor_vars[j].attributes_values_char[k],'i',(void *)&int_list,&nelts);
ierr = nc_put_att_int(ncafid, nc_associated_vars[i],"flag_values",NC_INT,nelts,int_list);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) setting flags numerical attribute on variable",ierr);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) setting flags numerical attribute on associated variable %s, for variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_vars[j].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
free(int_list);
@@ -2812,7 +2812,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
icdl = cmor_tables[cmor_vars[j].ref_table_id].vars[cmor_vars[j].ref_var_id].deflate_level;
ierr = nc_def_var_deflate(ncafid,nc_associated_vars[i],ics,icd,icdl);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) defining compression parameters for variable '%s'",ierr,cmor_vars[j].id);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) defining compression parameters for associated variable '%s' for variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_vars[j].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -2829,7 +2829,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
if (j!=-1) {
ierr = nc_def_var(ncid,cmor_axes[j].id,NC_DOUBLE,0,&nc_singletons[i],&nc_singletons[i]);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) defining scalar variable %s for variable %s",ierr,cmor_axes[j].id,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) defining scalar variable %s for variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_axes[j].id,cmor_vars[var_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* now puts on its attributes */
@@ -2847,7 +2847,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
ierr = cmor_put_nc_char_attribute(ncid,nc_singletons[i],"bounds",msg,cmor_vars[var_id].id) ;
ierr = nc_def_var(ncid,msg,NC_DOUBLE,1,&dim_bnds,&nc_singletons_bnds[i]);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) defining scalar bounds variable %s for variable %s",ierr,cmor_axes[j].id,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) defining scalar bounds variable %s for variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_axes[j].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -2863,7 +2863,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
else if (mtype=='l' ) ierr = nc_def_var(ncid,cmor_vars[var_id].id,NC_INT,cmor_vars[var_id].ndims,&nc_dim[0],&nc_vars[cmor_vars[var_id].ndims]);
else if (mtype=='i' ) ierr = nc_def_var(ncid,cmor_vars[var_id].id,NC_INT,cmor_vars[var_id].ndims,&nc_dim[0],&nc_vars[cmor_vars[var_id].ndims]);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) writing variable: %s",ierr,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) writing variable: %s (table: %s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
@@ -2877,7 +2877,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
ierr = cmor_convert_string_to_list(cmor_vars[var_id].attributes_values_char[j],'i',(void *)&int_list,&nelts);
ierr = nc_put_att_int(ncid,cmor_vars[var_id].nc_var_id ,"flag_values",NC_INT,nelts,int_list);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) setting flags numerical attribute on variable",ierr);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) setting flags numerical attribute on variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
free(int_list);
@@ -2897,7 +2897,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
icdl = cmor_tables[cmor_vars[var_id].ref_table_id].vars[cmor_vars[var_id].ref_var_id].deflate_level;
ierr = nc_def_var_deflate(ncid,cmor_vars[var_id].nc_var_id,ics,icd,icdl);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) defining compression parameters for variable '%s'",ierr,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) defining compression parameters for variable '%s' (table: %s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* Chunking stuff */
@@ -2907,7 +2907,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
if (!((cmor_vars[var_id].grid_id>-1) && (cmor_grids[cmor_vars[var_id].grid_id].istimevarying==1))) {
ierr = nc_def_var_chunking(ncid,cmor_vars[var_id].nc_var_id,NC_CHUNKED,&nc_dim_chunking[0]);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) defining chunking parameters for variable '%s'",ierr,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) defining chunking parameters for variable '%s' (table: %s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -2916,9 +2916,9 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
/* Done with NetCDF file definitions */
ierr = nc_enddef(ncid);
- if (ierr != NC_NOERR && ierr != NC_ENOTINDEFINE) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) leaving definition mode for file %s",ierr,outname);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR && ierr != NC_ENOTINDEFINE) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) leaving definition mode for file %s",ierr,nc_strerror(ierr),outname);cmor_handle_error(msg,CMOR_CRITICAL);}
ierr = nc_enddef(ncafid);
- if (ierr != NC_NOERR && ierr != NC_ENOTINDEFINE) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) leaving definition mode for metafile %s",ierr,cmor_current_dataset.associated_file_name);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR && ierr != NC_ENOTINDEFINE) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) leaving definition mode for metafile %s",ierr,nc_strerror(ierr),cmor_current_dataset.associated_file_name);cmor_handle_error(msg,CMOR_CRITICAL);}
/* Write non time dimension of variable into the NetCDF file */
@@ -2945,7 +2945,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
k=-1;
for(j=0;j<=cmor_nvars;j++) if ((strcmp(cmor_vars[j].id,"a")==0) && (cmor_vars[j].zaxis==cmor_vars[var_id].axes_ids[i])) { k=j; break;}
if (k==-1) {
- snprintf(msg,CMOR_MAX_STRING,"could not find 'a' coeff for axis: %s",cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"could not find 'a' coeff for axis: %s, for variable %s (table: %s)",cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (j=0;j<cmor_axes[cmor_vars[var_id].axes_ids[i]].length;j++) cmor_axes[cmor_vars[var_id].axes_ids[i]].values[j]=cmor_vars[k].values[j];
@@ -2953,7 +2953,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
k=-1;
for(j=0;j<=cmor_nvars;j++) if ((strcmp(cmor_vars[j].id,"b")==0) && (cmor_vars[j].zaxis==cmor_vars[var_id].axes_ids[i])) { k=j; break;}
if (k==-1) {
- snprintf(msg,CMOR_MAX_STRING,"could find 'b' coeff for axis: %s",cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"could find 'b' coeff for axis: %s, for variable %s (table: %s)",cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (j=0;j<cmor_axes[cmor_vars[var_id].axes_ids[i]].length;j++) cmor_axes[cmor_vars[var_id].axes_ids[i]].values[j]+=cmor_vars[k].values[j];
@@ -2963,14 +2963,14 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
k=-1;
for(j=0;j<=cmor_nvars;j++) if ((strcmp(cmor_vars[j].id,"a_bnds")==0) && (cmor_vars[j].zaxis==cmor_vars[var_id].axes_ids[i])) { k=j; break;}
if (k==-1) {
- snprintf(msg,CMOR_MAX_STRING,"could not find 'a_bnds' coeff for axis: %s",cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"could not find 'a_bnds' coeff for axis: %s, for variable %s (table: %s)",cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (j=0;j<cmor_axes[cmor_vars[var_id].axes_ids[i]].length*2;j++) cmor_axes[cmor_vars[var_id].axes_ids[i]].bounds[j]=cmor_vars[k].values[j];
k=-1;
for(j=0;j<=cmor_nvars;j++) if ((strcmp(cmor_vars[j].id,"b_bnds")==0) && (cmor_vars[j].zaxis==cmor_vars[var_id].axes_ids[i])) { k=j; break;}
if (k==-1) {
- snprintf(msg,CMOR_MAX_STRING,"could find 'b_bnds' coef for axis: %s",cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"could find 'b_bnds' coef for axis: %s, for variable %s (table: %s)",cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (j=0;j<cmor_axes[cmor_vars[var_id].axes_ids[i]].length*2;j++) cmor_axes[cmor_vars[var_id].axes_ids[i]].bounds[j]+=cmor_vars[k].values[j];
@@ -2982,7 +2982,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
k=-1;
for(j=0;j<=cmor_nvars;j++) if ((strcmp(cmor_vars[j].id,"ap")==0) && (cmor_vars[j].zaxis==cmor_vars[var_id].axes_ids[i])) { k=j; break;}
if (k==-1) {
- snprintf(msg,CMOR_MAX_STRING,"could not find 'ap' coeef for axis: %s",cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"could not find 'ap' coeef for axis: %s, for variable %s (table: %s)",cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (j=0;j<cmor_axes[cmor_vars[var_id].axes_ids[i]].length;j++) cmor_axes[cmor_vars[var_id].axes_ids[i]].values[j]=cmor_vars[k].values[j]/cmor_vars[l].values[0];
@@ -2990,7 +2990,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
k=-1;
for(j=0;j<=cmor_nvars;j++) if ((strcmp(cmor_vars[j].id,"b")==0) && (cmor_vars[j].zaxis==cmor_vars[var_id].axes_ids[i])) { k=j; break;}
if (k==-1) {
- snprintf(msg,CMOR_MAX_STRING,"could find 'b' coef for axis: %s",cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"could find 'b' coef for axis: %s, for variable %s (table: %s)",cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (j=0;j<cmor_axes[cmor_vars[var_id].axes_ids[i]].length;j++) cmor_axes[cmor_vars[var_id].axes_ids[i]].values[j]+=cmor_vars[k].values[j];
@@ -3000,14 +3000,14 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
k=-1;
for(j=0;j<=cmor_nvars;j++) if ((strcmp(cmor_vars[j].id,"ap_bnds")==0) && (cmor_vars[j].zaxis==cmor_vars[var_id].axes_ids[i])) { k=j; break;}
if (k==-1) {
- snprintf(msg,CMOR_MAX_STRING,"could not find 'ap_bnds' coeff for axis: %s",cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"could not find 'ap_bnds' coeff for axis: %s, for variable %s (table: %s)",cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (j=0;j<cmor_axes[cmor_vars[var_id].axes_ids[i]].length*2;j++) cmor_axes[cmor_vars[var_id].axes_ids[i]].bounds[j]=cmor_vars[k].values[j]/cmor_vars[l].values[0];
k=-1;
for(j=0;j<=cmor_nvars;j++) if ((strcmp(cmor_vars[j].id,"b_bnds")==0) && (cmor_vars[j].zaxis==cmor_vars[var_id].axes_ids[i])) { k=j; break;}
if (k==-1) {
- snprintf(msg,CMOR_MAX_STRING,"could find 'b_bnds' coef for axis: %s",cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"could find 'b_bnds' coef for axis: %s, for variable %s (table: %s)",cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (j=0;j<cmor_axes[cmor_vars[var_id].axes_ids[i]].length*2;j++) cmor_axes[cmor_vars[var_id].axes_ids[i]].bounds[j]+=cmor_vars[k].values[j];
@@ -3018,7 +3018,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
k=-1;
for(j=0;j<=cmor_nvars;j++) if ((strcmp(cmor_vars[j].id,"sigma")==0) && (cmor_vars[j].zaxis==cmor_vars[var_id].axes_ids[i])) { k=j; break;}
if (k==-1) {
- snprintf(msg,CMOR_MAX_STRING,"could not find 'sigma' coeef for axis: %s",cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"could not find 'sigma' coeef for axis: %s, for variable %s (table: %s)",cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (j=0;j<cmor_axes[cmor_vars[var_id].axes_ids[i]].length;j++) cmor_axes[cmor_vars[var_id].axes_ids[i]].values[j]=cmor_vars[k].values[j];
@@ -3027,7 +3027,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
k=-1;
for(j=0;j<=cmor_nvars;j++) if ((strcmp(cmor_vars[j].id,"sigma_bnds")==0) && (cmor_vars[j].zaxis==cmor_vars[var_id].axes_ids[i])) { k=j; break;}
if (k==-1) {
- snprintf(msg,CMOR_MAX_STRING,"could not find 'sigma_bnds' coeff for axis: %s",cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"could not find 'sigma_bnds' coeff for axis: %s, for variable %s (table: %s)",cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (j=0;j<cmor_axes[cmor_vars[var_id].axes_ids[i]].length*2;j++) cmor_axes[cmor_vars[var_id].axes_ids[i]].bounds[j]=cmor_vars[k].values[j];
@@ -3040,13 +3040,13 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
if (cmor_axes[cmor_vars[var_id].axes_ids[i]].store_in_netcdf == 1) {
ierr = nc_put_var_double(ncid,nc_vars[i],cmor_axes[cmor_vars[var_id].axes_ids[i]].values);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) writing axis '%s' values",ierr,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) writing axis '%s' values for variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (ncid!=ncafid) {
ierr = nc_put_var_double(ncafid,nc_vars_af[i],cmor_axes[cmor_vars[var_id].axes_ids[i]].values);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) writing axis '%s' values to metafile",ierr,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) writing axis '%s' values to metafile, for variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -3060,13 +3060,13 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
counts[1]=strlen(cmor_axes[cmor_vars[var_id].axes_ids[i]].cvalues[j]);
ierr = nc_put_vara_text(ncid,nc_vars[i],starts,counts,cmor_axes[cmor_vars[var_id].axes_ids[i]].cvalues[j]);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) writing axis '%s' value number %d (%s)",ierr,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,j,cmor_axes[cmor_vars[var_id].axes_ids[i]].cvalues[j]);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) writing axis '%s' value number %d (%s), for variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_axes[cmor_vars[var_id].axes_ids[i]].id,j,cmor_axes[cmor_vars[var_id].axes_ids[i]].cvalues[j],cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (ncid!=ncafid) {
ierr = nc_put_vara_text(ncafid,nc_vars_af[i],starts,counts,cmor_axes[cmor_vars[var_id].axes_ids[i]].cvalues[j]);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i) writing axis '%s' values to metafile",ierr,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) writing axis '%s' values to metafile, for variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -3076,7 +3076,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
if (cmor_axes[cmor_vars[var_id].axes_ids[i]].bounds!=NULL) {
ierr = nc_put_var_double(ncafid,nc_bnds_vars[i],cmor_axes[cmor_vars[var_id].axes_ids[i]].bounds);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NC error (%i) on variable %s writing bounds for dim %i (%s)",ierr,cmor_vars[var_id].id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id);
+ snprintf(msg,CMOR_MAX_STRING,"NC error (%i: %s) on variable %s writing bounds for dim %i (%s), for variable %s (table: %s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,i,cmor_axes[cmor_vars[var_id].axes_ids[i]].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -3132,14 +3132,14 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
if (j!=-1) {
ierr = nc_put_var_double(ncid,nc_singletons[i],cmor_axes[j].values);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) writing scalar variable %s for variable %s, value: %lf",ierr,cmor_axes[j].id,cmor_vars[var_id].id,cmor_axes[j].values[0]);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) writing scalar variable %s for variable %s (table: %s), value: %lf",ierr,nc_strerror(ierr),cmor_axes[j].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_axes[j].values[0]);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* now see if we need bounds */
if (cmor_axes[j].bounds!=NULL) { /*yep */
ierr = nc_put_var_double(ncid,nc_singletons_bnds[i],cmor_axes[j].bounds);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) writing scalar bounds variable %s for variable %s, values: %lf, %lf",ierr,cmor_axes[j].id,cmor_vars[var_id].id,cmor_axes[j].bounds[0],cmor_axes[j].bounds[1]);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) writing scalar bounds variable %s for variable %s (table: %s), values: %lf, %lf",ierr,nc_strerror(ierr),cmor_axes[j].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_axes[j].bounds[0],cmor_axes[j].bounds[1]);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -3164,7 +3164,7 @@ int cmor_write(int var_id,void *data, char type, char *suffix, int ntimes_passed
free(myuuid_str);
uuid_destroy(myuuid);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) for variable %s writing global att: %s (%s)",ierr,cmor_vars[var_id].id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) for variable %s (table: %s) writing global att: %s (%s)",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,cmor_current_dataset.attributes_names[i],cmor_current_dataset.attributes_values[i]); cmor_handle_error(msg,CMOR_CRITICAL);}
cmor_vars[var_id].time_nc_id=cmor_vars[varid].time_nc_id; /* in case we are doing a zfactor var */
cmor_vars[var_id].time_bnds_nc_id=cmor_vars[varid].time_bnds_nc_id; /* in case we are doing a zfactor var */
}
@@ -3235,7 +3235,7 @@ int cmor_create_output_path(int var_id,char *outpath)
strncat(outpath,"/",CMOR_MAX_STRING-strlen(outpath));
if (createdirs==1) {
if ((mkdir(outpath, (S_IRWXU | S_IRWXG | S_IRWXO )) == -1) && (errno != EEXIST)) {
- sprintf(tmp,"creating outpath: %s, not enough permission?",outpath);
+ sprintf(tmp,"creating outpath: %s, for variable %s (table: %s). Not enough permission?",outpath,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(tmp,CMOR_CRITICAL);
}
}
@@ -3249,7 +3249,7 @@ int cmor_create_output_path(int var_id,char *outpath)
strncat(outpath,"/",CMOR_MAX_STRING-strlen(outpath));
if (createdirs==1) {
if ((mkdir(outpath, (S_IRWXU | S_IRWXG | S_IRWXO )) == -1) && (errno != EEXIST)) {
- sprintf(tmp,"creating outpath: %s, not enough permission?",outpath);
+ sprintf(tmp,"creating outpath: %s, for variable %s (table: %s). Not enough permission?",outpath,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(tmp,CMOR_CRITICAL);
}
}
@@ -3262,7 +3262,7 @@ int cmor_create_output_path(int var_id,char *outpath)
strncat(outpath,"/",CMOR_MAX_STRING-strlen(outpath));
if (createdirs==1) {
if ((mkdir(outpath, (S_IRWXU | S_IRWXG | S_IRWXO )) == -1) && (errno != EEXIST)) {
- sprintf(tmp,"creating outpath: %s, not enough permission?",outpath);
+ sprintf(tmp,"creating outpath: %s, for variable %s (table: %s). Not enough permission?",outpath,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(tmp,CMOR_CRITICAL);
}
}
@@ -3289,7 +3289,7 @@ int cmor_create_output_path(int var_id,char *outpath)
}
if (createdirs==1) {
if ((mkdir(outpath, (S_IRWXU | S_IRWXG | S_IRWXO )) == -1) && (errno != EEXIST)) {
- sprintf(tmp,"creating outpath: %s, not enough permission?",outpath);
+ sprintf(tmp,"creating outpath: %s, for variable %s (table: %s). Not enough permission?",outpath,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(tmp,CMOR_CRITICAL);
}
}
@@ -3298,7 +3298,7 @@ int cmor_create_output_path(int var_id,char *outpath)
cmor_get_cur_dataset_attribute("experiment_id",tmp);
/* ok here we check the exptid is ok */
if (cmor_check_expt_id(tmp,cmor_vars[var_id].ref_table_id,"experiment","experiment_id")!=0) {
- snprintf(tmp2,CMOR_MAX_STRING,"Invalid dataset experiment id: %s, check against table: %s",tmp,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
+ snprintf(tmp2,CMOR_MAX_STRING,"Invalid dataset experiment id: %s, for variable %s. Check against table: %s",tmp,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(tmp2,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -3334,7 +3334,7 @@ int cmor_create_output_path(int var_id,char *outpath)
/* } */
if (createdirs==1) {
if ((mkdir(outpath, (S_IRWXU | S_IRWXG | S_IRWXO )) == -1) && (errno != EEXIST)) {
- sprintf(tmp,"creating outpath: %s, not enough permission?",outpath);
+ sprintf(tmp,"creating outpath: %s, for variable %s (table: %s). Not enough permission?",outpath,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(tmp,CMOR_CRITICAL);
}
}
@@ -3398,7 +3398,7 @@ int cmor_create_output_path(int var_id,char *outpath)
strncat(outpath,"/",CMOR_MAX_STRING-strlen(outpath));
if (createdirs==1) {
if ((mkdir(outpath, (S_IRWXU | S_IRWXG | S_IRWXO )) == -1) && (errno != EEXIST)) {
- sprintf(tmp,"creating outpath: %s, not enough permission?",outpath);
+ sprintf(tmp,"creating outpath: %s, for variable %s (table: %s). Not enough permission?",outpath,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(tmp,CMOR_CRITICAL);
}
}
@@ -3426,7 +3426,7 @@ int cmor_create_output_path(int var_id,char *outpath)
strncat(outpath,"/",CMOR_MAX_STRING-strlen(outpath));
if (createdirs==1) {
if ((mkdir(outpath, (S_IRWXU | S_IRWXG | S_IRWXO )) == -1) && (errno != EEXIST)) {
- sprintf(tmp,"creating outpath: %s, not enough permission?",outpath);
+ sprintf(tmp,"creating outpath: %s, for variable %s (table: %s). Not enough permission?",outpath,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(tmp,CMOR_CRITICAL);
}
}
@@ -3436,7 +3436,7 @@ int cmor_create_output_path(int var_id,char *outpath)
strncat(outpath,"/",CMOR_MAX_STRING-strlen(outpath));
if (createdirs==1) {
if ((mkdir(outpath, (S_IRWXU | S_IRWXG | S_IRWXO )) == -1) && (errno != EEXIST)) {
- sprintf(tmp,"creating outpath: %s, not enough permission?",outpath);
+ sprintf(tmp,"creating outpath: %s, for variable %s (table: %s). Not enough permission?",outpath,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(tmp,CMOR_CRITICAL);
}
}
@@ -3470,7 +3470,7 @@ int cmor_create_output_path(int var_id,char *outpath)
strncat(outpath,"/",CMOR_MAX_STRING-strlen(outpath));
if (createdirs==1) {
if ((mkdir(outpath, (S_IRWXU | S_IRWXG | S_IRWXO )) == -1) && (errno != EEXIST)) {
- sprintf(tmp,"creating outpath: %s, not enough permission?",outpath);
+ sprintf(tmp,"creating outpath: %s, for variable %s (table: %s). Not enough permission?",outpath,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(tmp,CMOR_CRITICAL);
}
}
@@ -3517,7 +3517,7 @@ int cmor_close_variable(int var_id, char *file_name, int *preserve)
ierr = nc_close(cmor_vars[var_id].initialized);
if (ierr != NC_NOERR) {
- snprintf(msg,CMOR_MAX_STRING,"NCError (%i) closing variable %s!",ierr,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s) closing variable %s (table: %s)!",ierr,nc_strerror(ierr),cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
@@ -3545,7 +3545,7 @@ int cmor_close_variable(int var_id, char *file_name, int *preserve)
else {
sprintf(ctmp,"%i",cmor_vars[var_id].ntimes_written_coords[i]);
}
- snprintf(msg,CMOR_MAX_STRING,"while closing variable %i (%s) we noticed it has a time varying grid, you wrote %s time steps for the variable, but its associated variable %i (%s) has %s times written", cmor_vars[var_id].self, cmor_vars[var_id].id, ctmp2, cmor_vars[cmor_grids[cmor_vars[var_id].grid_id].associated_variables[i]].self,cmor_vars[cmor_grids[cmor_vars[var_id].grid_id].associated_variables[i]].id,ctmp);
+ snprintf(msg,CMOR_MAX_STRING,"while closing variable %i (%s, table %s) we noticed it has a time varying grid, you wrote %s time steps for the variable, but its associated variable %i (%s) has %s times written", cmor_vars[var_id].self, cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id, ctmp2, cmor_vars[cmor_grids[cmor_vars[var_id].grid_id].associated_variables[i]].self,cmor_vars[cmor_grids[cmor_vars[var_id].grid_id].associated_variables[i]].id,ctmp);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -3556,7 +3556,7 @@ int cmor_close_variable(int var_id, char *file_name, int *preserve)
if (cmor_vars[var_id].ntimes_written != cmor_vars[var_id].ntimes_written_associated[i]) {
sprintf(ctmp2,"%i",cmor_vars[var_id].ntimes_written);
sprintf(ctmp,"%i",cmor_vars[var_id].ntimes_written_associated[i]);
- snprintf(msg,CMOR_MAX_STRING,"while closing variable %i (%s) we noticed it has a time varying associated variable, you wrote %s time steps for the variable, but its associated variable %i (%s) has %s times written", cmor_vars[var_id].self, cmor_vars[var_id].id, ctmp2, cmor_vars[cmor_vars[var_id].associated_ids[i]].self,cmor_vars[cmor_vars[var_id].associated_ids[i]].id,ctmp);
+ snprintf(msg,CMOR_MAX_STRING,"while closing variable %i (%s, table %s) we noticed it has a time varying associated variable, you wrote %s time steps for the variable, but its associated variable %i (%s) has %s times written", cmor_vars[var_id].self,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id, ctmp2, cmor_vars[cmor_vars[var_id].associated_ids[i]].self,cmor_vars[cmor_vars[var_id].associated_ids[i]].id,ctmp);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -3569,7 +3569,7 @@ int cmor_close_variable(int var_id, char *file_name, int *preserve)
cmor_get_cur_dataset_attribute("calendar",msg2);
if (cmor_calendar_c2i(msg2,&icalo)!=0) {
- snprintf(msg,CMOR_MAX_STRING,"Cannot convert times for calendar: %s",msg2);
+ snprintf(msg,CMOR_MAX_STRING,"Cannot convert times for calendar: %s, closing variable %s (table: %s)",msg2,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
@@ -3775,7 +3775,7 @@ int cmor_close(void)
}
}
else if ((cmor_vars[i].needsinit==1)&&(cmor_vars[i].closed!=1)) {
- snprintf(msg,CMOR_MAX_STRING,"variable %s (%i) has been defined but never initialized",cmor_vars[i].id,i);
+ snprintf(msg,CMOR_MAX_STRING,"variable %s (%i, table: %s) has been defined but never initialized",cmor_vars[i].id,i,cmor_tables[cmor_vars[i].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_WARNING);
}
}
diff --git a/Src/cmor_axes.c b/Src/cmor_axes.c
index 21c918c..aa16b93 100644
--- a/Src/cmor_axes.c
+++ b/Src/cmor_axes.c
@@ -230,7 +230,7 @@ int cmor_set_axis_attribute(int id, char *attribute_name, char type, void *value
else if (type=='d') cmor_axes[id].attributes_values_num[index] = (double)*(double*)value;
else if (type=='l') cmor_axes[id].attributes_values_num[index] = (double)*(long*)value;
else {
- snprintf(msg,CMOR_MAX_STRING,"unknown type %c allowed types are c,i,l,f,d",type);
+ snprintf(msg,CMOR_MAX_STRING,"unknown type %c allowed types are c,i,l,f,d, for attribute %s of axis %s (table: %s)",type,attribute_name,cmor_axes[id].id,cmor_tables[cmor_axes[id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -250,7 +250,7 @@ int cmor_get_axis_attribute(int id, char *attribute_name, char type, void *value
if (strcmp(cmor_axes[id].attributes[i],attribute_name)==0) {index=i;break;} /* we found it */
}
if (index==-1) {
- snprintf(msg,CMOR_MAX_STRING,"Attribute %s could not be found for axis %i\n",attribute_name,id);
+ snprintf(msg,CMOR_MAX_STRING,"Attribute %s could not be found for axis %i (%s, table: %s)",attribute_name,id,cmor_axes[id].id,cmor_tables[cmor_axes[id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -320,7 +320,7 @@ int cmor_check_monotonic(double *values,int length, char *name,int isbounds, int
treatlon=1;
}
else {
- snprintf(msg,CMOR_MAX_STRING,"axis %s has non monotonic bounds values : %lf, %lf, %lf",name,values[2*i],values[2*i+2],values[2*i+4]);
+ snprintf(msg,CMOR_MAX_STRING,"axis %s (table: %s) has non monotonic bounds values : %lf, %lf, %lf",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,values[2*i],values[2*i+2],values[2*i+4]);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -357,7 +357,7 @@ int cmor_check_monotonic(double *values,int length, char *name,int isbounds, int
mono=-1;
nloop+=1;
if (nloop==length) {
- sprintf(msg,"longitude axis bounds are not monotonic");
+ sprintf(msg,"longitude axis bounds are not monotonic, axis %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -390,7 +390,7 @@ int cmor_check_monotonic(double *values,int length, char *name,int isbounds, int
/* printf("------length: %i, storeddir: %c, vlue-1, vlaue0: %lf and %lf\n",length,refaxis->stored_direction,values[length-1],values[0]); */
if ((length>1) && (((refaxis->stored_direction=='i') && (values[length-1]<values[0])) || ((refaxis->stored_direction=='d') && (values[0]<values[length-1])))) { /* need to flip that axis */
if (cmor_axes[axis_id].revert==1) {
- snprintf(msg,CMOR_MAX_STRING, "bounds of axis %s need to be flipped but axis values did not need to. This is inconsistent",name);
+ snprintf(msg,CMOR_MAX_STRING, "bounds of axis %s (table: %s) need to be flipped but axis values did not need to. This is inconsistent",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (i=0;i<length/2;i++) {
@@ -412,7 +412,7 @@ int cmor_check_monotonic(double *values,int length, char *name,int isbounds, int
/* ok now check the monotonic again */
for (i=0;i<length/2-2;i++) {
if (((values[2*i]-values[2*i+2])/(values[2*i+2]-values[2*i+4]))<0.) {
- snprintf(msg,CMOR_MAX_STRING,"axis %s has really non monotonic bounds values : %lf, %lf, %lf",name,values[i],values[i+2],values[i+4]);
+ snprintf(msg,CMOR_MAX_STRING,"axis %s (table: %s), has really non monotonic bounds values : %lf, %lf, %lf",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,values[i],values[i+2],values[i+4]);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -420,12 +420,12 @@ int cmor_check_monotonic(double *values,int length, char *name,int isbounds, int
j=1;
for (i=0;i<length-2;i+=2) {
if ((values[i]<values[i+1])&&(values[i]>values[i+2])) {
- sprintf(msg,"Axis: '%s', your bounds direction seems to be decreasing, but within cell %i they are stored increasingly: you have [%lf, %lf], but the next set is: [%lf, %lf]",name,i,values[i],values[i+1],values[i+2],values[i+3]);
+ sprintf(msg,"Axis: '%s' (table: %s), your bounds direction seems to be decreasing, but within cell %i they are stored increasingly: you have [%lf, %lf], but the next set is: [%lf, %lf]",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,i,values[i],values[i+1],values[i+2],values[i+3]);
cmor_handle_error(msg,CMOR_WARNING);
j++;
}
if ((values[i]>values[i+1]) && (values[i]<values[i+2])) {
- sprintf(msg,"Axis: '%s', your bounds direction seems to be increasing, but within cell %i they are stored decreasingly: you have [%lf, %lf], but the next set is: [%lf, %lf]",name,i,values[i],values[i+1],values[i+2],values[i+3]);
+ sprintf(msg,"Axis: '%s' (table: %s), your bounds direction seems to be increasing, but within cell %i they are stored decreasingly: you have [%lf, %lf], but the next set is: [%lf, %lf]",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,i,values[i],values[i+1],values[i+2],values[i+3]);
cmor_handle_error(msg,CMOR_WARNING);
j++;
}
@@ -438,7 +438,7 @@ int cmor_check_monotonic(double *values,int length, char *name,int isbounds, int
}
}
else if (j!=1) {
- sprintf(msg,"Some but not all of your longitude bounds need to be flipped, see warnings ot see which ones");
+ sprintf(msg,"Some but not all of your longitude bounds need to be flipped, see warnings ot see which ones, axis: %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -449,13 +449,13 @@ int cmor_check_monotonic(double *values,int length, char *name,int isbounds, int
for (i=0;i<length-2;i++) {
/* also check that bounds do not overlap */
if (((values[i]<values[i+1]) && (values[i+2]<values[i+1])) || ((values[i]>values[i+1]) && (values[i+2]>values[i+1]))) {
- snprintf(msg,CMOR_MAX_STRING,"axis %s has overlapping bounds values : %lf, %lf, %lf at index: %i",name,values[i],values[i+1],values[i+2],i);
+ snprintf(msg,CMOR_MAX_STRING,"axis %s (table: %s) has overlapping bounds values : %lf, %lf, %lf at index: %i",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,values[i],values[i+1],values[i+2],i);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
for (i=0;i<length-2;i=i+2) {
if (values[i+1]!=values[i+2]) {
- snprintf(msg,CMOR_MAX_STRING,"axis %s has bounds values that leave gaps (index %i): %lf, %lf, %lf",name,i,values[i],values[i+1],values[i+2]);
+ snprintf(msg,CMOR_MAX_STRING,"axis %s (table: %s) has bounds values that leave gaps (index %i): %lf, %lf, %lf",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,i,values[i],values[i+1],values[i+2]);
cmor_handle_error(msg,CMOR_WARNING);
}
}
@@ -469,7 +469,7 @@ int cmor_check_monotonic(double *values,int length, char *name,int isbounds, int
break;
}
else {
- snprintf(msg,CMOR_MAX_STRING,"axis %s has non monotonic values : %lf, %lf and %lf",name,values[i],values[i+1],values[i+2]);
+ snprintf(msg,CMOR_MAX_STRING,"axis %s (table: %s) has non monotonic values : %lf, %lf and %lf",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,values[i],values[i+1],values[i+2]);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -502,7 +502,7 @@ int cmor_check_monotonic(double *values,int length, char *name,int isbounds, int
mono=-1;
nloop+=1;
if (nloop==length) {
- sprintf(msg,"longitude axis is not monotonic");
+ sprintf(msg,"longitude axis is not monotonic (axis: %s, table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -533,7 +533,7 @@ int cmor_check_monotonic(double *values,int length, char *name,int isbounds, int
/* printf("length: %i, storeddir: %c, vlue-1, vlaue0: %lf and %lf\n",length,refaxis->stored_direction,values[length-1],values[0]); */
if ((length>1) && (((refaxis->stored_direction=='i') && (values[length-1]<values[0])) || ((refaxis->stored_direction=='d') && (values[0]<values[length-1])))) { /* need to flip that axis */
if ((isbounds==1) && (cmor_axes[axis_id].revert==1)) {
- snprintf(msg,CMOR_MAX_STRING, "bounds of axis %s need to be flipped but axis values did not need to. This is inconsistent",name);
+ snprintf(msg,CMOR_MAX_STRING, "bounds of axis %s (table: %s), need to be flipped but axis values did not need to. This is inconsistent",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
cmor_axes[axis_id].revert=-1;
@@ -547,13 +547,13 @@ int cmor_check_monotonic(double *values,int length, char *name,int isbounds, int
/* ok make sure we have data spanning only 1 modulo */
if (abs(values[length-1]-values[0])>360.) {
- snprintf(msg,CMOR_MAX_STRING,"axis %s has values spanning more 360 degrees %lf, %lf",name,values[0],values[length-1]);
+ snprintf(msg,CMOR_MAX_STRING,"axis %s (table: %s) has values spanning more 360 degrees %lf, %lf",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,values[0],values[length-1]);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* ok now check the monotonic again */
for (i=0;i<length-2;i++) {
if (((values[i]-values[i+1])/(values[i+1]-values[i+2]))<0.) {
- snprintf(msg,CMOR_MAX_STRING,"axis %s has non monotonic values : %lf, %lf and %lf",name,values[i],values[i+1],values[i+2]);
+ snprintf(msg,CMOR_MAX_STRING,"axis %s (table: %s) has non monotonic values : %lf, %lf and %lf",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,values[i],values[i+1],values[i+2]);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -613,7 +613,7 @@ int cmor_treat_axis_values(int axis_id, double *values, int length, int n_reques
/*ok this part will try to convert time values to the right units */
cmor_get_cur_dataset_attribute("calendar",&msg[0]);
if (cmor_calendar_c2i(msg,&acal)!=0) {
- snprintf(msg,CMOR_MAX_STRING,"none standard calendar... hum we will try to accomodate this later\n");
+ snprintf(msg,CMOR_MAX_STRING,"non-standard calendar... hum we will try to accomodate this later\n");
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -627,7 +627,7 @@ int cmor_treat_axis_values(int axis_id, double *values, int length, int n_reques
ut_trim(local_unit,UT_ASCII);
user_units = ut_parse(ut_read, local_unit, UT_ASCII);
if (ut_get_status() != UT_SUCCESS ) {
- snprintf(msg,CMOR_MAX_STRING,"In udunits analyzing units from user (%s)",local_unit);
+ snprintf(msg,CMOR_MAX_STRING,"In udunits analyzing units from user (%s), axis %s (table: %s)",local_unit,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
@@ -637,20 +637,20 @@ int cmor_treat_axis_values(int axis_id, double *values, int length, int n_reques
ut_trim(local_unit,UT_ASCII);
cmor_units = ut_parse(ut_read, local_unit,UT_ASCII);
if (ut_get_status() != UT_SUCCESS ) {
- snprintf(msg,CMOR_MAX_STRING,"In udunits analyzing table defined units (%s) for axis: %s",local_unit,refaxis->id );
+ snprintf(msg,CMOR_MAX_STRING,"In udunits analyzing table defined units (%s) for axis: %s (table: %s)",local_unit,refaxis->id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id );
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
}
if (ut_are_convertible(cmor_units,user_units)==0 ) {
- snprintf(msg,CMOR_MAX_STRING,"axis %i (%s): cmor and user units are incompatible: %s and %s",axis_id,cmor_axes[axis_id].id,refaxis->units,units);
+ snprintf(msg,CMOR_MAX_STRING,"axis %i (%s, table: %s): cmor and user units are incompatible: %s and %s",axis_id,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,refaxis->units,units);
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
}
ut_cmor_converter=ut_get_converter(user_units,cmor_units);
if (ut_get_status() != UT_SUCCESS ) {
- snprintf(msg,CMOR_MAX_STRING,"In udunits getting converter" );
+ snprintf(msg,CMOR_MAX_STRING,"In udunits getting converter, for axis %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id );
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
@@ -658,25 +658,25 @@ int cmor_treat_axis_values(int axis_id, double *values, int length, int n_reques
cv_convert_doubles(ut_cmor_converter,values,length,values);
/* cv_convert_doubles(ut_cmor_converter,&cmor_axes[cmor_naxes].values[0],length,&cmor_axes[cmor_naxes].values[0]); */
if (ut_get_status() != UT_SUCCESS ) {
- snprintf(msg,CMOR_MAX_STRING,"In udunits converting values" );
+ snprintf(msg,CMOR_MAX_STRING,"In udunits converting values, for axis %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id );
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
}
cv_free(ut_cmor_converter);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter, for axis %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(cmor_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units, for axis %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(user_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units, for axis %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -703,7 +703,7 @@ int cmor_treat_axis_values(int axis_id, double *values, int length, int n_reques
}
}
if (found==0) {
- snprintf(msg,CMOR_MAX_STRING,"requested value %f for axis %s was not found",refaxis->requested[j],name);
+ snprintf(msg,CMOR_MAX_STRING,"requested value %f for axis %s (table: %s) was not found",refaxis->requested[j],name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -713,7 +713,7 @@ int cmor_treat_axis_values(int axis_id, double *values, int length, int n_reques
/* stored_direction*/
if ((length>1) && (((refaxis->stored_direction=='i') && (values[length-1]<values[0])) || ((refaxis->stored_direction=='d') && (values[0]<values[length-1])))) { /* need to flip that axis */
if ((isbounds==1) && (axis->revert==1)) {
- snprintf(msg,CMOR_MAX_STRING, "bounds of axis %s need to be flipped but axis values did not need to. This is inconsistent",name);
+ snprintf(msg,CMOR_MAX_STRING, "bounds of axis %s (table: %s) need to be flipped but axis values did not need to. This is inconsistent",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
axis->revert=-1;
@@ -779,7 +779,7 @@ int cmor_treat_axis_values(int axis_id, double *values, int length, int n_reques
}
}
if (found==0) {
- snprintf(msg,CMOR_MAX_STRING,"requested value %f for axis %s was not found",refaxis->requested_bounds[j],name);
+ snprintf(msg,CMOR_MAX_STRING,"requested value %f for axis %s (table: %s) was not found",refaxis->requested_bounds[j],name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -812,7 +812,7 @@ int cmor_treat_axis_values(int axis_id, double *values, int length, int n_reques
treatlon = 1;
}
else {
- snprintf(msg,CMOR_MAX_STRING,"axis %s, detected value at: %f when valid_min is %f\n",name,values[i],refaxis->valid_min);
+ snprintf(msg,CMOR_MAX_STRING,"axis %s (table: %s), detected value at: %f when valid_min is %f\n",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,values[i],refaxis->valid_min);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -836,7 +836,7 @@ int cmor_treat_axis_values(int axis_id, double *values, int length, int n_reques
treatlon = 1;
}
else {
- snprintf(msg,CMOR_MAX_STRING,"axis %s, detected value at: %f when valid_max is %f\n",name,values[i],refaxis->valid_max);
+ snprintf(msg,CMOR_MAX_STRING,"axis %s (table: %s) , detected value at: %f when valid_max is %f\n",name,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,values[i],refaxis->valid_max);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -922,7 +922,7 @@ int cmor_check_interval(int axis_id, char *interval, double *values, int nvalues
nval = nvalues/2+1;
tmp_values = malloc(sizeof(double)*nval);
if (tmp_values==NULL) {
- snprintf(ctmp,CMOR_MAX_STRING,"Error allocating memory for %i values in check_interval (%s)",nval,interval);
+ snprintf(ctmp,CMOR_MAX_STRING,"Error allocating memory for %i values in check_interval (%s), axis: %s (table: %s)",nval,interval,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(ctmp,CMOR_CRITICAL);
}
for (i=0;i<nval-1;i++) tmp_values[i] = values[i*2];
@@ -949,34 +949,34 @@ int cmor_check_interval(int axis_id, char *interval, double *values, int nvalues
cmor_units = ut_parse(ut_read, msg,UT_ASCII);
user_units = ut_parse(ut_read, ctmp2, UT_ASCII);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"In udunuits parsing user units: %s",ctmp2);
+ snprintf(msg,CMOR_MAX_STRING,"In udunuits parsing user units: %s, axis: %s (table: %s)",ctmp2,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (ut_are_convertible(cmor_units,user_units)==0 ) {
- snprintf(ctmp,CMOR_MAX_STRING,"axis interval units (%s) are incompatible with seconds",ctmp2);
+ snprintf(ctmp,CMOR_MAX_STRING,"axis interval units (%s) are incompatible with seconds, axis: %s (table: %s)",ctmp2,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(ctmp,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
}
ut_cmor_converter=ut_get_converter(user_units,cmor_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"In udunuits getting converter");
+ snprintf(msg,CMOR_MAX_STRING,"In udunuits getting converter, axis: %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
tmp = cv_convert_double(ut_cmor_converter,interv);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"In udunuits converting");
+ snprintf(msg,CMOR_MAX_STRING,"In udunuits converting, axis: %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
interv = tmp;
cv_free(ut_cmor_converter);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter, axis: %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(user_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units, axis: %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
@@ -992,18 +992,18 @@ int cmor_check_interval(int axis_id, char *interval, double *values, int nvalues
}
user_units = ut_parse(ut_read, ctmp2, UT_ASCII);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"In udunuits parsing user units: %s",ctmp2);
+ snprintf(msg,CMOR_MAX_STRING,"In udunuits parsing user units: %s, axis: %s (table: %s)",ctmp2,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (ut_are_convertible(cmor_units,user_units)==0 ) {
- snprintf(ctmp,CMOR_MAX_STRING,"axis interval units (%s) are incompatible with seconds",ctmp2);
+ snprintf(ctmp,CMOR_MAX_STRING,"axis interval units (%s) are incompatible with seconds, axis: %s (table: %s)",ctmp2,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(ctmp,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
}
ut_cmor_converter=ut_get_converter(user_units,cmor_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error getting converter from %s to %s",ctmp2,msg);
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error getting converter from %s to %s, axis: %s (table: %s)",ctmp2,msg,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
tmp=0.;
@@ -1012,7 +1012,7 @@ int cmor_check_interval(int axis_id, char *interval, double *values, int nvalues
/* now converts to seconds */
tmp = cv_convert_double(ut_cmor_converter,diff);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"In udunuits converting");
+ snprintf(msg,CMOR_MAX_STRING,"In udunuits converting, axis: %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
diff = tmp;
@@ -1057,18 +1057,18 @@ int cmor_check_interval(int axis_id, char *interval, double *values, int nvalues
}
cv_free(ut_cmor_converter);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter, axis: %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(cmor_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units, axis: %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(user_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units, axis: %s (table: %s)",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (isbounds == 1) free(tmp_values);
@@ -1161,7 +1161,7 @@ int cmor_axis(int *axis_id, char *name,char *units, int length,void *coord_vals,
/* remembers what the original type was */
i = cmor_axes[cmor_naxes].hybrid_in;
if ((strcmp(name,"standard_hybrid_sigma")!=0) && (strcmp(name,"alternate_hybrid_sigma")!=0) && (strcmp(name,"standard_sigma")!=0)) {
- snprintf(msg,CMOR_MAX_STRING,"axis: %s converting to \"standard_hybrid_sigma\" from unknown type: %s",cmor_axes[cmor_naxes].id,name);
+ snprintf(msg,CMOR_MAX_STRING,"axis: %s (table: %s) converting to \"standard_hybrid_sigma\" from unknown type: %s",cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id,name);
cmor_handle_error(msg,CMOR_CRITICAL);
}
printf("yep we are copnverting to: %s\n",refaxis.convert_to);
@@ -1173,7 +1173,7 @@ int cmor_axis(int *axis_id, char *name,char *units, int length,void *coord_vals,
return 0;
}
else {
- snprintf(msg,CMOR_MAX_STRING,"axis: %s is declared to be converted to unknown type: %s",cmor_axes[cmor_naxes].id,refaxis.convert_to);
+ snprintf(msg,CMOR_MAX_STRING,"axis: %s (table: %s) is declared to be converted to unknown type: %s",cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id,refaxis.convert_to);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -1190,11 +1190,11 @@ int cmor_axis(int *axis_id, char *name,char *units, int length,void *coord_vals,
/* test whether bounds are requested or not */
if ((cell_bounds==NULL) && (refaxis.must_have_bounds==1)) {
if (refaxis.axis!='T') {
- snprintf(msg,CMOR_MAX_STRING,"axis: %s must have bounds, you did not pass any when creating it via cmor_axis",cmor_axes[cmor_naxes].id);
+ snprintf(msg,CMOR_MAX_STRING,"axis: %s (table: %s) must have bounds, you did not pass any when creating it via cmor_axis",cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
else if (coord_vals!=NULL) { /* we passed time values that means we do not intend to pass them later */
- snprintf(msg,CMOR_MAX_STRING,"axis: %s must have bounds, you did not pass any when creating it via cmor_axis",cmor_axes[cmor_naxes].id);
+ snprintf(msg,CMOR_MAX_STRING,"axis: %s (table: %s) must have bounds, you did not pass any when creating it via cmor_axis",cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -1202,7 +1202,7 @@ int cmor_axis(int *axis_id, char *name,char *units, int length,void *coord_vals,
if (type!='c') {
cmor_axes[cmor_naxes].values=malloc(length*sizeof(double));
if ( cmor_axes[cmor_naxes].values == NULL ) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_axis: cannot allocate memory for %i double elts for axis %s",length,cmor_axes[cmor_naxes].id);
+ snprintf(msg,CMOR_MAX_STRING,"cannot allocate memory for %i double elts for axis %s (table: %s)",length,cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (type=='f') for (i=0;i<length;i++) cmor_axes[cmor_naxes].values[i] = (double)((float *)coord_vals)[i];
@@ -1215,7 +1215,7 @@ int cmor_axis(int *axis_id, char *name,char *units, int length,void *coord_vals,
else {
cmor_axes[cmor_naxes].cvalues=malloc(length*sizeof(char *));
if (cmor_axes[cmor_naxes].cvalues == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_axis: cannot allocate memory for %i char elts for axis %s",length,cmor_axes[cmor_naxes].id);
+ snprintf(msg,CMOR_MAX_STRING,"cannot allocate memory for %i char elts for axis %s (table: %s)",length,cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (cell_bounds_ndim==0) k=CMOR_MAX_STRING;
@@ -1225,7 +1225,7 @@ int cmor_axis(int *axis_id, char *name,char *units, int length,void *coord_vals,
if (j>k) j=k;
cmor_axes[cmor_naxes].cvalues[i]=malloc((j+1)*sizeof(char));
if (cmor_axes[cmor_naxes].cvalues[i] == NULL ) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_axis: cannot allocate memory for %i char elts for axis %s",j+1,cmor_axes[cmor_naxes].id);
+ snprintf(msg,CMOR_MAX_STRING,"cannot allocate memory for %i char elts for axis %s (table: %s)",j+1,cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
strncpy(cmor_axes[cmor_naxes].cvalues[i],&((char *)coord_vals)[i*k],j);
@@ -1246,7 +1246,7 @@ int cmor_axis(int *axis_id, char *name,char *units, int length,void *coord_vals,
if (strncmp(ctmp,cmor_axes[cmor_naxes].cvalues[l],strlen(ctmp))==0) k=l;
}
if (k==-1) {
- snprintf(msg,CMOR_MAX_STRING,"Requested region for axis '%s' is not passed: '%s'",cmor_axes[cmor_naxes].id,ctmp);
+ snprintf(msg,CMOR_MAX_STRING,"Requested region for axis '%s' (table: %s) is not passed: '%s'",cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id,ctmp);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -1262,7 +1262,7 @@ int cmor_axis(int *axis_id, char *name,char *units, int length,void *coord_vals,
if ((cell_bounds!=NULL) && (cell_bounds_ndim!=0)) {
cmor_axes[cmor_naxes].bounds=malloc(2*length*sizeof(double));
if (cmor_axes[cmor_naxes].bounds == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_axis: cannot allocate memory for %i bounds elts for axis %s",2*length,cmor_axes[cmor_naxes].id);
+ snprintf(msg,CMOR_MAX_STRING,"cannot allocate memory for %i bounds elts for axis %s (table: %s)",2*length,cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (cell_bounds_ndim == 2) {
@@ -1270,14 +1270,14 @@ int cmor_axis(int *axis_id, char *name,char *units, int length,void *coord_vals,
else if (type=='d') for (i=0;i<length;i++) { cmor_axes[cmor_naxes].bounds[2*i]=(double)((double *)cell_bounds)[2*i];cmor_axes[cmor_naxes].bounds[2*i+1]=(double)((double *)cell_bounds)[2*i+1]; }
else if (type=='l') for (i=0;i<length;i++) { cmor_axes[cmor_naxes].bounds[2*i]=(double)((long *)cell_bounds)[2*i];cmor_axes[cmor_naxes].bounds[2*i+1]=(double)((long *)cell_bounds)[2*i+1]; }
else if (type=='i') for (i=0;i<length;i++) { cmor_axes[cmor_naxes].bounds[2*i]=(double)((int *)cell_bounds)[2*i];cmor_axes[cmor_naxes].bounds[2*i+1]=(double)((int *)cell_bounds)[2*i+1]; }
- else { /* ??? charcter axis code here */ snprintf(msg,CMOR_MAX_STRING,"CMOR cannot handle axes of type %c please submit a request or change type\n",type); cmor_handle_error(msg,CMOR_CRITICAL);}
+ else { /* ??? charcter axis code here */ snprintf(msg,CMOR_MAX_STRING,"CMOR cannot handle axes of type %c please change type, axis: %s (table: %s)",type,cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id); cmor_handle_error(msg,CMOR_CRITICAL);}
}
else if (cell_bounds_ndim == 1) {
if (type=='f') for (i=0;i<length;i++) { cmor_axes[cmor_naxes].bounds[2*i]=(double)((float *)cell_bounds)[i]; cmor_axes[cmor_naxes].bounds[2*i+1]=(double)((float *)cell_bounds)[i+1]; }
else if (type=='d') for (i=0;i<length;i++) {cmor_axes[cmor_naxes].bounds[2*i]=(double)((double *)cell_bounds)[i]; cmor_axes[cmor_naxes].bounds[2*i+1]=(double)((double *)cell_bounds)[i+1]; }
else if (type=='i') for (i=0;i<length;i++) { cmor_axes[cmor_naxes].bounds[2*i]=(double)((int *)cell_bounds)[i]; cmor_axes[cmor_naxes].bounds[2*i+1]=(double)((int *)cell_bounds)[i+1]; }
else if (type=='l') for (i=0;i<length;i++) { cmor_axes[cmor_naxes].bounds[2*i]=(double)((long *)cell_bounds)[i]; cmor_axes[cmor_naxes].bounds[2*i+1]=(double)((long *)cell_bounds)[i+1]; }
- else { /* ??? charcter axis code here */ snprintf(msg,CMOR_MAX_STRING,"CMOR cannot handle axes of type %c please submit a request or change type\n",type); cmor_handle_error(msg,CMOR_CRITICAL);}
+ else { /* ??? charcter axis code here */ snprintf(msg,CMOR_MAX_STRING,"CMOR cannot handle axes of type %c please change type, axis: %s (table: %s)",type,cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id); cmor_handle_error(msg,CMOR_CRITICAL);}
}
/* for (i=0;i<length;i++) printf("bounds: %i -> %lf,%lf\n",i,cmor_axes[cmor_naxes].bounds[2*i],cmor_axes[cmor_naxes].bounds[2*i+1]); */
ierr = cmor_treat_axis_values(cmor_naxes, &cmor_axes[cmor_naxes].bounds[0],2*length,0,units, name, 1 );
@@ -1292,7 +1292,7 @@ int cmor_axis(int *axis_id, char *name,char *units, int length,void *coord_vals,
}
else {
if ((refaxis.axis!='T') && (refaxis.index_only=='n')) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_axis: function called for axis '%s' w/o any values",cmor_axes[cmor_naxes].id);
+ snprintf(msg,CMOR_MAX_STRING,"function called for axis '%s' (table: %s) w/o any values",cmor_axes[cmor_naxes].id,cmor_tables[CMOR_TABLE].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (refaxis.index_only!='n') {
@@ -1452,12 +1452,12 @@ int cmor_set_axis_def_att(cmor_axis_def_t *axis,char att[CMOR_MAX_STRING],char v
}
if (axis->n_requested_bounds!=0) { /* ok we already had some read in need to memorize it */
if (axis->requested_bounds == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"axis: looks like we already read %d requested bounds but they are not stored in the internal tables, maybe some bad cleanup",axis->n_requested_bounds);
+ snprintf(msg,CMOR_MAX_STRING,"axis (%s, table: %s): looks like we already read %d requested bounds but they are not stored in the internal tables, maybe some bad cleanup",axis->id, cmor_tables[axis->table_id].table_id,axis->n_requested_bounds);
cmor_handle_error(msg,CMOR_CRITICAL);
}
tmp=malloc(axis->n_requested_bounds*sizeof(double));
if (tmp == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"axis: cannot allocate memory for %i requested bounds elts for axis %s",axis->n_requested,axis->id);
+ snprintf(msg,CMOR_MAX_STRING,"axis (%s, table: %s): cannot allocate memory for %i requested bounds elts for axis %s",axis->id, cmor_tables[axis->table_id].table_id,axis->n_requested,axis->id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (i=0;i<axis->n_requested_bounds;i++) {
@@ -1471,7 +1471,7 @@ int cmor_set_axis_def_att(cmor_axis_def_t *axis,char att[CMOR_MAX_STRING],char v
}
axis->requested_bounds=malloc(axis->n_requested_bounds*sizeof(double));
if (axis->requested_bounds == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"axis: cannot allocate memory for %i requested bounds elts for axis %s",axis->n_requested,axis->id);
+ snprintf(msg,CMOR_MAX_STRING,"axis (%s, table: %s): cannot allocate memory for %i requested bounds elts for axis %s",axis->id, cmor_tables[axis->table_id].table_id,axis->n_requested,axis->id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (i=0;i<n;i++) { axis->requested_bounds[axis->n_requested_bounds-n+i]=vals[i];}
@@ -1503,12 +1503,12 @@ int cmor_set_axis_def_att(cmor_axis_def_t *axis,char att[CMOR_MAX_STRING],char v
}
if (axis->n_requested!=0) { /* ok we already had some read in need to memorize it */
if (axis->requested == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"axis: looks like we already read %d requested values but they are not stored in the internal tables, maybe some bad cleanup",axis->n_requested);
+ snprintf(msg,CMOR_MAX_STRING,"axis (%s, table: %s): looks like we already read %d requested values but they are not stored in the internal tables, maybe some bad cleanup",axis->id, cmor_tables[axis->table_id].table_id,axis->n_requested);
cmor_handle_error(msg,CMOR_CRITICAL);
}
tmp=malloc(axis->n_requested*sizeof(double));
if (tmp == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"axis: cannot allocate memory for %i requested elts for axis %s",axis->n_requested,axis->id);
+ snprintf(msg,CMOR_MAX_STRING,"axis (%s, table: %s): cannot allocate memory for %i requested elts for axis %s",axis->id, cmor_tables[axis->table_id].table_id,axis->n_requested,axis->id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (i=0;i<axis->n_requested;i++) {
@@ -1522,7 +1522,7 @@ int cmor_set_axis_def_att(cmor_axis_def_t *axis,char att[CMOR_MAX_STRING],char v
}
axis->requested=malloc(axis->n_requested*sizeof(double));
if (axis->requested == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"axis: cannot allocate memory for %i requested elts for axis %s",axis->n_requested,axis->id);
+ snprintf(msg,CMOR_MAX_STRING,"axis (%s, table: %s): cannot allocate memory for %i requested elts for axis %s",axis->id, cmor_tables[axis->table_id].table_id,axis->n_requested,axis->id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (i=0;i<n;i++) { /* printf("requested: %i : %f\n",i,vals[i]); */ axis->requested[i]=vals[i];}
@@ -1538,14 +1538,14 @@ int cmor_set_axis_def_att(cmor_axis_def_t *axis,char att[CMOR_MAX_STRING],char v
axis->n_requested=1;
axis->crequested=malloc((strlen(val)+1)*sizeof(char));
if (axis->crequested == NULL ) {
- snprintf(msg,CMOR_MAX_STRING,"axis: cannot allocate memory for %ld requested char elts for axis %s",(long int)strlen(val)+1,axis->id);
+ snprintf(msg,CMOR_MAX_STRING,"axis (%s, table: %s): cannot allocate memory for %ld requested char elts for axis %s",axis->id, cmor_tables[axis->table_id].table_id,(long int)strlen(val)+1,axis->id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
strcpy(axis->crequested,val);
}
}
else {
- snprintf(msg,CMOR_MAX_STRING,"Unknown attribute >>>%s<<< for axis section, value: %s",att,val);
+ snprintf(msg,CMOR_MAX_STRING,"Unknown attribute >>>%s<<< for axis section (%s, table: %s), value: %s",att,axis->id, cmor_tables[axis->table_id].table_id,val);
cmor_handle_error(msg,CMOR_WARNING);
}
cmor_pop_traceback();
diff --git a/Src/cmor_grids.c b/Src/cmor_grids.c
index d0c9498..bc35115 100644
--- a/Src/cmor_grids.c
+++ b/Src/cmor_grids.c
@@ -538,7 +538,7 @@ int cmor_time_varying_grid_coordinate(int *coord_grid_id, int grid_id, char *ta
break;
case (2) :
if (nvertices == 0 ) {
- sprintf(msg,"your definnig a vertices dependent variable (%s) associated wth grid %i, but you declared this grid as having 0 vertices",table_entry,grid_id);
+ sprintf(msg,"your defining a vertices dependent variable (%s) associated wth grid %i, but you declared this grid as having 0 vertices",table_entry,grid_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (cmor_grids[cmor_vars[*coord_grid_id].grid_id].associated_variables[3] == -1) {
diff --git a/Src/cmor_tables.c b/Src/cmor_tables.c
index 1c6f0e7..bd4fbe1 100644
--- a/Src/cmor_tables.c
+++ b/Src/cmor_tables.c
@@ -69,7 +69,7 @@ int cmor_set_dataset_att(cmor_table_t *table, char att[CMOR_MAX_STRING],char val
d2+=d;
sscanf(value,"%f",&d);
if (d>d2) {
- snprintf(value2,CMOR_MAX_STRING,"Table is defined for cmor_version %f, this library verson is: %i.%i.%i, %f",d,CMOR_VERSION_MAJOR,CMOR_VERSION_MINOR,CMOR_VERSION_PATCH,d2);
+ snprintf(value2,CMOR_MAX_STRING,"Table %s is defined for cmor_version %f, this library verson is: %i.%i.%i, %f",table->table_id,d,CMOR_VERSION_MAJOR,CMOR_VERSION_MINOR,CMOR_VERSION_PATCH,d2);
cmor_handle_error(value2,CMOR_CRITICAL);
cmor_ntables--;
cmor_pop_traceback();
@@ -123,7 +123,8 @@ int cmor_set_dataset_att(cmor_table_t *table, char att[CMOR_MAX_STRING],char val
else if (strcmp(att,"table_id")==0) {
for (n=0;n==cmor_ntables;n++) {
if (strcmp(cmor_tables[n].table_id,value)==0) {
- cmor_handle_error("Table already defined",CMOR_CRITICAL);
+ snprintf(value2,CMOR_MAX_STRING,"Table %s is already defined",table->table_id);
+ cmor_handle_error(value2,CMOR_CRITICAL);
cmor_ntables--;
cmor_pop_traceback();
return 1;
@@ -143,7 +144,8 @@ int cmor_set_dataset_att(cmor_table_t *table, char att[CMOR_MAX_STRING],char val
else if (strcmp(att,"expt_id_ok")==0) {
table->nexps++;
if (table->nexps>CMOR_MAX_ELEMENTS) {
- cmor_handle_error("Too many experiments defined",CMOR_CRITICAL);
+ snprintf(value2,CMOR_MAX_STRING,"Table %s: Too many experiments defined",table->table_id);
+ cmor_handle_error(value2,CMOR_CRITICAL);
cmor_ntables--;
cmor_pop_traceback();
return 1;
@@ -194,7 +196,7 @@ int cmor_set_dataset_att(cmor_table_t *table, char att[CMOR_MAX_STRING],char val
/* Never actually implemented supposed to control table has not been altered */
}
else {
- snprintf(value,CMOR_MAX_STRING,"unknown keyword for dataset: %s (%s)",att,value);
+ snprintf(value,CMOR_MAX_STRING,"table: %s, unknown keyword for dataset: %s (%s)",table->table_id,att,value);
cmor_handle_error(value,CMOR_WARNING);
}
cmor_pop_traceback();
@@ -210,7 +212,10 @@ int cmor_set_table(int table) {
snprintf(msg,CMOR_MAX_STRING,"Invalid table number: %i",table);
cmor_handle_error(msg,CMOR_CRITICAL);
}
- if (cmor_tables[table].table_id=='\0') cmor_handle_error("Invalid table , not loaded yet!",CMOR_CRITICAL);
+ if (cmor_tables[table].table_id=='\0') {
+ snprintf(msg,CMOR_MAX_STRING,"Invalid table: %i , not loaded yet!",table);
+ cmor_handle_error(msg,CMOR_CRITICAL);
+ }
CMOR_TABLE = table;
cmor_pop_traceback();
return 0;
@@ -308,7 +313,8 @@ int cmor_load_table(char table[CMOR_MAX_STRING], int *table_id) {
do_mapping=0;
cmor_tables[cmor_ntables].naxes++;
if (cmor_tables[cmor_ntables].naxes>=CMOR_MAX_ELEMENTS) {
- cmor_handle_error("Too many axes defined for table",CMOR_CRITICAL);
+ snprintf(msg,CMOR_MAX_STRING,"Too many axes defined for table: %s",cmor_tables[cmor_ntables].table_id);
+ cmor_handle_error(msg,CMOR_CRITICAL);
cmor_ntables--;
cmor_pop_traceback();
return 1;
@@ -325,7 +331,8 @@ int cmor_load_table(char table[CMOR_MAX_STRING], int *table_id) {
do_mapping=0;
cmor_tables[cmor_ntables].nvars++;
if (cmor_tables[cmor_ntables].nvars>=CMOR_MAX_ELEMENTS) {
- cmor_handle_error("Too many variables defined for table",CMOR_CRITICAL);
+ snprintf(msg,CMOR_MAX_STRING,"Too many variables defined for table: %s",cmor_tables[cmor_ntables].table_id);
+ cmor_handle_error(msg,CMOR_CRITICAL);
cmor_ntables--;
cmor_pop_traceback();
return 1;
@@ -342,13 +349,14 @@ int cmor_load_table(char table[CMOR_MAX_STRING], int *table_id) {
do_mapping=1;
cmor_tables[cmor_ntables].nmappings++;
if (cmor_tables[cmor_ntables].nmappings>=CMOR_MAX_ELEMENTS) {
- cmor_handle_error("Too many mappings defined for table",CMOR_CRITICAL);
+ snprintf(msg,CMOR_MAX_STRING,"Too many mappings defined for table: %s",cmor_tables[cmor_ntables].table_id);
+ cmor_handle_error(msg,CMOR_CRITICAL);
cmor_ntables--;
cmor_pop_traceback();
return 1;
}
for(n=0;n<cmor_tables[cmor_ntables].nmappings-1;n++) if (strcmp(cmor_tables[cmor_ntables].mappings[cmor_tables[cmor_ntables].nmappings].id,cmor_tables[cmor_ntables].mappings[n].id)==0) {
- snprintf(msg,CMOR_MAX_STRING,"mapping: %s already defined within this table",cmor_tables[cmor_ntables].mappings[n].id);
+ snprintf(msg,CMOR_MAX_STRING,"mapping: %s already defined within this table (%s)",cmor_tables[cmor_ntables].mappings[n].id,cmor_tables[cmor_ntables].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
};
@@ -356,7 +364,7 @@ int cmor_load_table(char table[CMOR_MAX_STRING], int *table_id) {
cmor_init_grid_mapping(&cmor_tables[cmor_ntables].mappings[cmor_tables[cmor_ntables].nmappings],word2);
}
else { /* nothing knwon we will not be setting any attributes! */
- snprintf(msg,CMOR_MAX_STRING,"unknown section: %s",word);
+ snprintf(msg,CMOR_MAX_STRING,"unknown section: %s, for table: %s",word,cmor_tables[cmor_ntables].table_id);
cmor_handle_error(msg,CMOR_WARNING);
do_dataset=0;
do_var=0;
@@ -416,7 +424,7 @@ int cmor_load_table(char table[CMOR_MAX_STRING], int *table_id) {
cmor_set_mapping_attribute(&cmor_tables[cmor_ntables].mappings[cmor_tables[cmor_ntables].nmappings],word,word2);
}
else {
- snprintf(msg,CMOR_MAX_STRING,"attribute for unknown section: %s,%s",word,word2);
+ snprintf(msg,CMOR_MAX_STRING,"attribute for unknown section: %s,%s (table: %s)",word,word2,cmor_tables[cmor_ntables].table_id);
cmor_handle_error(msg,CMOR_WARNING);
/*printf("attribute for unknown section\n");*/
}
diff --git a/Src/cmor_variables.c b/Src/cmor_variables.c
index 20059b9..aa969c6 100644
--- a/Src/cmor_variables.c
+++ b/Src/cmor_variables.c
@@ -60,7 +60,7 @@ int cmor_has_required_variable_attributes(int var_id)
}
astr[j]='\0';
if (cmor_has_variable_attribute(var_id,astr)!=0) {
- snprintf(msg,CMOR_MAX_STRING,"variable %s does not have required attribute: %s",cmor_vars[var_id].id,astr);
+ snprintf(msg,CMOR_MAX_STRING,"variable %s (table %s) does not have required attribute: %s",cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,astr);
cmor_handle_error(msg,CMOR_CRITICAL);
}
j=0;
@@ -100,7 +100,7 @@ int cmor_set_variable_attribute(int id, char *attribute_name, char type, void *v
else if (type=='d') cmor_vars[id].attributes_values_num[index] = (double)*(double*)value;
else if (type=='l') cmor_vars[id].attributes_values_num[index] = (double)*(long*)value;
else {
- snprintf(msg,CMOR_MAX_STRING,"unknown type %c allowed types are c,i,l,f,d",type);
+ snprintf(msg,CMOR_MAX_STRING,"unknown type %c for attribute %s of variable %s (table %s),allowed types are c,i,l,f,d",type,attribute_name,cmor_vars[id].id,cmor_tables[cmor_vars[id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -121,7 +121,7 @@ int cmor_get_variable_attribute(int id, char *attribute_name, void *value)
if (strcmp(cmor_vars[id].attributes[i],attribute_name)==0) {index=i;break;} /* we found it */
}
if (index==-1) {
- snprintf(msg,CMOR_MAX_STRING,"Attribute %s could not be found for variable %i",attribute_name,id);
+ snprintf(msg,CMOR_MAX_STRING,"Attribute %s could not be found for variable %i (%s, table: %s)",attribute_name,id,cmor_vars[id].id,cmor_tables[cmor_vars[id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -179,7 +179,7 @@ int cmor_get_variable_attribute_type(int id, char *attribute_name, char *type)
if (strcmp(cmor_vars[id].attributes[i],attribute_name)==0) {index=i;break;} /* we found it */
}
if (index==-1) {
- snprintf(msg,CMOR_MAX_STRING,"Attribute %s could not be found for variable %i",attribute_name,id);
+ snprintf(msg,CMOR_MAX_STRING,"Attribute %s could not be found for variable %i (%s, table: %s)",attribute_name,id,cmor_vars[id].id,cmor_tables[cmor_vars[id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
@@ -232,7 +232,7 @@ int cmor_zfactor (int *zvar_id,int axis_id, char *name, char *units, int ndims,
}
cmor_vars[var_id].values = malloc(n*sizeof(double));
if (cmor_vars[var_id].values == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_zfactor: cannot allocate memory for %i double elts %s var '%s'",n,cmor_vars[*zvar_id].id,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"cmor_zfactor: zaxis %s, cannot allocate memory for %i double elts %s var '%s' (table: %s)",cmor_axes[axis_id].id,n,cmor_vars[var_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (i=0;i<n;i++) {
@@ -246,39 +246,39 @@ int cmor_zfactor (int *zvar_id,int axis_id, char *name, char *units, int ndims,
strncpy(local_unit,cmor_vars[var_id].ounits,CMOR_MAX_STRING);
cmor_units = ut_parse(ut_read, local_unit,UT_ASCII);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error parsing units: %s",local_unit);
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error parsing units: %s, zaxis: %s, variable %s (table: %s)",local_unit,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
strncpy(local_unit,units,CMOR_MAX_STRING);
ut_trim(local_unit,UT_ASCII);
user_units = ut_parse(ut_read, local_unit, UT_ASCII);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error parsing units: %s",local_unit);
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error parsing units: %s, zaxis %s, variable %s (table: %s)",local_unit,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_cmor_converter=ut_get_converter(user_units,cmor_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error getting converter from %s to %s",units,cmor_vars[var_id].ounits);
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error getting converter from %s to %s, zaxis: %s, variable %s (table: %s)",units,cmor_vars[var_id].ounits,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
cv_convert_doubles(ut_cmor_converter,&cmor_vars[var_id].values[0],n,&cmor_vars[var_id].values[0]);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error converting units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error with converter (from %s to %s), zaxis: %s, variable %s (table: %s)",units,cmor_vars[var_id].ounits,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
cv_free(ut_cmor_converter);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter, zaxis %s, variable %s (table: %s)",cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(cmor_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units %s, zaxis %s, variable %s (table: %s)",cmor_vars[var_id].ounits,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(user_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units %s, zaxis %s,variable %s (table: %s)",units,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
@@ -307,14 +307,14 @@ int cmor_zfactor (int *zvar_id,int axis_id, char *name, char *units, int ndims,
}
}
if (k==0) {
- snprintf(msg,CMOR_MAX_STRING,"zfactor: %s, is not time dependent and you did not provide any values",name);
+ snprintf(msg,CMOR_MAX_STRING,"zfactor: axis %s, variable %s (table %s), is not time dependent and you did not provide any values",cmor_axes[axis_id].id,name,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
*zvar_id = var_id;
}
if (bounds != NULL) {
if (ndims!=1) {
- snprintf(msg,CMOR_MAX_STRING,"zfactor %s: you passed bounds values but you also declared %i dimensions, we will ignore you bounds",name,ndims);
+ snprintf(msg,CMOR_MAX_STRING,"zfactor axis %s, variable %s (table: %s): you passed bounds values but you also declared %i dimensions, we will ignore you bounds",cmor_axes[axis_id].id,name,cmor_tables[cmor_vars[var_id].ref_table_id].table_id,ndims);
cmor_handle_error(msg,CMOR_WARNING);
}
else {
@@ -327,7 +327,7 @@ int cmor_zfactor (int *zvar_id,int axis_id, char *name, char *units, int ndims,
n = cmor_axes[axes_ids[0]].length;
cmor_vars[var_id].values = malloc(2*n*sizeof(double));
if ( cmor_vars[var_id].values == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_zfactor: cannot allocate memory for %i double bounds elts %s var '%s'",2*n,cmor_vars[*zvar_id].id,cmor_vars[var_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"cmor_zfactor: zaxis %s, cannot allocate memory for %i double bounds elts %s var '%s' (table: %s)",cmor_axes[axis_id].id,2*n,cmor_vars[var_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
cmor_vars[var_id].isbounds=1;
@@ -341,40 +341,40 @@ int cmor_zfactor (int *zvar_id,int axis_id, char *name, char *units, int ndims,
strncpy(local_unit,cmor_vars[var_id].ounits,CMOR_MAX_STRING);
cmor_units = ut_parse(ut_read, local_unit,UT_ASCII);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error parsing units: %s",local_unit);
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error parsing units: %s, for zaxis %s, variable %s (table: %s)",local_unit,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
strncpy(local_unit,units,CMOR_MAX_STRING);
ut_trim(local_unit,UT_ASCII);
user_units = ut_parse(ut_read, local_unit, UT_ASCII);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error parsing units: %s",local_unit);
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error parsing units: %s, zaxis %s, variable %s (table: %s)",local_unit,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_cmor_converter=ut_get_converter(user_units,cmor_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error getting converter from %s to %s",units,cmor_vars[var_id].ounits);
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error getting converter from %s to %s, zaxis %s, variable %s (table: %s)",units,cmor_vars[var_id].ounits,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
cv_convert_doubles(ut_cmor_converter,&cmor_vars[var_id].values[0],2*n,&cmor_vars[var_id].values[0]);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error converting units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error converting units from %s to %s, zaxis %s, variable %s (table: %s)",units,cmor_vars[var_id].ounits,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
cv_free(ut_cmor_converter);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter, zaxis %s, variable %s (table: %s)",cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(cmor_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing cmor units %s, zaxis %s, variable %s (table: %s)",cmor_vars[var_id].ounits,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(user_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units %s, zaxis %s, variable %s (table: %s)",units,cmor_axes[axis_id].id,cmor_vars[var_id].id,cmor_tables[cmor_vars[var_id].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
@@ -406,41 +406,41 @@ int cmor_zfactor (int *zvar_id,int axis_id, char *name, char *units, int ndims,
ut_trim(local_unit,UT_ASCII);
user_units = ut_parse(ut_read, local_unit, UT_ASCII);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error parsing units from user: %s",local_unit);
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error parsing user units: %s, zaxis %s (table: %s), when creating zfactor: %s",local_unit,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,name);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (ut_are_convertible(cmor_units,user_units)==0 ) {
- snprintf(msg,CMOR_MAX_STRING,"Udunuits: Pa and user units (%s) are incompatible",units);
+ snprintf(msg,CMOR_MAX_STRING,"Udunuits: Pa and user units (%s) are incompatible, zaxis %s (table: %s), when creating zfactor: %s",units,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,name);
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
}
ut_cmor_converter=ut_get_converter(cmor_units,user_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error getting converter from Pa to %s",units);
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error getting converter from Pa to %s,variable %s (table %s), when creating zfactor: %s",units,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,name);
cmor_handle_error(msg,CMOR_CRITICAL);
}
tmp = (double) 1.e5;
tmp = cv_convert_double(ut_cmor_converter,tmp);
/* free units thing */
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error converting units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error converting units from Pa to %s, zaxis %s (table: %s), when creating zfactor: %s",local_unit,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,name);
cmor_handle_error(msg,CMOR_CRITICAL);
}
cv_free(ut_cmor_converter);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter, zaxis %s (table: %s), when creating zfactor: %s",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,name);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(cmor_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units Pa, zaxis: %s (table: %s), when creating zfactor: %s",cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,name);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(user_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units %s, zaxis %s (table: %s), when creating zfactor: %s",local_unit,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,name);
cmor_handle_error(msg,CMOR_CRITICAL);
}
@@ -463,7 +463,7 @@ int cmor_zfactor (int *zvar_id,int axis_id, char *name, char *units, int ndims,
j=-1;
for (n=0;n<=cmor_nvars;n++) if ((strcmp(cmor_vars[n].id,"ptop")==0) && (cmor_vars[n].zaxis==axis_id)) {j=n;break;}
if (j==-1) { /* we did not find the ztop! */
- snprintf(msg,CMOR_MAX_STRING,"zfactor variable \"ptop\" for zfactor axis: %i is not defined when creating zfactor %s, please define ptop first",axis_id,name);
+ snprintf(msg,CMOR_MAX_STRING,"zfactor variable \"ptop\" for zfactor axis: %i (%s, table: %s), is not defined when creating zfactor %s, please define ptop first",axis_id,cmor_axes[axis_id].id,cmor_tables[cmor_axes[axis_id].ref_table_id].table_id,name);
cmor_handle_error(msg,CMOR_CRITICAL);
}
tmp = (double) 1.e5;
@@ -647,7 +647,7 @@ int cmor_variable(int *var_id, char *name, char *units, int ndims, int axes_ids[
/*if ((refvar.positive!='\0') && (positive!=NULL) && (positive[0]!=refvar.positive)) cmor_vars[vrid].sign=-1;*/
if ((positive!=NULL) && (positive[0]!='\0')) {
if ((positive[0]!='d') && positive[0]!='u') {
- snprintf(msg,CMOR_MAX_STRING,"variable '%s': unknown value for positive : %s (only first character is considered, which was: %c)",cmor_vars[vrid].id,positive,positive[0]);
+ snprintf(msg,CMOR_MAX_STRING,"variable '%s' (table %s): unknown value for positive : %s (only first character is considered, which was: %c)",cmor_vars[vrid].id,cmor_tables[cmor_vars[vrid].ref_table_id].table_id,positive,positive[0]);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (refvar.positive=='u') {
@@ -665,23 +665,23 @@ int cmor_variable(int *var_id, char *name, char *units, int ndims, int axes_ids[
}
}
else {
- snprintf(msg,CMOR_MAX_STRING,"variable '%s' you passed positive value:%s, but table does not mention it, will be ignored, if you really want this in your variable output use cmor_set_variable_attribute function",cmor_vars[vrid].id,positive);
+ snprintf(msg,CMOR_MAX_STRING,"variable '%s' (table %s) you passed positive value:%s, but table does not mention it, will be ignored, if you really want this in your variable output use cmor_set_variable_attribute function",cmor_vars[vrid].id,cmor_tables[cmor_vars[vrid].ref_table_id].table_id,positive);
cmor_handle_error(msg,CMOR_WARNING);
}
}
else {
if (cmor_is_required_variable_attribute(refvar,"positive")==0) {
- snprintf(msg,CMOR_MAX_STRING,"you need to provide the 'positive' argument for variable: %s",cmor_vars[vrid].id);
+ snprintf(msg,CMOR_MAX_STRING,"you need to provide the 'positive' argument for variable: %s (table %s)",cmor_vars[vrid].id,cmor_tables[cmor_vars[vrid].ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (refvar.positive!='\0') {
if (refvar.positive=='u') {
if (cmor_is_required_variable_attribute(refvar,"positive")==0) cmor_set_variable_attribute(vrid,"positive",'c',"up");
- snprintf(msg,CMOR_MAX_STRING,"you did not provide the 'positive' argument for variable: %s",cmor_vars[vrid].id);
+ snprintf(msg,CMOR_MAX_STRING,"you did not provide the 'positive' argument for variable: %s (table %s)",cmor_vars[vrid].id,cmor_tables[cmor_vars[vrid].ref_table_id].table_id);
}
else if (refvar.positive=='d') {
if (cmor_is_required_variable_attribute(refvar,"positive")==0) cmor_set_variable_attribute(vrid,"positive",'c',"down");
- snprintf(msg,CMOR_MAX_STRING,"you did not provide the 'positive' argument for variable: %s",cmor_vars[vrid].id);
+ snprintf(msg,CMOR_MAX_STRING,"you did not provide the 'positive' argument for variable: %s (table %s)",cmor_vars[vrid].id,cmor_tables[cmor_vars[vrid].ref_table_id].table_id);
}
cmor_handle_error(msg,CMOR_CRITICAL);
}
@@ -696,13 +696,13 @@ int cmor_variable(int *var_id, char *name, char *units, int ndims, int axes_ids[
/* ok we need to replace grids definitions with the grid axes */
for (i=0;i<ndims;i++) {
if (laxes_ids[i]>cmor_naxes) {
- sprintf(msg,"For variable (%s) you requested axis_id (%i) that has not been defined yet",cmor_vars[vrid].id,laxes_ids[i]);
+ sprintf(msg,"For variable %s (table %s) you requested axis_id (%i) that has not been defined yet",cmor_vars[vrid].id,cmor_tables[cmor_vars[vrid].ref_table_id].table_id,laxes_ids[i]);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (laxes_ids[i]<-CMOR_MAX_GRIDS+1) { /* grid definition */
grid_id = -laxes_ids[i]-CMOR_MAX_GRIDS;
if (grid_id>cmor_ngrids) {
- sprintf(msg,"For variable (%s) you requested grid_id (%i) that has not been defined yet",cmor_vars[vrid].id,laxes_ids[i]);
+ sprintf(msg,"For variable %s (table: %s) you requested grid_id (%i) that has not been defined yet",cmor_vars[vrid].id,cmor_tables[cmor_vars[vrid].ref_table_id].table_id,laxes_ids[i]);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* here we need to know if the refvar has been defined with lat/lon or in the grid space */
@@ -772,7 +772,7 @@ int cmor_variable(int *var_id, char *name, char *units, int ndims, int axes_ids[
}
if (j!=0) {
- snprintf(msg,CMOR_MAX_STRING,"You are defining variable '%s' with %i dimensions, when it should have %i",name,ndims,refvar.ndims);
+ snprintf(msg,CMOR_MAX_STRING,"You are defining variable '%s' (table %s) with %i dimensions, when it should have %i",name,cmor_tables[cmor_vars[vrid].ref_table_id].table_id,ndims,refvar.ndims);
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
@@ -798,7 +798,7 @@ int cmor_variable(int *var_id, char *name, char *units, int ndims, int axes_ids[
}
}
if (k!=i) {
- snprintf(msg,CMOR_MAX_STRING,"You defined variable '%s' with axis id '%s' which is not part of this variable according to your table, it says: ( ",refvar.id,cmor_tables[cmor_axes[laxes_ids[i]].ref_table_id].axes[cmor_axes[laxes_ids[i]].ref_axis_id].id);
+ snprintf(msg,CMOR_MAX_STRING,"You defined variable '%s' (table %s) with axis id '%s' which is not part of this variable according to your table, it says: ( ",refvar.id,cmor_tables[cmor_vars[vrid].ref_table_id].table_id,cmor_tables[cmor_axes[laxes_ids[i]].ref_table_id].axes[cmor_axes[laxes_ids[i]].ref_axis_id].id);
for (i=0;i<refvar.ndims;i++) {
strcat(msg,cmor_tables[CMOR_TABLE].axes[refvar.dimensions[i]].id);
strcat(msg," ");
@@ -819,7 +819,7 @@ int cmor_variable(int *var_id, char *name, char *units, int ndims, int axes_ids[
return 1;
}
if (cmor_axes[laxes_ids[i]].ref_table_id!=CMOR_TABLE && cmor_axes[laxes_ids[i]].isgridaxis!=1) {
- snprintf(msg,CMOR_MAX_STRING,"You are passing axis %i (named %s) which has been defined using table %i (%s) but the current table is %i (%s) (and isgridaxis says: %i)",laxes_ids[i],cmor_axes[laxes_ids[i]].id,cmor_axes[laxes_ids[i]].ref_table_id,cmor_tables[cmor_axes[laxes_ids[i]].ref_table_id].table_id,CMOR_TABLE,cmor_tables[CMOR_TABLE].table_id,cmor_axes[laxes_ids[i]].isgridaxis);
+ snprintf(msg,CMOR_MAX_STRING,"While creating variable %s, you are passing axis %i (named %s) which has been defined using table %i (%s) but the current table is %i (%s) (and isgridaxis says: %i)",cmor_vars[vrid].id,laxes_ids[i],cmor_axes[laxes_ids[i]].id,cmor_axes[laxes_ids[i]].ref_table_id,cmor_tables[cmor_axes[laxes_ids[i]].ref_table_id].table_id,CMOR_TABLE,cmor_tables[CMOR_TABLE].table_id,cmor_axes[laxes_ids[i]].isgridaxis);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* printf("ok: %s \n" , cmor_tables[cmor_axes[laxes_ids[i]].ref_table_id].axes[cmor_axes[laxes_ids[i]].ref_axis_id].id); */
@@ -1040,7 +1040,7 @@ int cmor_set_var_def_att(cmor_var_def_t *var,char att[CMOR_MAX_STRING],char val[
}
else {
if ((strcmp(dim,"longitude")!=0) && strcmp(dim,"latitude")!=0) { /* do not raise a warning if the axis is "longitude" / "latitude" it is probably a grid variable */
- snprintf(msg,CMOR_MAX_STRING,"Reading table: axis name: '%s' for variable: '%s' is not defined in table. Table defines dimensions: '%s' for this variable",dim,var->id,val);cmor_handle_error(msg,CMOR_CRITICAL);
+ snprintf(msg,CMOR_MAX_STRING,"Reading table %s: axis name: '%s' for variable: '%s' is not defined in table. Table defines dimensions: '%s' for this variable",cmor_tables[var->table_id].table_id,dim,var->id,val);cmor_handle_error(msg,CMOR_CRITICAL);
}
else {
var->dimensions[var->ndims]=-CMOR_MAX_GRIDS;
@@ -1094,13 +1094,13 @@ int cmor_set_var_def_att(cmor_var_def_t *var,char att[CMOR_MAX_STRING],char val[
var->shuffle = atoi(val);
if (atoi(val)!=0) {
if (USE_NETCDF_4 == 0) {
- sprintf(msg,"Reading a table that calls for NetCDF4 features, you are using NetCDF3 library");
+ sprintf(msg,"Reading a table (%s) that calls for NetCDF4 features, you are using NetCDF3 library",cmor_tables[var->table_id].table_id);
cmor_handle_error(msg,CMOR_WARNING);
}
else if ( (CMOR_NETCDF_MODE == CMOR_APPEND_3) ||
(CMOR_NETCDF_MODE == CMOR_REPLACE_3) ||
(CMOR_NETCDF_MODE == CMOR_PRESERVE_3)) {
- sprintf(msg,"Reading a table that calls for NetCDF4 features, you asked for NetCDF3 features");
+ sprintf(msg,"Reading a table (%s) that calls for NetCDF4 features, you asked for NetCDF3 features",cmor_tables[var->table_id].table_id);
cmor_handle_error(msg,CMOR_WARNING);
}
}
@@ -1109,13 +1109,13 @@ int cmor_set_var_def_att(cmor_var_def_t *var,char att[CMOR_MAX_STRING],char val[
var->deflate = atoi(val);
if (atoi(val)!=0) {
if (USE_NETCDF_4 == 0) {
- sprintf(msg,"Reading a table that calls for NetCDF4 features, you are using NetCDF3 library");
+ sprintf(msg,"Reading a table (%s) that calls for NetCDF4 features, you are using NetCDF3 library",cmor_tables[var->table_id].table_id);
cmor_handle_error(msg,CMOR_WARNING);
}
else if ( (CMOR_NETCDF_MODE == CMOR_APPEND_3) ||
(CMOR_NETCDF_MODE == CMOR_REPLACE_3) ||
(CMOR_NETCDF_MODE == CMOR_PRESERVE_3)) {
- sprintf(msg,"Reading a table that calls for NetCDF4 features, you asked for NetCDF3 features");
+ sprintf(msg,"Reading a table (%s) that calls for NetCDF4 features, you asked for NetCDF3 features",cmor_tables[var->table_id].table_id);
cmor_handle_error(msg,CMOR_WARNING);
}
}
@@ -1139,7 +1139,7 @@ int cmor_set_var_def_att(cmor_var_def_t *var,char att[CMOR_MAX_STRING],char val[
strncpy(var->out_name,val,CMOR_MAX_STRING);
}
else {
- snprintf(msg,CMOR_MAX_STRING,"unknown variable attribute: >>>>%s<<<< value: (%s)",att,val);
+ snprintf(msg,CMOR_MAX_STRING,"Table %s, unknown variable attribute: >>>>%s<<<< value: (%s)",cmor_tables[var->table_id].table_id,att,val);
cmor_handle_error(msg,CMOR_WARNING);
}
cmor_pop_traceback();
@@ -1173,7 +1173,7 @@ int cmor_get_original_shape(int *var_id, int *shape_array, int *rank, int blank_
for(i=0;i<*rank;i++) shape_array[i]=-1; /* init array */
if (*rank<avar.ndims) {
- snprintf(msg,CMOR_MAX_STRING,"trying to retrieve shape of variable %s into a %id array but this variable is %id",avar.id,*rank,avar.ndims);
+ snprintf(msg,CMOR_MAX_STRING,"trying to retrieve shape of variable %s (table: %s) into a %id array but this variable is %id",avar.id,cmor_tables[avar.ref_table_id].table_id,*rank,avar.ndims);
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (i=0;i<avar.ndims;i++) {
@@ -1213,6 +1213,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
cv_converter *ut_cmor_converter=NULL;
char local_unit[CMOR_MAX_STRING];
int n_lower_min=0,n_greater_max=0;
+ double emax,emin;
char msg_min[CMOR_MAX_STRING];
char msg_max[CMOR_MAX_STRING];
extern ut_system *ut_read;
@@ -1230,7 +1231,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
if (ntimes_passed!=0) {
counts[0]=ntimes_passed;
if (cmor_axes[avar->axes_ids[0]].axis!='T') {
- snprintf(msg,CMOR_MAX_STRING,"you are passing %i time steps for a static variable (no time dimension), please pass 0 (zero) as the number of times", ntimes_passed);
+ snprintf(msg,CMOR_MAX_STRING,"you are passing %i time steps for a static (no time dimension) variable (%s, table: %s), please pass 0 (zero) as the number of times", ntimes_passed, avar->id, cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -1278,39 +1279,39 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
if (mtype=='i') {
idata_tmp = malloc(sizeof(int)*nelements);
if (idata_tmp == NULL ) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_write_var_to_file: cannot allocate memory for %i int tmp elts var '%s'",nelements,avar->id);
- cmor_handle_error(msg,CMOR_CRITICAL);
- }
+ snprintf(msg,CMOR_MAX_STRING,"cannot allocate memory for %i int tmp elts var '%s' (table: %s)",nelements,avar->id,cmor_tables[avar->ref_table_id].table_id);
+ cmor_handle_error(msg,CMOR_CRITICAL);
+ }
}
else if (mtype=='l') {
ldata_tmp = malloc(sizeof(long)*nelements);
if (ldata_tmp == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_write_var_to_file: cannot allocate memory for %i long tmp elts var '%s'",nelements,avar->id);
- cmor_handle_error(msg,CMOR_CRITICAL);
- }
+ snprintf(msg,CMOR_MAX_STRING,"cannot allocate memory for %i long tmp elts var '%s' (table: %s)",nelements,avar->id,cmor_tables[avar->ref_table_id].table_id);
+ cmor_handle_error(msg,CMOR_CRITICAL);
+ }
}
else if (mtype=='d') {
- data_tmp = malloc(sizeof(double)*nelements);
+ data_tmp = malloc(sizeof(double)*nelements);
if (data_tmp == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_write_var_to_file: cannot allocate memory for %i double tmp elts var '%s'",nelements,avar->id);
- cmor_handle_error(msg,CMOR_CRITICAL);
- }
+ snprintf(msg,CMOR_MAX_STRING,"cannot allocate memory for %i double tmp elts var '%s' (table: %s)",nelements,avar->id,cmor_tables[avar->ref_table_id].table_id);
+ cmor_handle_error(msg,CMOR_CRITICAL);
+ }
}
else {
fdata_tmp = malloc(sizeof(float)*nelements);
if (fdata_tmp == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_write_var_to_file: cannot allocate memory for %i float tmp elts var '%s'",nelements,avar->id);
- cmor_handle_error(msg,CMOR_CRITICAL);
- }
+ snprintf(msg,CMOR_MAX_STRING,"cannot allocate memory for %i float tmp elts var '%s' (table: %s)",nelements,avar->id,cmor_tables[avar->ref_table_id].table_id);
+ cmor_handle_error(msg,CMOR_CRITICAL);
+ }
}
-
+
/* Reorder data, applies scaling, etc... */
if (dounits==1) {
strncpy(local_unit,avar->ounits,CMOR_MAX_STRING);
ut_trim(local_unit,UT_ASCII);
cmor_units = ut_parse(ut_read, local_unit,UT_ASCII);
if (ut_get_status() != UT_SUCCESS ) {
- snprintf(msg,CMOR_MAX_STRING,"in udunits analyzing units from cmor table (%s)",local_unit );
+ snprintf(msg,CMOR_MAX_STRING,"in udunits analyzing units from cmor table (%s) for variable %s (table: %s)",local_unit,avar->id,cmor_tables[avar->ref_table_id].table_id );
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
@@ -1319,20 +1320,20 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
ut_trim(local_unit,UT_ASCII);
user_units = ut_parse(ut_read, local_unit, UT_ASCII);
if (ut_get_status() != UT_SUCCESS ) {
- snprintf(msg,CMOR_MAX_STRING," in udunits analyzing units from user (%s)",local_unit);
+ snprintf(msg,CMOR_MAX_STRING,"in udunits analyzing units from user (%s) for variable %s (table: %s)",local_unit,avar->id,cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
}
if (ut_are_convertible(cmor_units,user_units)==0 ) {
- snprintf(msg,CMOR_MAX_STRING,"variable: %s, cmor and user units are incompatible: %s and %s",avar->id,avar->ounits,avar->iunits);
+ snprintf(msg,CMOR_MAX_STRING,"variable: %s, cmor and user units are incompatible: %s and %s for variable %s (table: %s)",avar->id,avar->ounits,avar->iunits,avar->id,cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
}
ut_cmor_converter=ut_get_converter(user_units,cmor_units);
if (ut_get_status() != UT_SUCCESS ) {
- snprintf(msg,CMOR_MAX_STRING," in udunits, getting converter");
+ snprintf(msg,CMOR_MAX_STRING," in udunits, getting converter for variable %s (table: %s)",avar->id,cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
@@ -1405,7 +1406,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
if (dounits==1) {
tmp = cv_convert_double(ut_cmor_converter,tmp);
if (ut_get_status() != UT_SUCCESS ) {
- snprintf(msg,CMOR_MAX_STRING," in udunits, converting values");
+ snprintf(msg,CMOR_MAX_STRING,"in udunits, converting values from %s to %s for variable %s (table: %s)",avar->iunits, avar->ounits, avar->id,cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
cmor_pop_traceback();
return 1;
@@ -1416,20 +1417,32 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
nelts+=1;
if ((avar->valid_min!=(float)1.e20) && (tmp<avar->valid_min)) {
n_lower_min+=1;
- if (n_lower_min==1) { /*first time */
- snprintf(msg_min,CMOR_MAX_STRING, "Invalid value(s) detected for variable '%s': %%i values were lower than minimum valid value (%.4g). First encountered bad value (%.5g) was at indices:" , avar->id, avar->valid_min,tmp);
+ if ((n_lower_min==1)|| (tmp<emin)) { /*minimum val */
+ emin = tmp;
+ snprintf(msg_min,CMOR_MAX_STRING, "Invalid value(s) detected for variable '%s' (table: %s): %%i values were lower than minimum valid value (%.4g). Minimum encountered bad value (%.5g) was at (axis: index/value):" , avar->id, cmor_tables[avar->ref_table_id].table_id, avar->valid_min,tmp);
for (j=0;j<avar->ndims;j++) {
- snprintf(msg2, CMOR_MAX_STRING, " %s: %i" , cmor_axes[avar->axes_ids[j]].id,counter2[j]);
+ if (cmor_axes[avar->axes_ids[j]].values!=NULL) {
+ snprintf(msg2, CMOR_MAX_STRING, " %s: %i/%.5g" , cmor_axes[avar->axes_ids[j]].id,counter2[j],cmor_axes[avar->axes_ids[j]].values[counter2[j]]);
+ }
+ else {
+ snprintf(msg2, CMOR_MAX_STRING, " %s: %i/%.5g" , cmor_axes[avar->axes_ids[j]].id,counter2[j],time_vals[counter2[j]]);
+ }
strncat(msg_min,msg2,CMOR_MAX_STRING-strlen(msg));
}
}
}
if ((avar->valid_max!=(float)1.e20) && (tmp>avar->valid_max)) {
n_greater_max+=1;
- if (n_greater_max==1) {
- snprintf(msg_max,CMOR_MAX_STRING, "Invalid value(s) detected for variable '%s': %%i values were greater than maximum valid value (%.4g). First encountered bad value (%.5g) is at indices:" , avar->id, avar->valid_max,tmp);
+ if ((n_greater_max==1)|| (tmp>emax)) {
+ emax=tmp;
+ snprintf(msg_max,CMOR_MAX_STRING, "Invalid value(s) detected for variable '%s' (table: %s): %%i values were greater than maximum valid value (%.4g).Maximum encountered bad value (%.5g) was at (axis: index/value):" , avar->id, cmor_tables[avar->ref_table_id].table_id, avar->valid_max,tmp);
for (j=0;j<avar->ndims;j++) {
- snprintf(msg2, CMOR_MAX_STRING, " %s: %i" , cmor_axes[avar->axes_ids[j]].id,counter2[j]);
+ if (cmor_axes[avar->axes_ids[j]].values!=NULL) {
+ snprintf(msg2, CMOR_MAX_STRING, " %s: %i/%.5g" , cmor_axes[avar->axes_ids[j]].id,counter2[j],cmor_axes[avar->axes_ids[j]].values[counter2[j]]);
+ }
+ else {
+ snprintf(msg2, CMOR_MAX_STRING, " %s: %i/%.5g" , cmor_axes[avar->axes_ids[j]].id,counter2[j],time_vals[counter2[j]]);
+ }
strncat(msg_max,msg2,CMOR_MAX_STRING-strlen(msg));
}
}
@@ -1452,39 +1465,39 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
}
if (avar->ok_min_mean_abs!=(float)1.e20) {
if (amean/nelts<.1*avar->ok_min_mean_abs) {
- snprintf(msg,CMOR_MAX_STRING, "Invalid Absolute Mean for variable '%s' (%.5g) is lower by more than an order of magnitude than minimum allowed: %.4g" , avar->id, amean/nelts, avar->ok_min_mean_abs);
+ snprintf(msg,CMOR_MAX_STRING, "Invalid Absolute Mean for variable '%s' (table: %s) (%.5g) is lower by more than an order of magnitude than minimum allowed: %.4g" , avar->id, cmor_tables[avar->ref_table_id].table_id, amean/nelts, avar->ok_min_mean_abs);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (amean/nelts<avar->ok_min_mean_abs) {
- snprintf(msg,CMOR_MAX_STRING, "Invalid Absolute Mean for variable '%s' (%.5g) is lower than minimum allowed: %.4g" , avar->id, amean/nelts, avar->ok_min_mean_abs);
+ snprintf(msg,CMOR_MAX_STRING, "Invalid Absolute Mean for variable '%s' (table: %s) (%.5g) is lower than minimum allowed: %.4g" , avar->id, cmor_tables[avar->ref_table_id].table_id, amean/nelts, avar->ok_min_mean_abs);
cmor_handle_error(msg,CMOR_WARNING);
}
}
if (avar->ok_max_mean_abs!=(float)1.e20) {
if (amean/nelts>10.*avar->ok_max_mean_abs) {
- snprintf(msg,CMOR_MAX_STRING, "Invalid Absolute Mean for variable '%s' (%.5g) is greater by more than an order of magnitude than maximum allowed: %.4g" , avar->id, amean/nelts, avar->ok_max_mean_abs);
+ snprintf(msg,CMOR_MAX_STRING, "Invalid Absolute Mean for variable '%s' (table: %s) (%.5g) is greater by more than an order of magnitude than maximum allowed: %.4g" , avar->id, cmor_tables[avar->ref_table_id].table_id, amean/nelts, avar->ok_max_mean_abs);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (amean/nelts>avar->ok_max_mean_abs) {
- snprintf(msg,CMOR_MAX_STRING, "Invalid Absolute Mean for variable '%s' (%.5g) is greater than maximum allowed: %.4g" , avar->id, amean/nelts, avar->ok_max_mean_abs);
+ snprintf(msg,CMOR_MAX_STRING, "Invalid Absolute Mean for variable '%s' (table: %s) (%.5g) is greater than maximum allowed: %.4g" , avar->id, cmor_tables[avar->ref_table_id].table_id, amean/nelts, avar->ok_max_mean_abs);
cmor_handle_error(msg,CMOR_WARNING);
}
}
if (dounits==1) {
cv_free(ut_cmor_converter);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing converter, variable %s (table: %s)", avar->id, cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(cmor_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units, variable %s (table: %s)", avar->id, cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ut_free(user_units);
if (ut_get_status() != UT_SUCCESS) {
- snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units");
+ snprintf(msg,CMOR_MAX_STRING,"Udunits: Error freeing units, variable %s (table: %s)", avar->id, cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -1496,7 +1509,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
if (ntimes_passed!=0){
if (time_vals!=NULL) {
if (cmor_axes[avar->axes_ids[0]].values!=NULL) {
- snprintf(msg,CMOR_MAX_STRING,"in cmor_write: variable '%s' you are passing time values but you already defined them via cmor_axis, this is not allowed",avar->id);
+ snprintf(msg,CMOR_MAX_STRING,"variable '%s' (table %s) you are passing time values but you already defined them via cmor_axis, this is not allowed",avar->id, cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
@@ -1518,7 +1531,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
/* } */
tmp_vals = malloc(ntimes_passed*2*sizeof(double));
if (tmp_vals == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_write: cannot malloc %i tmp bounds time vals for variable '%s'",ntimes_passed*2,avar->id);
+ snprintf(msg,CMOR_MAX_STRING,"cannot malloc %i tmp bounds time vals for variable '%s' (table: %s)",ntimes_passed*2,avar->id,cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
@@ -1552,7 +1565,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
ierr = nc_put_vara_double(ncid,avar->time_nc_id,starts,counts,&tmp_vals[0]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) writing time values for variable '%s'",ierr,avar->id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) writing time values for variable '%s' (%s)",ierr,nc_strerror(ierr),avar->id,cmor_tables[avar->ref_table_id].table_id);cmor_handle_error(msg,CMOR_CRITICAL);}
if (cmor_tables[cmor_axes[avar->axes_ids[0]].ref_table_id].axes[cmor_axes[avar->axes_ids[0]].ref_axis_id].climatology==0) {
/* all good in that case */
@@ -1567,7 +1580,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
}
else {
if (tmp_vals[0]<avar->last_time) {
- snprintf(msg,CMOR_MAX_STRING, "Time point: %lf ( %lf in output units) is not monotonic last time was: %lf (in output units)\n",time_vals[0],tmp_vals[0],avar->last_time);
+ snprintf(msg,CMOR_MAX_STRING, "Time point: %lf ( %lf in output units) is not monotonic last time was: %lf (in output units), variable %s (table: %s)",time_vals[0],tmp_vals[0],avar->last_time,avar->id,cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
@@ -1579,7 +1592,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
else {
/* checks wether you need bounds or not */
if (cmor_tables[cmor_axes[avar->axes_ids[0]].ref_table_id].axes[cmor_axes[avar->axes_ids[0]].ref_axis_id].must_have_bounds==1) {
- snprintf(msg,CMOR_MAX_STRING,"in cmor_write, time axis must have bounds, please pass them to cmor_write along with time values");
+ snprintf(msg,CMOR_MAX_STRING,"time axis must have bounds, please pass them to cmor_write along with time values, variable %s, table %s",avar->id,cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* avar->first_bound=1.e20; */
@@ -1588,7 +1601,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
cmor_get_cur_dataset_attribute("calendar",msg2);
tmp_vals = malloc(ntimes_passed*sizeof(double));
if (tmp_vals == NULL) {
- snprintf(msg,CMOR_MAX_STRING,"cmor_write: cannot malloc %i time vals for variable '%s'",ntimes_passed,avar->id);
+ snprintf(msg,CMOR_MAX_STRING,"cannot malloc %i time vals for variable '%s' (table: %s)",ntimes_passed,avar->id,cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
ierr = cmor_convert_time_values(time_vals,'d',ntimes_passed,&tmp_vals[0],cmor_axes[avar->axes_ids[0]].iunits,msg,msg2,msg2);
@@ -1601,12 +1614,12 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
avar->last_time = tmp_vals[ntimes_passed-1];
/* printf("setting last time to: %f\n",avar->last_time); */
free(tmp_vals);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i) writing times for variable '%s', already written in file: %i",ierr,avar->id,avar->ntimes_written);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF error (%i: %s) writing times for variable '%s' (table: %s), already written in file: %i",ierr,nc_strerror(ierr),avar->id,cmor_tables[avar->ref_table_id].table_id,avar->ntimes_written);cmor_handle_error(msg,CMOR_CRITICAL);}
}
}
else { /* ok we did not pass time values therefore it means they were defined via the axis */
if (cmor_axes[avar->axes_ids[0]].values==NULL) {
- snprintf(msg,CMOR_MAX_STRING,"in cmor_write: variable '%s' you are passing %i times but no values and you did not define them via cmor_axis",avar->id,ntimes_passed);
+ snprintf(msg,CMOR_MAX_STRING,"variable '%s' (table: %s) you are passing %i times but no values and you did not define them via cmor_axis",avar->id,cmor_tables[avar->ref_table_id].table_id,ntimes_passed);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (cmor_axes[avar->axes_ids[0]].bounds!=NULL) {
@@ -1615,7 +1628,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
counts2[1]=2;
starts[1]=0;
ierr = nc_put_vara_double(ncid,avar->time_bnds_nc_id,starts,counts2,&cmor_axes[avar->axes_ids[0]].bounds[starts[0]*2]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NCError (%i) writting time bounds values for variable '%s'",ierr,avar->id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NCError (%i: %s) writting time bounds values for variable '%s' (table: %s)",ierr,nc_strerror(ierr),avar->id,cmor_tables[avar->ref_table_id].table_id);cmor_handle_error(msg,CMOR_CRITICAL);}
/* /\* ok we need to store first and last bounds *\/ */
/* if (avar->ntimes_written==0) { */
/* avar->first_bound=cmor_axes[avar->axes_ids[0]].bounds[starts[0]*2]; */
@@ -1625,14 +1638,14 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
else {
/* checks wether you need bounds or not */
if (cmor_tables[cmor_axes[avar->axes_ids[0]].ref_table_id].axes[cmor_axes[avar->axes_ids[0]].ref_axis_id].must_have_bounds==1) {
- snprintf(msg,CMOR_MAX_STRING,"in cmor_write, time axis must have bounds, you defined it w/o");
+ snprintf(msg,CMOR_MAX_STRING,"time axis must have bounds, you defined it w/o any for variable %s (table: %s)",avar->id,cmor_tables[avar->ref_table_id].table_id);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* avar->first_bound=1.e20; */
/* avar->last_bound=1.e20; */
}
ierr = nc_put_vara_double(ncid,avar->time_nc_id,starts,counts,&cmor_axes[avar->axes_ids[0]].values[starts[0]]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NCError (%i) writting time values for variable '%s'",ierr,avar->id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NCError (%i: %s) writting time values for variable '%s' (table: %s)",ierr,nc_strerror(ierr),avar->id,cmor_tables[avar->ref_table_id].table_id);cmor_handle_error(msg,CMOR_CRITICAL);}
/* ok now we need to stroe first and last stuff */
if (avar->ntimes_written==0) {
avar->first_time = cmor_axes[avar->axes_ids[0]].values[starts[0]];
@@ -1652,7 +1665,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
}
if (ierr!=-1) {
if (cmor_axes[avar->axes_ids[ierr]].values==NULL) {
- snprintf(msg,CMOR_MAX_STRING,"in cmor_write: variable '%s' you are passing %i times but no values and you did not define them via cmor_axis",avar->id,ntimes_passed);
+ snprintf(msg,CMOR_MAX_STRING,"variable '%s' (table: %s) you are passing %i times but no values and you did not define them via cmor_axis",avar->id,cmor_tables[avar->ref_table_id].table_id,ntimes_passed);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* avar->first_bound=1.e20; */
@@ -1664,13 +1677,13 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
starts[0]=0;
starts[1]=0;
ierr = nc_put_vara_double(ncid,avar->time_bnds_nc_id,starts,counts2,&cmor_axes[avar->axes_ids[0]].bounds[starts[0]*2]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NCError (%i) writting time bounds values for variable '%s'",ierr,avar->id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NCError (%i: %s) writting time bounds values for variable '%s' (table: %s)",ierr,nc_strerror(ierr),avar->id,cmor_tables[avar->ref_table_id].table_id);cmor_handle_error(msg,CMOR_CRITICAL);}
/* avar->first_bound=cmor_axes[avar->axes_ids[0]].bounds[0]; */
/* avar->last_bound=cmor_axes[avar->axes_ids[0]].bounds[counts[0]*2]; */
}
ierr = nc_put_vara_double(ncid,avar->time_nc_id,starts,counts,&cmor_axes[avar->axes_ids[0]].values[starts[0]]);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NCError (%i) writting time values for variable '%s'",ierr,avar->id);cmor_handle_error(msg,CMOR_CRITICAL);}
- /* ok now we need to stroe first and last stuff */
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NCError (%i: %s) writting time values for variable '%s' (table: %s)",ierr,nc_strerror(ierr),avar->id,cmor_tables[avar->ref_table_id].table_id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ /* ok now we need to store first and last stuff */
avar->first_time = cmor_axes[avar->axes_ids[0]].values[0];
/* printf("setting last time (3) to: %lf\n",cmor_axes[avar->axes_ids[0]].values[starts[0]+counts[0]-1]); */
avar->last_time = cmor_axes[avar->axes_ids[0]].values[starts[0]+counts[0]-1];
@@ -1687,7 +1700,7 @@ int cmor_write_var_to_file(int ncid,cmor_var_t *avar,void *data,char itype, int
else if (mtype=='l') ierr = nc_put_vara_long(ncid,avar->nc_var_id,starts,counts,ldata_tmp);
else if (mtype=='i') ierr = nc_put_vara_int(ncid,avar->nc_var_id,starts,counts,idata_tmp);
- if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i), writing variable '%s' to file",ierr,avar->id);cmor_handle_error(msg,CMOR_CRITICAL);}
+ if (ierr != NC_NOERR) {snprintf(msg,CMOR_MAX_STRING,"NetCDF Error (%i: %s), writing variable '%s' (table %s) to file",ierr,nc_strerror(ierr),avar->id,cmor_tables[avar->ref_table_id].table_id);cmor_handle_error(msg,CMOR_CRITICAL);}
avar->ntimes_written+=ntimes_passed;
if (mtype=='d') free(data_tmp);
else if (mtype=='f') free(fdata_tmp);
diff --git a/Test/cmor_speed_and_compression.py b/Test/cmor_speed_and_compression.py
index 6a055c9..6206618 100644
--- a/Test/cmor_speed_and_compression.py
+++ b/Test/cmor_speed_and_compression.py
@@ -98,6 +98,7 @@ mincdms=1000
c0=st
s2=s*1
sh=list(s.shape)
+print 'shape:',sh
sh.insert(0,1)
s2=MV2.reshape(s2,sh)
s2.setAxis(1,s.getLatitude())
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/cmor.git
More information about the debian-science-commits
mailing list