00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifdef HAVE_CONFIG_H
00028 #include <config.h>
00029 #endif
00030
00031
00040
00041
00042
00043
00044
00045
00046
00047 #include <xsh_dfs.h>
00048 #include <xsh_error.h>
00049 #include <xsh_msg.h>
00050 #include <cpl.h>
00051 #include <string.h>
00052 #include <time.h>
00053 #include <xsh_utils_table.h>
00054 #include <xsh_data_star_flux.h>
00055
00056
00057
00058
00059 #define XSH_STAR_FLUX_UVB_WAV_MIN 308
00060
00061
00062
00063 cpl_error_code
00064 xsh_star_flux_list_filter_median(xsh_star_flux_list * result,
00065 int hsize )
00066 {
00067
00068 cpl_vector* vflux=NULL;
00069 cpl_vector* vmedian=NULL;
00070 double* pvmedian=NULL;
00071 int i=0;
00072
00073 XSH_ASSURE_NOT_NULL_MSG(result, "Null input flux list table frame");
00074 XSH_ASSURE_NOT_ILLEGAL_MSG(result->size > 2*hsize,"size < 2*hsize. You set a too large half window size.");
00075
00076 vflux=cpl_vector_wrap(result->size,result->flux);
00077 vmedian=cpl_vector_filter_median_create(vflux,hsize);
00078 pvmedian=cpl_vector_get_data(vmedian);
00079
00080 for(i=0;i<result->size;i++) {
00081 result->flux[i]=pvmedian[i];
00082 }
00083 cleanup:
00084
00085 cpl_vector_unwrap(vflux);
00086 xsh_free_vector(&vmedian);
00087 return cpl_error_get_code();
00088 }
00089
00090 xsh_star_flux_list * xsh_star_flux_list_create( int size )
00091 {
00092 xsh_star_flux_list * result = NULL ;
00093
00094
00095 XSH_CALLOC( result, xsh_star_flux_list, 1 ) ;
00096 result->header = NULL ;
00097 result->size = size ;
00098 XSH_CALLOC( result->lambda, double, size ) ;
00099 XSH_CALLOC( result->flux, double, size ) ;
00100
00101 cleanup:
00102 return result ;
00103 }
00104
00105 xsh_star_flux_list * xsh_star_flux_list_load( cpl_frame * star_frame )
00106 {
00107 cpl_table *table = NULL ;
00108 const char * tablename = NULL ;
00109 xsh_star_flux_list * result = NULL ;
00110 int nentries, i ;
00111 double * plambda, * pflux ;
00112
00113
00114 XSH_ASSURE_NOT_NULL( star_frame);
00115
00116
00117 check(tablename = cpl_frame_get_filename( star_frame ));
00118
00119
00120 XSH_TABLE_LOAD( table, tablename ) ;
00121 cpl_table_and_selected_double(table,XSH_STAR_FLUX_LIST_COLNAME_WAVELENGTH,CPL_LESS_THAN,XSH_STAR_FLUX_UVB_WAV_MIN);
00122 cpl_table_erase_selected(table);
00123 check( nentries = cpl_table_get_nrow( table ) ) ;
00124
00125
00126 check( result = xsh_star_flux_list_create( nentries ) ) ;
00127
00128 plambda = result->lambda ;
00129 pflux = result->flux ;
00130
00131 check(result->header = cpl_propertylist_load(tablename, 0));
00132
00133 check(cpl_table_cast_column(table,XSH_STAR_FLUX_LIST_COLNAME_WAVELENGTH,"F_WAVELENGTH",CPL_TYPE_FLOAT));
00134 check(cpl_table_cast_column(table,XSH_STAR_FLUX_LIST_COLNAME_FLUX,"F_FLUX",CPL_TYPE_FLOAT))
00135 ;
00136
00137
00138 for( i = 0 ; i< nentries ; i++, plambda++, pflux++ ) {
00139 float value ;
00140
00141 check( xsh_get_table_value( table, "F_WAVELENGTH",
00142 CPL_TYPE_FLOAT, i, &value ) ) ;
00143 *plambda = value ;
00144 check( xsh_get_table_value( table, "F_FLUX",
00145 CPL_TYPE_FLOAT, i, &value ) ) ;
00146 *pflux = value ;
00147 }
00148
00149 cleanup:
00150 if (cpl_error_get_code () != CPL_ERROR_NONE) {
00151 xsh_error_msg("can't load frame %s",cpl_frame_get_filename(star_frame));
00152 xsh_star_flux_list_free(&result);
00153 }
00154 XSH_TABLE_FREE( table);
00155 return result ;
00156 }
00157
00158 void xsh_star_flux_list_free( xsh_star_flux_list ** list )
00159 {
00160 if ( list != NULL && *list != NULL ) {
00161 xsh_free_propertylist(&(*list)->header);
00162 check( cpl_free( (*list)->lambda ) ) ;
00163 check( cpl_free( (*list)->flux ) ) ;
00164
00165 check( cpl_free( *list ) ) ;
00166 *list = NULL ;
00167 }
00168
00169 cleanup:
00170 return ;
00171 }
00172
00173 cpl_error_code
00174 xsh_star_flux_list_dump_ascii( xsh_star_flux_list * list, const char* filename )
00175 {
00176 FILE * fout ;
00177 int size=0;
00178 int i=0;
00179 double * plambda=NULL;
00180 double * pflux=NULL;
00181
00182 XSH_ASSURE_NOT_NULL_MSG(list,"Null input std star flux list!Exit");
00183 size=list->size;
00184
00185 plambda = list->lambda ;
00186 pflux = list->flux ;
00187
00188 if((fout=fopen(filename,"w"))==NULL) {
00189
00190 return CPL_ERROR_FILE_IO ;
00191 } else {
00192 for(i=0;i<size;i++) {
00193 fprintf(fout, "%f %f \n", plambda[i], pflux[i]);
00194 }
00195 }
00196 if ( fout ) fclose( fout ) ;
00197
00198 cleanup:
00199 return cpl_error_get_code() ;
00200 }
00201
00202
00203
00204 cpl_frame * xsh_star_flux_list_save( xsh_star_flux_list * list,
00205 const char * filename, const char * tag )
00206 {
00207 cpl_table * table = NULL ;
00208 cpl_frame * result = NULL ;
00209 int size, i ;
00210 double * plambda, * pflux ;
00211
00212 XSH_ASSURE_NOT_NULL(list);
00213 XSH_ASSURE_NOT_NULL(filename);
00214
00215
00216 check(table = cpl_table_new( 2 ));
00217
00218
00219 check(
00220 cpl_table_new_column(table, XSH_STAR_FLUX_LIST_COLNAME_WAVELENGTH,
00221 CPL_TYPE_FLOAT));
00222 check(
00223 cpl_table_new_column(table, XSH_STAR_FLUX_LIST_COLNAME_FLUX,
00224 CPL_TYPE_FLOAT));
00225
00226 size = list->size ;
00227 plambda = list->lambda ;
00228 pflux = list->flux ;
00229
00230 check(cpl_table_set_size(table, size));
00231
00232
00233 for( i = 0 ; i<size ; i++, plambda++, pflux++ ) {
00234 float value ;
00235
00236 value = *plambda ;
00237 check(cpl_table_set_float(table, XSH_STAR_FLUX_LIST_COLNAME_WAVELENGTH,
00238 i, value ));
00239 value = *pflux ;
00240 check(cpl_table_set_float(table, XSH_STAR_FLUX_LIST_COLNAME_FLUX,
00241 i, value ));
00242 }
00243
00244
00245 check(cpl_table_save( table, list->header, NULL, filename, CPL_IO_DEFAULT));
00246
00247
00248
00249 check(result=xsh_frame_product( filename, tag,
00250 CPL_FRAME_TYPE_TABLE,
00251 CPL_FRAME_GROUP_PRODUCT,
00252 CPL_FRAME_LEVEL_TEMPORARY));
00253
00254 xsh_msg_dbg_low( "Star Flux Frame Saved" ) ;
00255
00256 cleanup:
00257 XSH_TABLE_FREE( table);
00258 return result ;
00259 }
00260
00261
00262
00263
00264 cpl_frame *
00265 xsh_star_flux_list_save_order( xsh_star_flux_list * list,
00266 const char * filename,
00267 const char * tag,
00268 const int order )
00269 {
00270 cpl_table * table = NULL ;
00271 cpl_frame * result = NULL ;
00272 int size, i ;
00273 double * plambda, * pflux ;
00274
00275 XSH_ASSURE_NOT_NULL(list);
00276 XSH_ASSURE_NOT_NULL(filename);
00277
00278
00279 check(table = cpl_table_new( 2 ));
00280
00281
00282 check(
00283 cpl_table_new_column(table, XSH_STAR_FLUX_LIST_COLNAME_WAVELENGTH,
00284 CPL_TYPE_FLOAT));
00285 check(
00286 cpl_table_new_column(table, XSH_STAR_FLUX_LIST_COLNAME_FLUX,
00287 CPL_TYPE_FLOAT));
00288
00289 size = list->size ;
00290 plambda = list->lambda ;
00291 pflux = list->flux ;
00292
00293 check(cpl_table_set_size(table, size));
00294
00295
00296 for( i = 0 ; i<size ; i++, plambda++, pflux++ ) {
00297 float value ;
00298
00299 value = *plambda ;
00300 check(cpl_table_set_float(table, XSH_STAR_FLUX_LIST_COLNAME_WAVELENGTH,
00301 i, value ));
00302 value = *pflux ;
00303 check(cpl_table_set_float(table, XSH_STAR_FLUX_LIST_COLNAME_FLUX,
00304 i, value ));
00305 }
00306
00307
00308 if(order==0) {
00309 check(cpl_table_save( table,list->header,NULL,filename,CPL_IO_DEFAULT));
00310 } else {
00311 check(cpl_table_save( table,list->header,NULL,filename,CPL_IO_EXTEND));
00312 }
00313
00314
00315
00316 check(result=xsh_frame_product( filename, tag,
00317 CPL_FRAME_TYPE_TABLE,
00318 CPL_FRAME_GROUP_PRODUCT,
00319 CPL_FRAME_LEVEL_TEMPORARY));
00320
00321 xsh_msg_dbg_low( "Star Flux Frame Saved" ) ;
00322
00323 cleanup:
00324 XSH_TABLE_FREE( table);
00325 return result ;
00326 }
00327
00328
00329
00330
00331 double * xsh_star_flux_list_get_lambda( xsh_star_flux_list * list )
00332 {
00333 XSH_ASSURE_NOT_NULL( list ) ;
00334
00335 cleanup:
00336 return list->lambda ;
00337 }
00338
00339 double * xsh_star_flux_list_get_flux( xsh_star_flux_list * list )
00340 {
00341 XSH_ASSURE_NOT_NULL( list ) ;
00342
00343 cleanup:
00344 return list->flux ;
00345 }
00346
00347