예제 #1
0
파일: cmor_grids.c 프로젝트: AZed/uvcdat
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();
}
예제 #2
0
파일: cmor_grids.c 프로젝트: AZed/uvcdat
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;
}
예제 #3
0
파일: cmor_grids.c 프로젝트: AZed/uvcdat
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;
}
예제 #4
0
파일: cmor_grids.c 프로젝트: jkettleb/cmor
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;
}
예제 #5
0
파일: cmor_grids.c 프로젝트: AZed/uvcdat
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;
}
예제 #6
0
파일: cmor_grids.c 프로젝트: AZed/uvcdat
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;
}
예제 #7
0
파일: cmor_grids.c 프로젝트: AZed/uvcdat
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;
}
예제 #8
0
파일: cmor_grids.c 프로젝트: AZed/uvcdat
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;
}