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 <xsh_pfits.h>
00051 #include <cpl.h>
00052 #include <string.h>
00053 #include <time.h>
00054 #include <math.h>
00055 #include <xsh_utils_table.h>
00056 #include <xsh_data_star_flux.h>
00057 #include <xsh_data_spectrum.h>
00058 #include <xsh_data_spectrum1D.h>
00059
00060
00061
00062
00063 #define XSH_STAR_FLUX_UVB_WAV_MIN 308
00064
00065
00066
00067 cpl_error_code
00068 xsh_star_flux_list_filter_median(xsh_star_flux_list * result,
00069 int hsize )
00070 {
00071
00072 cpl_vector* vflux=NULL;
00073 cpl_vector* vmedian=NULL;
00074 double* pvmedian=NULL;
00075 int i=0;
00076
00077 XSH_ASSURE_NOT_NULL_MSG(result, "Null input flux list table frame");
00078 XSH_ASSURE_NOT_ILLEGAL_MSG(result->size > 2*hsize,"size < 2*hsize. You set a too large half window size.");
00079
00080 vflux=cpl_vector_wrap(result->size,result->flux);
00081 vmedian=cpl_vector_filter_median_create(vflux,hsize);
00082 pvmedian=cpl_vector_get_data(vmedian);
00083
00084 for(i=0;i<result->size;i++) {
00085 result->flux[i]=pvmedian[i];
00086 }
00087 cleanup:
00088
00089 cpl_vector_unwrap(vflux);
00090 xsh_free_vector(&vmedian);
00091 return cpl_error_get_code();
00092 }
00093
00094 cpl_error_code
00095 xsh_star_flux_list_filter_lowpass(xsh_star_flux_list * result,
00096 cpl_lowpass filter_type,
00097 int hsize )
00098 {
00099
00100 cpl_vector* vflux=NULL;
00101 cpl_vector* vlowpass=NULL;
00102 double* pvlowpass=NULL;
00103 int i=0;
00104
00105 XSH_ASSURE_NOT_NULL_MSG(result, "Null input flux list table frame");
00106 XSH_ASSURE_NOT_ILLEGAL_MSG(result->size > 2*hsize,"size < 2*hsize. You set a too large half window size.");
00107
00108 vflux=cpl_vector_wrap(result->size,result->flux);
00109 vlowpass=cpl_vector_filter_lowpass_create(vflux,filter_type,hsize);
00110 pvlowpass=cpl_vector_get_data(vlowpass);
00111
00112 for(i=0;i<result->size;i++) {
00113 result->flux[i]=pvlowpass[i];
00114 }
00115 cleanup:
00116
00117 cpl_vector_unwrap(vflux);
00118 xsh_free_vector(&vlowpass);
00119 return cpl_error_get_code();
00120 }
00121
00122
00123 xsh_star_flux_list * xsh_star_flux_list_create( int size )
00124 {
00125 xsh_star_flux_list * result = NULL ;
00126
00127
00128 XSH_CALLOC( result, xsh_star_flux_list, 1 ) ;
00129 result->header = NULL ;
00130 result->size = size ;
00131 XSH_CALLOC( result->lambda, double, size ) ;
00132 XSH_CALLOC( result->flux, double, size ) ;
00133
00134 cleanup:
00135 return result ;
00136 }
00137
00138 xsh_star_flux_list * xsh_star_flux_list_load( cpl_frame * star_frame )
00139 {
00140 cpl_table *table = NULL ;
00141 const char * tablename = NULL ;
00142 xsh_star_flux_list * result = NULL ;
00143 int nentries, i ;
00144 double * plambda, * pflux ;
00145
00146
00147 XSH_ASSURE_NOT_NULL( star_frame);
00148
00149
00150 check(tablename = cpl_frame_get_filename( star_frame ));
00151
00152
00153 XSH_TABLE_LOAD( table, tablename ) ;
00154
00155
00156
00157
00158
00159
00160 check( nentries = cpl_table_get_nrow( table ) ) ;
00161
00162
00163 check( result = xsh_star_flux_list_create( nentries ) ) ;
00164
00165 plambda = result->lambda ;
00166 pflux = result->flux ;
00167
00168 check(result->header = cpl_propertylist_load(tablename, 0));
00169
00170 check(cpl_table_cast_column(table,XSH_STAR_FLUX_LIST_COLNAME_WAVELENGTH,"F_WAVELENGTH",CPL_TYPE_FLOAT));
00171 check(cpl_table_cast_column(table,XSH_STAR_FLUX_LIST_COLNAME_FLUX,"F_FLUX",CPL_TYPE_FLOAT))
00172 ;
00173
00174
00175 for( i = 0 ; i< nentries ; i++, plambda++, pflux++ ) {
00176 float value ;
00177
00178 check( xsh_get_table_value( table, "F_WAVELENGTH",
00179 CPL_TYPE_FLOAT, i, &value ) ) ;
00180 *plambda = value ;
00181 check( xsh_get_table_value( table, "F_FLUX",
00182 CPL_TYPE_FLOAT, i, &value ) ) ;
00183 *pflux = value ;
00184 }
00185
00186 cleanup:
00187 if (cpl_error_get_code () != CPL_ERROR_NONE) {
00188 xsh_error_msg("can't load frame %s",cpl_frame_get_filename(star_frame));
00189 xsh_star_flux_list_free(&result);
00190 }
00191 XSH_TABLE_FREE( table);
00192 return result ;
00193 }
00194
00195 cpl_error_code
00196 xsh_star_flux_list_to_frame( xsh_star_flux_list* list, cpl_frame* frame)
00197 {
00198 xsh_spectrum *s = NULL ;
00199 const char * name = NULL ;
00200 int size=0;
00201 double* pflux=NULL;
00202 int i=0;
00203 const char* tag=NULL;
00204
00205
00206 XSH_ASSURE_NOT_NULL( frame);
00207 XSH_ASSURE_NOT_NULL( list);
00208
00209 s=xsh_spectrum_load(frame);
00210
00211
00212 size=s->size;
00213 cpl_ensure_code(list->size == s->size, CPL_ERROR_ILLEGAL_INPUT);
00214
00215 cpl_ensure_code(list->lambda[0] == s->lambda_min, CPL_ERROR_ILLEGAL_INPUT);
00216 cpl_ensure_code(list->lambda[size-1] == s->lambda_max, CPL_ERROR_ILLEGAL_INPUT);
00217
00218
00219 pflux=xsh_spectrum_get_flux(s);
00220 for(i=0;i<size;i++) {
00221 pflux[i]=list->flux[i];
00222 }
00223
00224
00225 name = cpl_frame_get_filename(frame);
00226 tag = cpl_frame_get_tag(frame);
00227 xsh_spectrum_save(s,name,tag);
00228
00229 cleanup:
00230
00231 return cpl_error_get_code() ;
00232 }
00233
00234
00235
00236 xsh_star_flux_list * xsh_star_flux_list_load_spectrum( cpl_frame * star_frame )
00237 {
00238
00239
00240 xsh_star_flux_list * result = NULL ;
00241 int nentries, i ;
00242 double * plambda, * pflux ;
00243 xsh_spectrum* spectrum=NULL;
00244
00245
00246 XSH_ASSURE_NOT_NULL( star_frame);
00247
00248
00249
00250
00251
00252 check(spectrum=xsh_spectrum_load(star_frame)) ;
00253 nentries = xsh_pfits_get_naxis1(spectrum->flux_header);
00254
00255
00256 check( result = xsh_star_flux_list_create( nentries ) ) ;
00257 result->header = cpl_propertylist_duplicate(spectrum->flux_header);
00258 plambda = result->lambda ;
00259 pflux = result->flux ;
00260
00261 double* pima=NULL;
00262 pima=cpl_image_get_data_double(spectrum->flux);
00263
00264 double wmin=0;
00265 wmin = xsh_pfits_get_crval1(result->header);
00266 double wstep=0;
00267 wstep = xsh_pfits_get_cdelt1(result->header);
00268
00269
00270 for( i = 0 ; i< nentries ; i++, plambda++, pflux++ ) {
00271
00272 *plambda = (float) (wmin+i*wstep) ;
00273 *pflux = (float) pima[i];
00274
00275 }
00276
00277 cleanup:
00278 if (cpl_error_get_code () != CPL_ERROR_NONE) {
00279 xsh_error_msg("can't load frame %s",cpl_frame_get_filename(star_frame));
00280 xsh_star_flux_list_free(&result);
00281 }
00282
00283 xsh_spectrum_free( &spectrum );
00284 return result ;
00285 }
00286
00287 void xsh_star_flux_list_free( xsh_star_flux_list ** list )
00288 {
00289 if ( list != NULL && *list != NULL ) {
00290 xsh_free_propertylist(&(*list)->header);
00291 cpl_free( (*list)->lambda ) ;
00292 cpl_free( (*list)->flux ) ;
00293
00294 cpl_free( *list ) ;
00295 *list = NULL ;
00296 }
00297
00298
00299 return ;
00300 }
00301
00302 cpl_error_code
00303 xsh_star_flux_list_dump_ascii( xsh_star_flux_list * list, const char* filename )
00304 {
00305 FILE * fout ;
00306 int size=0;
00307 int i=0;
00308 double * plambda=NULL;
00309 double * pflux=NULL;
00310
00311 XSH_ASSURE_NOT_NULL_MSG(list,"Null input std star flux list!Exit");
00312 size=list->size;
00313
00314 plambda = list->lambda ;
00315 pflux = list->flux ;
00316
00317 if((fout=fopen(filename,"w"))==NULL) {
00318
00319 return CPL_ERROR_FILE_IO ;
00320 } else {
00321 for(i=0;i<size;i++) {
00322 fprintf(fout, "%f %f \n", plambda[i], pflux[i]);
00323 }
00324 }
00325 if ( fout ) fclose( fout ) ;
00326
00327 cleanup:
00328 return cpl_error_get_code() ;
00329 }
00330
00331
00332
00333 cpl_frame * xsh_star_flux_list_save( xsh_star_flux_list * list,
00334 const char * filename, const char * tag )
00335 {
00336 cpl_table * table = NULL ;
00337 cpl_frame * result = NULL ;
00338 int size, i ;
00339 double * plambda, * pflux ;
00340
00341 XSH_ASSURE_NOT_NULL(list);
00342 XSH_ASSURE_NOT_NULL(filename);
00343
00344
00345 check(table = cpl_table_new( 2 ));
00346
00347
00348 check(
00349 cpl_table_new_column(table, XSH_STAR_FLUX_LIST_COLNAME_WAVELENGTH,
00350 CPL_TYPE_FLOAT));
00351 check(
00352 cpl_table_new_column(table, XSH_STAR_FLUX_LIST_COLNAME_FLUX,
00353 CPL_TYPE_FLOAT));
00354
00355 size = list->size ;
00356 plambda = list->lambda ;
00357 pflux = list->flux ;
00358
00359 check(cpl_table_set_size(table, size));
00360
00361
00362 for( i = 0 ; i<size ; i++, plambda++, pflux++ ) {
00363 float value ;
00364
00365 value = *plambda ;
00366 check(cpl_table_set_float(table, XSH_STAR_FLUX_LIST_COLNAME_WAVELENGTH,
00367 i, value ));
00368 value = *pflux ;
00369 check(cpl_table_set_float(table, XSH_STAR_FLUX_LIST_COLNAME_FLUX,
00370 i, value ));
00371 }
00372
00373
00374 check(cpl_table_save( table, list->header, NULL, filename, CPL_IO_DEFAULT));
00375
00376
00377
00378 check(result=xsh_frame_product( filename, tag,
00379 CPL_FRAME_TYPE_TABLE,
00380 CPL_FRAME_GROUP_PRODUCT,
00381 CPL_FRAME_LEVEL_TEMPORARY));
00382
00383 xsh_msg_dbg_low( "Star Flux Frame Saved" ) ;
00384
00385 cleanup:
00386 XSH_TABLE_FREE( table);
00387 return result ;
00388 }
00389
00390
00391
00392
00393 cpl_frame *
00394 xsh_star_flux_list_save_order( xsh_star_flux_list * list,
00395 const char * filename,
00396 const char * tag,
00397 const int order )
00398 {
00399 cpl_table * table = NULL ;
00400 cpl_frame * result = NULL ;
00401 int size, i ;
00402 double * plambda, * pflux ;
00403
00404 XSH_ASSURE_NOT_NULL(list);
00405 XSH_ASSURE_NOT_NULL(filename);
00406
00407
00408 check(table = cpl_table_new( 2 ));
00409
00410
00411 check(
00412 cpl_table_new_column(table, XSH_STAR_FLUX_LIST_COLNAME_WAVELENGTH,
00413 CPL_TYPE_FLOAT));
00414 check(
00415 cpl_table_new_column(table, XSH_STAR_FLUX_LIST_COLNAME_FLUX,
00416 CPL_TYPE_FLOAT));
00417
00418 size = list->size ;
00419 plambda = list->lambda ;
00420 pflux = list->flux ;
00421
00422 check(cpl_table_set_size(table, size));
00423
00424
00425 for( i = 0 ; i<size ; i++, plambda++, pflux++ ) {
00426 float value ;
00427
00428 value = *plambda ;
00429 check(cpl_table_set_float(table, XSH_STAR_FLUX_LIST_COLNAME_WAVELENGTH,
00430 i, value ));
00431 value = *pflux ;
00432 check(cpl_table_set_float(table, XSH_STAR_FLUX_LIST_COLNAME_FLUX,
00433 i, value ));
00434 }
00435
00436
00437 if(order==0) {
00438 check(cpl_table_save( table,list->header,NULL,filename,CPL_IO_DEFAULT));
00439 } else {
00440 check(cpl_table_save( table,list->header,NULL,filename,CPL_IO_EXTEND));
00441 }
00442
00443
00444
00445 check(result=xsh_frame_product( filename, tag,
00446 CPL_FRAME_TYPE_TABLE,
00447 CPL_FRAME_GROUP_PRODUCT,
00448 CPL_FRAME_LEVEL_TEMPORARY));
00449
00450 xsh_msg_dbg_low( "Star Flux Frame Saved" ) ;
00451
00452 cleanup:
00453 XSH_TABLE_FREE( table);
00454 return result ;
00455 }
00456
00457
00458
00459
00460 double * xsh_star_flux_list_get_lambda( xsh_star_flux_list * list )
00461 {
00462 XSH_ASSURE_NOT_NULL( list ) ;
00463
00464 cleanup:
00465 return list->lambda ;
00466 }
00467
00468 double * xsh_star_flux_list_get_flux( xsh_star_flux_list * list )
00469 {
00470 XSH_ASSURE_NOT_NULL( list ) ;
00471
00472 cleanup:
00473 return list->flux ;
00474 }
00475
00476
00477 xsh_star_flux_list* xsh_star_flux_list_duplicate( xsh_star_flux_list * list )
00478 {
00479 XSH_ASSURE_NOT_NULL( list ) ;
00480
00481 xsh_star_flux_list* result=NULL;
00482 int size=list->size;
00483
00484 result=xsh_star_flux_list_create(size );
00485
00486
00487
00488
00489 memcpy(result->lambda,list->lambda,size*sizeof(double));
00490 memcpy(result->flux,list->flux,size*sizeof(double));
00491
00492 cleanup:
00493 return result;
00494 }
00495
00496 void xsh_star_flux_list_extrapolate_wave_end( xsh_star_flux_list * list , const double wmax)
00497 {
00498 XSH_ASSURE_NOT_NULL( list ) ;
00499 int size=list->size;
00500 int i=0;
00501 int k=0;
00502 int off=10;
00503 double f1=0;
00504 double f2=0;
00505 double w1=0;
00506 double w2=0;
00507 double x1=0;
00508 double x2=0;
00509 double m=0;
00510 double x=0;
00511 double w=0;
00512 int computed=0;
00513
00514
00515
00516
00517
00518
00519 for (i = 0; i < size; i++) {
00520 if (list->lambda[i]<wmax) {
00521 k++;
00522 } else {
00523
00524 if (computed == 0) {
00525 f2 = list->flux[k];
00526 f1 = list->flux[k - off];
00527 w2 = 1./list->lambda[k];
00528 x2 = w2*w2*w2*w2;
00529 w1 = 1./list->lambda[k - off];
00530 x1 = w1*w1*w1*w1;
00531 m = (f2 - f1) / (x2 - x1);
00532 computed=1;
00533
00534 } else {
00535 w=1./list->lambda[i];
00536 x=w*w*w*w;
00537
00538 list->flux[i]=f1+m*(x-x1);
00539
00540 }
00541 }
00542 }
00543
00544 cleanup:
00545 return;
00546 }
00547
00548 cpl_error_code
00549 xsh_star_flux_list_divide( xsh_star_flux_list * result, xsh_star_flux_list * factor)
00550 {
00551
00552 XSH_ASSURE_NOT_NULL( result ) ;
00553 XSH_ASSURE_NOT_NULL( factor ) ;
00554
00555
00556 XSH_ASSURE_NOT_ILLEGAL_MSG(result->size==factor->size,"List of different sizes");
00557 int size=result->size;
00558
00559
00560
00561 int i=0;
00562 for(i=0;i<size;i++) {
00563 result->flux[i] /= factor->flux[i];
00564 }
00565
00566 cleanup:
00567 return cpl_error_get_code();
00568 }
00569