void cmor_set_mapping_attribute(cmor_mappings_t *mapping,char att[CMOR_MAX_STRING],char val[CMOR_MAX_STRING] )
{
int i,n;
char msg[CMOR_MAX_STRING];
cmor_add_traceback("cmor_set_mapping_attribute");
if (strcmp(att,"coordinates")==0) {
strncpy(mapping->coordinates,val,CMOR_MAX_STRING);
}
else if (strcmp(att,"parameter")==0) {
n=-1;
for (i=0;i<mapping->nattributes;i++) {
if (strcmp(mapping->attributes_names[i],val)==0) {
n=i;
break;
}
}
if (n==-1) {
n = mapping->nattributes;
mapping->nattributes++;
}
strncpy(mapping->attributes_names[n],val,CMOR_MAX_STRING);
}
else {
snprintf(msg,CMOR_MAX_STRING,"Unknown attribute: '%s' for mapping '%s' (value was: '%s')",att,mapping->id,val);
cmor_handle_error(msg,CMOR_WARNING);
}
cmor_pop_traceback();
}
int cmor_copy_data(double **dest1, void *data, char type, int nelts) {
int i;
char msg[CMOR_MAX_STRING];
double *dest;
cmor_add_traceback("cmor_copy_data");
dest = *dest1;
/* First free the dest if already allocated */
if (dest !=NULL) {
free(dest);
}
/* allocate space */
dest = malloc(nelts*sizeof(double));
/* and copy elements */
for (i=0;i<nelts;i++) {
if (type=='f') dest[i] = (double)((float *)data)[i];
else if (type=='i') dest[i] = (double)((int *)data)[i];
else if (type=='l') dest[i] = (double)((long *)data)[i];
else if (type=='d') dest[i] = (double)((double *)data)[i];
else {
snprintf(msg,CMOR_MAX_STRING,"wrong data type: %c",type);
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
*dest1=dest;
cmor_pop_traceback();
return 0;
}
void cmor_init_grid_mapping(cmor_mappings_t *mapping,char *id)
{
int n;
cmor_add_traceback("cmor_init_grid_mapping");
cmor_is_setup();
mapping->nattributes=0;
for(n=0;n<CMOR_MAX_GRID_ATTRIBUTES;n++) mapping->attributes_names[n][0]='\0';
strcpy(mapping->coordinates,"");
strncpy(mapping->id,id,CMOR_MAX_STRING);
cmor_pop_traceback();
return;
}
void cmor_convert_value( char *units, char *ctmp, double *tmp ) {
/* -------------------------------------------------------------------- */
/* Local variables */
/* -------------------------------------------------------------------- */
ut_unit *user_units = NULL, *cmor_units = NULL;
cv_converter *ut_cmor_converter = NULL;
double value;
char msg[CMOR_MAX_STRING];
cmor_add_traceback( "cmor_convert_value" );
value = *tmp;
if( units[0] != '\0' ) {
cmor_prep_units( ctmp, units, &cmor_units, &user_units,
&ut_cmor_converter );
*tmp = cv_convert_double( ut_cmor_converter, value );
if( ut_get_status( ) != UT_SUCCESS ) {
snprintf( msg, CMOR_MAX_STRING,
"Udunits: Error converting units from %s to %s",
units, ctmp );
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" );
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" );
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" );
cmor_handle_error( msg, CMOR_CRITICAL );
}
} else
*tmp = value;
cmor_pop_traceback( );
return;
}
int cmor_grid(int *grid_id, int ndims, int *axes_ids, char type, void *lat, void *lon, int nvertices, void *blat, void *blon) {
int i,j,n,did_vertices=0;
char msg[CMOR_MAX_STRING];
int axes[2];
double *dummy_values;
cmor_add_traceback("cmor_grid");
if ((axes_ids==NULL) || (ndims==0)) {
snprintf(msg,CMOR_MAX_STRING,"You need to define the grid axes first");
cmor_handle_error(msg,CMOR_CRITICAL);
}
cmor_ngrids+=1;
if (cmor_ngrids>=CMOR_MAX_GRIDS) {
snprintf(msg,CMOR_MAX_STRING,"Too many grids defined, maximum possible grids is currently set to %i", CMOR_MAX_GRIDS);
cmor_handle_error(msg,CMOR_CRITICAL);
}
n=1;
for (i=0;i<ndims;i++) {
if (axes_ids[i]>cmor_naxes) {
snprintf(msg,CMOR_MAX_STRING,"Defining grid, Axis %i not defined yet",axes_ids[i]);
cmor_handle_error(msg,CMOR_CRITICAL);
}
if (cmor_tables[cmor_axes[axes_ids[i]].ref_table_id].axes[cmor_axes[axes_ids[i]].ref_axis_id].axis=='T') {
cmor_grids[cmor_ngrids].istimevarying = 1;
/* snprintf(msg,CMOR_MAX_STRING,"defining grid: axis: %s is time axis, grids are not allowed to be time-varying at the moment",cmor_axes[axes_ids[i]].id); */
/* cmor_handle_error(msg,CMOR_CRITICAL); */
}
cmor_grids[cmor_ngrids].original_axes_ids[i]=axes_ids[i];
cmor_grids[cmor_ngrids].axes_ids[i]=axes_ids[i];
cmor_axes[axes_ids[i]].isgridaxis=1;
n*=cmor_axes[axes_ids[i]].length;
}
cmor_grids[cmor_ngrids].ndims = ndims;
cmor_grids[cmor_ngrids].nvertices = nvertices;
if (lat==NULL) {
if (cmor_grids[cmor_ngrids].istimevarying != 1) {
snprintf(msg,CMOR_MAX_STRING,"you need to pass the latitude values when defining a grid");
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
else {
axes[0]=-cmor_ngrids-CMOR_MAX_GRIDS;
if (cmor_grids[cmor_ngrids].istimevarying != 1) {
cmor_copy_data(&cmor_grids[cmor_ngrids].lats,lat,type,n);
cmor_variable(&cmor_grids[cmor_ngrids].associated_variables[0],"latitude","degrees_north",1,&axes[0],'d',NULL,NULL,NULL,NULL,NULL,NULL);
cmor_vars[cmor_grids[cmor_ngrids].associated_variables[0]].needsinit=0;
/* for (i=0;i<5;i++) { */
/* printf("%i: %lf\n",i,cmor_grids[cmor_ngrids].lats[i]); */
/* } */
}
}
if (lon==NULL) {
if (cmor_grids[cmor_ngrids].istimevarying != 1) {
snprintf(msg,CMOR_MAX_STRING,"you need to pass the longitude values when defining a grid");
cmor_handle_error(msg,CMOR_CRITICAL);
}
}
else {
cmor_copy_data(&cmor_grids[cmor_ngrids].lons,lon,type,n);
axes[0]=-cmor_ngrids-CMOR_MAX_GRIDS;
/* for (i=0;i<5;i++) printf("%i: %lf\n",i,cmor_grids[cmor_ngrids].lons[i]); */
cmor_variable(&cmor_grids[cmor_ngrids].associated_variables[1],"longitude","degrees_east",1,&axes[0],'d',NULL,NULL,NULL,NULL,NULL,NULL);
cmor_vars[cmor_grids[cmor_ngrids].associated_variables[1]].needsinit=0;
}
if (blat==NULL) {
if (cmor_grids[cmor_ngrids].istimevarying != 1) {
snprintf(msg,CMOR_MAX_STRING,"it is recommended you pass the latitude bounds values when defining a grid");
cmor_handle_error(msg,CMOR_WARNING);
}
}
else {
cmor_copy_data(&cmor_grids[cmor_ngrids].blats,blat,type,n*nvertices);
dummy_values=malloc(sizeof(double)*nvertices);
for (j=0;j<nvertices;j++) dummy_values[j]=(double)j;
cmor_axis(&axes[1],"vertices","1",nvertices,dummy_values,'d',NULL,0,NULL);
free(dummy_values);
did_vertices=1;
cmor_variable(&cmor_grids[cmor_ngrids].associated_variables[2],"vertices_latitude","degrees_north",2,&axes[0],'d',NULL,NULL,NULL,NULL,NULL,NULL);
cmor_vars[cmor_grids[cmor_ngrids].associated_variables[2]].needsinit=0;
if (cmor_has_variable_attribute(cmor_grids[cmor_ngrids].associated_variables[0],"bounds")==0) {
cmor_get_variable_attribute(cmor_grids[cmor_ngrids].associated_variables[0],"bounds",&msg);
strncat(msg," ",CMOR_MAX_STRING-strlen(msg) );
strncat(msg,cmor_vars[cmor_grids[cmor_ngrids].associated_variables[2]].id,CMOR_MAX_STRING-strlen(msg) );
}
else {
strncpy(msg,cmor_vars[cmor_grids[cmor_ngrids].associated_variables[2]].id,CMOR_MAX_STRING);
}
cmor_set_variable_attribute_internal(cmor_grids[cmor_ngrids].associated_variables[0],"bounds",'c',msg);
}
if (blon==NULL) {
if (cmor_grids[cmor_ngrids].istimevarying != 1) {
snprintf(msg,CMOR_MAX_STRING,"it is recommended you pass the longitude bounds values when defining a grid");
cmor_handle_error(msg,CMOR_WARNING);
}
}
else {
cmor_copy_data(&cmor_grids[cmor_ngrids].blons,blon,type,n*nvertices);
if (did_vertices == 0 ) {
dummy_values=malloc(sizeof(double)*nvertices);
for (j=0;j<nvertices;j++) dummy_values[j]=(double)j;
cmor_axis(&axes[1],"vertices","1",nvertices,dummy_values,'d',NULL,0,NULL);
free(dummy_values);
}
cmor_variable(&cmor_grids[cmor_ngrids].associated_variables[3],"vertices_longitude","degrees_east",2,&axes[0],'d',NULL,NULL,NULL,NULL,NULL,NULL);
cmor_vars[cmor_grids[cmor_ngrids].associated_variables[3]].needsinit=0;
if (cmor_has_variable_attribute(cmor_grids[cmor_ngrids].associated_variables[1],"bounds")==0) {
cmor_get_variable_attribute(cmor_grids[cmor_ngrids].associated_variables[1],"bounds",&msg);
strncat(msg," ",CMOR_MAX_STRING-strlen(msg) );
strncat(msg,cmor_vars[cmor_grids[cmor_ngrids].associated_variables[3]].id,CMOR_MAX_STRING-strlen(msg) );
}
else {
strncpy(msg,cmor_vars[cmor_grids[cmor_ngrids].associated_variables[3]].id,CMOR_MAX_STRING);
}
cmor_set_variable_attribute_internal(cmor_grids[cmor_ngrids].associated_variables[1],"bounds",'c',msg);
}
/* if (area==NULL) { */
/* snprintf(msg,CMOR_MAX_STRING,"it is recommended you pass the area values when defining a grid"); */
/* cmor_handle_error(msg,CMOR_WARNING); */
/* } */
/* else { */
/* cmor_copy_data(&cmor_grids[cmor_ngrids].area,area,type,n); */
/* cmor_variable(&cmor_grids[cmor_ngrids].associated_variables[4],"area","m2",1,&axes[0],'d',NULL,NULL,NULL,NULL,NULL,NULL); */
/* cmor_vars[cmor_grids[cmor_ngrids].associated_variables[4]].needsinit=0; */
/* } */
*grid_id = -cmor_ngrids-CMOR_MAX_GRIDS;
cmor_pop_traceback();
return 0;
}
int cmor_time_varying_grid_coordinate(int *coord_grid_id, int grid_id, char *table_entry, char *units, char type, void *missing, int *coordinate_type) {
int ierr=0,j;
int axes[2];
char msg[CMOR_MAX_STRING];
int ctype=-1;
double *dummy_values;
int nvertices=cmor_grids[-grid_id-CMOR_MAX_GRIDS].nvertices;
axes[0]=grid_id;
cmor_add_traceback("cmor_time_varying_grid_coordinate");
cmor_is_setup();
strcpy(msg,"not found");
if (coordinate_type == NULL) {
for (j=0;j<cmor_tables[cmor_axes[cmor_grids[-grid_id-CMOR_MAX_GRIDS].axes_ids[0]].ref_table_id].nvars;j++) {
if (strcmp(cmor_tables[cmor_axes[cmor_grids[-grid_id-CMOR_MAX_GRIDS].axes_ids[0]].ref_table_id].vars[j].id,table_entry)==0) {
strncpy(msg,cmor_tables[cmor_axes[cmor_grids[-grid_id-CMOR_MAX_GRIDS].axes_ids[0]].ref_table_id].vars[j].standard_name,CMOR_MAX_STRING);
break;
}
}
if (strcmp(msg,"latitude")==0) ctype = 0;
if (strcmp(msg,"longitude")==0) ctype = 1;
if (strcmp(msg,"vertices_latitude")==0) ctype = 2;
if (strcmp(msg,"vertices_longitude")==0) ctype = 3;
}
else {
ctype = *coordinate_type;
}
switch (ctype) {
case (0) :
ierr = cmor_variable(coord_grid_id,table_entry,units,1,axes,type,missing,NULL,NULL,NULL,NULL,NULL);
cmor_grids[cmor_vars[*coord_grid_id].grid_id].associated_variables[0] = *coord_grid_id;
/* ??? additional attributes to add to this variable ? */
break;
case (1) :
ierr = cmor_variable(coord_grid_id,table_entry,units,1,axes,type,missing,NULL,NULL,NULL,NULL,NULL);
cmor_grids[cmor_vars[*coord_grid_id].grid_id].associated_variables[1] = *coord_grid_id;
/* ??? additional attributes to add to this variable ? */
break;
case (2) :
if (nvertices == 0 ) {
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) {
dummy_values=malloc(sizeof(double)*nvertices);
for (j=0;j<nvertices;j++) dummy_values[j]=(double)j;
cmor_axis(&axes[1],"vertices","1",nvertices,dummy_values,'d',NULL,0,NULL);
free(dummy_values);
cmor_grids[-grid_id-CMOR_MAX_GRIDS].nvertices = axes[1];
}
else {
axes[1] = cmor_grids[-grid_id-CMOR_MAX_GRIDS].nvertices;
}
ierr = cmor_variable(coord_grid_id,table_entry,units,2,axes,type,missing,NULL,NULL,NULL,NULL,NULL);
cmor_grids[cmor_vars[*coord_grid_id].grid_id].associated_variables[2] = *coord_grid_id;
/* adds the bounds attribute */
if (cmor_has_variable_attribute(cmor_grids[cmor_vars[*coord_grid_id].grid_id].associated_variables[0],"bounds")==0) {
cmor_get_variable_attribute(cmor_grids[cmor_vars[*coord_grid_id].grid_id].associated_variables[0],"bounds",&msg);
strncat(msg," ",CMOR_MAX_STRING-strlen(msg) );
strncat(msg,cmor_vars[*coord_grid_id].id,CMOR_MAX_STRING-strlen(msg) );
}
else {
strncpy(msg,cmor_vars[*coord_grid_id].id,CMOR_MAX_STRING);
}
cmor_set_variable_attribute_internal(cmor_grids[cmor_vars[*coord_grid_id].grid_id].associated_variables[0],"bounds",'c',msg);
break;
case (3) :
if (nvertices == 0 ) {
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[2] == -1) {
dummy_values=malloc(sizeof(double)*nvertices);
for (j=0;j<nvertices;j++) dummy_values[j]=(double)j;
cmor_axis(&axes[1],"vertices","1",nvertices,dummy_values,'d',NULL,0,NULL);
free(dummy_values);
cmor_grids[-grid_id-CMOR_MAX_GRIDS].nvertices = axes[1];
}
else {
axes[1] = cmor_grids[-grid_id-CMOR_MAX_GRIDS].nvertices;
}
ierr = cmor_variable(coord_grid_id,table_entry,units,2,axes,type,missing,NULL,NULL,NULL,NULL,NULL);
cmor_grids[cmor_vars[*coord_grid_id].grid_id].associated_variables[3] = *coord_grid_id;
/* adds the bounds attribute */
if (cmor_has_variable_attribute(cmor_grids[cmor_vars[*coord_grid_id].grid_id].associated_variables[1],"bounds")==0) {
cmor_get_variable_attribute(cmor_grids[cmor_vars[*coord_grid_id].grid_id].associated_variables[1],"bounds",&msg);
strncat(msg," ",CMOR_MAX_STRING-strlen(msg) );
strncat(msg,cmor_vars[*coord_grid_id].id,CMOR_MAX_STRING-strlen(msg) );
}
else {
strncpy(msg,cmor_vars[*coord_grid_id].id,CMOR_MAX_STRING);
}
cmor_set_variable_attribute_internal(cmor_grids[cmor_vars[*coord_grid_id].grid_id].associated_variables[1],"bounds",'c',msg);
break;
default:
sprintf(msg,"unknown coord type: %i",ctype);
cmor_handle_error(msg,CMOR_CRITICAL);
break;
}
cmor_vars[*coord_grid_id].needsinit=0;
cmor_pop_traceback();
return ierr;
}
int cmor_set_grid_mapping(int gid, char *name, int nparam, char **attributes_names, int lparams, double attributes_values[CMOR_MAX_GRID_ATTRIBUTES], char **units, int lnunits ){
int grid_id, nattributes,ndims;
int i,j,k,l;
char *achar,*bchar;
char lattributes_names[CMOR_MAX_GRID_ATTRIBUTES][CMOR_MAX_STRING];
char lunits[CMOR_MAX_GRID_ATTRIBUTES][CMOR_MAX_STRING];
char grid_attributes[CMOR_MAX_GRID_ATTRIBUTES][CMOR_MAX_STRING];
char msg[CMOR_MAX_STRING];
char msg2[CMOR_MAX_STRING];
char grid_dimensions[CMOR_MAX_DIMENSIONS][CMOR_MAX_STRING];
cmor_add_traceback("cmor_set_grid_mapping");
if (nparam>=CMOR_MAX_GRID_ATTRIBUTES) {
snprintf(msg,CMOR_MAX_STRING,"CMOR allows only %i grid parameters too be defined , you are trying to define %i parameters, if you really need that many recompile cmor changing the value of parameter: CMOR_MAX_GRID_ATTRIBUTES",CMOR_MAX_GRID_ATTRIBUTES,nparam);
cmor_handle_error(msg,CMOR_CRITICAL);
}
achar = (char *)attributes_names;
bchar = (char *)units;
for(i=0;i<nparam;i++) {
strncpy(lattributes_names[i],achar,CMOR_MAX_STRING);
strncpy(lunits[i],bchar,CMOR_MAX_STRING);
achar += lparams;
bchar += lnunits;
}
/* for(i=0;i<nparam;i++) printf("ok paramter: %i is: %s, with value %lf and units '%s'\n",i,lattributes_names[i],attributes_values[i],lunits[i]); */
grid_id = -gid-CMOR_MAX_GRIDS;
/* reads in grid definitions */
cmor_grid_valid_mapping_attribute_names(name, &nattributes, grid_attributes,&ndims,grid_dimensions);
/* printf("coming back we haver set %i atts\n",nattributes); */
/* for (i=0;i<nattributes;i++) {printf("%i, %s, %s, %s\n",i,grid_attributes[i],grid_dimensions[0],grid_dimensions[1]);} */
if (ndims!=cmor_grids[grid_id].ndims) {
snprintf(msg,CMOR_MAX_STRING,"you defined your grid with %i axes but grid_mapping '%s' requires exactly %i axes",cmor_grids[grid_id].ndims,name,ndims);
cmor_handle_error(msg,CMOR_CRITICAL);
}
/* first of all depending on some grid names we need to make sure we have the right axes set in the right order */
k=0;
for(i=0;i<ndims;i++){
for(j=0;j<cmor_grids[grid_id].ndims;j++) {
cmor_get_axis_attribute(cmor_grids[grid_id].original_axes_ids[j],"standard_name",'c',&msg);
if (strcmp(grid_dimensions[i],msg)==0) {
cmor_grids[grid_id].axes_ids[i]=cmor_grids[grid_id].original_axes_ids[j];
/* Now we probably need to alter the lat/lon,etc.. associated variables as well ! */
for (l=0;l<4;l++) {
if (cmor_vars[cmor_grids[cmor_ngrids].associated_variables[l]].ndims!=0) {
cmor_vars[cmor_grids[cmor_ngrids].associated_variables[l]].axes_ids[i]=cmor_grids[grid_id].original_axes_ids[j];
}
}
k++;
}
}
}
if (k!=ndims) {
snprintf(msg,CMOR_MAX_STRING,"setting grid mapping to '%s' we could not find all the required axes, required axes are:",name);
for (i=0;i<ndims;i++) {snprintf(msg2,CMOR_MAX_STRING," %s",grid_dimensions[i]);strncat(msg,msg2,CMOR_MAX_STRING-strlen(msg) );}
cmor_handle_error(msg,CMOR_CRITICAL);
}
for (i=0;i<nparam;i++) {
if (cmor_attribute_in_list(lattributes_names[i],nattributes, &grid_attributes[0])==1) {
if ((strcmp(lattributes_names[i],"standard_parallel1")==0 || strcmp(lattributes_names[i],"standard_parallel2")==0) && ( strcmp(name,"lambert_conformal_conic")==0)) {/* ok do nothing it is just that we need 2 values for this parameter */
cmor_set_grid_attribute(gid,lattributes_names[i],&attributes_values[i],lunits[i]);
}
else {
snprintf(msg,CMOR_MAX_STRING,"in grid_mapping, attribute '%s' (with value: %lf) is not a known attribute for grid mapping: '%s'",lattributes_names[i],attributes_values[i],name);
cmor_handle_error(msg,CMOR_WARNING);
}
}
else {
cmor_set_grid_attribute(gid,lattributes_names[i],&attributes_values[i],lunits[i]);
}
}
/* checks all paramter (but last 6 which are optional) have been set */
for (i=0;i<nattributes-6;i++) {
if (cmor_has_grid_attribute(gid,grid_attributes[i])==1) {
snprintf(msg,CMOR_MAX_STRING,"Grid mapping attribute %s has not been set, you should consider setting it",grid_attributes[i]);
cmor_handle_error(msg,CMOR_WARNING);
}
}
/* ok finally we need to copy the name to the grid struct */
strncpy(cmor_grids[grid_id].mapping,name,CMOR_MAX_STRING);
cmor_pop_traceback();
return 0;
}
int cmor_set_grid_attribute(int gid, char *name, double *value, char *units) {
int i,j,iatt;
int grid_id;
char ctmp[CMOR_MAX_STRING];
char msg[CMOR_MAX_STRING];
double tmp;
cmor_add_traceback("cmor_set_grid_attribute");
grid_id=-gid-CMOR_MAX_GRIDS;
iatt = cmor_grids[grid_id].nattributes;
tmp = *value;
/* locate attribute index */
for (i=0;i<cmor_grids[grid_id].nattributes;i++) {
if (strcmp(name,cmor_grids[grid_id].attributes_names[i])==0) iatt=i;
}
if (iatt==cmor_grids[grid_id].nattributes) cmor_grids[grid_id].nattributes++;
/* loop thru attributes */
if (strcmp(name,"false_easting")==0) {
j=-1;
for (i=0;i<cmor_grids[grid_id].ndims;i++) {
cmor_get_axis_attribute(cmor_grids[grid_id].axes_ids[i],"standard_name",'c',&ctmp[0]);
if (strcmp(ctmp,"projection_x_coordinate")==0) j=i;
}
if (j==-1) {
snprintf(ctmp,CMOR_MAX_STRING,"grid mapping attribute: 'false easting' must be set in conjunction with ut_cmor_a 'projection_x_coordinate' axis, I could not find such an axis on your grid, we will not set this attribute");
cmor_handle_error(ctmp,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
}
cmor_get_axis_attribute(cmor_grids[grid_id].axes_ids[j],"units",'c',&ctmp[0]);
cmor_convert_value(units,ctmp,&tmp);
}
else if (strcmp(name,"false_northing")==0) {
j=-1;
for (i=0;i<cmor_grids[grid_id].ndims;i++) {
cmor_get_axis_attribute(cmor_grids[grid_id].axes_ids[i],"standard_name",'c',&ctmp[0]);
if (strcmp(ctmp,"projection_y_coordinate")==0) j=i;
}
if (j==-1) {
snprintf(ctmp,CMOR_MAX_STRING,"grid mapping attribute: 'false easting' must be set in conjunction with a 'projection_x_coordinate' axis, I could not find such an axis on your grid, we will not set this attribute");
cmor_handle_error(ctmp,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
}
cmor_get_axis_attribute(cmor_grids[grid_id].axes_ids[j],"units",'c',&ctmp[0]);
cmor_convert_value(units,ctmp,&tmp);
}
else if (strcmp(name,"grid_north_pole_latitude")==0 || strcmp(name,"latitude_of_projection_origin")==0 || strcmp(name,"standard_parallel")==0 || strcmp(name,"standard_parallel1")==0 || strcmp(name,"standard_parallel2")==0 ) {
strcpy(ctmp,"degrees_north");
cmor_convert_value(units,ctmp,&tmp);
if ((tmp<-90) || (tmp>90.)) {
snprintf(msg,CMOR_MAX_STRING,"%s parameter must be between -90 and 90 %s, will not be set",name,ctmp);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
}
}
else if (strcmp(name,"grid_north_pole_longitude")==0 || strcmp(name,"longitude_of_prime_meridian")==0 || strcmp(name,"longitude_of_central_meridian")==0 || strcmp(name,"longitude_of_projection_origin")==0 || strcmp(name,"north_pole_grid_longitude")==0 || strcmp(name,"straight_vertical_longitude_from_pole")==0) {
strcpy(ctmp,"degrees_east");
cmor_convert_value(units,ctmp,&tmp);
if ((tmp<-180) || (tmp>180.)) {
snprintf(msg,CMOR_MAX_STRING,"%s parameter must be between -180 and 180 %s, will not be set",name,ctmp);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
}
}
else if (strcmp(name,"perspective_point_height")==0 || strcmp(name,"semi_major_axis")==0 || strcmp(name,"semi_minor_axis")==0 ) {
strcpy(ctmp,"m");
cmor_convert_value(units,ctmp,&tmp);
}
else if (strcmp(name,"scale_factor_at_central_meridian")==0 || strcmp(name,"scale_factor_at_projection_origin")==0 ) {
strcpy(ctmp,"m");
cmor_convert_value(units,ctmp,&tmp);
if (tmp<0) {
snprintf(msg,CMOR_MAX_STRING,"%s parameter must be between positive, will not be set",name);
cmor_handle_error(msg,CMOR_NORMAL);
cmor_pop_traceback();
return 1;
}
}
/*printf("setting: %s to %lf (orig: %lf)\n",name,tmp,value);*/
strncpy(cmor_grids[grid_id].attributes_names[iatt],name,CMOR_MAX_STRING);
cmor_grids[grid_id].attributes_values[iatt] = tmp;
cmor_pop_traceback();
return 0;
}