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