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 #ifdef HAVE_CONFIG_H
00027 #include <config.h>
00028 #endif
00029
00030 #define CPL_MODE 0
00031
00038
00041
00042
00043
00044
00045 #include <math.h>
00046 #include <xsh_drl.h>
00047
00048 #include <xsh_utils_table.h>
00049 #include <xsh_badpixelmap.h>
00050 #include <xsh_utils_wrappers.h>
00051 #include <xsh_data_pre.h>
00052 #include <xsh_dfs.h>
00053 #include <xsh_pfits.h>
00054 #include <xsh_error.h>
00055 #include <xsh_msg.h>
00056 #include <xsh_fit.h>
00057 #include <xsh_data_instrument.h>
00058 #include <xsh_data_localization.h>
00059 #include <xsh_data_spectrum.h>
00060 #include <xsh_data_rec.h>
00061 #include <xsh_utils_ifu.h>
00062 #include <xsh_ifu_defs.h>
00063 #include <xsh_parameters.h>
00064 #include <cpl.h>
00065
00066
00067
00068
00069 static void chunk_coadd( double* data, double* flux, int* qual, int nx, int ny,
00070 int ifirst, int ilast, const int decode_bp, int *skymask);
00071
00072 static void tab_minmax_get_index( double* data, int size,
00073 xsh_slit_limit_param * slit_limit_par,
00074 int* min, int* max);
00075
00076 static xsh_localization* xsh_localize_obj_auto( cpl_frame * rec_frame,
00077 cpl_frame *skymask_frame,
00078 xsh_instrument* instrument, xsh_localize_obj_param * loc_obj_par,
00079 xsh_slit_limit_param * slit_limit_par,const int decode_bp);
00080
00081 static xsh_localization* xsh_localize_obj_manual(
00082 xsh_instrument *instrument, xsh_localize_obj_param *loc_obj_par);
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106 static void chunk_coadd( double* data, double *flux, int* qual, int nx, int ny,
00107 int ifirst, int ilast, const int decode_bp,int *skymask)
00108 {
00109 int i,j;
00110 int* nbgoodpixels = NULL;
00111
00112 XSH_ASSURE_NOT_NULL(data);
00113 XSH_ASSURE_NOT_NULL(flux);
00114 XSH_ASSURE_NOT_NULL(qual);
00115 XSH_ASSURE_NOT_NULL(skymask);
00116 XSH_ASSURE_NOT_ILLEGAL(ifirst >= 0 && ifirst <= ilast && ilast < nx);
00117
00118 XSH_CALLOC( nbgoodpixels, int, ny);
00119
00120 for(j=0; j<ny; j++){
00121 data[j] = 0;
00122 }
00123
00124 for(i=ifirst; i<=ilast; i++){
00125 if (skymask[i] == 0){
00126 for( j=0 ; j<ny ; j++) {
00127 if ( (qual[i+j*nx] & decode_bp) == 0 ){
00128 nbgoodpixels[j]++;
00129 data[j] +=flux[i+j*nx];
00130 }
00131 else{
00132 xsh_msg_dbg_high("bad pixel at %d %d",i,j);
00133 }
00134 }
00135 }
00136 else{
00137 xsh_msg_dbg_medium("Mask by sky lines : column %d", i);
00138 }
00139 }
00140
00141 for(j=0; j<ny; j++){
00142 if ( nbgoodpixels[j] != 0 ) data[j] = data[j] / (float)(nbgoodpixels[j]);
00143 else data[j] = 0. ;
00144 }
00145
00146 cleanup:
00147 XSH_FREE(nbgoodpixels);
00148 return;
00149 }
00150
00151 static void tab_minmax_get_index( double* data, int size,
00152 xsh_slit_limit_param * slit_limit_par,
00153 int* min, int* max)
00154 {
00155 int i, maxi, mini ;
00156 int slit0, slit1 ;
00157
00158 XSH_ASSURE_NOT_NULL(data);
00159 XSH_ASSURE_NOT_NULL(min);
00160 XSH_ASSURE_NOT_NULL(max);
00161
00162 if ( slit_limit_par == NULL ) {
00163 slit0 = 0 ;
00164 slit1 = size ;
00165 }
00166 else {
00167 slit0 = slit_limit_par->min_slit_idx + 1 ;
00168 slit1 = slit_limit_par->max_slit_idx ;
00169 }
00170 maxi = 0 ;
00171 mini = 0 ;
00172
00173 for(i = slit0; i<slit1; i++) {
00174 if (data[i]>data[maxi]){
00175 maxi = i;
00176 }
00177 else if (data[i]<data[mini]){
00178 mini = i;
00179 }
00180 }
00181 *min = mini;
00182 *max = maxi;
00183
00184 cleanup:
00185 return;
00186 }
00187
00188
00189
00190
00191
00192
00210
00211 cpl_frame* xsh_localize_obj (cpl_frame *rec_frame,
00212 cpl_frame *skymask_frame,
00213 xsh_instrument* instrument,
00214 xsh_localize_obj_param * loc_obj_par,
00215 xsh_slit_limit_param * slitlimit_par,
00216 const char * fname)
00217 {
00218 cpl_frame *merge_frame = NULL;
00219 cpl_frame *res_frame = NULL;
00220 xsh_localization *loc_list = NULL;
00221 xsh_merge_param merge_par = {MEAN_MERGE_METHOD};
00222 const char* rec_prefix = "LOCALIZE";
00223 char filename[80];
00224
00225
00226
00227 XSH_ASSURE_NOT_NULL( loc_obj_par);
00228 XSH_ASSURE_NOT_NULL( instrument);
00229
00230 xsh_msg_dbg_medium( "Entering xsh_localize_obj") ;
00231
00232 if ( rec_frame != NULL){
00233 const char* filename = NULL;
00234 check( merge_frame = xsh_merge_ord( rec_frame, instrument, &merge_par,
00235 rec_prefix));
00236 check( filename = cpl_frame_get_filename( merge_frame));
00237 check( cpl_frame_set_level( merge_frame, CPL_FRAME_LEVEL_TEMPORARY));
00238 xsh_add_temporary_file( filename);
00239 }
00240
00241
00242 xsh_msg_dbg_medium("method %s",LOCALIZE_METHOD_PRINT( loc_obj_par->method));
00243
00244 if ( loc_obj_par->method == LOC_MANUAL_METHOD){
00245 xsh_msg_dbg_medium("slit position %f slit half height %f",
00246 loc_obj_par->slit_position, loc_obj_par->slit_hheight);
00247 check( loc_list = xsh_localize_obj_manual( instrument, loc_obj_par));
00248 }
00249 else{
00250 check( loc_list = xsh_localize_obj_auto( merge_frame, skymask_frame,
00251 instrument,
00252 loc_obj_par, slitlimit_par,instrument->decode_bp));
00253 }
00254
00255 xsh_msg_dbg_low( "Saving Localization Table" ) ;
00256 if ( fname == NULL ) {
00257
00258
00259
00260
00261 sprintf(filename,"LOCALIZATION_TABLE_%s.fits",
00262 xsh_instrument_arm_tostring(instrument));
00263 xsh_add_temporary_file(filename);
00264 } else {
00265 sprintf(filename,fname);
00266 }
00267 check( res_frame = xsh_localization_save( loc_list, filename, instrument));
00268
00269 cleanup:
00270 xsh_localization_free( &loc_list);
00271 xsh_free_frame( &merge_frame);
00272
00273 return res_frame ;
00274 }
00275
00276
00277 static xsh_localization* xsh_localize_obj_manual(
00278 xsh_instrument *instrument, xsh_localize_obj_param *loc_obj_par)
00279 {
00280 xsh_localization *loc_list = NULL;
00281 int deg_poly = 0;
00282 double slit_cen, slit_up, slit_low;
00283 cpl_size pows = 0;
00284
00285
00286 XSH_ASSURE_NOT_NULL( loc_obj_par);
00287 XSH_ASSURE_NOT_NULL( instrument);
00288
00289
00290 xsh_msg_dbg_medium("slit position %f slit half height %f",
00291 loc_obj_par->slit_position, loc_obj_par->slit_hheight);
00292
00293 check( loc_list = xsh_localization_create());
00294
00295 slit_cen = loc_obj_par->slit_position;
00296 slit_up = slit_cen + loc_obj_par->slit_hheight;
00297 slit_low = slit_cen - loc_obj_par->slit_hheight;
00298
00299 loc_list->pol_degree = deg_poly;
00300 check( loc_list->cenpoly = cpl_polynomial_new( 1));
00301 check( loc_list->edglopoly = cpl_polynomial_new( 1));
00302 check( loc_list->edguppoly = cpl_polynomial_new( 1));
00303 check( cpl_polynomial_set_coeff( loc_list->cenpoly,
00304 &pows, slit_cen));
00305 check( cpl_polynomial_set_coeff( loc_list->edglopoly,
00306 &pows, slit_low));
00307 check( cpl_polynomial_set_coeff( loc_list->edguppoly,
00308 &pows, slit_up));
00309
00310 cleanup:
00311 return loc_list;
00312 }
00313
00314
00332
00333 static xsh_localization*
00334 xsh_localize_obj_auto( cpl_frame *merge_frame,
00335 cpl_frame *skymask_frame,
00336 xsh_instrument *instrument,
00337 xsh_localize_obj_param *loc_obj_par,
00338 xsh_slit_limit_param *slitlimit_par,const int decode_bp)
00339 {
00340 xsh_localization *loc_list = NULL;
00341 xsh_spectrum *spectrum = NULL;
00342 double* slit_center = NULL;
00343 double* slit_upper = NULL;
00344 double* slit_lower = NULL;
00345 double* chunk_center = NULL;
00346 cpl_vector* slit_center_v = NULL;
00347 cpl_vector* slit_upper_v = NULL;
00348 cpl_vector* slit_lower_v = NULL;
00349 cpl_vector* chunk_center_v = NULL;
00350
00351 #if 0
00352 int i = 0;
00353 int skip_order_nb = 0;
00354 int first_order_index = 0;
00355 int slit_nod, slit_lim ;
00356 #endif
00357
00358 int level;
00359
00360 int nslit, nlambda, chunk_size;
00361 double* slit_tab = NULL;
00362 double *flux = NULL;
00363 double *errs = NULL;
00364 int *qual = NULL;
00365 int ichunk, skip_chunk=0, nb_chunk;
00366 cpl_polynomial *cen_poly = NULL;
00367 int loc_degree;
00368 double lambda_min, lambda_step;
00369 double slit_min, slit_step, kappa=2.0;
00370 int islit, iter, niter=5, nbrej=-1;
00371 cpl_vector *dispslit = NULL;
00372 cpl_vector *gausspos = NULL;
00373 cpl_vector *gaussval = NULL;
00374 int *sky_mask = NULL;
00375 cpl_table *skymask_table = NULL;
00376 const char* skymask_name = NULL;
00377
00378
00379 XSH_ASSURE_NOT_NULL( loc_obj_par);
00380 XSH_ASSURE_NOT_NULL( instrument);
00381 XSH_ASSURE_NOT_NULL( merge_frame);
00382
00383
00384 kappa = loc_obj_par->kappa;
00385 niter = loc_obj_par->niter;
00386 loc_degree = loc_obj_par->loc_deg_poly;
00387 xsh_msg_dbg_medium( "Entering xsh_localize_obj_auto") ;
00388 xsh_msg_dbg_medium("Localize deg_poly %d chunk %d Thresh %f kappa %f niter %d",
00389 loc_degree, loc_obj_par->loc_chunk_nb, loc_obj_par->loc_thresh,
00390 kappa, niter);
00391 if ( loc_obj_par->use_skymask){
00392 XSH_ASSURE_NOT_NULL( skymask_frame);
00393 check( skymask_name = cpl_frame_get_filename( skymask_frame));
00394 xsh_msg_dbg_medium("Sky mask %s", skymask_name);
00395 }
00396
00397 level = xsh_debug_level_get();
00398
00399
00400 check( spectrum = xsh_spectrum_load( merge_frame));
00401 check( nslit = xsh_spectrum_get_size_slit( spectrum));
00402 check( nlambda = xsh_spectrum_get_size_lambda( spectrum));
00403 lambda_min = spectrum->lambda_min;
00404 lambda_step = spectrum->lambda_step;
00405 slit_min = spectrum->slit_min;
00406 slit_step = spectrum->slit_step;
00407
00408 check( flux = cpl_image_get_data_double( spectrum->flux));
00409 check( errs = cpl_image_get_data_double( spectrum->errs));
00410 check( qual = cpl_image_get_data_int( spectrum->qual));
00411
00412
00413 XSH_CALLOC( chunk_center, double, loc_obj_par->loc_chunk_nb);
00414 XSH_CALLOC( slit_center, double, loc_obj_par->loc_chunk_nb);
00415 XSH_CALLOC( slit_upper, double, loc_obj_par->loc_chunk_nb);
00416 XSH_CALLOC( slit_lower, double, loc_obj_par->loc_chunk_nb);
00417
00418
00419 XSH_CALLOC( sky_mask, int, nlambda);
00420
00421 if ( loc_obj_par->use_skymask){
00422 float *skymask_data = NULL;
00423 int irow, nrow;
00424 double fwhm =0.0, sky_min, sky_max;
00425 int isky_min, isky_max, imask;
00426 double width, resolution;
00427
00428 XSH_TABLE_LOAD( skymask_table, skymask_name);
00429
00430 check( xsh_sort_table_1( skymask_table, "WAVELENGTH", CPL_FALSE));
00431 check( skymask_data = cpl_table_get_data_float( skymask_table,
00432 "WAVELENGTH"));
00433 check( nrow = cpl_table_get_nrow( skymask_table));
00434
00435 xsh_msg_dbg_low("lambda min %f, step %f", lambda_min, lambda_step);
00436
00437 for( irow=0; irow < nrow; irow++){
00438 check( width = xsh_pfits_get_slit_width( spectrum->flux_header, instrument));
00439 resolution = xsh_resolution_get( instrument, width);
00440 fwhm = skymask_data[irow]/resolution;
00441 sky_min = skymask_data[irow]-fwhm;
00442 sky_max = skymask_data[irow]+fwhm;
00443 isky_min = (int)xsh_round_double((sky_min-lambda_min)/lambda_step);
00444 isky_max = (int)xsh_round_double((sky_max-lambda_min)/lambda_step);
00445 for( imask=isky_min; imask <=isky_max; imask++){
00446 sky_mask[imask] = 1;
00447 }
00448 }
00449 if (level >= XSH_DEBUG_LEVEL_MEDIUM){
00450 FILE *mask_file = NULL;
00451 char mask_name[256];
00452 int idbg=0;
00453
00454 sprintf( mask_name, "skymask.reg");
00455 mask_file = fopen( mask_name, "w");
00456
00457 fprintf( mask_file,"# Region file format: DS9 version 4.1\n");
00458 fprintf( mask_file,"global color=green dashlist=8 3 width=1 font=\"helvetica 10 normal\"\
00459 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1\n");
00460 fprintf(mask_file,"physical\n");
00461
00462 for(idbg=0; idbg< nlambda; idbg++){
00463
00464 if (sky_mask[idbg] == 1){
00465 fprintf( mask_file, "line(%d,%d,%d,%d)\n",idbg+1, nslit, idbg+1, 1);
00466 }
00467 }
00468 fclose( mask_file);
00469 }
00470 }
00471
00472 check( loc_list = xsh_localization_create());
00473
00474 #if 0
00475
00476 {
00477 float arcsec ;
00478 switch( xsh_instrument_get_arm( instrument ) ) {
00479 case XSH_ARM_NIR:
00480 arcsec = XSH_ARCSEC_NIR ;
00481 break ;
00482 case XSH_ARM_UVB:
00483 arcsec = XSH_ARCSEC_UVB ;
00484 break ;
00485 case XSH_ARM_VIS:
00486 arcsec = XSH_ARCSEC_VIS ;
00487 break ;
00488 default:
00489 arcsec = 0.15 ;
00490 break ;
00491 }
00492 slit_nod = loc_obj_par->nod_step/arcsec ;
00493 xsh_msg_dbg_medium( "nod_step: %lf, slit_nod: %d",
00494 loc_obj_par->nod_step, slit_nod ) ;
00495 }
00496 #endif
00497 XSH_CALLOC( slit_tab, double, nslit);
00498 check( gaussval = cpl_vector_wrap( nslit, slit_tab));
00499 check( gausspos = cpl_vector_new( nslit));
00500 for( islit=0; islit < nslit; islit++){
00501 cpl_vector_set( gausspos, islit, islit);
00502 }
00503
00504 chunk_size = (nlambda-1) / (double)(loc_obj_par->loc_chunk_nb);
00505
00506
00507
00508
00509 for( ichunk=0; ichunk< loc_obj_par->loc_chunk_nb; ichunk++){
00510
00511
00512
00513
00514
00515 int ifirst=0,ilast=0,icenter=0;
00516 double slit_cen=0, slit_low=0, slit_up=0;
00517 double threshold = 0.0;
00518 int is_valid_chunk = 1;
00519
00520 ifirst = ichunk*chunk_size;
00521 ilast = (ichunk+1)*chunk_size;
00522 icenter = (int)((ifirst+ilast)/2);
00523
00524 xsh_msg_dbg_medium("%d-%d", ifirst,ilast);
00525
00526
00527 chunk_coadd( slit_tab, flux, qual, nlambda, nslit, ifirst, ilast, decode_bp, sky_mask);
00528
00529 if (level >= XSH_DEBUG_LEVEL_MEDIUM){
00530 FILE *coadd_file = NULL;
00531 char coadd_name[256];
00532 int icoadd=0;
00533 const char* filename = cpl_frame_get_filename( merge_frame);
00534
00535 sprintf( coadd_name, "%s_%d_%d.dat",filename,ifirst,ilast);
00536 coadd_file = fopen( coadd_name, "w");
00537
00538 for(icoadd=0; icoadd<nslit; icoadd++){
00539 fprintf(coadd_file, "%d %f\n",icoadd,slit_tab[icoadd]);
00540 }
00541 fclose( coadd_file);
00542 }
00543
00544 if ( loc_obj_par->method == LOC_GAUSSIAN_METHOD){
00545 double cenpos=0, sigma=0,area=0, offset=0;
00546 double kappa=3.0;
00547
00548 xsh_msg_dbg_medium("Using GAUSSIAN method to fit chunk %d_%d", ifirst,ilast);
00549 cpl_vector_fit_gaussian( gausspos, NULL, gaussval, NULL, CPL_FIT_ALL, &cenpos,
00550 &sigma,
00551 &area, &offset, NULL,
00552 NULL, NULL);
00553 if( cpl_error_get_code() == CPL_ERROR_CONTINUE ){
00554 xsh_msg_dbg_low("CONTINUE to fit %d_%d x0 %f sigma %f", ifirst,ilast,cenpos,sigma);
00555 }
00556 if( cpl_error_get_code() == CPL_ERROR_NONE ){
00557 slit_cen = cenpos;
00558 slit_low = cenpos-kappa*sigma;
00559 slit_up = cenpos+kappa*sigma;
00560 if (slit_low < 0) slit_low = 0;
00561 if (slit_up >= nslit) slit_up = nslit-1;
00562 }
00563 else{
00564 xsh_msg_dbg_low("FAILED to fit %d_%d", ifirst,ilast);
00565 is_valid_chunk=0;
00566 xsh_error_reset();
00567 }
00568 }
00569 else
00570 {
00571 int ymax=0, ymin=0;
00572 int ylow=0, yup=0;
00573 tab_minmax_get_index( slit_tab, nslit, slitlimit_par, &ymin, &ymax);
00574 if (ymin == ymax){
00575 xsh_msg_warning( "No maximum found in chunk (skip it)");
00576 is_valid_chunk=0;
00577 }
00578 else{
00579
00580
00581 xsh_msg_dbg_medium("ymin [%d] = %f ymax [%d] = %f",ymin,
00582 slit_tab[ymin], ymax, slit_tab[ymax]);
00583
00584 threshold = slit_tab[ymin]+(slit_tab[ymax]-slit_tab[ymin])*
00585 loc_obj_par->loc_thresh;
00586 xsh_msg_dbg_medium("Threshold at %f",threshold);
00587
00588
00589 yup = ymax+1;
00590 while( yup < nslit && (slit_tab[yup] >= threshold)) {
00591 yup++;
00592 }
00593
00594
00595 ylow = ymax-1;
00596 while( ylow > 0 && (slit_tab[ylow] >= threshold)) {
00597 ylow--;
00598 }
00599
00600 slit_cen = ymax;
00601 slit_low = ylow;
00602 slit_up = yup;
00603 }
00604 }
00605
00606 if ( is_valid_chunk == 1){
00607 chunk_center[ichunk-skip_chunk] = lambda_min+lambda_step*icenter;
00608 slit_center[ichunk-skip_chunk] = slit_min+slit_step*slit_cen;
00609 slit_lower[ichunk-skip_chunk] = slit_min+slit_step*slit_low;
00610 slit_upper[ichunk-skip_chunk] = slit_min+slit_step*slit_up;
00611 }
00612 else{
00613 skip_chunk++;
00614 }
00615 }
00616
00617 nb_chunk = loc_obj_par->loc_chunk_nb-skip_chunk;
00618
00619 XSH_ASSURE_NOT_ILLEGAL(loc_obj_par->loc_deg_poly < nb_chunk);
00620
00621 check( chunk_center_v = cpl_vector_wrap(
00622 nb_chunk, chunk_center));
00623 check( slit_center_v = cpl_vector_wrap(
00624 nb_chunk, slit_center));
00625
00626 check( cen_poly =
00627 xsh_polynomial_fit_1d_create( chunk_center_v, slit_center_v,
00628 loc_degree, NULL));
00629
00630
00631 if ( niter > 0){
00632 xsh_msg_dbg_low("Doing sigma clipping");
00633 iter = 0;
00634
00635 while ( (loc_degree < (nb_chunk-nbrej)) && iter < niter
00636 && nbrej != 0){
00637 double sigma_med;
00638
00639 nbrej = 0;
00640 xsh_msg_dbg_medium( " *** NBITER = %d / %d ***", iter+1, niter);
00641 dispslit = cpl_vector_new( nb_chunk);
00642
00643 for(ichunk = 0; ichunk < nb_chunk; ichunk++){
00644 double slit_fit;
00645 double lambda;
00646 double slit_diff;
00647
00648 lambda = chunk_center[ichunk];
00649
00650 check( slit_fit = cpl_polynomial_eval_1d( cen_poly,
00651 lambda, NULL));
00652
00653 slit_diff = slit_center[ichunk]-slit_fit;
00654 xsh_msg_dbg_low("slit_center %f FIT %f, DIFF %d %f", slit_center[ichunk], slit_fit, ichunk, slit_diff);
00655 check( cpl_vector_set( dispslit, ichunk, slit_diff));
00656 }
00657
00658 check( sigma_med = cpl_vector_get_stdev( dispslit));
00659 xsh_msg_dbg_medium(" kappa %f SIGMA MEDIAN = %f", kappa, sigma_med);
00660
00661 for(ichunk = 0; ichunk < nb_chunk; ichunk++){
00662 if ( fabs(cpl_vector_get( dispslit, ichunk)) > (kappa * sigma_med) ){
00663 nbrej++;
00664 }
00665 else{
00666 chunk_center[ichunk-nbrej] = chunk_center[ichunk];
00667 slit_center[ichunk-nbrej] = slit_center[ichunk];
00668 slit_lower[ichunk-nbrej] = slit_lower[ichunk];
00669 slit_upper[ichunk-nbrej] = slit_upper[ichunk];
00670 }
00671 }
00672
00673 xsh_msg_dbg_medium(" Removed %d points", nbrej);
00674
00675 nb_chunk -= nbrej;
00676
00677
00678 xsh_unwrap_vector( &chunk_center_v);
00679 xsh_unwrap_vector( &slit_center_v);
00680 xsh_free_polynomial( &cen_poly);
00681
00682 check( chunk_center_v = cpl_vector_wrap(
00683 nb_chunk, chunk_center));
00684 check( slit_center_v = cpl_vector_wrap(
00685 nb_chunk, slit_center));
00686
00687 check( cen_poly =
00688 xsh_polynomial_fit_1d_create( chunk_center_v, slit_center_v,
00689 loc_degree, NULL));
00690 xsh_free_vector( &dispslit);
00691 iter++;
00692 }
00693 }
00694
00695 if (level >= XSH_DEBUG_LEVEL_MEDIUM){
00696 FILE *debug_file = NULL;
00697 char debug_name[256];
00698 int idebug=0;
00699 const char* filename = cpl_frame_get_filename( merge_frame);
00700
00701 sprintf( debug_name, "%s_points.dat",filename);
00702 debug_file = fopen( debug_name, "w");
00703
00704 fprintf( debug_file,"#chunk_pos slit_low slit_cen slit_up\n");
00705
00706 for(idebug=0; idebug<nb_chunk; idebug++){
00707 fprintf( debug_file, "%f %f %f %f\n",chunk_center[idebug],
00708 slit_lower[idebug], slit_center[idebug], slit_upper[idebug]);
00709 }
00710 fclose( debug_file);
00711 }
00712
00713
00714 check( slit_lower_v = cpl_vector_wrap(
00715 nb_chunk, slit_lower));
00716 check( slit_upper_v = cpl_vector_wrap(
00717 nb_chunk, slit_upper));
00718 loc_list->pol_degree = loc_degree;
00719
00720 check(loc_list->cenpoly = cpl_polynomial_duplicate( cen_poly));
00721 check(loc_list->edglopoly =
00722 xsh_polynomial_fit_1d_create( chunk_center_v, slit_lower_v,
00723 loc_degree, NULL));
00724 check(loc_list->edguppoly =
00725 xsh_polynomial_fit_1d_create( chunk_center_v, slit_upper_v,
00726 loc_degree, NULL));
00727
00728 cleanup:
00729 xsh_unwrap_vector( &chunk_center_v);
00730 xsh_unwrap_vector( &slit_center_v);
00731 xsh_unwrap_vector( &slit_upper_v);
00732 xsh_unwrap_vector( &slit_lower_v);
00733 xsh_unwrap_vector( &gaussval);
00734 xsh_free_vector( &gausspos);
00735 XSH_FREE( chunk_center);
00736 XSH_FREE( slit_center);
00737 XSH_FREE( slit_upper);
00738 XSH_FREE( slit_lower);
00739 XSH_FREE( slit_tab);
00740 XSH_FREE( sky_mask);
00741 xsh_free_table( &skymask_table);
00742 xsh_free_polynomial( &cen_poly);
00743 xsh_spectrum_free( &spectrum);
00744 return loc_list;
00745
00746 }
00747
00748 static int comp_lambda( const void * one, const void * two )
00749 {
00750 float * un = (float *)one, * deux = (float *)two ;
00751
00752 if ( *un < *deux ) return -1 ;
00753 else if ( *un == *deux ) return 0 ;
00754 else return 1 ;
00755 }
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897 cpl_frameset * xsh_localize_obj_ifu( cpl_frameset *rec_frameset,
00898 cpl_frame *skymask_frame,
00899 xsh_instrument * instrument,
00900 xsh_localize_obj_param * locobj_par,
00901 xsh_slit_limit_param *slitlimit_par)
00902 {
00903 int i, slitlet;
00904 cpl_frameset *result_frameset = NULL;
00905 char fname[256];
00906
00907 XSH_ASSURE_NOT_NULL( rec_frameset);
00908 XSH_ASSURE_NOT_NULL( instrument);
00909 XSH_ASSURE_NOT_NULL( locobj_par);
00910
00911 check( result_frameset = cpl_frameset_new());
00912
00913 for( i = 0, slitlet = LOWER_IFU_SLITLET ; i < 3 ; i++, slitlet++ ) {
00914 cpl_frame * loc_frame = NULL;
00915 cpl_frame *rec_frame = NULL;
00916
00917 sprintf( fname ,"LOCALIZE_TABLE_%s_IFU_%s.fits", SlitletName[slitlet],
00918 xsh_instrument_arm_tostring( instrument));
00919
00920 xsh_msg( "Localizing slitlet %s, frame '%s'", SlitletName[slitlet], fname);
00921
00922 check( rec_frame = cpl_frameset_get_frame( rec_frameset, i));
00923
00924 check( loc_frame = xsh_localize_obj( rec_frame, skymask_frame, instrument,
00925 locobj_par,slitlimit_par, fname));
00926 check( cpl_frameset_insert( result_frameset, loc_frame));
00927 }
00928
00929 cleanup:
00930 if ( cpl_error_get_code() != CPL_ERROR_NONE ) {
00931 xsh_free_frameset( &result_frameset);
00932 }
00933 return result_frameset;
00934 }
00935
00936
00937
00943 double xsh_convert_seeing( cpl_frame* frame)
00944 {
00945 double mu=-1.0;
00946 double avg_seeing, seeing_start, seeing_end;
00947 double avg_airmass;
00948 double k;
00949 const char* filename = NULL;
00950 cpl_propertylist *header = NULL;
00951
00952 XSH_ASSURE_NOT_NULL( frame);
00953
00954 check( filename = cpl_frame_get_filename( frame));
00955 check( header = cpl_propertylist_load( filename, 0));
00956 check( avg_airmass = xsh_pfits_get_airm_mean( header));
00957 check( seeing_start = xsh_pfits_get_seeing_start( header));
00958 check( seeing_end = xsh_pfits_get_seeing_end( header));
00959 avg_seeing = 0.5*(seeing_start+seeing_end);
00960
00961 k = sqrt( 1.0-78.08*pow(XSH_LAMBDA_DIMM,0.4)*
00962 pow(avg_airmass,-0.6)*pow(avg_seeing,-1.0/3.0));
00963
00964 xsh_msg("K %f", k);
00965
00966 mu = 1.0/CPL_MATH_FWHM_SIG*avg_seeing*pow(XSH_LAMBDA_DIMM,0.2)*
00967 pow(avg_airmass,0.6)*k;
00968
00969 xsh_msg("Mu %f", mu);
00970
00971 cleanup:
00972 if ( cpl_error_get_code() != CPL_ERROR_NONE ) {
00973 mu =-1;
00974 }
00975 xsh_free_propertylist( &header);
00976 return mu;
00977 }
00978
00979
00980
01002 cpl_frame* xsh_localize_ifu_slitlet( cpl_frame *merge2d_slitlet,
01003 cpl_frame *skymask_frame, int smooth_hsize,
01004 int nscales, int HF_skip, const char* resname, double cut_sigma_low,
01005 double cut_sigma_up, double cut_snr_low, double cut_snr_up,
01006 double slit_min, double slit_max, int deg, int box_hsize,
01007 xsh_instrument *instrument)
01008
01009 {
01010 cpl_frame *result = NULL;
01011 double wmin, wmax, wstep;
01012 double smin, smax, sstep;
01013 int wsize, ssize;
01014 xsh_spectrum *spectrum2d = NULL;
01015 double *flux = NULL;
01016 double *errs = NULL;
01017 int *qual = NULL;
01018 int i, j, k;
01019 int level;
01020 double *slit_vect_data = NULL;
01021 double *sliterr_vect_data = NULL;
01022 double *slit_pos_data = NULL;
01023 int slit_vect_size;
01024 cpl_vector *slit_vect = NULL;
01025 cpl_vector *sliterr_vect = NULL;
01026 cpl_vector *slit_pos = NULL;
01027 cpl_vector *smooth_vect = NULL;
01028 double *spos_data = NULL;
01029 double *errpos_data = NULL;
01030 double *wpos_data = NULL;
01031 double *sigma_data = NULL;
01032 double *snr_data = NULL;
01033 int data_size=0, ndata_size=0;
01034 cpl_vector *spos_vect = NULL;
01035 cpl_vector *wpos_vect = NULL;
01036 cpl_vector *sigma_vect = NULL;
01037 cpl_vector *snr_vect = NULL;
01038 cpl_vector *sigma_sort_vect = NULL;
01039 cpl_vector *snr_sort_vect = NULL;
01040 double *sposg_data = NULL;
01041 double *wposg_data = NULL;
01042 cpl_matrix *decomp = NULL;
01043 int nb_scales;
01044 cpl_table *table = NULL;
01045 char tablename[256];
01046 cpl_propertylist *header = NULL;
01047 double n05, n95, snr_05, snr_95, sigma_05, sigma_95;
01048 int jmin, jmax;
01049
01050 int *sky_mask = NULL;
01051 cpl_table *skymask_table = NULL;
01052 const char* skymask_name = NULL;
01053
01054 XSH_ASSURE_NOT_NULL( merge2d_slitlet);
01055 XSH_ASSURE_NOT_ILLEGAL( smooth_hsize >= 0);
01056 XSH_ASSURE_NOT_ILLEGAL( nscales > 0);
01057 XSH_ASSURE_NOT_ILLEGAL( nscales > HF_skip);
01058 XSH_ASSURE_NOT_ILLEGAL( box_hsize >= 0);
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074 level = xsh_debug_level_get();
01075 check( spectrum2d = xsh_spectrum_load( merge2d_slitlet));
01076 check( wmin = xsh_spectrum_get_lambda_min( spectrum2d));
01077 check( wmax = xsh_spectrum_get_lambda_max( spectrum2d));
01078 check( wstep = xsh_spectrum_get_lambda_step( spectrum2d));
01079
01080 if ( skymask_frame != NULL){
01081 check( skymask_name = cpl_frame_get_filename( skymask_frame));
01082 xsh_msg_dbg_medium("Sky mask %s", skymask_name);
01083 }
01084 wsize = spectrum2d->size_lambda;
01085
01086
01087 smin = spectrum2d->slit_min;
01088 smax = spectrum2d->slit_max;
01089 sstep = spectrum2d->slit_step;
01090 ssize = spectrum2d->size_slit;
01091
01092 jmin = 0;
01093 jmax = ssize;
01094
01095
01096 while( (smin+jmin*sstep) < slit_min){
01097 jmin++;
01098 }
01099 while( (smin+jmax*sstep) > slit_max){
01100 jmax--;
01101 }
01102
01103
01104 if ( jmin > jmax || jmax <= 0 || jmin >= ssize){
01105 jmin = 0;
01106 jmax = ssize;
01107 }
01108 xsh_msg_dbg_medium( "Use [%d-%d] from [%d %d] slitlet",
01109 jmin, jmax, 0, ssize);
01110
01111 check( flux = xsh_spectrum_get_flux( spectrum2d));
01112 check( errs = xsh_spectrum_get_errs( spectrum2d));
01113 check( qual = xsh_spectrum_get_qual( spectrum2d));
01114
01115 XSH_MALLOC( slit_vect_data, double , ssize);
01116 XSH_MALLOC( sliterr_vect_data, double, ssize);
01117 XSH_MALLOC( slit_pos_data, double , ssize);
01118
01119 XSH_MALLOC( spos_data, double , wsize);
01120 XSH_MALLOC( errpos_data, double, wsize);
01121 XSH_MALLOC( wpos_data, double , wsize);
01122
01123 XSH_MALLOC( sigma_data, double , wsize);
01124 XSH_MALLOC( snr_data, double , wsize);
01125
01126
01127 XSH_CALLOC( sky_mask, int, wsize);
01128
01129 if ( skymask_frame != NULL){
01130 float *skymask_data = NULL;
01131 int irow, nrow;
01132 double fwhm =0.0, sky_min, sky_max;
01133 int isky_min, isky_max, imask;
01134 double width, resolution;
01135
01136 XSH_TABLE_LOAD( skymask_table, skymask_name);
01137
01138 check( xsh_sort_table_1( skymask_table, "WAVELENGTH", CPL_FALSE));
01139 check( skymask_data = cpl_table_get_data_float( skymask_table,
01140 "WAVELENGTH"));
01141 check( nrow = cpl_table_get_nrow( skymask_table));
01142
01143 for( irow=0; irow < nrow; irow++){
01144 check( width = xsh_pfits_get_slit_width( spectrum2d->flux_header, instrument));
01145 resolution = xsh_resolution_get( instrument, width);
01146 fwhm = skymask_data[irow]/resolution;
01147 sky_min = skymask_data[irow]-fwhm;
01148 sky_max = skymask_data[irow]+fwhm;
01149 isky_min = (int)xsh_round_double((sky_min-wmin)/wstep);
01150 if (isky_min < 0){
01151 isky_min=0;
01152 }
01153 isky_max = (int)xsh_round_double((sky_max-wmin)/wstep);
01154 if ( isky_max >= wsize){
01155 isky_max = wsize-1;
01156 }
01157 for( imask=isky_min; imask <=isky_max; imask++){
01158 sky_mask[imask] = 1;
01159 }
01160 }
01161
01162 if (level >= XSH_DEBUG_LEVEL_MEDIUM){
01163 FILE *mask_file = NULL;
01164 char mask_name[256];
01165 int idbg=0;
01166
01167 sprintf( mask_name, "skymask.reg");
01168 mask_file = fopen( mask_name, "w");
01169
01170 fprintf( mask_file,"# Region file format: DS9 version 4.1\n");
01171 fprintf( mask_file,"global color=green dashlist=8 3 width=1 font=\"helvetica 10 normal\"\
01172 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1\n");
01173 fprintf(mask_file,"physical\n");
01174
01175 for(idbg=0; idbg< wsize; idbg++){
01176
01177 if (sky_mask[idbg] == 1){
01178 fprintf( mask_file, "line(%d,%d,%d,%d)\n",idbg+1, ssize, idbg+1, 1);
01179 }
01180 }
01181 fclose( mask_file);
01182 }
01183 }
01184
01185
01186 data_size = 0;
01187
01188 for (i = 0; i < wsize; i++) {
01189 double slitcen = 0;
01190 double sigma = 0;
01191 double area = 0;
01192 double offset = 0;
01193 double a = 0, b = 0, c = 0;
01194 double frac_rej = 0;
01195
01196 cpl_matrix *covariance = NULL;
01197 double fit_err;
01198 int good_fit = 0;
01199
01200 slit_vect_size = 0;
01201
01202
01203 for (j = jmin; j < jmax; j++) {
01204 double val = 0, err = 0;
01205 int start, end;
01206 int ngood = 0, nbad = 0;
01207
01208
01209 start = i - box_hsize;
01210 end = i + box_hsize;
01211
01212 if (start < 0) {
01213 start = 0;
01214 }
01215 if (end >= wsize) {
01216 end = wsize - 1;
01217 }
01218
01219 for (k = start; k <= end; k++) {
01220 if ( (qual[k + j * wsize] & instrument->decode_bp) == 0 ) {
01221 val += flux[k + j * wsize];
01222 ngood++;
01223 } else {
01224 nbad++;
01225 }
01226
01227 }
01228
01229 val += flux[i+j*wsize];
01230 err = errs[i+j*wsize];
01231
01232 if ( ngood > 0){
01233 val *= (double)(nbad+ngood)/(double)ngood;
01234
01235 slit_pos_data[slit_vect_size] = j;
01236 sliterr_vect_data[slit_vect_size] = err;
01237 slit_vect_data[slit_vect_size] = val;
01238
01239 slit_vect_size++;
01240 }
01241 }
01242
01243 frac_rej = 1-((double)slit_vect_size/(double)ssize);
01244 if ( frac_rej < 0.5){
01245 check( slit_pos = cpl_vector_wrap( slit_vect_size, slit_pos_data));
01246 check( slit_vect = cpl_vector_wrap( slit_vect_size, slit_vect_data));
01247 check( sliterr_vect = cpl_vector_wrap( slit_vect_size, sliterr_vect_data));
01248
01249 check( smooth_vect = cpl_vector_filter_median_create( slit_vect,
01250 smooth_hsize));
01251
01252
01253 #if CPL_MODE
01254 cpl_vector_fit_gaussian( slit_pos, NULL, slit_vect, sliterr_vect,
01255 CPL_FIT_ALL, &slitcen, &sigma, &area, &offset, &mse, NULL, &covariance);
01256 a = offset;
01257 fit_err = sqrt(cpl_matrix_get(covariance,0,0))*sstep;
01258 good_fit = (cpl_error_get_code() == CPL_ERROR_NONE);
01259 #else
01260 {
01261 double init_par[6];
01262 double fit_errs[6];
01263 int status = 0;
01264 xsh_gsl_init_gaussian_fit( slit_pos, slit_vect, init_par);
01265 xsh_gsl_fit_gaussian( slit_pos, slit_vect, deg, init_par, fit_errs, &status);
01266 area = init_par[0];
01267 a = init_par[1];
01268 b = init_par[2];
01269 c = init_par[3];
01270 slitcen = init_par[4];
01271 sigma = init_par[5];
01272 offset = a+b*slitcen+c*slitcen*slitcen;
01273 fit_err = fit_errs[4]*sstep;
01274 good_fit= (status == 0);
01275 }
01276 #endif
01277
01278 if ( good_fit){
01279 double height=0;
01280 double snr=0;
01281
01282 height = area / sqrt(2*M_PI*sigma*sigma);
01283 snr = (height+offset)/offset;
01284
01285
01286 if ( (area > 0) && (slitcen > 0) && (slitcen < ssize)
01287 && (sigma < ssize) && (snr > 0)){
01288 spos_data[data_size] = smin+slitcen*sstep;
01289 errpos_data[data_size] = fit_err;
01290 wpos_data[data_size] = wmin+i*wstep;
01291 sigma_data[data_size] = sigma*sstep;
01292 snr_data[data_size] = snr;
01293 #if 0
01294
01295 if ( (wpos_data[data_size] >= (1500-wstep)) && (wpos_data[data_size] <= (1500+wstep))){
01296 char test_name[256];
01297 FILE* test_file = NULL;
01298 int itest;
01299 double dtest;
01300
01301 sprintf( test_name, "data_w%f_%s.dat", wpos_data[data_size],resname);
01302 XSH_REGDEBUG("Produce test file %s", test_name);
01303 test_file = fopen( test_name, "w+");
01304 fprintf( test_file, "# pos slit\n");
01305
01306 for( itest=0; itest < slit_vect_size; itest++){
01307 fprintf( test_file, "%f %f\n", cpl_vector_get( slit_pos, itest), cpl_vector_get( slit_vect, itest));
01308 }
01309
01310 fclose( test_file);
01311
01312 sprintf( test_name, "gauss_w%f_%s.dat", wpos_data[data_size],resname);
01313 XSH_REGDEBUG("Produce test file %s", test_name);
01314
01315 test_file = fopen( test_name, "w+");
01316 fprintf( test_file, "# pos gauss offset x0=%f_sig=%f_area=%f_offset=%f\n", slitcen, sigma, area, offset);
01317
01318 for( dtest=0; dtest < slit_vect_size; dtest+=0.1){
01319 double z, gauss;
01320 double off;
01321
01322 off = a+b*dtest+c*dtest*dtest;
01323 z = ( dtest-slitcen)/(sigma*XSH_MATH_SQRT_2);
01324 gauss = height*exp(-(z*z))+off;
01325
01326 fprintf( test_file, "%f %f %f\n", dtest, gauss, off);
01327 }
01328
01329 fclose( test_file);
01330 }
01331 #endif
01332 data_size++;
01333 }
01334 }
01335 else{
01336 xsh_error_reset();
01337 }
01338 xsh_free_matrix( &covariance);
01339 xsh_free_vector( &smooth_vect);
01340 xsh_unwrap_vector( &slit_pos);
01341 xsh_unwrap_vector( &slit_vect);
01342 xsh_unwrap_vector( &sliterr_vect);
01343 }
01344 }
01345
01346
01347
01348 check( sigma_vect = cpl_vector_wrap( data_size, sigma_data));
01349 check( snr_vect = cpl_vector_wrap( data_size, snr_data));
01350 check( sigma_sort_vect = cpl_vector_duplicate( sigma_vect));
01351 check( snr_sort_vect = cpl_vector_duplicate( snr_vect));
01352
01353 check( cpl_vector_sort( sigma_sort_vect, 1));
01354 check( cpl_vector_sort( snr_sort_vect, 1));
01355
01356 n05 = (data_size-1)*cut_sigma_low;
01357 i = ceil( n05);
01358 sigma_05 = cpl_vector_get( sigma_sort_vect, i);
01359 n05 = (data_size-1)*cut_snr_low;
01360 i = ceil( n05);
01361 snr_05 = cpl_vector_get( snr_sort_vect, i);
01362
01363
01364 n95 = (data_size-1)*cut_sigma_up;
01365 i = floor( n95);
01366 sigma_95 = cpl_vector_get( sigma_sort_vect, i);
01367 n95 = (data_size-1)*cut_snr_up;
01368 i = floor( n95);
01369 snr_95 = cpl_vector_get( snr_sort_vect, i);
01370
01371
01372 for( i=0; i< data_size; i++){
01373 double sigma, snr;
01374
01375 sigma = sigma_data[i];
01376 snr = snr_data[i];
01377 if ( sigma_05 <= sigma && sigma <= sigma_95 && snr_05 <= snr && snr <=snr_95){
01378 wpos_data[ndata_size] = wpos_data[i];
01379 spos_data[ndata_size] = spos_data[i];
01380 errpos_data[ndata_size] = errpos_data[i];
01381 ndata_size++;
01382 }
01383 }
01384 xsh_msg_dbg_low( "Filtering by snr [%f,%f] and sigma [%f,%f] from %d lines to %d lines",
01385 sigma_05, sigma_95, snr_05, snr_95, data_size, ndata_size);
01386
01387
01388 if (level >= XSH_DEBUG_LEVEL_MEDIUM){
01389 FILE *test_file = NULL;
01390 int itest;
01391 char test_name[256];
01392 #if CPL_MODE
01393 sprintf( test_name, "cpl_gaussian_fit_%s.dat", resname);
01394 #else
01395 sprintf( test_name, "gsl_gaussian_fit_%s.dat", resname);
01396 #endif
01397 test_file = fopen( test_name, "w");
01398 fprintf( test_file, "# wavelength slit_fit fit_err sigma\n");
01399
01400 for(itest=0; itest<ndata_size; itest++){
01401 fprintf( test_file, "%f %f %f %f\n", wpos_data[itest], spos_data[itest], errpos_data[itest],
01402 sigma_data[itest]);
01403 }
01404 xsh_msg_dbg_medium( "Produce file %s", test_name);
01405 fclose( test_file);
01406 }
01407
01408 check( wpos_vect = cpl_vector_new( wsize));
01409 check( spos_vect = cpl_vector_new( wsize));
01410 check( sposg_data = cpl_vector_get_data( spos_vect));
01411 check( wposg_data = cpl_vector_get_data( wpos_vect));
01412 j=0;
01413
01414 for(i=0; i< wsize; i++){
01415 double wave, wkeep;
01416 double slit;
01417
01418 wave = wmin+i*wstep;
01419 wkeep = wpos_data[j];
01420 check( cpl_vector_set( wpos_vect, i, wave));
01421 if ( fabs(wave -wkeep) < 0.0000001){
01422 slit = spos_data[j];
01423 if (j < (ndata_size-1)){
01424 j++;
01425 }
01426 }
01427 else{
01428 slit = xsh_data_interpolate( wave, ndata_size, wpos_data, spos_data);
01429 }
01430 check( cpl_vector_set( spos_vect, i, slit));
01431 }
01432
01433 check( decomp = xsh_atrous( spos_vect, nscales));
01434
01435 nb_scales = nscales-HF_skip;
01436
01437
01438 for( i=0; i< wsize; i++){
01439 sposg_data[i] = 0;
01440 for(j=0; j<nb_scales; j++){
01441 sposg_data[i] += cpl_matrix_get( decomp, j, i);
01442 }
01443 }
01444
01445
01446 check( table = cpl_table_new( wsize));
01447 XSH_TABLE_NEW_COL(table, XSH_OBJPOS_COLNAME_WAVELENGTH,
01448 XSH_OBJPOS_UNIT_WAVELENGTH, CPL_TYPE_DOUBLE);
01449 XSH_TABLE_NEW_COL(table, XSH_OBJPOS_COLNAME_SLIT,
01450 XSH_OBJPOS_UNIT_SLIT, CPL_TYPE_DOUBLE);
01451
01452 for( i=0; i< wsize; i++){
01453 check( cpl_table_set_double( table, XSH_OBJPOS_COLNAME_WAVELENGTH,
01454 i, wposg_data[i]));
01455 check( cpl_table_set_double( table, XSH_OBJPOS_COLNAME_SLIT,
01456 i, sposg_data[i]));
01457 }
01458 sprintf( tablename, resname);
01459 header = cpl_propertylist_new();
01460 check( cpl_table_save( table, header, NULL, tablename, CPL_IO_DEFAULT));
01461
01462 check(result=xsh_frame_product( tablename,
01463 "OBJPOS_TAB",
01464 CPL_FRAME_TYPE_TABLE,
01465 CPL_FRAME_GROUP_PRODUCT,
01466 CPL_FRAME_LEVEL_TEMPORARY));
01467
01468
01469 check (xsh_add_temporary_file( tablename));
01470
01471 cleanup:
01472 XSH_TABLE_FREE( table);
01473 xsh_free_propertylist( &header);
01474 xsh_free_matrix( &decomp);
01475 xsh_free_vector( &spos_vect);
01476 xsh_free_vector( &wpos_vect);
01477 xsh_free_vector( &sigma_sort_vect);
01478 xsh_free_vector( &snr_sort_vect);
01479 xsh_unwrap_vector( &sigma_vect);
01480 xsh_unwrap_vector( &snr_vect);
01481 XSH_FREE( sigma_data);
01482 XSH_FREE( snr_data);
01483 XSH_FREE( spos_data);
01484 XSH_FREE( errpos_data);
01485 XSH_FREE( wpos_data);
01486 XSH_FREE( slit_pos_data);
01487 XSH_FREE( slit_vect_data);
01488 XSH_FREE( sliterr_vect_data);
01489 xsh_free_vector( &smooth_vect);
01490 xsh_spectrum_free( &spectrum2d);
01491 XSH_FREE(sky_mask);
01492 xsh_free_table( &skymask_table);
01493 return result;
01494 }
01495
01496
01497
01509 cpl_frameset* xsh_localize_ifu( cpl_frameset *merge2d_frameset,
01510 cpl_frame *skymask_frame,
01511 xsh_localize_ifu_param * locifu_par, xsh_instrument *instrument,
01512 const char* prefix)
01513 {
01514 int i, slitlet;
01515 cpl_frameset *result_frameset = NULL;
01516 char fname[256];
01517 int smooth_hsize;
01518 int nscales;
01519 int HF_skip;
01520 double cut_sigma_low;
01521 double cut_sigma_up;
01522 double cut_snr_low;
01523 double cut_snr_up;
01524 double slit_min = -6.0;
01525 double slit_max = 6.0;
01526 cpl_frame *frame = NULL;
01527 const char *frame_name = NULL;
01528 cpl_propertylist *header = NULL;
01529 int deg = 2, skymask=0;
01530 int box_hsize;
01531 cpl_frame *mask_frame = NULL;
01532
01533 XSH_ASSURE_NOT_NULL( merge2d_frameset);
01534 XSH_ASSURE_NOT_NULL( instrument);
01535 XSH_ASSURE_NOT_NULL( locifu_par);
01536
01537 smooth_hsize = locifu_par->smooth_hsize;
01538 nscales = locifu_par->nscales;
01539 HF_skip = locifu_par->HF_skip;
01540 cut_sigma_low = locifu_par->cut_sigma_low;
01541 cut_sigma_up = locifu_par->cut_sigma_up;
01542 cut_snr_low = locifu_par->cut_snr_low;
01543 cut_snr_up = locifu_par->cut_snr_up;
01544 skymask = locifu_par->use_skymask;
01545 box_hsize = locifu_par->box_hsize;
01546
01547 if (skymask){
01548 mask_frame = skymask_frame;
01549 }
01550
01551 check( frame = cpl_frameset_get_frame( merge2d_frameset, 0));
01552 check( frame_name = cpl_frame_get_filename( frame));
01553 check( header = cpl_propertylist_load( frame_name, 0));
01554 check( slit_min = xsh_pfits_get_rectify_space_min( header));
01555 xsh_free_propertylist( &header);
01556
01557 check( frame = cpl_frameset_get_frame( merge2d_frameset, 2));
01558 check( frame_name = cpl_frame_get_filename( frame));
01559 check( header = cpl_propertylist_load( frame_name, 0));
01560 check( slit_max = xsh_pfits_get_rectify_space_max( header));
01561 xsh_free_propertylist( &header);
01562
01563 slit_min += locifu_par->slitlow_edges_mask;
01564 slit_max -= locifu_par->slitup_edges_mask;
01565
01566 deg = locifu_par->bckg_deg;
01567
01568 check( result_frameset = cpl_frameset_new());
01569
01570 for( i = 0, slitlet = LOWER_IFU_SLITLET ; i < 3 ; i++, slitlet++ ) {
01571 cpl_frame * loc_frame = NULL;
01572 cpl_frame *merge2d_frame = NULL;
01573
01574 sprintf( fname ,"%s_LOCIFU_%s_%s.fits", prefix, SlitletName[slitlet],
01575 xsh_instrument_arm_tostring( instrument));
01576
01577 xsh_msg( "Localizing IFU in [%f,%f] slitlet %s, frame '%s'", slit_min, slit_max,
01578 SlitletName[slitlet], fname);
01579
01580 check( merge2d_frame = cpl_frameset_get_frame( merge2d_frameset, i));
01581
01582
01583 check( loc_frame = xsh_localize_ifu_slitlet( merge2d_frame, mask_frame,
01584 smooth_hsize, nscales,
01585 HF_skip, fname, cut_sigma_low, cut_sigma_up, cut_snr_low, cut_snr_up,
01586 slit_min, slit_max, deg, box_hsize, instrument));
01587
01588 check( cpl_frameset_insert( result_frameset, loc_frame));
01589 }
01590
01591 cleanup:
01592 if ( cpl_error_get_code() != CPL_ERROR_NONE ) {
01593 xsh_free_frameset( &result_frameset);
01594 xsh_free_propertylist( &header);
01595 }
01596 return result_frameset;
01597 }
01598