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
00031
00032
00033 #include <xsh_utils_scired_slit.h>
00034 #include <xsh_dfs.h>
00035 #include <xsh_utils.h>
00036 #include <xsh_utils_table.h>
00037 #include <xsh_utils_efficiency.h>
00038 #include <xsh_data_spectrum.h>
00039 #include <xsh_model_utils.h>
00040 #include <xsh_error.h>
00041 #include <xsh_drl_check.h>
00042 #include <xsh_pfits.h>
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00105
00116
00117
00118 cpl_error_code
00119 xsh_stare_params_bin_scale(cpl_frameset* raws,
00120 xsh_background_param* backg,
00121 xsh_opt_extract_param *opt_extract_par,
00122 int* sub_sky_nbkpts1,
00123 int* sub_sky_nbkpts2)
00124 {
00125
00126 cpl_frame* frame=NULL;
00127 const char* name=NULL;
00128 cpl_propertylist *plist=NULL;
00129 int binx=0;
00130 int biny=0;
00131
00132 check(frame=cpl_frameset_get_first(raws));
00133 check(name=cpl_frame_get_filename(frame));
00134 check(plist=cpl_propertylist_load(name,0));
00135 check(binx=xsh_pfits_get_binx(plist));
00136 check(biny=xsh_pfits_get_biny(plist));
00137 xsh_free_propertylist( &plist);
00138
00139 if(biny>1) {
00140
00141
00142
00143
00144
00145
00146 backg->radius_y=backg->radius_y/biny;
00147
00148
00149 *sub_sky_nbkpts1*=0.75*biny;
00150 *sub_sky_nbkpts2*=0.75*biny;
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190 }
00191
00192
00193 if(binx>1) {
00194
00195 backg->radius_x=backg->radius_x/binx;
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217 opt_extract_par->box_hsize=opt_extract_par->box_hsize/binx;
00218
00219 }
00220
00221 cleanup:
00222 xsh_free_propertylist(&plist);
00223 return cpl_error_get_code();
00224
00225 }
00226
00227
00228 cpl_frameset* xsh_nod_group_by_reloff( cpl_frameset *ord_set,
00229 xsh_instrument *instrument, xsh_stack_param* stack_par,xsh_clipping_param *crh_clipping_par)
00230 {
00231
00232 cpl_frameset *result = NULL;
00233 cpl_frameset *rmcrh_set = NULL;
00234 cpl_frame *frame = NULL;
00235 cpl_propertylist *header = NULL;
00236
00237 const char* nod_name = NULL;
00238
00239 double rel_ra=0;
00240 double rel_dec=0;
00241 double A_cum_ra=0;
00242 double A_cum_dec=0;
00243 int A_number=1, B_number =1;
00244 int nod_number;
00245 char ftag[40];
00246 char name[40];
00247
00248 cpl_frame *crhm_frame = NULL;
00249
00250 XSH_ASSURE_NOT_NULL( ord_set);
00251 XSH_ASSURE_NOT_NULL( instrument);
00252 XSH_ASSURE_NOT_NULL( crh_clipping_par);
00253
00254 check( result=cpl_frameset_new());
00255
00256 check( frame = cpl_frameset_get_first( ord_set));
00257 check( nod_name = cpl_frame_get_filename( frame));
00258 check( header = cpl_propertylist_load( nod_name, 0));
00259
00260 check( A_cum_ra = xsh_pfits_get_ra_cumoffset( header));
00261 check( A_cum_dec = xsh_pfits_get_dec_cumoffset( header));
00262
00263 xsh_free_propertylist( &header);
00264
00265 while( frame != NULL){
00266 double cum_ra=0;
00267 double cum_dec=0;
00268 double nrel_ra, nrel_dec;
00269 const char *type= NULL;
00270
00271 check( nod_name = cpl_frame_get_filename( frame));
00272 check( header = cpl_propertylist_load( nod_name, 0));
00273 check( cum_ra = xsh_pfits_get_ra_cumoffset( header));
00274 check( cum_dec = xsh_pfits_get_dec_cumoffset( header));
00275 check( rel_ra = xsh_pfits_get_ra_reloffset( header));
00276 check( rel_dec = xsh_pfits_get_dec_reloffset( header));
00277
00278 if ( cum_ra == A_cum_ra && cum_dec == A_cum_dec){
00279 type = "A";
00280 nod_number = A_number;
00281 }
00282 else{
00283 type = "B";
00284 nod_number = B_number;
00285 }
00286
00287 xsh_msg("name %s cumoffset %f %f reloffset %f %f nod_seq_number : %s%d", nod_name,
00288 cum_ra, cum_dec, rel_ra, rel_dec, type, nod_number);
00289
00290 xsh_free_propertylist( &header);
00291
00292 check( rmcrh_set = cpl_frameset_new());
00293 cpl_frameset_insert( rmcrh_set, cpl_frame_duplicate( frame));
00294
00295 check( frame = cpl_frameset_get_next( ord_set));
00296
00297 while( frame != NULL){
00298 check( nod_name = cpl_frame_get_filename( frame));
00299 check( header = cpl_propertylist_load( nod_name, 0));
00300 check( nrel_ra = xsh_pfits_get_ra_reloffset( header));
00301 check( nrel_dec = xsh_pfits_get_dec_reloffset( header));
00302 xsh_free_propertylist( &header);
00303
00304 if ( rel_ra == nrel_ra && nrel_dec == rel_dec){
00305 cpl_frameset_insert( rmcrh_set, cpl_frame_duplicate( frame));
00306 }
00307 else{
00308 break;
00309 }
00310 check( frame = cpl_frameset_get_next( ord_set));
00311 }
00312
00313
00314 sprintf( ftag,"med_%s%d", type, nod_number);
00315 sprintf(name,"%s.fits",ftag);
00316 check( crhm_frame = xsh_remove_crh_multiple( rmcrh_set, ftag, stack_par,crh_clipping_par,
00317 instrument, NULL,NULL,0 ));
00318
00319 check( cpl_frameset_insert( result, crhm_frame));
00320 xsh_add_temporary_file(name);
00321
00322 if ( cum_ra == A_cum_ra && cum_dec == A_cum_dec){
00323 A_number++;
00324 }
00325 else{
00326 B_number++;
00327 }
00328 xsh_free_frameset( &rmcrh_set);
00329 }
00330
00331 cleanup:
00332 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00333 xsh_free_propertylist( &header);
00334 xsh_free_frameset( &rmcrh_set);
00335 xsh_free_frameset( &result);
00336 }
00337 return result;
00338 }
00339
00340
00341 static cpl_frame* xsh_frame_divide_flat( int do_flat, cpl_frame* src,
00342 cpl_frame *mflat, const char* tag, xsh_instrument* instr)
00343 {
00344 cpl_frame *result = NULL;
00345
00346 if ( do_flat == CPL_TRUE){
00347 xsh_msg( "Divide by flat");
00348 check( result = xsh_divide_flat( src, mflat, tag, instr));
00349 }
00350 else{
00351 check( result = cpl_frame_duplicate( src));
00352 }
00353
00354 cleanup:
00355 return result;
00356 }
00357
00358 static cpl_error_code
00359 xsh_nod_rectify_and_shift_with_key(const char* nod_name,
00360 const char* qual_name,
00361 const char* rec_prefix,
00362 cpl_frame* frame2D,
00363 cpl_frame* order_tab_edges,
00364 cpl_frame* wave_tab,
00365 cpl_frame* model_config_frame,
00366 cpl_frame* spectral_format,
00367 cpl_frame* disp_tab_frame,
00368 xsh_instrument* instrument,
00369 xsh_rectify_param *rectify_par,
00370 double** ref_ra,
00371 double** ref_dec,
00372 cpl_frame **shift2_frame,
00373 cpl_frame **shift1_frame)
00374
00375 {
00376
00377
00378 char file_name[80];
00379 cpl_frame * rec2_frame = NULL ;
00380 cpl_frame * rec2eso_frame = NULL ;
00381 cpl_frame * rec2tab_frame = NULL ;
00382 cpl_frame *shift2eso_frame = NULL;
00383 cpl_frame * rec1_frame = NULL ;
00384 cpl_frame *shift1eso_frame = NULL;
00385
00386
00387 sprintf(file_name,"REC2_%s_%s",qual_name,nod_name);
00388 check(rec2_frame = xsh_rectify( frame2D,order_tab_edges,
00389 wave_tab,model_config_frame,instrument,
00390 rectify_par,spectral_format,disp_tab_frame,
00391 file_name,&rec2eso_frame,&rec2tab_frame,
00392 rec_prefix));
00393 xsh_add_temporary_file(file_name);
00394 sprintf(file_name,"SHIFT2_%s_%s",qual_name,nod_name);
00395
00396 check( *shift2_frame = shift_with_kw( rec2_frame, instrument,rectify_par,
00397 file_name, &shift2eso_frame,
00398 ref_ra,ref_dec, 0));
00399 xsh_add_temporary_file(file_name);
00400 sprintf(file_name,"REC1_FAST_%s_%s",qual_name,nod_name);
00401 check( rec1_frame = xsh_rec_list_frame_invert( rec2_frame, file_name,
00402 instrument));
00403 xsh_add_temporary_file(file_name);
00404 sprintf(file_name,"SHIFT1_FAST_%s_%s",qual_name,nod_name);
00405 check( *shift1_frame = shift_with_kw( rec1_frame, instrument,
00406 rectify_par, file_name,
00407 &shift1eso_frame, ref_ra,
00408 ref_dec, 1));
00409 xsh_add_temporary_file(file_name);
00410 cleanup:
00411
00412 xsh_free_frame( &rec1_frame);
00413 xsh_free_frame( &rec2_frame);
00414 xsh_free_frame( &shift1eso_frame);
00415 xsh_free_frame( &shift2eso_frame);
00416 xsh_free_frame( &rec2eso_frame);
00417 xsh_free_frame( &rec2tab_frame);
00418
00419 return cpl_error_get_code();
00420 }
00421
00422 cpl_frameset*
00423 xsh_scired_slit_nod_fast(
00424 cpl_frameset *nod_set,
00425 cpl_frame* spectral_format,
00426 cpl_frame* master_flat,
00427 cpl_frame* order_tab_edges,
00428 cpl_frame* wave_tab,
00429 cpl_frame* model_config_frame,
00430 cpl_frame* disp_tab_frame,
00431 cpl_frame* wavemap,
00432 xsh_instrument* instrument,
00433 xsh_remove_crh_single_param *crh_single_par,
00434 xsh_rectify_param *rectify_par,
00435 const int do_flatfield,
00436 const int compute_eff,
00437 const char* rec_prefix,
00438 cpl_frameset **comb_eff_set)
00439
00440 {
00441
00442 cpl_frame *rm_crh = NULL;
00443 cpl_frame * div2_frame = NULL ;
00444 cpl_frame * eff2_frame = NULL ;
00445 cpl_frame *shift1_frame = NULL;
00446 cpl_frame *shift2_frame = NULL;
00447 cpl_frame *shift1_eff_frame = NULL;
00448 cpl_frame *shift2_eff_frame = NULL;
00449 double* ref_ra=NULL;
00450 double* ref_dec=NULL;
00451 double* ref_eff_ra=NULL;
00452 double* ref_eff_dec=NULL;
00453 cpl_frameset* comb_set=NULL;
00454
00455
00456 int i=0;
00457 int nb_pairs=0;
00458
00459 xsh_msg("Method fast");
00460 check( comb_set = cpl_frameset_new());
00461
00462 if(compute_eff) {
00463 check( *comb_eff_set = cpl_frameset_new());
00464 }
00465
00466
00467 check( nb_pairs = cpl_frameset_get_size( nod_set));
00468
00469 for( i = 0; i< nb_pairs; i++){
00470 cpl_frame *nod_frame = NULL;
00471 const char* nod_name = NULL;
00472 char tag[80];
00473 char name[80];
00474
00475 nod_frame = cpl_frameset_get_frame( nod_set, i);
00476 nod_name = cpl_frame_get_filename( nod_frame);
00477 xsh_msg_dbg_high( "***** Frame %s", nod_name);
00478
00479
00480
00481
00482
00483
00484
00485
00486 sprintf(tag,"NOCRH_%s", xsh_instrument_arm_tostring( instrument ));
00487 sprintf(name,"%s.fits",tag);
00488
00489
00490 check( rm_crh = xsh_abs_remove_crh_single( nod_frame, wavemap,instrument,
00491 crh_single_par, tag));
00492
00493
00494
00495 sprintf(tag,"DIV2_FLATFIELD_%s", xsh_instrument_arm_tostring(instrument)) ;
00496 sprintf(name,"%s.fits",tag);
00497 check( div2_frame =xsh_frame_divide_flat( do_flatfield, rm_crh, master_flat,
00498 tag, instrument));
00499 xsh_add_temporary_file(name);
00500
00501
00502 check(xsh_nod_rectify_and_shift_with_key(nod_name,"RECTIFIED",rec_prefix,
00503 div2_frame,order_tab_edges,
00504 wave_tab,model_config_frame,
00505 spectral_format,
00506 disp_tab_frame,
00507 instrument,
00508 rectify_par,&ref_ra,&ref_dec,
00509 &shift1_frame,&shift2_frame));
00510
00511 cpl_frameset_insert( comb_set, shift2_frame);
00512 cpl_frameset_insert( comb_set, shift1_frame);
00513
00514 if(compute_eff) {
00515 if(disp_tab_frame != NULL) {
00516 int conserve_flux=rectify_par->conserve_flux;
00517
00518 sprintf(tag,"NOCRH_EFF_%s",xsh_instrument_arm_tostring(instrument)) ;
00519 check( eff2_frame =xsh_frame_divide_flat(0, rm_crh, master_flat,
00520 tag, instrument));
00521 rectify_par->conserve_flux=1;
00522 check(xsh_nod_rectify_and_shift_with_key(nod_name,"EFF",rec_prefix,
00523 eff2_frame,order_tab_edges,
00524 wave_tab,model_config_frame,
00525 spectral_format,
00526 disp_tab_frame,
00527 instrument,
00528 rectify_par,
00529 &ref_eff_ra,&ref_eff_dec,
00530 &shift1_eff_frame,
00531 &shift2_eff_frame));
00532 rectify_par->conserve_flux=conserve_flux;
00533 cpl_frameset_insert( *comb_eff_set, shift2_eff_frame);
00534 cpl_frameset_insert( *comb_eff_set, shift1_eff_frame);
00535 xsh_free_frame( &eff2_frame);
00536
00537 }
00538 }
00539 xsh_free_frame( &rm_crh);
00540 xsh_free_frame( &div2_frame);
00541
00542
00543 }
00544
00545 cleanup:
00546 XSH_FREE( ref_ra);
00547 XSH_FREE( ref_dec);
00548 XSH_FREE( ref_eff_ra);
00549 XSH_FREE( ref_eff_dec);
00550 xsh_free_frame( &eff2_frame);
00551 xsh_free_frame( &div2_frame);
00552 return comb_set;
00553 }
00554
00555
00556
00557
00558 cpl_frameset*
00559 xsh_scired_slit_nod_accurate(
00560 cpl_frameset *nod_set,
00561 cpl_frame* spectral_format,
00562 cpl_frame* master_flat,
00563 cpl_frame* order_tab_edges,
00564 cpl_frame* wave_tab,
00565 cpl_frame* model_config_frame,
00566 cpl_frame* disp_tab_frame,
00567 cpl_frame* wavemap,
00568 cpl_frame *skymask_frame,
00569 xsh_instrument* instrument,
00570 xsh_remove_crh_single_param *crh_single_par,
00571 xsh_rectify_param *rectify_par,
00572 xsh_localize_obj_param *loc_obj_par,
00573 const char *throw_name,
00574 const int do_flatfield,
00575 const char* rec_prefix
00576 )
00577 {
00578 int i=0;
00579 cpl_frame * a_b = NULL;
00580
00581
00582 char file_tag[40];
00583 char file_name[80];
00584
00585 int nb_nod=0;
00586 double *throw_shift = NULL;
00587 double *throw_tab = NULL;
00588
00589 cpl_frame * loc_a_b = NULL, * loc_b_a = NULL ;
00590 cpl_frame * loc_a_b_0 = NULL;
00591
00592 cpl_frameset *comb_set = NULL;
00593
00594
00595 xsh_msg("Method accurate");
00596 check( comb_set = cpl_frameset_new());
00597
00598 check( nb_nod = cpl_frameset_get_size( nod_set));
00599
00600 int file_exist=access(throw_name, F_OK);
00601 if (file_exist != 0) {
00602 xsh_msg_error("The Name %s of ASCII file containing the list of throw shifts with respect to the first exposure was not found. Exit.",throw_name);
00603 cpl_error_set(cpl_func, CPL_ERROR_FILE_NOT_FOUND);
00604 goto cleanup;
00605 }
00606
00607 if ( strcmp( throw_name, "") != 0 && file_exist ==0 ){
00608 FILE* throw_file = NULL;
00609 char throw_line[200];
00610 int iline;
00611
00612 xsh_msg("Load Throw shifts from file %s", throw_name);
00613 throw_file = fopen( throw_name, "r");
00614
00615 XSH_CALLOC( throw_tab, double, nb_nod);
00616
00617 iline=0;
00618
00619 while (fgets( throw_line, 200, throw_file) != NULL){
00620 char shiftval[200];
00621
00622 sscanf( throw_line, "%s",shiftval);
00623 if (iline < nb_nod){
00624 throw_tab[iline] = atof( shiftval);
00625 }
00626 iline++;
00627 }
00628 if (iline != nb_nod){
00629 xsh_error_msg("Invalid number of lines in ASCII file %s : %d - expected number : %d",
00630 throw_name, iline, nb_nod);
00631 }
00632 fclose( throw_file);
00633 }
00634
00635
00636 for( i = 0; i<nb_nod ; i++) {
00637 cpl_frame * rm_crh = NULL ;
00638 cpl_frame * divided = NULL ;
00639 cpl_frame * shifted_a_b = NULL;
00640 cpl_frame * shifted_a_b_eso = NULL;
00641 cpl_frame * shifted_a_b_tab = NULL;
00642 cpl_frame *inv_shifted_a_b = NULL;
00643 cpl_frame *loc_rec = NULL;
00644 cpl_frame *loc_rec_eso = NULL;
00645 cpl_frame *loc_rec_tab = NULL;
00646 cpl_frame *inv_loc_rec = NULL;
00647 char str[16] ;
00648 int mode =0;
00649
00650 if (throw_tab != NULL){
00651 throw_shift = &throw_tab[i];
00652 }
00653
00654 if (i%2 == 0){
00655 sprintf( str, "AB_%d_%s", i/2, xsh_instrument_arm_tostring(instrument)) ;
00656 mode =0;
00657 }
00658 else{
00659 sprintf( str, "BA_%d_%s", i/2, xsh_instrument_arm_tostring(instrument)) ;
00660 mode=1;
00661 }
00662 check( a_b = cpl_frameset_get_frame( nod_set, i));
00663 xsh_msg_dbg_high( "***** Frame %s", cpl_frame_get_filename( a_b ) ) ;
00664
00665
00666 xsh_msg( "Remove crh (single frame)" ) ;
00667 sprintf(file_tag, "SLIT_NOD_NOCRH_%s",str) ;
00668
00669 check( rm_crh = xsh_abs_remove_crh_single(a_b, wavemap, instrument,
00670 crh_single_par, file_tag));
00671
00672
00673 sprintf(file_tag,"SLIT_NOD_NOCRH_FF_%s", str);
00674 check( divided = xsh_frame_divide_flat( do_flatfield, rm_crh,master_flat, file_tag,
00675 instrument));
00676
00677 if ( i > 1 && throw_shift == NULL){
00678 if (i%2 == 0){
00679 xsh_msg("TEST %d : on fait loc_ab et loc_ba", i);
00680 sprintf(file_name,"LOC_REC_%s.fits", str);
00681 check( loc_rec = xsh_rectify( divided, order_tab_edges,
00682 wave_tab, model_config_frame, instrument,
00683 rectify_par, spectral_format, disp_tab_frame,
00684 file_name, &loc_rec_eso, &loc_rec_tab, rec_prefix));
00685 xsh_msg( "Localize the object (A%d)", i/2);
00686 sprintf( file_name,"LOCALIZE_%s.fits", str);
00687 check( loc_a_b = xsh_localize_obj( loc_rec, skymask_frame, instrument, loc_obj_par,
00688 NULL, file_name));
00689 xsh_add_temporary_file(file_name);
00690
00691 xsh_msg( "Negative rectify");
00692 sprintf(file_name,"DRL_INV_LOC_REC_%s", str);
00693 check( inv_loc_rec = xsh_rec_list_frame_invert( loc_rec,
00694 file_name, instrument));
00695
00696 xsh_msg( "Localize the object (B%d)", i/2);
00697 sprintf(file_name,"INV_LOCALIZE_%s.fits", str);
00698 check( loc_b_a = xsh_localize_obj( inv_loc_rec, skymask_frame, instrument, loc_obj_par,
00699 NULL, file_name));
00700 }
00701 else{
00702 xsh_msg("TEST %d : loc_ab = loc_ba", i);
00703 loc_a_b = loc_b_a;
00704 }
00705 }
00706
00707 xsh_msg( "Rectify and shift");
00708 sprintf(file_name,"SHIFT_REC_NOCRH_%s.fits", str);
00709
00710 check( shifted_a_b = xsh_rectify_and_shift( divided,order_tab_edges,
00711 wave_tab,
00712 model_config_frame,
00713 instrument,
00714 rectify_par,
00715 spectral_format,
00716 loc_a_b,
00717 loc_a_b_0,
00718 throw_shift,
00719 disp_tab_frame,
00720 file_name,
00721 &shifted_a_b_eso,
00722 &shifted_a_b_tab));
00723 xsh_free_frame( &loc_a_b);
00724
00725 if ( i==0 && throw_shift == NULL){
00726 xsh_msg( "Localize the object (A0)");
00727 sprintf(file_name,"LOCALIZE_%s.fits", str);
00728 check( loc_a_b_0 = xsh_localize_obj( shifted_a_b, skymask_frame, instrument, loc_obj_par,
00729 NULL, file_name));
00730 xsh_add_temporary_file(file_name);
00731
00732 xsh_msg( "Negative rectify");
00733 sprintf(file_name,"DRL_INV_LOC_REC_%s", str);
00734 check( inv_shifted_a_b = xsh_rec_list_frame_invert( shifted_a_b,
00735 file_name, instrument));
00736 xsh_msg( "Localize the object (B0)");
00737 sprintf(file_name,"INV_LOCALIZE_%s.fits", str);
00738 check( loc_a_b = xsh_localize_obj( inv_shifted_a_b, skymask_frame, instrument, loc_obj_par,
00739 NULL, file_name));
00740 }
00741 check( cpl_frameset_insert( comb_set, shifted_a_b));
00742
00743 xsh_free_frame( &rm_crh);
00744 xsh_free_frame( ÷d);
00745 xsh_free_frame( &shifted_a_b_eso);
00746 xsh_free_frame( &shifted_a_b_tab);
00747 xsh_free_frame( &inv_shifted_a_b);
00748 xsh_free_frame( &loc_rec);
00749 xsh_free_frame( &loc_rec_eso);
00750 xsh_free_frame( &loc_rec_tab);
00751 xsh_free_frame( &inv_loc_rec);
00752 }
00753
00754 cleanup:
00755 if ( cpl_error_get_code() != CPL_ERROR_NONE || file_exist!=0){
00756 xsh_free_frameset( &comb_set);
00757 }
00758 xsh_free_frame( &loc_a_b_0);
00759 xsh_free_frame( &loc_a_b);
00760 XSH_FREE( throw_tab);
00761 return comb_set;
00762
00763
00764 }
00765
00766
00767 cpl_error_code
00768 xsh_scired_slit_nod_get_calibs(cpl_frameset* raws,
00769 cpl_frameset* calib,
00770 xsh_instrument* instrument,
00771 cpl_frame** bpmap,
00772 cpl_frame** master_bias,
00773 cpl_frame** master_flat,
00774 cpl_frame** order_tab_edges,
00775 cpl_frame** wave_tab,
00776 cpl_frame** model_config_frame,
00777 cpl_frame** wavemap,
00778 cpl_frame** slitmap,
00779 cpl_frame** disp_tab_frame,
00780 cpl_frame** spectral_format,
00781 cpl_frame** skymask_frame,
00782 cpl_frame** response_ord_frame,
00783 cpl_frame** frm_atmext,
00784 int do_computemap,
00785 int use_skymask,
00786 int pscan,
00787 const char* rec_prefix,
00788 const char* recipe_id)
00789
00790 {
00791 int recipe_use_model=FALSE;
00792 cpl_frame* ref_frame=NULL;
00793 cpl_boolean mode_phys;
00794 mode_phys=xsh_mode_is_physmod(calib,instrument);
00795 check(*bpmap=xsh_check_load_master_bpmap(calib,instrument,recipe_id));
00796
00797 if(pscan==0) {
00798
00799 if ( xsh_instrument_get_arm(instrument) != XSH_ARM_NIR){
00800
00801 check(*master_bias = xsh_find_master_bias( calib, instrument));
00802 }
00803 }
00804
00805 check( *order_tab_edges = xsh_find_order_tab_edges( calib, instrument));
00806
00807
00808 if(mode_phys) {
00809 xsh_msg("RECIPE USE MODEL");
00810 recipe_use_model = TRUE;
00811 if((*model_config_frame = xsh_find_frame_with_tag(calib,
00812 XSH_MOD_CFG_OPT_2D,
00813 instrument)) == NULL) {
00814
00815 xsh_error_reset();
00816 if ((*model_config_frame = xsh_find_frame_with_tag(calib,XSH_MOD_CFG_TAB,
00817 instrument)) == NULL) {
00818 xsh_error_reset();
00819
00820 if ((*model_config_frame = xsh_find_frame_with_tag(calib,XSH_MOD_CFG_OPT_AFC,
00821 instrument)) == NULL) {
00822 xsh_error_reset();
00823 }
00824 }
00825
00826 }
00827 } else {
00828 xsh_msg("RECIPE USE WAVE SOLUTION");
00829 check( *wave_tab = xsh_find_wave_tab( calib, instrument));
00830 recipe_use_model = FALSE;
00831 }
00832
00833 XSH_ASSURE_NOT_ILLEGAL( model_config_frame != NULL || wave_tab != NULL);
00834
00835 if( NULL == (*master_flat = xsh_find_master_flat( calib,instrument))) {
00836 xsh_msg_error("You must provide a %s frame in input",
00837 XSH_GET_TAG_FROM_MODE ( XSH_MASTER_FLAT, instrument));
00838 goto cleanup;
00839 }
00840 if(do_computemap && recipe_use_model==FALSE) {
00841 check( *wavemap = xsh_find_wavemap( calib, instrument));
00842 }
00843
00844 if(NULL == (*disp_tab_frame = xsh_find_disp_tab( calib, instrument))) {
00845 xsh_msg("To compute efficiency, you must provide a DISP_TAB_ARM input");
00846 }
00847
00848 if ( recipe_use_model){
00849 ref_frame=cpl_frameset_get_first(raws);
00850 }
00851 else{
00852 ref_frame = *master_flat;
00853 }
00854 check( xsh_check_get_map( *disp_tab_frame, *order_tab_edges,
00855 ref_frame, *model_config_frame, calib, instrument,
00856 do_computemap, recipe_use_model, rec_prefix,
00857 wavemap, slitmap));
00858
00859 check( *spectral_format = xsh_find_spectral_format( calib, instrument));
00860
00861 if ( use_skymask == TRUE){
00862 xsh_msg("Using sky mask");
00863 check( *skymask_frame = xsh_find_frame_with_tag( calib, XSH_SKY_LINE_LIST,
00864 instrument));
00865 }
00866 if((*response_ord_frame=xsh_find_frame_with_tag(calib,XSH_MRESPONSE_MERGE1D_SLIT,
00867 instrument)) == NULL ) {
00868 check( *response_ord_frame = xsh_find_frame_with_tag(calib,
00869 XSH_RESPONSE_MERGE1D_SLIT,
00870 instrument));
00871 }
00872 if(*response_ord_frame != NULL) {
00873 *frm_atmext=xsh_find_frame_with_tag(calib,XSH_ATMOS_EXT,instrument);
00874 if(*frm_atmext==NULL) {
00875 xsh_msg_error("Provide atmospheric extinction frame");
00876 }
00877 }
00878
00879 cleanup:
00880 return cpl_error_get_code();
00881 }
00882
00883
00889 static cpl_error_code
00890 xsh_scired_nod_params_monitor(xsh_rectify_param * rectify_par,
00891 xsh_localize_obj_param * loc_obj_par)
00892 {
00893
00894
00895
00896 xsh_msg_dbg_low("rectify params: radius=%g bin_lambda=%g bin_space=%g",
00897 rectify_par->rectif_radius,rectify_par->rectif_bin_lambda,
00898 rectify_par->rectif_bin_space);
00899
00900 xsh_msg_dbg_low("localize params: chunk_nb=%d nod_step=%g",
00901 loc_obj_par->loc_chunk_nb,loc_obj_par->nod_step);
00902
00903 return cpl_error_get_code();
00904
00905 }
00906
00907
00908
00909
00910 cpl_error_code
00911 xsh_scired_nod_get_parameters(cpl_parameterlist* parameters,
00912 xsh_instrument* instrument,
00913 xsh_remove_crh_single_param** crh_single_par,
00914 xsh_rectify_param** rectify_par,
00915 xsh_merge_param** merge_par,
00916 xsh_extract_param** extract_par,
00917 xsh_combine_nod_param** combine_nod_par,
00918 xsh_slit_limit_param** slit_limit_par,
00919 xsh_localize_obj_param** loc_obj_par,
00920 int* rectify_fast, int* pscan,
00921 const char* rec_id
00922 )
00923
00924
00925 {
00926 check( *loc_obj_par = xsh_parameters_localize_obj_get(rec_id,
00927 parameters));
00928 check( *rectify_par = xsh_parameters_rectify_get(rec_id,
00929 parameters));
00930 check( *rectify_fast = xsh_parameters_rectify_fast_get(rec_id,
00931 parameters));
00932 check( *crh_single_par = xsh_parameters_remove_crh_single_get(rec_id,
00933 parameters));
00934 check( *merge_par = xsh_parameters_merge_ord_get(rec_id,
00935 parameters));
00936 check( *extract_par=xsh_parameters_extract_get(rec_id, parameters));
00937 check( *combine_nod_par = xsh_parameters_combine_nod_get(rec_id,
00938 parameters)) ;
00939 check( *slit_limit_par = xsh_parameters_slit_limit_get(rec_id,
00940 parameters));
00941
00942 check(xsh_rectify_params_set_defaults(parameters,rec_id,instrument,*rectify_par));
00943
00944 check( xsh_scired_nod_params_monitor(*rectify_par,*loc_obj_par));
00945 check( *pscan=xsh_parameters_get_int(parameters,rec_id,"pre-overscan-corr"));
00946
00947 cleanup:
00948 return cpl_error_get_code();
00949 }
00950
00951
00952 cpl_error_code
00953 xsh_flux_calibrate1D(cpl_frame* rect1D,
00954 cpl_frame* atmext,
00955 cpl_frame* response,
00956 xsh_merge_param * mpar,
00957 xsh_instrument* inst,
00958 const char* rec_prefix,
00959 cpl_frame** fcal_rect_1D,
00960 cpl_frame** fcal_1D)
00961 {
00962
00963 char file_tag[80];
00964 char file_name[80];
00965 char arm_str[8] ;
00966 cpl_frame* nrm_1D=NULL;
00967 const char* tag=NULL;
00968
00969
00970 tag=cpl_frame_get_tag(rect1D);
00971 sprintf(arm_str,"%s",xsh_instrument_arm_tostring(inst));
00972 xsh_msg("tag=%s",tag);
00973 if(strstr(tag,XSH_ORDER_OXT1D) == NULL) {
00974 sprintf(file_tag,"%s_%s_%s",rec_prefix,XSH_NORM_ORDER1D,arm_str);
00975 } else {
00976 sprintf(file_tag,"%s_%s_%s",rec_prefix,XSH_NORM_OXT1D,arm_str);
00977 }
00978 xsh_msg("file_tag1=%s",file_tag);
00979 sprintf(file_name,"%s.fits",file_tag);
00980 xsh_add_temporary_file(file_name);
00981
00982 check(nrm_1D=xsh_normalize_spectrum_ord(rect1D,atmext,1,inst,file_tag));
00983 if(strstr(tag,XSH_ORDER_OXT1D) == NULL) {
00984 sprintf(file_tag,"%s_%s_%s",rec_prefix,XSH_FLUX_ORDER1D,arm_str);
00985 } else {
00986 sprintf(file_tag,"%s_%s_%s",rec_prefix,XSH_FLUX_OXT1D,arm_str);
00987 }
00988 sprintf(file_name,"%s.fits",file_tag);
00989
00990
00991 check(*fcal_rect_1D=xsh_util_multiply_by_response_ord(nrm_1D,response,file_tag));
00992 check(*fcal_1D= xsh_merge_ord(*fcal_rect_1D,inst,mpar,rec_prefix));
00993 xsh_msg("file_tag2=%s",file_tag);
00994
00995
00996 cleanup:
00997 xsh_free_frame(&nrm_1D);
00998 return cpl_error_get_code();
00999
01000 }
01001
01002
01003
01004 cpl_error_code
01005 xsh_flux_calibrate2D(cpl_frame* rect2D,
01006 cpl_frame* atmext,
01007 cpl_frame* response,
01008 xsh_merge_param * mpar,
01009 xsh_instrument* inst,
01010 const char* rec_prefix,
01011 cpl_frame** fcal_rect_2D,
01012 cpl_frame** fcal_2D)
01013 {
01014
01015
01016 char file_tag[80];
01017 char file_name[80];
01018 char arm_str[8] ;
01019 cpl_frame* nrm_2D=NULL;
01020
01021 sprintf(arm_str,"%s",xsh_instrument_arm_tostring(inst));
01022
01023 sprintf(file_tag,"%s_%s_%s",rec_prefix,XSH_NORM_ORDER2D,arm_str);
01024 sprintf(file_name,"%s.fits",file_tag);
01025 check(nrm_2D=xsh_normalize_spectrum_ord(rect2D,atmext,1,inst,file_tag));
01026 xsh_add_temporary_file(file_name);
01027
01028
01029 sprintf(file_tag,"%s_%s_%s",rec_prefix,XSH_FLUX_ORDER2D,arm_str);
01030 check(*fcal_rect_2D=xsh_util_multiply_by_response_ord(nrm_2D,response,file_tag));
01031 check(*fcal_2D = xsh_merge_ord(*fcal_rect_2D, inst,mpar,rec_prefix));
01032
01033 cleanup:
01034 xsh_free_frame(&nrm_2D);
01035 return cpl_error_get_code();
01036
01037
01038 }
01039
01040 cpl_error_code
01041 xsh_flux_calibrate(cpl_frame* rect2D,
01042 cpl_frame* rect1D,
01043 cpl_frame* atmext,
01044 cpl_frame* response,
01045 xsh_merge_param * mpar,
01046 xsh_instrument* inst,
01047 const char* rec_prefix,
01048 cpl_frame** fcal_rect_2D,
01049 cpl_frame** fcal_rect_1D,
01050 cpl_frame** fcal_2D,
01051 cpl_frame** fcal_1D)
01052 {
01053
01054
01055 check(xsh_flux_calibrate2D(rect2D,atmext,response,mpar,inst,rec_prefix,
01056 fcal_rect_2D,fcal_2D));
01057 check(xsh_flux_calibrate1D(rect1D,atmext,response,mpar,inst,rec_prefix,
01058 fcal_rect_1D,fcal_1D));
01059
01060 cleanup:
01061
01062
01063 return cpl_error_get_code();
01064 }
01065
01066
01067
01068 cpl_error_code
01069 xsh_slit_stare_get_calibs(cpl_frameset* calib,
01070 xsh_instrument* instrument,
01071 cpl_frame** spectralformat,
01072 cpl_frame** mbias,
01073 cpl_frame** mdark,
01074 cpl_frame** mflat,
01075 cpl_frame** otab_edges,
01076 cpl_frame** model_cfg,
01077 cpl_frame** wave_tab,
01078 cpl_frame** sky_list,
01079 cpl_frame** qc_sky,
01080 cpl_frame** bpmap,
01081 cpl_frame** sframe_sky_sub_tab,
01082 cpl_frame** wmap,
01083 cpl_frame** smap,
01084 const char* rec_id,
01085 int * recipe_use_model,
01086 int pscan)
01087 {
01088
01089
01090 int binx=1;
01091 int biny=1;
01092 cpl_propertylist* plist=NULL;
01093 cpl_boolean mode_phys;
01094 mode_phys=xsh_mode_is_physmod(calib,instrument);
01095 check(*spectralformat = xsh_find_spectral_format( calib, instrument));
01096
01097 XSH_ASSURE_NOT_NULL_MSG(*spectralformat,"Null input spectral format frame");
01098 check(xsh_instrument_update_from_spectralformat(instrument,*spectralformat));
01099
01100
01101 if (pscan == 0) {
01102 if ( xsh_instrument_get_arm(instrument) != XSH_ARM_NIR){
01103
01104 if((*mbias = xsh_find_master_bias( calib, instrument)) == NULL) {
01105 xsh_msg_error("You must give a MASTER_BIAS_ARM frame");
01106 return CPL_ERROR_DATA_NOT_FOUND;
01107 }
01108 }
01109 }
01110
01111 if((*mdark = xsh_find_master_dark( calib, instrument))==NULL) {
01112 xsh_msg_warning("Frame %s not provided",XSH_MASTER_DARK);
01113 xsh_error_reset();
01114 }
01115
01116 check( *mflat = xsh_find_master_flat( calib, instrument ));
01117 if ( xsh_instrument_get_arm(instrument) != XSH_ARM_NIR) {
01118 check(plist=cpl_propertylist_load(cpl_frame_get_filename(*mflat),0));
01119 check(binx=xsh_pfits_get_binx(plist));
01120 check(biny=xsh_pfits_get_biny(plist));
01121 xsh_free_propertylist(&plist);
01122 }
01123 check(*otab_edges = xsh_find_order_tab_edges(calib,instrument));
01124
01125
01126 if(mode_phys) {
01127 if((*model_cfg = xsh_find_frame_with_tag(calib,XSH_MOD_CFG_OPT_2D,
01128 instrument)) == NULL) {
01129 xsh_error_reset();
01130 if ((*model_cfg = xsh_find_frame_with_tag(calib,XSH_MOD_CFG_TAB,
01131 instrument)) == NULL) {
01132 xsh_error_reset();
01133
01134 if ((*model_cfg = xsh_find_frame_with_tag(calib,XSH_MOD_CFG_OPT_AFC,
01135 instrument)) == NULL) {
01136 xsh_error_reset();
01137 }
01138 }
01139 }
01140 xsh_msg("RECIPE USE MODEL");
01141 *recipe_use_model = TRUE;
01142 } else {
01143 xsh_msg("RECIPE USE WAVE SOLUTION");
01144 check( *wave_tab = xsh_find_wave_tab( calib, instrument));
01145 *recipe_use_model = FALSE;
01146 }
01147
01148 if ( *model_cfg != NULL){
01149 check(*sky_list = xsh_find_frame_with_tag( calib, XSH_SKY_LINE_LIST,
01150 instrument));
01151 if ( *sky_list != NULL){
01152
01153 check(*qc_sky=xsh_util_physmod_model_THE_create(*model_cfg,instrument,
01154 *sky_list,1,1,9,1));
01155 }
01156 }
01157
01158
01159 check(*bpmap=xsh_check_load_master_bpmap(calib,instrument,rec_id));
01160 if ((*sframe_sky_sub_tab = xsh_find_frame_with_tag(calib,XSH_SKY_SUB_BKPTS,
01161 instrument)) == NULL) {
01162 xsh_error_reset();
01163 } else {
01164 xsh_msg_warning("Data reduction with user defined break points number from file %s",
01165 cpl_frame_get_filename(*sframe_sky_sub_tab));
01166 }
01167
01168
01169 check(*wmap = xsh_find_frame_with_tag(calib,XSH_WAVE_MAP,instrument));
01170 check(*smap = xsh_find_frame_with_tag(calib,XSH_SLIT_MAP,instrument));
01171
01172 cleanup:
01173 xsh_free_propertylist(&plist);
01174 return cpl_error_get_code();
01175 }
01176
01177 cpl_error_code
01178 xsh_slit_offset_get_calibs(cpl_frameset* calib,xsh_instrument* instrument,
01179 cpl_frame** bpmap,cpl_frame** mbias,
01180 cpl_frame** mdark, cpl_frame** otab_edges,
01181 cpl_frame** model_cfg, cpl_frame** wave_tab,
01182 cpl_frame** mflat, cpl_frame** wmap, cpl_frame** smap,
01183 cpl_frame** spectral_format,const char* rec_id)
01184 {
01185
01186
01187 cpl_boolean mode_phys;
01188 mode_phys=xsh_mode_is_physmod(calib,instrument);
01189
01190 check(*bpmap=xsh_check_load_master_bpmap(calib,instrument,rec_id));
01191
01192
01193 if ( xsh_instrument_get_arm(instrument) != XSH_ARM_NIR){
01194
01195 check( *mbias = xsh_find_frame_with_tag(calib,XSH_MASTER_BIAS,instrument));
01196 }
01197
01198
01199 if((*mdark=xsh_find_frame_with_tag(calib,XSH_MASTER_DARK,instrument))==NULL){
01200 xsh_error_reset();
01201 }
01202
01203 if(mode_phys) {
01204 check( *otab_edges = xsh_find_order_tab_edges( calib, instrument));
01205 if((*model_cfg=xsh_find_frame_with_tag(calib,XSH_MOD_CFG_OPT_2D,instrument)) == NULL) {
01206 xsh_error_reset();
01207 if ((*model_cfg = xsh_find_frame_with_tag(calib,XSH_MOD_CFG_TAB,
01208 instrument)) == NULL) {
01209 xsh_error_reset();
01210
01211 if ((*model_cfg = xsh_find_frame_with_tag(calib,XSH_MOD_CFG_OPT_AFC,
01212 instrument)) == NULL) {
01213 xsh_error_reset();
01214 }
01215 }
01216 }
01217 } else {
01218
01219 *wave_tab = xsh_find_wave_tab( calib, instrument ) ;
01220 }
01221
01222 XSH_ASSURE_NOT_ILLEGAL( *model_cfg != NULL || *wave_tab != NULL ) ;
01223
01224 check( *mflat = xsh_find_master_flat( calib, instrument));
01225
01226 check( *wmap = xsh_find_wavemap( calib, instrument));
01227 check( *smap = xsh_find_slitmap( calib, instrument));
01228 check( *spectral_format = xsh_find_spectral_format( calib, instrument));
01229
01230
01231 cleanup:
01232 return cpl_error_get_code();
01233
01234 }
01235
01236 cpl_error_code
01237 xsh_slit_stare_get_params(cpl_parameterlist* parameters,
01238 const char* rec_id,
01239 int* pre_overscan_corr,
01240 xsh_clipping_param** crh_clipping_par,
01241 xsh_background_param** backg_par,
01242 xsh_localize_obj_param** loc_obj_par,
01243 xsh_rectify_param** rectify_par,
01244 xsh_remove_crh_single_param** crh_single_par,
01245 int* sub_sky_nbkpts1,
01246 int* do_flatfield,
01247 int* sub_sky_nbkpts2,
01248 xsh_subtract_sky_single_param** sky_par,
01249 xsh_extract_param** extract_par,
01250 int* do_optextract,
01251 xsh_merge_param** merge_par,
01252 xsh_opt_extract_param** opt_extract_par,
01253 int* do_trace_obj)
01254 {
01255
01256 check( *pre_overscan_corr = xsh_parameters_get_int( parameters, rec_id,
01257 "pre-overscan-corr"));
01258
01259 check( *crh_clipping_par = xsh_parameters_clipping_crh_get(rec_id,parameters));
01260 check( *backg_par = xsh_parameters_background_get(rec_id,parameters));
01261
01262 check( *loc_obj_par = xsh_parameters_localize_obj_get(rec_id,parameters));
01263 check( *rectify_par = xsh_parameters_rectify_get(rec_id,parameters));
01264 check( *crh_single_par = xsh_parameters_remove_crh_single_get(rec_id,parameters));
01265
01266 check( *sub_sky_nbkpts1 = xsh_parameters_subtract_sky_single_get_first(
01267 rec_id,parameters));
01268 check( *do_flatfield = xsh_parameters_get_boolean( parameters, rec_id,
01269 "do-flatfield"));
01270 check( *sub_sky_nbkpts2 = xsh_parameters_subtract_sky_single_get_second(
01271 rec_id,parameters));
01272 check( *sky_par= xsh_parameters_subtract_sky_single_get(rec_id,parameters));
01273
01274 check( *extract_par = xsh_parameters_extract_get( rec_id, parameters));
01275 check( *do_optextract = xsh_parameters_get_boolean( parameters, rec_id,
01276 "do-optextract"));
01277 check( *opt_extract_par = xsh_parameters_opt_extract_get(rec_id,parameters));
01278
01279 check( *merge_par = xsh_parameters_merge_ord_get(rec_id,parameters));
01280
01281 check( *do_trace_obj = xsh_parameters_get_boolean( parameters,rec_id,
01282 "trace-obj"));
01283
01284
01285 cleanup:
01286 return cpl_error_get_code();
01287 }
01288
01289
01290 cpl_error_code
01291 xsh_slit_offset_get_params(cpl_parameterlist* parameters,
01292 const char* rec_id,
01293 xsh_clipping_param** crh_clipping_par,
01294 xsh_background_param** backg_par,
01295 xsh_localize_obj_param** loc_obj_par,
01296 xsh_rectify_param** rectify_par,
01297 xsh_remove_crh_single_param** crh_single_par,
01298 double* opt_kappa,
01299 xsh_merge_param** merge_par,
01300 xsh_extract_param**extract_par,
01301 xsh_combine_nod_param** combine_nod_param,
01302 int* do_flatfield,
01303 int* gen_sky)
01304 {
01305
01306
01307 check( *crh_clipping_par = xsh_parameters_clipping_crh_get(rec_id,parameters));
01308 check( *backg_par = xsh_parameters_background_get(rec_id,parameters));
01309
01310 check( *loc_obj_par = xsh_parameters_localize_obj_get(rec_id,parameters));
01311 check( *rectify_par = xsh_parameters_rectify_get(rec_id,parameters));
01312 check( *crh_single_par = xsh_parameters_remove_crh_single_get(rec_id,parameters));
01313 if ( (*rectify_par)->rectify_full_slit == 1 ){
01314
01315 xsh_msg( "Use Full Slit" ) ;
01316 }
01317 else {
01318 xsh_msg( "Use Max Possible Slit" ) ;
01319 }
01320
01321 check( *opt_kappa = xsh_parameters_optimal_extract_get_kappa(rec_id,parameters));
01322
01323 check( *merge_par = xsh_parameters_merge_ord_get(rec_id,parameters));
01324
01325 check(*extract_par=xsh_parameters_extract_get(rec_id, parameters )) ;
01326
01327 check(*combine_nod_param = xsh_parameters_combine_nod_get(rec_id,parameters )) ;
01328
01329 check( *do_flatfield = xsh_parameters_get_boolean( parameters,rec_id,
01330 "do-flatfield"));
01331
01332 check( *gen_sky = xsh_parameters_get_boolean( parameters, rec_id,
01333 "gen-sky"));
01334
01335 cleanup:
01336 return cpl_error_get_code();
01337
01338 }
01339
01340
01341 cpl_error_code
01342 xsh_slit_stare_correct_crh_and_sky(xsh_localize_obj_param * loc_obj_par,
01343 xsh_remove_crh_single_param* crh_single_par,
01344 xsh_rectify_param* rectify_par,
01345 int do_sub_sky,
01346 const char* rec_prefix,
01347 cpl_frame* rmbkg,
01348 cpl_frame* order_tab_edges,
01349 cpl_frame* slitmap,
01350 cpl_frame* wavemap,
01351 cpl_frame* model_config,
01352 cpl_frame* single_frame_sky_sub_tab,
01353 xsh_instrument* instrument,
01354 int sub_sky_nbkpts1,
01355 xsh_subtract_sky_single_param* sky_par,
01356 cpl_frame** sky,
01357 cpl_frame** sky_eso,
01358 cpl_frame** sky_ima,
01359 cpl_frame* wave_tab,
01360 cpl_frame* disp_tab,
01361 cpl_frame* spectral_format,
01362 int nb_raw_frames,
01363 cpl_frame** loc_table,
01364 cpl_frame** clean,
01365 cpl_frame** clean_obj)
01366 {
01367
01368 char sky_tag[80];
01369 char sky_name[80];
01370 char rec_name[80];
01371 cpl_frame * sub_sky = NULL ;
01372 cpl_frame * rect = NULL ;
01374 if( (loc_obj_par->method != LOC_MANUAL_METHOD) ||
01375 (nb_raw_frames == 1 && crh_single_par->nb_iter > 0)){
01376 xsh_msg("Preliminary sky subtraction for CRH single or automatic localization");
01377 xsh_msg("Sky will be put back later");
01378
01379 sprintf(sky_tag,"%s_TMPSKY",rec_prefix);
01380 sprintf(sky_name,"%s.fits",sky_tag);
01381
01382 if(do_sub_sky) {
01383 check( sub_sky = xsh_check_subtract_sky_single( CPL_TRUE, rmbkg,
01384 order_tab_edges,
01385 slitmap,
01386 wavemap,
01387 NULL, NULL,
01388 single_frame_sky_sub_tab,
01389 instrument,
01390 sub_sky_nbkpts1,
01391 sky_par,
01392 sky,
01393 sky_eso,
01394 sky_ima,
01395 sky_tag));
01396 xsh_add_temporary_file(sky_name);
01397
01398 } else {
01399 sub_sky = cpl_frame_duplicate(rmbkg);
01400 xsh_add_temporary_file(sky_name);
01401 }
01402 if( loc_obj_par->method != LOC_MANUAL_METHOD){
01403 xsh_msg("Localize auto");
01404 sprintf(rec_name,"%s_%s_%s.fits",
01405 rec_prefix,XSH_ORDER2D,
01406 xsh_instrument_arm_tostring(instrument));
01407
01408
01409
01410 check( rect = xsh_rectify( sub_sky, order_tab_edges,
01411 wave_tab, model_config,
01412 instrument, rectify_par,
01413 spectral_format, disp_tab,
01414 rec_name, NULL, NULL,rec_prefix));
01415
01416
01417 check( *loc_table = xsh_localize_obj( rect, NULL, instrument,
01418 loc_obj_par, NULL, NULL));
01419 xsh_free_frame( &rect);
01420 }
01421 else{
01422 check( *loc_table = xsh_localize_obj( NULL, NULL,
01423 instrument, loc_obj_par, NULL, NULL));
01424 }
01425
01426
01427 check( *clean = xsh_check_remove_crh_single( nb_raw_frames, sub_sky,
01428 crh_single_par, wavemap, instrument, rec_prefix));
01429 if(do_sub_sky) {
01430 check( *clean_obj = xsh_add_sky_model( *clean, *sky_ima,
01431 instrument, rec_prefix));
01432 } else {
01433 *clean_obj=cpl_frame_duplicate(*clean);
01434 }
01435
01436 xsh_free_frame( &sub_sky);
01437 xsh_free_frame( sky);
01438 xsh_free_frame( sky_eso);
01439 xsh_free_frame( sky_ima);
01440 }
01441 else {
01442
01443 check( *clean_obj=cpl_frame_duplicate(rmbkg));
01444 check( *loc_table = xsh_localize_obj( NULL, NULL,
01445 instrument, loc_obj_par, NULL, NULL));
01446 }
01447
01448
01449 cleanup:
01450
01451 xsh_free_frame(&sub_sky) ;
01452 xsh_free_frame(&rect) ;
01453
01454 return cpl_error_get_code();
01455
01456 }
01457
01458
01459 cpl_error_code
01460 xsh_slit_stare_get_maps(cpl_frameset* calib,
01461 int do_compute_map,int recipe_use_model,
01462 const char* rec_prefix,xsh_instrument* instrument,
01463 cpl_frame* model_config_frame,cpl_frame* crhm_frame,
01464 cpl_frame* disp_tab_frame, cpl_frame* order_tab_edges,
01465 cpl_frame** wavemap_frame, cpl_frame** slitmap_frame)
01466 {
01467 char wave_map_tag[80];
01468 char slit_map_tag[80];
01469 int found_temp=1;
01470 if ( do_compute_map){
01471 if (recipe_use_model){
01472 sprintf(wave_map_tag,"%s_%s_%s",rec_prefix,XSH_WAVE_MAP_MODEL,
01473 xsh_instrument_arm_tostring( instrument ));
01474 sprintf(slit_map_tag,"%s_%s_%s",rec_prefix,XSH_SLIT_MAP_MODEL,
01475 xsh_instrument_arm_tostring( instrument ));
01476
01477 check(xsh_model_temperature_update_frame(&model_config_frame,crhm_frame,
01478 instrument,&found_temp));
01479
01480 check( xsh_create_model_map( model_config_frame, instrument,
01481 wave_map_tag,slit_map_tag,
01482 wavemap_frame, slitmap_frame,0));
01483 }
01484 else{
01485 xsh_msg("Compute the wave map and the slit map");
01486 check( xsh_create_map( disp_tab_frame, order_tab_edges,
01487 crhm_frame, instrument,
01488 wavemap_frame, slitmap_frame,
01489 rec_prefix));
01490 }
01491 }
01492 else {
01493 xsh_msg( "Get the wave map and the slit map from sof" ) ;
01494 check( *slitmap_frame = xsh_find_slitmap(calib, instrument));
01495 check( *wavemap_frame = xsh_find_wavemap(calib, instrument));
01496 }
01497
01498 cleanup:
01499 return cpl_error_get_code();
01500 }
01501
01502
01503 cpl_error_code
01504 xsh_scired_util_spectra_flux_calibrate(cpl_frame* res2D,cpl_frame* res1D,
01505 cpl_frame* response,cpl_frame* atmext,
01506 xsh_instrument* inst,
01507 const char* prefix,
01508 cpl_frame** fluxcal_2D,
01509 cpl_frame** fluxcal_1D)
01510 {
01511 char file_tag[40];
01512 cpl_frame* nrm_1D=NULL;
01513 cpl_frame* nrm_2D=NULL;
01514
01515 sprintf(file_tag,"%s_NORM2D_%s",prefix,xsh_instrument_arm_tostring(inst));
01516 check(nrm_2D=xsh_normalize_spectrum(res2D,atmext,0,inst,file_tag));
01517 sprintf(file_tag,"%s_FLUXCAL2D_%s",prefix,xsh_instrument_arm_tostring(inst));
01518 check(*fluxcal_2D=xsh_util_multiply_by_response(nrm_2D,response,file_tag));
01519 sprintf(file_tag,"%s_NORM1D_%s",prefix,xsh_instrument_arm_tostring(inst));
01520 check(nrm_1D=xsh_normalize_spectrum(res1D,atmext,0,inst,file_tag));
01521 sprintf(file_tag,"%s_FLUXCAL1D_%s",prefix,xsh_instrument_arm_tostring(inst));
01522 check(*fluxcal_1D=xsh_util_multiply_by_response(nrm_1D,response,file_tag));
01523
01524 cleanup:
01525 xsh_free_frame(&nrm_1D);
01526 xsh_free_frame(&nrm_2D);
01527
01528 return cpl_error_get_code();
01529
01530 }
01531
01532
01533 cpl_frame* xsh_compute_efficiency(cpl_frame* mer1D, cpl_frame* std_cat,
01534 cpl_frame* atm_ext, cpl_frame* high_abs_win,
01535 xsh_instrument* instr)
01536 {
01537
01538 cpl_frame* eff=NULL;
01539
01540 if(NULL == (eff=xsh_efficiency_compute(mer1D,std_cat,atm_ext,high_abs_win,instr))) {
01541 xsh_msg_error("An error occurred during efficiency computation");
01542 xsh_msg_error("The recipe recovers without efficiency product generation");
01543 cpl_error_reset();
01544 } else {
01545 check(xsh_frame_table_monitor_flux_qc(eff,"WAVELENGTH","EFF","EFF",instr));
01546 }
01547
01548 cleanup:
01549 return eff;
01550 }
01551
01552 cpl_error_code
01553 xsh_compute_resampling_accuracy(cpl_frame* wavemap,
01554 cpl_frame* slitmap,
01555 cpl_frame* order_tab_edges,
01556 cpl_frame* model_config,
01557 cpl_frame* merged2D,
01558 xsh_instrument* instrument) {
01559
01560 cpl_propertylist* plist=NULL;
01561 const char* name=NULL;
01562 double rms_x=0;
01563 double rms_y=0;
01564 cpl_table* tab=NULL;
01565 cpl_table* ext=NULL;
01566
01567 xsh_pre* pre=NULL;
01568
01569 int ord_min=0;
01570 int ord_max=0;
01571 int ord_avg=0;
01572
01573 int next=0;
01574 int status=0;
01575
01576 int xmin=0;
01577 int xmax=0;
01578 int ymin=0;
01579 int ymax=0;
01580 int xcen=0;
01581 int ycen=0;
01582
01583 double wmin=0;
01584 double wmax=0;
01585 double wdif;
01586 double sdif;
01587
01588 double smin=0;
01589 double smax=0;
01590 double* wmap=NULL;
01591 double* smap=NULL;
01592
01593 cpl_image* wmap_ima=NULL;
01594 cpl_image* smap_ima=NULL;
01595 xsh_spectrum* s=NULL;
01596
01597 int nx=0;
01598 int ny=0;
01599
01600 double wrms=0;
01601 double srms=0;
01602 double werr=0;
01603 double serr=0;
01604 int nline=1;
01605
01606 XSH_ASSURE_NOT_NULL_MSG(wavemap,"Null input wavemap");
01607 XSH_ASSURE_NOT_NULL_MSG(slitmap,"Null input wavemap");
01608 XSH_ASSURE_NOT_NULL_MSG(order_tab_edges,"Null input order tab edges");
01609 XSH_ASSURE_NOT_NULL_MSG(model_config,"Null input model config");
01610 XSH_ASSURE_NOT_NULL_MSG(merged2D,"Null input sci frame");
01611 XSH_ASSURE_NOT_NULL_MSG(instrument,"Null input instrument structure");
01612
01613
01614 name=cpl_frame_get_filename(order_tab_edges);
01615 tab=cpl_table_load(name,2,0);
01616
01617 check(ord_min=cpl_table_get_column_min(tab,"ORDER"));
01618 check(ord_max=cpl_table_get_column_max(tab,"ORDER"));
01619 ord_avg=0.5*(ord_min+ord_max);
01620
01621 check(next=cpl_table_and_selected_int(tab,"ORDER",CPL_EQUAL_TO,ord_avg));
01622 check(ext=cpl_table_extract_selected(tab));
01623 xsh_free_table(&tab);
01624
01625 check(xcen=(int)cpl_table_get_double(ext,"CENTER_X",next/2,&status));
01626 xcen/=instrument->binx;
01627 xmin=xcen-1;
01628 xmax=xcen+1;
01629
01630 check(ycen=(int)cpl_table_get_double(ext,"CENTER_Y",next/2,&status));
01631 ycen/=instrument->biny;
01632 ymin=ycen-1;
01633 ymax=ycen+1;
01634 xsh_free_table(&ext);
01635
01636 check(name=cpl_frame_get_filename(wavemap));
01637 check(wmap_ima=cpl_image_load(name,CPL_TYPE_DOUBLE,0,0));
01638 check(wmap=cpl_image_get_data_double(wmap_ima));
01639 check(nx=cpl_image_get_size_x(wmap_ima));
01640 check(ny=cpl_image_get_size_y(wmap_ima));
01641
01642 name=cpl_frame_get_filename(slitmap);
01643 smap_ima=cpl_image_load(name,CPL_TYPE_DOUBLE,0,0);
01644 smap=cpl_image_get_data_double(wmap_ima);
01645
01646 wmin=wmap[nx*ycen+xmin];
01647 wmax=wmap[nx*ycen+xmax];
01648
01649 smin=smap[nx*ymin+xcen];
01650 smax=smap[nx*ymax+xcen];
01651
01652 wdif=fabs(0.5*(wmin-wmax));
01653 sdif=fabs(0.5*(smin-smax));
01654 xsh_free_image(&wmap_ima);
01655 xsh_free_image(&smap_ima);
01656
01657 name=cpl_frame_get_filename(model_config);
01658 plist=cpl_propertylist_load(name,0);
01659 if(cpl_propertylist_has(plist,XSH_QC_MODEL_ANNEAL_RESX_RMS) ){
01660 xsh_msg_warning("Key %s not found %s, %s will be set to 0",
01661 XSH_QC_MODEL_ANNEAL_RESX_RMS,XSH_QC_LAMRMS,XSH_QC_LAMERR);
01662
01663 check(rms_x=cpl_propertylist_get_double(plist,XSH_QC_MODEL_ANNEAL_RESX_RMS));
01664 }
01665 if(cpl_propertylist_has(plist,XSH_QC_MODEL_ANNEAL_RESY_RMS) ){
01666 xsh_msg_warning("Key %s not found %s, %s will be set to 0",
01667 XSH_QC_MODEL_ANNEAL_RESY_RMS,XSH_QC_SPATRMS,XSH_QC_SPATERR);
01668
01669 check(rms_y=cpl_propertylist_get_double(plist,XSH_QC_MODEL_ANNEAL_RESY_RMS));
01670 }
01671
01672 if(cpl_propertylist_has(plist,XSH_QC_MODEL_NDAT) ){
01673 nline=cpl_propertylist_get_int(plist,XSH_QC_MODEL_NDAT);
01674 }
01675 xsh_free_propertylist(&plist);
01676
01677 srms=rms_x*sdif;
01678 wrms=rms_y*wdif;
01679 serr=srms/sqrt(nline);
01680 werr=wrms/sqrt(nline);
01681 name=cpl_frame_get_filename(merged2D);
01682 check(s=xsh_spectrum_load(merged2D));
01683
01684
01685
01686 cpl_propertylist_append_double(s->flux_header,XSH_QC_SPATRMS,srms);
01687 cpl_propertylist_set_comment(s->flux_header,XSH_QC_SPATRMS,XSH_QC_SPATRMS_C);
01688 cpl_propertylist_append_double(s->flux_header,XSH_QC_SPATERR,serr);
01689 cpl_propertylist_set_comment(s->flux_header,XSH_QC_SPATERR,XSH_QC_SPATERR_C);
01690
01691 cpl_propertylist_append_double(s->flux_header,XSH_QC_LAMRMS,wrms);
01692 cpl_propertylist_set_comment(s->flux_header,XSH_QC_LAMRMS,XSH_QC_LAMRMS_C);
01693 cpl_propertylist_append_double(s->flux_header,XSH_QC_LAMERR,werr);
01694 cpl_propertylist_set_comment(s->flux_header,XSH_QC_LAMERR,XSH_QC_LAMERR_C);
01695
01696 cpl_propertylist_append_int(s->flux_header,XSH_QC_LAMNLIN,nline);
01697 cpl_propertylist_set_comment(s->flux_header,XSH_QC_LAMNLIN,XSH_QC_LAMNLIN_C);
01698
01699
01700 cleanup:
01701 xsh_pre_free(&pre);
01702 xsh_free_table(&tab);
01703 xsh_free_table(&ext);
01704 xsh_free_image(&wmap_ima);
01705 xsh_free_image(&smap_ima);
01706 xsh_free_propertylist(&plist);
01707 xsh_spectrum_free(&s);
01708 return cpl_error_get_code();
01709
01710 }
01711