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
00037
00038
00039
00040
00041
00042
00043
00044 #include <xsh_dfs.h>
00045 #include <xsh_pfits.h>
00046 #include <xsh_data_pre.h>
00047 #include <xsh_data_pre_3d.h>
00048 #include <xsh_error.h>
00049 #include <xsh_msg.h>
00050 #include <cpl.h>
00051 #include <string.h>
00052 #include <time.h>
00053 #include <math.h>
00054 #include <xsh_paf_save.h>
00055 #include <xsh_utils_table.h>
00056 #include <xsh_utils_image.h>
00057 #include <xsh_utils.h>
00058 #include <xsh_data_spectrum.h>
00059
00060
00061
00062
00063 static cpl_frame *xsh_find_frame (cpl_frameset * frames,
00064 const char *tags[]);
00065
00066
00076 int
00077 xsh_parameter_get_default_flag(const cpl_parameter* p) {
00078 int flag_gasgano=0;
00079 int flag_norm=0;
00080 int flag=0;
00081 cpl_type type =0;
00082
00083 flag_norm = (cpl_parameter_get_default_flag(p) == 0) ? 1 : 0;
00084 type=cpl_parameter_get_type(p);
00085
00086 switch(type) {
00087 case CPL_TYPE_BOOL:
00088 flag_gasgano = (cpl_parameter_get_default_bool(p) ==
00089 cpl_parameter_get_bool(p)) ? 1:0;
00090 break;
00091 case CPL_TYPE_INT:
00092 flag_gasgano = (cpl_parameter_get_default_int(p) ==
00093 cpl_parameter_get_int(p)) ? 1:0;
00094 break;
00095 case CPL_TYPE_DOUBLE:
00096 flag_gasgano = (cpl_parameter_get_default_double(p) ==
00097 cpl_parameter_get_double(p)) ? 1:0;
00098 break;
00099 case CPL_TYPE_STRING:
00100 flag_gasgano = (cpl_parameter_get_default_string(p) ==
00101 cpl_parameter_get_string(p)) ? 1:0;
00102 break;
00103
00104 default:
00105 xsh_msg_error("type not supported");
00106 }
00107
00108 flag = (flag_gasgano && flag_norm) ? 0 : 1;
00109
00110 return flag;
00111 }
00112
00119 cpl_error_code
00120 xsh_validate_model_cfg(cpl_frame* mod, cpl_frameset* set) {
00121
00122 const char* mod_name=NULL;
00123 const char* raw_name=NULL;
00124 cpl_frame* raw_frame=0;
00125 cpl_propertylist* mod_header=NULL;
00126
00127 double mod_mjd=0;
00128 double raw_mjd=0;
00129
00130 raw_frame=cpl_frameset_get_frame(set,0);
00131
00132 mod_name=cpl_frame_get_filename(mod);
00133 mod_header=cpl_propertylist_load(mod_name,0);
00134 mod_mjd=xsh_pfits_get_mjdobs(mod_header);
00135
00136 raw_name=cpl_frame_get_filename(raw_frame);
00137
00138 check(raw_mjd=xsh_pfits_get_mjdobs(mod_header));
00139
00140 if(raw_mjd < mod_mjd) {
00141
00142 xsh_msg_warning("Raw frame %s has MJD-OBS prior than model cfg frame %s",
00143 raw_name,mod_name);
00144 xsh_msg_warning("The user should use a model cfg frame corresponding to a more recent period");
00145 }
00146
00147 cleanup:
00148 return cpl_error_get_code();
00149
00150 }
00151
00157 cpl_frameset*
00158 xsh_frameset_ext_table_frames(cpl_frameset* set) {
00159 cpl_frameset* result=NULL;
00160 int nset=0;
00161 int i=0;
00162 cpl_frame* frm=NULL;
00163 cpl_propertylist* plist=NULL;
00164 const char* name=NULL;
00165 int naxis=0;
00166
00167 check(nset=cpl_frameset_get_size(set));
00168 result=cpl_frameset_new();
00169 for(i=0;i<nset;i++) {
00170 check(frm=cpl_frameset_get_frame(set,i));
00171 check(name=cpl_frame_get_filename(frm));
00172 check(plist=cpl_propertylist_load(name,0));
00173 check(naxis=xsh_pfits_get_naxis(plist));
00174 if(naxis==0) {
00175 check(cpl_frameset_insert(result,cpl_frame_duplicate(frm)));
00176 }
00177 xsh_free_propertylist(&plist);
00178 }
00179
00180 cleanup:
00181
00182 return result;
00183 }
00184
00185
00195
00196 int xsh_dfs_files_dont_exist(cpl_frameset *frameset)
00197 {
00198 const char *func = "dfs_files_dont_exist";
00199 cpl_frame *frame;
00200
00201
00202 if (frameset == NULL) {
00203 cpl_error_set(func, CPL_ERROR_NULL_INPUT);
00204 return 1;
00205 }
00206
00207 if (cpl_frameset_is_empty(frameset)) {
00208 return 0;
00209 }
00210
00211 frame = cpl_frameset_get_first(frameset);
00212
00213 while (frame) {
00214 if (access(cpl_frame_get_filename(frame), F_OK)) {
00215 cpl_msg_error(func, "File %s (%s) was not found",
00216 cpl_frame_get_filename(frame),
00217 cpl_frame_get_tag(frame));
00218 cpl_error_set(func, CPL_ERROR_FILE_NOT_FOUND);
00219 }
00220
00221 frame = cpl_frameset_get_next(frameset);
00222 }
00223
00224 if (cpl_error_get_code())
00225 return 1;
00226
00227 return 0;
00228 }
00229
00235 cpl_frameset*
00236 xsh_frameset_ext_image_frames(cpl_frameset* set) {
00237 cpl_frameset* result=NULL;
00238 int nset=0;
00239 int i=0;
00240 cpl_frame* frm=NULL;
00241 cpl_propertylist* plist=NULL;
00242 const char* name=NULL;
00243 int naxis=0;
00244
00245 check(nset=cpl_frameset_get_size(set));
00246 result=cpl_frameset_new();
00247 for(i=0;i<nset;i++) {
00248 check(frm=cpl_frameset_get_frame(set,i));
00249 check(name=cpl_frame_get_filename(frm));
00250 check(plist=cpl_propertylist_load(name,0));
00251 check(naxis=xsh_pfits_get_naxis(plist));
00252 if(naxis==2) {
00253 check(cpl_frameset_insert(result,cpl_frame_duplicate(frm)));
00254 }
00255 xsh_free_propertylist(&plist);
00256 }
00257
00258 cleanup:
00259
00260 return result;
00261 }
00262
00268 cpl_frameset*
00269 xsh_frameset_drl_frames(cpl_frameset* set) {
00270 cpl_frameset* result=NULL;
00271 int nset=0;
00272 int i=0;
00273 cpl_frame* frm=NULL;
00274 cpl_propertylist* plist=NULL;
00275 const char* name=NULL;
00276 int naxis=0;
00277
00278 check(nset=cpl_frameset_get_size(set));
00279 result=cpl_frameset_new();
00280 for(i=0;i<nset;i++) {
00281 check(frm=cpl_frameset_get_frame(set,i));
00282 check(name=cpl_frame_get_filename(frm));
00283 check(plist=cpl_propertylist_load(name,0));
00284 check(naxis=xsh_pfits_get_naxis(plist));
00285 if(naxis==0) {
00286 check(cpl_frameset_insert(result,cpl_frame_duplicate(frm)));
00287 }
00288 xsh_free_propertylist(&plist);
00289 }
00290
00291 cleanup:
00292
00293 return result;
00294 }
00301 cpl_error_code
00302 xsh_ensure_raws_input_offset_recipe_is_proper(cpl_frameset** raws,
00303 xsh_instrument* instrument)
00304 {
00305 int nraws=0;
00306 cpl_frameset* obj=NULL;
00307 cpl_frameset* sky=NULL;
00308 const char * obj_tag=NULL;
00309 const char * sky_tag=NULL;
00310 int nobj=0;
00311 int nsky=0;
00312 int i=0;
00313 int ndif=0;
00314 cpl_frame* frm=NULL;
00315
00316 check(nraws=cpl_frameset_get_size(*raws));
00317
00318 assure(nraws>=2, CPL_ERROR_ILLEGAL_INPUT, "Too few input frames. At least one OBJ and a SKY frame are required" );
00319
00320 if(xsh_instrument_get_mode(instrument) == XSH_MODE_IFU) {
00321 obj_tag = XSH_GET_TAG_FROM_ARM( XSH_OBJECT_IFU_OFFSET,instrument);
00322 } else {
00323 obj_tag = XSH_GET_TAG_FROM_ARM( XSH_OBJECT_SLIT_OFFSET,instrument);
00324 }
00325
00326 check(obj=xsh_frameset_extract(*raws,obj_tag));
00327 nobj=cpl_frameset_get_size(obj);
00328 if(nobj==0) {
00329 if(xsh_instrument_get_mode(instrument) == XSH_MODE_IFU) {
00330 obj_tag = XSH_GET_TAG_FROM_ARM( XSH_STD_FLUX_IFU_OFFSET,instrument);
00331 } else {
00332 obj_tag = XSH_GET_TAG_FROM_ARM( XSH_STD_FLUX_SLIT_OFFSET,instrument);
00333 }
00334 xsh_free_frameset(&obj);
00335 check(obj=xsh_frameset_extract(*raws,obj_tag));
00336 nobj=cpl_frameset_get_size(obj);
00337 }
00338
00339 if(xsh_instrument_get_mode(instrument) == XSH_MODE_IFU) {
00340 sky_tag = XSH_GET_TAG_FROM_ARM( XSH_SKY_IFU,instrument);
00341 } else {
00342 sky_tag = XSH_GET_TAG_FROM_ARM( XSH_SKY_SLIT,instrument);
00343 }
00344 xsh_free_frameset(&sky);
00345 check(sky=xsh_frameset_extract(*raws,sky_tag));
00346
00347
00348
00349 nsky=cpl_frameset_get_size(sky);
00350
00351 assure(nobj>0, CPL_ERROR_ILLEGAL_INPUT, "Too few input obj frames. At least a OBJ frame is required" );
00352
00353 assure(nsky>0, CPL_ERROR_ILLEGAL_INPUT, "Too few input sky frames. At least a SKY frame is required" );
00354
00355 if(nobj>nsky) {
00356 xsh_msg("case nobj> nsky");
00357 ndif=nobj-nsky;
00358 for(i=0;i<ndif;i++) {
00359 check(frm=cpl_frameset_get_frame(obj,nobj-i-1));
00360 check(cpl_frameset_erase_frame(obj,frm));
00361 }
00362 } else if(nsky>nobj) {
00363 xsh_msg("case nsky> nobj");
00364 ndif=nsky-nobj;
00365 for(i=0;i<ndif;i++) {
00366 check(frm=cpl_frameset_get_frame(sky,nsky-i-1));
00367 check(cpl_frameset_erase_frame(sky,frm));
00368 }
00369 } else {
00370 ndif=nsky-nobj;
00371 xsh_free_frameset(&obj);
00372 xsh_free_frameset(&sky);
00373 return CPL_ERROR_NONE;
00374
00375 }
00376 xsh_free_frameset(raws);
00377 check(*raws=cpl_frameset_duplicate(obj));
00378 check(xsh_frameset_merge(*raws,sky));
00379
00380 cleanup:
00381 xsh_free_frameset(&obj);
00382 xsh_free_frameset(&sky);
00383
00384 return cpl_error_get_code();
00385
00386 }
00387
00388
00395 static double
00396 xsh_get_offsety(cpl_propertylist* plist)
00397 {
00398
00399 double offsety=0;
00400 double ra_off=0;
00401 double dec_off=0;
00402 double posang=0;
00403
00404 if(cpl_propertylist_has(plist,XSH_NOD_CUMULATIVE_OFFSETY)) {
00405 offsety=xsh_pfits_get_cumoffsety(plist);
00406 } else {
00407 ra_off=xsh_pfits_get_ra_cumoffset(plist);
00408 dec_off=xsh_pfits_get_dec_cumoffset(plist);
00409 posang = xsh_pfits_get_posang(plist);
00410 posang = posang/180.0* M_PI;
00411
00412
00413
00414
00415 offsety=(cos(-posang)*dec_off+
00416 sin(-posang)*ra_off);
00417 xsh_msg("ra_off=%f,dec_off=%f,offsety=%f,posang=%f",
00418 ra_off,dec_off,offsety,posang);
00419 }
00420
00421 return offsety;
00422
00423 }
00424
00432 cpl_frameset*
00433 xsh_frameset_extract_offsety_matches(cpl_frameset* raws,const double offset)
00434 {
00435 cpl_frame* frm=NULL;
00436 cpl_frameset* result=NULL;
00437 cpl_propertylist* plist=NULL;
00438 double offsety=0;
00439 const char* name=NULL;
00440 int nraw=0;
00441 int i=0;
00442
00443 XSH_ASSURE_NOT_NULL_MSG(raws,"null input frameset");
00444 nraw=cpl_frameset_get_size(raws);
00445 result=cpl_frameset_new();
00446 for(i=0;i<nraw;i++) {
00447 frm=cpl_frameset_get_frame(raws,i);
00448 name=cpl_frame_get_filename(frm);
00449 plist=cpl_propertylist_load(name,0);
00450 offsety=xsh_get_offsety(plist);
00451
00452 if(fabs(offsety-offset)<1.E-8) {
00453 cpl_frameset_insert(result,cpl_frame_duplicate(frm));
00454 }
00455 xsh_free_propertylist(&plist);
00456 }
00457
00458 cleanup:
00459 xsh_free_propertylist(&plist);
00460
00461 return result;
00462
00463 }
00464
00465
00466
00474 cpl_frameset*
00475 xsh_frameset_extract_offsety_mismatches(cpl_frameset* raws,const double offset)
00476 {
00477 cpl_frame* frm=NULL;
00478 cpl_frameset* result=NULL;
00479 cpl_propertylist* plist=NULL;
00480 double offsety=0;
00481 const char* name=NULL;
00482 int nraw=0;
00483 int i=0;
00484
00485 double ra_off=0;
00486 double dec_off=0;
00487 double posang=0;
00488
00489 XSH_ASSURE_NOT_NULL_MSG(raws,"null input frameset");
00490 nraw=cpl_frameset_get_size(raws);
00491 result=cpl_frameset_new();
00492 for(i=0;i<nraw;i++) {
00493 frm=cpl_frameset_get_frame(raws,i);
00494 name=cpl_frame_get_filename(frm);
00495 plist=cpl_propertylist_load(name,0);
00496 if(cpl_propertylist_has(plist,XSH_NOD_CUMULATIVE_OFFSETY)) {
00497 offsety=xsh_pfits_get_cumoffsety(plist);
00498 } else {
00499 ra_off=xsh_pfits_get_ra_cumoffset(plist);
00500 dec_off=xsh_pfits_get_dec_cumoffset(plist);
00501 posang = xsh_pfits_get_posang(plist);
00502 posang = posang/180.0* M_PI;
00503
00504
00505
00506
00507 offsety=(cos(-posang)*dec_off+
00508 sin(-posang)*ra_off);
00509 xsh_msg("ra_off=%f,dec_off=%f,offsety=%f,posang=%f",
00510 ra_off,dec_off,offsety,posang);
00511 }
00512 if(offsety!=offset) {
00513 cpl_frameset_insert(result,cpl_frame_duplicate(frm));
00514 }
00515 xsh_free_propertylist(&plist);
00516 }
00517
00518 cleanup:
00519 xsh_free_propertylist(&plist);
00520
00521 return result;
00522
00523 }
00524
00531 cpl_frameset*
00532 xsh_extract_nod_pairs(cpl_frameset* raws,
00533 cpl_vector* offset)
00534 {
00535 int nraws=0;
00536 cpl_frameset* set_a=NULL;
00537 cpl_frameset* set_b=NULL;
00538 cpl_frameset* result=NULL;
00539 cpl_propertylist* plist=NULL;
00540 double offsety_a=0;
00541
00542
00543 int na=0;
00544 int nb=0;
00545 int i=0;
00546 int j=0;
00547 int k=0;
00548 cpl_frame* frm_a=NULL;
00549 cpl_frame* frm_b=NULL;
00550 cpl_frame* frm_tmp=NULL;
00551 double mjd_obs_a=0;
00552 double mjd_obs_b=0;
00553 double mjd_obs_tmp=0;
00554 const char* name=NULL;
00555 int noff=0;
00556 double mjd_obs_ref=-999999.;
00557 XSH_ASSURE_NOT_NULL_MSG(raws,"null input frameset");
00558
00559 check(nraws=cpl_frameset_get_size(raws));
00560 xsh_msg("nraws=%d",nraws);
00561 assure(nraws>=2, CPL_ERROR_ILLEGAL_INPUT, "Too few input frames. At least two NOD positions are required" );
00562
00563 noff=cpl_vector_get_size(offset);
00564 result=cpl_frameset_new();
00565 for(i=0;i<noff;i++) {
00566 offsety_a=cpl_vector_get(offset,i);
00567 xsh_msg("offsety_a=%f",offsety_a);
00568 xsh_free_frameset(&set_a);
00569 xsh_free_frameset(&set_b);
00570 check(set_a=xsh_frameset_extract_offsety_matches(raws,offsety_a));
00571 check(set_b=xsh_frameset_extract_offsety_mismatches(raws,offsety_a));
00572
00573 na=cpl_frameset_get_size(set_a);
00574 nb=cpl_frameset_get_size(set_b);
00575 xsh_msg("na=%d nb=%d",na,nb);
00576 for(k=0;k<na;k++) {
00577
00578 check(frm_a=cpl_frameset_get_frame(set_a,k));
00579 check(name=cpl_frame_get_filename(frm_a));
00580 check(plist=cpl_propertylist_load(name,0));
00581 check(mjd_obs_a=xsh_pfits_get_mjdobs(plist));
00582 xsh_free_propertylist(&plist);
00583
00584
00585
00586 mjd_obs_b=mjd_obs_ref;
00587 for(j=0;j<nb;j++) {
00588
00589 check(frm_tmp=cpl_frameset_get_frame(set_b,j));
00590 check(name=cpl_frame_get_filename(frm_tmp));
00591 check(plist=cpl_propertylist_load(name,0));
00592 check(mjd_obs_tmp=xsh_pfits_get_mjdobs(plist));
00593
00594 if(fabs(mjd_obs_tmp-mjd_obs_a) < fabs(mjd_obs_b-mjd_obs_a)) {
00595 mjd_obs_b=mjd_obs_tmp;
00596 frm_b=frm_tmp;
00597 }
00598 }
00599
00600
00601 cpl_frameset_erase_frame(raws,frm_a);
00602
00603
00604
00605
00606
00607
00608
00609 cpl_frameset_erase_frame(raws,frm_b);
00610 cpl_frameset_insert(result,cpl_frame_duplicate(frm_a));
00611 cpl_frameset_insert(result,cpl_frame_duplicate(frm_b));
00612 xsh_free_frameset(&set_a);
00613 xsh_free_frameset(&set_b);
00614 check(set_a=xsh_frameset_extract_offsety_matches(raws,offsety_a));
00615 check(set_b=xsh_frameset_extract_offsety_mismatches(raws,offsety_a));
00616 na=cpl_frameset_get_size(set_a);
00617 nb=cpl_frameset_get_size(set_b);
00618
00619 xsh_msg("check again na=%d nb=%d",na,nb);
00620
00621 }
00622 xsh_msg("ok0 i=%d",i);
00623
00624 }
00625
00626 cleanup:
00627 xsh_free_frameset(&set_a);
00628 xsh_free_frameset(&set_b);
00629 xsh_free_propertylist(&plist);
00630
00631
00632 return result;
00633
00634 }
00635
00636
00637
00638
00645 cpl_frameset*
00646 xsh_extract_obj_and_sky_pairs(cpl_frameset* raws, xsh_instrument* instrument)
00647 {
00648 int nraws=0;
00649 cpl_frameset* obj=NULL;
00650 cpl_frameset* sky=NULL;
00651 cpl_frameset* result=NULL;
00652 cpl_propertylist* plist=NULL;
00653
00654 const char * obj_tag=NULL;
00655 const char * sky_tag=NULL;
00656 int nobj=0;
00657 int nsky=0;
00658 int i=0;
00659 int j=0;
00660 cpl_frame* frm_obj=NULL;
00661 cpl_frame* frm_sky=NULL;
00662 cpl_frame* frm_tmp=NULL;
00663 double mjdobs_obj=0;
00664 double mjdobs_sky=0;
00665 double mjdobs_tmp=0;
00666 const char* name=NULL;
00667
00668 check(nraws=cpl_frameset_get_size(raws));
00669 xsh_msg("nraws=%d",nraws);
00670 assure(nraws>=2, CPL_ERROR_ILLEGAL_INPUT, "Too few input frames. At least one OBJ and a SKY frame are required" );
00671 if(xsh_instrument_get_mode(instrument) == XSH_MODE_IFU) {
00672 obj_tag = XSH_GET_TAG_FROM_ARM( XSH_OBJECT_IFU_OFFSET,instrument);
00673 sky_tag = XSH_GET_TAG_FROM_ARM( XSH_SKY_IFU,instrument);
00674 } else {
00675 obj_tag = XSH_GET_TAG_FROM_ARM( XSH_OBJECT_SLIT_OFFSET,instrument);
00676 sky_tag = XSH_GET_TAG_FROM_ARM( XSH_SKY_SLIT,instrument);
00677 }
00678
00679 check(obj=xsh_frameset_extract(raws,obj_tag));
00680 check(sky=xsh_frameset_extract(raws,sky_tag));
00681
00682 nobj=cpl_frameset_get_size(obj);
00683 nsky=cpl_frameset_get_size(sky);
00684
00685 assure(nobj>0, CPL_ERROR_ILLEGAL_INPUT, "Too few input obj frames. At least a OBJ frame is required" );
00686
00687 assure(nsky>0, CPL_ERROR_ILLEGAL_INPUT, "Too few input sky frames. At least a SKY frame is required" );
00688
00689 result=cpl_frameset_new();
00690 for(i=0;i<nobj;i++) {
00691 check(frm_obj=cpl_frameset_get_frame(obj,i));
00692 check(name=cpl_frame_get_filename(frm_obj));
00693 check(plist=cpl_propertylist_load(name,0));
00694 check(mjdobs_obj=xsh_pfits_get_mjdobs(plist));
00695 xsh_free_propertylist(&plist);
00696
00697
00698 check(frm_sky=cpl_frameset_get_frame(sky,0));
00699 check(name=cpl_frame_get_filename(frm_sky));
00700 check(plist=cpl_propertylist_load(name,0));
00701 check(mjdobs_sky=xsh_pfits_get_mjdobs(plist));
00702 xsh_free_propertylist(&plist);
00703 cpl_frameset_insert(result,cpl_frame_duplicate(frm_obj));
00704
00705 for(j=1;j<nsky;j++) {
00706 check(frm_tmp=cpl_frameset_get_frame(sky,j));
00707 check(name=cpl_frame_get_filename(frm_tmp));
00708 check(plist=cpl_propertylist_load(name,0));
00709 check(mjdobs_tmp=xsh_pfits_get_mjdobs(plist));
00710
00711 if(fabs(mjdobs_tmp-mjdobs_obj) < fabs(mjdobs_sky-mjdobs_obj)) {
00712 mjdobs_sky=mjdobs_tmp;
00713 frm_sky=frm_tmp;
00714 }
00715 }
00716 cpl_frameset_insert(result,cpl_frame_duplicate(frm_sky));
00717 }
00718
00719
00720 cleanup:
00721 xsh_free_frameset(&obj);
00722 xsh_free_frameset(&sky);
00723 xsh_free_propertylist(&plist);
00724
00725 return result;
00726
00727 }
00728
00734 cpl_error_code
00735 xsh_ensure_raws_number_is_even(cpl_frameset* raws)
00736 {
00737 int nraws=0;
00738 cpl_frame* frame1=NULL;
00739 cpl_frame* frame2=NULL;
00740 cpl_frame* frameN=NULL;
00741 cpl_propertylist* plist1=NULL;
00742 cpl_propertylist* plist2=NULL;
00743 cpl_propertylist* plistN=NULL;
00744 const char* name1=NULL;
00745 const char* name2=NULL;
00746 const char* nameN=NULL;
00747 double yshift1=0;
00748 double yshift2=0;
00749 double yshiftN=0;
00750
00751
00752 check(nraws=cpl_frameset_get_size(raws));
00753 if ( (nraws % 2) != 0 ) {
00754 xsh_msg_warning("odd number of frames: nraws=%d",nraws);
00755 check(frame1=cpl_frameset_get_frame(raws,0));
00756 check(frame2=cpl_frameset_get_frame(raws,1));
00757 check(frameN=cpl_frameset_get_frame(raws,nraws-1));
00758 check(name1=cpl_frame_get_filename(frame1));
00759 check(name2=cpl_frame_get_filename(frame2));
00760 check(nameN=cpl_frame_get_filename(frameN));
00761 check(plist1=cpl_propertylist_load(name1,0));
00762 check(plist2=cpl_propertylist_load(name2,0));
00763 check(plistN=cpl_propertylist_load(nameN,0));
00764 check(yshift1=xsh_get_offsety(plist1));
00765 check(yshift2=xsh_get_offsety(plist2));
00766 check(yshiftN=xsh_get_offsety(plistN));
00767
00768
00769
00770
00771
00772 if(yshift1 == yshiftN) {
00773 xsh_msg_warning("yshift(Frame1)==yshift(FrameN)");
00774 if ( fabs(yshift1-yshift2) <= DBL_MIN ) {
00775 xsh_msg_warning("yshift(Frame1)==yshift(Frame2)");
00776 xsh_msg_warning("Remove last from list. Frame %s",
00777 cpl_frame_get_filename(frameN));
00778 cpl_frameset_erase_frame(raws,frameN);
00779 } else {
00780 xsh_msg_warning("yshift(Frame1)!=yshift(Frame2)");
00781 xsh_msg_warning("Remove first from list. Frame %s",
00782 cpl_frame_get_filename(frameN));
00783 cpl_frameset_erase_frame(raws,frame1);
00784 }
00785 } else {
00786 xsh_msg_warning("yshift(Frame1)!=yshift(FrameN)");
00787 if (fabs(yshift1 - yshift2) <= DBL_MIN) {
00788 xsh_msg_warning("yshift(Frame1)==yshift(Frame2)");
00789 xsh_msg_warning("Remove last from list. Frame %s",
00790 cpl_frame_get_filename(frame1));
00791 cpl_frameset_erase_frame(raws,frame1);
00792 } else {
00793 xsh_msg_warning("yshift(Frame1)!=yshift(Frame2)");
00794 xsh_msg_warning("Remove first from list. Frame %s",
00795 cpl_frame_get_filename(frameN));
00796 cpl_frameset_erase_frame(raws,frameN);
00797 }
00798 }
00799 }
00800
00801 cleanup:
00802 xsh_free_propertylist(&plist1);
00803 xsh_free_propertylist(&plist2);
00804 xsh_free_propertylist(&plistN);
00805
00806 return cpl_error_get_code();
00807
00808 }
00814 int
00815 xsh_print_rec_status(const int val) {
00816 if(cpl_error_get_code() != CPL_ERROR_NONE) {
00817 xsh_msg_error("Recipe status at %d",val);
00818 xsh_msg_error("%s",(const char*) cpl_error_get_message());
00819 xsh_msg_error("%s",(const char*) cpl_error_get_where());
00820 return -1;
00821 }
00822 return 0;
00823 }
00824
00825
00837 void
00838 xsh_frame_config(const char* fname,
00839 const char* tag,
00840 cpl_frame_type type,
00841 cpl_frame_group group,
00842 cpl_frame_level level,
00843 cpl_frame** frame)
00844 {
00845
00846 check(cpl_frame_set_filename(*frame,fname));
00847 check(cpl_frame_set_tag(*frame,tag));
00848 check(cpl_frame_set_type(*frame,type));
00849 check(cpl_frame_set_group(*frame,group));
00850 check(cpl_frame_set_level(*frame,level));
00851
00852 cleanup:
00853
00854 return;
00855
00856 }
00867 cpl_frame*
00868 xsh_frame_product(const char* fname, const char* tag, cpl_frame_type type,
00869 cpl_frame_group group,cpl_frame_level level)
00870 {
00871 cpl_frame* frame=NULL;
00872 check(frame=cpl_frame_new());
00873
00874 check(xsh_frame_config(fname,tag,type,group,level,&frame));
00875
00876 return frame;
00877
00878 cleanup:
00879 xsh_free_frame(&frame);
00880
00881 return NULL;
00882 }
00883
00894
00895
00896
00897 int xsh_file_exists(const char * filename)
00898 {
00899 int exists=0;
00900 FILE* fo=NULL;
00901 if ((fo=fopen(filename,"r"))==NULL) {
00902 exists=0;
00903 } else {
00904 exists=1;
00905 }
00906 if(fo != NULL ) {
00907 fclose(fo);
00908 }
00909 return exists;
00910 }
00911
00912
00919
00920 cpl_frameset *
00921 xsh_frameset_extract(const cpl_frameset *frames,
00922 const char *tag)
00923 {
00924 cpl_frameset *subset = NULL;
00925 const cpl_frame *f;
00926
00927
00928
00929 assure( frames != NULL, CPL_ERROR_ILLEGAL_INPUT, "Null frameset" );
00930 assure( tag != NULL, CPL_ERROR_ILLEGAL_INPUT, "Null tag" );
00931
00932 subset = cpl_frameset_new();
00933
00934 for (f = cpl_frameset_find_const(frames, tag);
00935 f != NULL;
00936 f = cpl_frameset_find_const(frames, NULL)) {
00937
00938 cpl_frameset_insert(subset, cpl_frame_duplicate(f));
00939 }
00940 cleanup:
00941 return subset;
00942 }
00943
00950
00951 cpl_error_code
00952 xsh_frameset_merge(cpl_frameset * set1, cpl_frameset* set2)
00953 {
00954
00955 cpl_frame* frm_tmp=NULL;
00956 cpl_frame* frm_dup=NULL;
00957
00958 passure(set1 != NULL, "Wrong input set");
00959
00960 check(frm_tmp = cpl_frameset_get_first(set2));
00961 while (frm_tmp != NULL)
00962 {
00963 frm_dup=cpl_frame_duplicate(frm_tmp);
00964 cpl_frameset_insert(set1,frm_dup);
00965 frm_tmp = cpl_frameset_get_next(set2);
00966 }
00967
00968 cleanup:
00969 return cpl_error_get_code();
00970 }
00971
00972
00979
00980 xsh_instrument* xsh_dfs_set_groups (cpl_frameset * set)
00981 {
00982 cpl_frame * cur_frame = NULL;
00983 xsh_instrument* instrument = NULL;
00984
00985
00986 assure (set != NULL, CPL_ERROR_NULL_INPUT, "Null frame set");
00987 assure (!cpl_frameset_is_empty(set),CPL_ERROR_ILLEGAL_INPUT,
00988 "Empty frame set");
00989
00990
00991 instrument = xsh_instrument_new();
00992
00993
00994 for (cur_frame = cpl_frameset_get_first (set);
00995 cur_frame != NULL;
00996 cur_frame = cpl_frameset_get_next (set)) {
00997 const char *tag = NULL;
00998
00999 check(tag = cpl_frame_get_tag (cur_frame));
01000
01001
01002
01003 check(cpl_frame_set_group (cur_frame, CPL_FRAME_GROUP_NONE));
01004
01005
01006 if (XSH_IS_RAW (tag)) {
01007 check(cpl_frame_set_group (cur_frame, CPL_FRAME_GROUP_RAW));
01008 }
01009
01010 else if (XSH_IS_CALIB (tag)) {
01011 check(cpl_frame_set_group (cur_frame, CPL_FRAME_GROUP_CALIB));
01012 }
01013
01014 else {
01015 xsh_msg_error("Unrecognized frame tag '%s'",tag);
01016 check(cpl_error_set(cpl_func,CPL_ERROR_ILLEGAL_INPUT ));
01017
01018
01019 }
01020
01021
01022
01023 check_msg(xsh_instrument_parse_tag(instrument,tag),
01024 "invalid tag %s in file %s",
01025 tag, cpl_frame_get_filename (cur_frame));
01026 }
01027
01028 assure(xsh_instrument_get_arm(instrument)!=XSH_ARM_UNDEFINED,
01029 CPL_ERROR_TYPE_MISMATCH,"Arm is undefined");
01030 xsh_instrument_get_config( instrument ) ;
01031 xsh_msg( "Arm %s, Mode %s Nb Orders %d, min: %d, max: %d",
01032 xsh_instrument_arm_tostring(instrument),
01033 xsh_instrument_mode_tostring( instrument),
01034 instrument->config->orders, instrument->config->order_min,
01035 instrument->config->order_max ) ;
01036 cleanup:
01037 if (cpl_error_get_code () != CPL_ERROR_NONE){
01038 xsh_instrument_free(&instrument);
01039 instrument = NULL;
01040 }
01041 return instrument;
01042 }
01043
01050
01051 cpl_error_code
01052 xsh_dfs_extract_raw_frames (cpl_frameset * input, cpl_frameset * raws)
01053 {
01054 cpl_frame *cur_frame = NULL;
01055
01056
01057 for (cur_frame = cpl_frameset_get_first (input);
01058 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01059
01060 if (cpl_frame_get_group (cur_frame) == CPL_FRAME_GROUP_RAW) {
01061 cpl_frameset_insert (raws, cpl_frame_duplicate(cur_frame));
01062 }
01063 }
01064
01065 return cpl_error_get_code();
01066
01067 }
01068
01075
01076 cpl_error_code
01077 xsh_dfs_extract_calib_frames (cpl_frameset * input, cpl_frameset * calib)
01078 {
01079 cpl_frame *cur_frame = NULL;
01080
01081
01082 for (cur_frame = cpl_frameset_get_first (input);
01083 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01084
01085 if (cpl_frame_get_group (cur_frame) == CPL_FRAME_GROUP_CALIB) {
01086 cpl_frameset_insert (calib, cpl_frame_duplicate(cur_frame));
01087 }
01088 }
01089
01090 return cpl_error_get_code();
01091
01092 }
01093
01094
01101
01102 cpl_error_code
01103 xsh_dfs_extract_pro_frames (cpl_frameset * input, cpl_frameset * pros)
01104 {
01105 cpl_frame *cur_frame = NULL;
01106 XSH_ASSURE_NOT_NULL_MSG(pros,"Null pros frameset. Alllocated it outside!");
01107
01108 for (cur_frame = cpl_frameset_get_first (input);
01109 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01110
01111 if (cpl_frame_get_group (cur_frame) == CPL_FRAME_GROUP_PRODUCT) {
01112 cpl_frameset_insert (pros, cpl_frame_duplicate(cur_frame));
01113 }
01114 }
01115 cleanup:
01116 return cpl_error_get_code();
01117
01118 }
01119
01120
01127
01128 void
01129 xsh_dfs_split_in_group (cpl_frameset * input, cpl_frameset * raws,
01130 cpl_frameset * calib)
01131 {
01132 cpl_frame *cur_frame = NULL;
01133
01134
01135 for (cur_frame = cpl_frameset_get_first (input);
01136 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01137
01138 if (cpl_frame_get_group (cur_frame) == CPL_FRAME_GROUP_RAW) {
01139
01140 cpl_frameset_insert (raws, cpl_frame_duplicate(cur_frame));
01141 }
01142
01143 else if (cpl_frame_get_group (cur_frame) == CPL_FRAME_GROUP_CALIB) {
01144 cpl_frameset_insert (calib, cpl_frame_duplicate(cur_frame));
01145 }
01146
01147 else {
01148 xsh_msg_error ("Unrecognized group for frame %s",
01149 cpl_frame_get_filename (cur_frame));
01150 }
01151 }
01152 }
01153
01154
01155
01163
01164 void
01165 xsh_dfs_split_qth_d2(cpl_frameset * input,
01166 cpl_frameset** qth,
01167 cpl_frameset** d2)
01168 {
01169 cpl_frame* cur_frame = NULL;
01170 cpl_frame* temp =NULL;
01171
01172
01173 XSH_ASSURE_NOT_NULL( input);
01174 XSH_ASSURE_NOT_NULL( qth);
01175 XSH_ASSURE_NOT_NULL( d2);
01176
01177
01178 XSH_NEW_FRAMESET( *qth);
01179 XSH_NEW_FRAMESET( *d2);
01180
01181
01182 for (cur_frame = cpl_frameset_get_first (input);
01183 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01184 const char* tag = NULL;
01185
01186 check(tag = cpl_frame_get_tag(cur_frame));
01187
01188 if ( strstr(tag,"D2") != NULL) {
01189 check(temp = cpl_frame_duplicate(cur_frame));
01190 check(cpl_frameset_insert(*d2, temp));
01191 }
01192
01193 else if ( strstr(tag, "QTH") != NULL) {
01194 check(temp = cpl_frame_duplicate(cur_frame));
01195 check(cpl_frameset_insert(*qth, temp));
01196 }
01197
01198 else {
01199 xsh_msg_error ("Invalid tag %s for frame %s",tag,
01200 cpl_frame_get_filename (cur_frame));
01201 }
01202 }
01203
01204 cleanup:
01205 if (cpl_error_get_code() != CPL_ERROR_NONE){
01206 xsh_free_frame(&temp);
01207 xsh_free_frameset(d2);
01208 xsh_free_frameset(qth);
01209 }
01210 return;
01211 }
01212
01219
01220 void xsh_dfs_split_nir(cpl_frameset * input, cpl_frameset** on,
01221 cpl_frameset** off)
01222 {
01223 cpl_frame* cur_frame = NULL;
01224 cpl_frame* temp =NULL;
01225
01226
01227 XSH_ASSURE_NOT_NULL(input);
01228 XSH_ASSURE_NOT_NULL(on);
01229 XSH_ASSURE_NOT_NULL(off);
01230
01231
01232 XSH_NEW_FRAMESET(*on);
01233 XSH_NEW_FRAMESET(*off);
01234
01235
01236 for (cur_frame = cpl_frameset_get_first (input);
01237 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01238 const char* tag = NULL;
01239
01240 check(tag = cpl_frame_get_tag(cur_frame));
01241
01242 if ( strstr(tag,"ON") != NULL) {
01243 check(temp = cpl_frame_duplicate(cur_frame));
01244 check(cpl_frameset_insert(*on, temp));
01245 }
01246
01247 else if ( strstr(tag, "OFF") != NULL) {
01248 check(temp = cpl_frame_duplicate(cur_frame));
01249 check(cpl_frameset_insert(*off, temp));
01250 }
01251
01252 else {
01253 xsh_msg_error ("Invalid tag %s for frame %s",tag,
01254 cpl_frame_get_filename (cur_frame));
01255 }
01256 }
01257
01258 cleanup:
01259 if (cpl_error_get_code() != CPL_ERROR_NONE){
01260 xsh_free_frame(&temp);
01261 xsh_free_frameset(on);
01262 xsh_free_frameset(off);
01263 }
01264 return;
01265 }
01266
01267
01278
01279 int
01280 xsh_dfs_split_offset(cpl_frameset * input,
01281 const char * object_tag,
01282 const char * sky_tag,
01283 cpl_frameset ** object,
01284 cpl_frameset ** sky)
01285 {
01286 cpl_frame* cur_frame = NULL;
01287 cpl_frame* temp =NULL;
01288 int nobj = 0, nsky = 0 ;
01289
01290
01291 XSH_ASSURE_NOT_NULL(input);
01292 XSH_ASSURE_NOT_NULL(object);
01293 XSH_ASSURE_NOT_NULL(sky);
01294
01295
01296 *object=cpl_frameset_new();
01297 *sky=cpl_frameset_new();
01298
01299
01300 for (cur_frame = cpl_frameset_get_first (input);
01301 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01302 const char* tag = NULL;
01303
01304 check(tag = cpl_frame_get_tag(cur_frame));
01305
01306 xsh_msg_dbg_medium( "Tag: %s", tag ) ;
01307
01308 if ( strstr(tag, object_tag) != NULL) {
01309 check(temp = cpl_frame_duplicate(cur_frame));
01310 check(cpl_frameset_insert(*object, temp));
01311 nobj++ ;
01312 }
01313
01314 else if ( strstr(tag, sky_tag) != NULL) {
01315 check(temp = cpl_frame_duplicate(cur_frame));
01316 check(cpl_frameset_insert(*sky, temp));
01317 nsky++ ;
01318 }
01319
01320 else {
01321 xsh_msg_error ("Invalid tag %s for frame %s",tag,
01322 cpl_frame_get_filename (cur_frame));
01323 }
01324
01325 }
01326
01327 xsh_msg_dbg_medium( "Nobj: %d, Nsky: %d", nobj, nsky ) ;
01328 XSH_ASSURE_NOT_ILLEGAL( nobj == nsky ) ;
01329
01330 cleanup:
01331
01332 if (cpl_error_get_code() != CPL_ERROR_NONE){
01333 xsh_print_rec_status(0);
01334 xsh_free_frame(&temp);
01335 return 0 ;
01336 }
01337 return nobj ;
01338 }
01339
01340
01341
01342
01349 static const char*
01350 xsh_create_final_tag(const char* pcatg_prefix, xsh_instrument* inst,
01351 const cpl_frame* frame)
01352 {
01353
01354
01355 const char* pro_catg=NULL;
01356
01357 if(pcatg_prefix==NULL) {
01358 pro_catg = cpl_frame_get_tag (frame);
01359 } else {
01360 pro_catg=xsh_stringcat_any(pcatg_prefix,"_",xsh_instrument_arm_tostring(inst),"" ) ;
01361 }
01362
01363 return pro_catg;
01364 }
01365
01371 static char*
01372 xsh_create_final_name(const char* final_prefix)
01373 {
01374 char* final_name=NULL;
01375 time_t now ;
01376 char* date = NULL ;
01377 if ( xsh_time_stamp_get() ) {
01378 time( &now ) ;
01379 date = xsh_sdate_utc( &now ) ;
01380 final_name = xsh_stringcat_any( XSH_PRODUCT_PREFIX,
01381 final_prefix, "_", date, ".fits", "" ) ;
01382 } else if ( strstr( final_prefix, ".fits" ) == NULL ) {
01383 final_name=xsh_stringcat_any(XSH_PRODUCT_PREFIX,final_prefix,".fits","");
01384 } else {
01385 final_name=xsh_stringcat_any(XSH_PRODUCT_PREFIX,final_prefix, "" );
01386 }
01387
01388 XSH_FREE(date);
01389
01390 return final_name;
01391 }
01392
01393
01405
01406 static bool
01407 xsh_dfs_tag_check( const char* tag, const char* tag_list[], int size)
01408 {
01409 int i;
01410
01411 for( i=0; i< size; i++){
01412 if ( strstr( tag, tag_list[i])!=NULL){
01413 return true;
01414 }
01415 }
01416 return false;
01417 }
01418
01419
01430
01431 void
01432 xsh_dfs_filter( cpl_frameset * set, const char* tags[], int size){
01433 cpl_frame *cur_frame = NULL;
01434
01435 XSH_ASSURE_NOT_NULL( set);
01436 XSH_ASSURE_NOT_NULL( tags);
01437 XSH_ASSURE_NOT_ILLEGAL( size > 0);
01438
01439
01440 check( cur_frame = cpl_frameset_get_first (set));
01441
01442 while(cur_frame != NULL){
01443 const char* ftag = NULL;
01444
01445 check( ftag = cpl_frame_get_tag( cur_frame));
01446 if (!xsh_dfs_tag_check( ftag, tags, size)){
01447 cpl_frame *del_frame = NULL;
01448
01449 del_frame = cur_frame;
01450 check( cur_frame = cpl_frameset_get_next( set));
01451 check( cpl_frameset_erase_frame( set, del_frame));
01452 }
01453 else{
01454 check(cur_frame = cpl_frameset_get_next (set));
01455 }
01456 }
01457
01458 cleanup:
01459 return;
01460 }
01461
01462
01470
01471 cpl_frameset *
01472 xsh_frameset_extract_pre(cpl_frameset * frameset, const char* prefix)
01473 {
01474 cpl_frameset* set=NULL;
01475 cpl_frame* current=NULL;
01476 cpl_frame* found=NULL;
01477 int sz=0;
01478 int i=0;
01479 char tag[256];
01480 char name[256];
01481
01482 check(sz=cpl_frameset_get_size(frameset));
01483
01484 check(set=cpl_frameset_new());
01485 for(i=0;i<sz;i++) {
01486 check( current = cpl_frameset_get_frame(frameset, i));
01487 sprintf(name, "%s_PRE_%d.fits", prefix, i);
01488 sprintf(tag, "%s_PRE_%d", prefix, i);
01489
01490 if(xsh_file_exists(name) == 1) {
01491 check(found=cpl_frame_duplicate(current));
01492 check( cpl_frame_set_filename(found, name) );
01493 cpl_frameset_insert(set,found);
01494 }
01495
01496 }
01497 cleanup:
01498
01499 return set;
01500
01501 }
01502
01503
01509
01510 cpl_frame *
01511 xsh_find_bpmap (cpl_frameset * set)
01512 {
01513 cpl_frame *cur_frame = NULL;
01514
01515
01516 for (cur_frame = cpl_frameset_get_first (set);
01517 cur_frame != NULL; cur_frame = cpl_frameset_get_next (set)) {
01518 if (strstr (cpl_frame_get_tag (cur_frame), "BADPIXEL_MAP")) {
01519 return cur_frame;
01520 }
01521 }
01522 return NULL;
01523 }
01524
01525
01526
01532
01533 cpl_frame *
01534 xsh_find_master_bpmap (cpl_frameset * set)
01535 {
01536 cpl_frame *cur_frame = NULL;
01537
01538
01539 for (cur_frame = cpl_frameset_get_first (set);
01540 cur_frame != NULL; cur_frame = cpl_frameset_get_next (set)) {
01541 if (strstr (cpl_frame_get_tag (cur_frame), XSH_MASTER_BP_MAP)) {
01542 return cur_frame;
01543 }
01544 }
01545 return NULL;
01546 }
01547
01548
01554
01555 cpl_frame * xsh_find_off(cpl_frameset* set)
01556 {
01557 cpl_frame *cur_frame = NULL;
01558
01559
01560 for (cur_frame = cpl_frameset_get_first (set);
01561 cur_frame != NULL; cur_frame = cpl_frameset_get_next (set)) {
01562 if (strstr (cpl_frame_get_tag (cur_frame), "OFF")) {
01563 return cur_frame;
01564 }
01565 }
01566 return NULL;
01567 }
01568
01569
01575
01576 cpl_frame * xsh_find_on(cpl_frameset* set)
01577 {
01578 cpl_frame *cur_frame = NULL;
01579
01580
01581 for (cur_frame = cpl_frameset_get_first (set);
01582 cur_frame != NULL; cur_frame = cpl_frameset_get_next (set)) {
01583 if (strstr (cpl_frame_get_tag (cur_frame), "ON")) {
01584 return cur_frame;
01585 }
01586 }
01587 return NULL;
01588 }
01589
01596
01597 void
01598 xsh_dfs_find_flat(cpl_frameset* raws,cpl_frameset* flat)
01599 {
01600 cpl_frame *cur_frame = NULL;
01601 const char* tag = NULL;
01602
01603 assure (raws != NULL, CPL_ERROR_NULL_INPUT, "Null frameset");
01604 assure (flat != NULL, CPL_ERROR_NULL_INPUT, "Null frameset");
01605
01606
01607 tag = cpl_frame_get_tag(cpl_frameset_get_first(raws));
01608
01609
01610 for (cur_frame = cpl_frameset_get_first (raws);
01611 cur_frame != NULL; cur_frame = cpl_frameset_get_next (raws))
01612 {
01613 tag = cpl_frame_get_tag (cur_frame);
01614 if (strstr(tag,"FLAT")!=NULL)
01615 cpl_frameset_insert (flat, cur_frame);
01616 }
01617
01618 cleanup:
01619 return;
01620
01621 }
01622
01623
01638
01639 char *
01640 xsh_unique_filename (const char *context, const char *caller_id,
01641 const char *pro_catg)
01642 {
01643 if (context != NULL) {
01644
01645 return xsh_stringcat_6 (context, "-", caller_id, "-", pro_catg, ".fits");
01646 }
01647 else {
01648 return xsh_stringcat_4 (caller_id, "-", pro_catg, ".fits");
01649 }
01650 }
01651
01652
01664 void xsh_add_product(cpl_frame *frame,
01665 cpl_frameset * frameset,
01666 const cpl_parameterlist * parameters,
01667 const char *recipe_id,
01668 xsh_instrument* instrument,
01669 const char *final_prefix ,
01670 const char* type)
01671 {
01672 cpl_propertylist *primary_header = NULL;
01673 cpl_propertylist *tbl_header = NULL;
01674 int extension=0;
01675 const char *pro_catg = NULL;
01676 cpl_frame* product_frame = NULL;
01677
01678 cpl_table *table = NULL ;
01679 cpl_image *image = NULL ;
01680 cpl_imagelist *imagelist = NULL ;
01681
01682
01683 const char *fname = NULL;
01684 char *final_name = NULL ;
01685 char* date = NULL ;
01686
01687
01688
01689 XSH_ASSURE_NOT_NULL(frame);
01690 XSH_ASSURE_NOT_NULL(frameset);
01691 XSH_ASSURE_NOT_NULL(parameters);
01692 XSH_ASSURE_NOT_NULL(recipe_id);
01693 XSH_ASSURE_NOT_NULL(instrument);
01694 XSH_ASSURE_NOT_NULL(final_prefix);
01695
01696 check(pro_catg = cpl_frame_get_tag (frame));
01697 XSH_ASSURE_NOT_NULL(pro_catg);
01698
01699
01700 check(fname = cpl_frame_get_filename( frame ));
01701 check(primary_header = cpl_propertylist_load( fname, 0 ));
01702
01703 if(strcmp(type,"imagelist") == 0) {
01704 check(imagelist = cpl_imagelist_load( fname, CPL_TYPE_FLOAT, 0 ));
01705 } else if(strcmp(type,"image") == 0) {
01706 check(image = cpl_image_load( fname, CPL_TYPE_FLOAT, 0,0 ));
01707 } else if(strcmp(type,"table") == 0) {
01708 check(table = cpl_table_load( fname, 1,0 ));
01709 } else {
01710 xsh_msg_error("Frame type %s not supported",type);
01711 }
01712
01713
01714 check( cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT));
01715 check_msg (cpl_dfs_setup_product_header ( primary_header,
01716 frame,frameset,parameters,
01717 recipe_id,
01718 instrument->pipeline_id,
01719 instrument->dictionary,NULL),
01720 "Problem in the product DFS-compliance");
01721
01722
01723 final_name=xsh_create_final_name(final_prefix);
01724
01725 xsh_msg_dbg_low( "Final product name: %s", final_name ) ;
01726
01727
01728
01729
01730 if(strcmp(type,"imagelist") == 0) {
01731 cpl_imagelist_save(imagelist, final_name, CPL_BPP_IEEE_FLOAT,
01732 primary_header,CPL_IO_DEFAULT ) ;
01733 } else if(strcmp(type,"image") == 0) {
01734 cpl_image_save(image, final_name, CPL_BPP_IEEE_FLOAT,
01735 primary_header,CPL_IO_DEFAULT ) ;
01736 } else if(strcmp(type,"table") == 0) {
01737 check(cpl_table_save( table, primary_header, tbl_header,
01738 final_name, extension ));
01739 }
01740
01741
01742
01743
01744
01745
01746
01747
01748
01749
01750
01751
01752
01753
01754
01755
01756
01757 if(strcmp(type,"imagelist") == 0) {
01758 check(product_frame=xsh_frame_product(final_name,pro_catg,
01759 CPL_FRAME_TYPE_IMAGE,
01760 CPL_FRAME_GROUP_PRODUCT,
01761 CPL_FRAME_LEVEL_FINAL));
01762 } else if(strcmp(type,"image") == 0) {
01763 check(product_frame=xsh_frame_product(final_name,pro_catg,
01764 CPL_FRAME_TYPE_IMAGE,
01765 CPL_FRAME_GROUP_PRODUCT,
01766 CPL_FRAME_LEVEL_FINAL));
01767 } else if(strcmp(type,"table") == 0) {
01768 check(product_frame=xsh_frame_product(final_name,pro_catg,
01769 CPL_FRAME_TYPE_TABLE,
01770 CPL_FRAME_GROUP_PRODUCT,
01771 CPL_FRAME_LEVEL_FINAL));
01772
01773 }
01774
01775 check(cpl_frameset_insert(frameset, product_frame));
01776 xsh_add_product_file(final_name);
01777 cleanup:
01778 XSH_FREE(date);
01779 xsh_free_propertylist(&primary_header);
01780 xsh_free_image( &image ) ;
01781 xsh_free_imagelist( &imagelist ) ;
01782 xsh_free_table( &table ) ;
01783 XSH_FREE( final_name ) ;
01784
01785 return;
01786 }
01787
01797 void
01798 xsh_add_product_vector( cpl_frame *frame,
01799 cpl_frameset *frameset,
01800 const cpl_parameterlist *parameters,
01801 const char *recipe_id,
01802 xsh_instrument* instrument,
01803 const char * final_prefix)
01804 {
01805
01806 cpl_vector *vect = NULL;
01807 cpl_propertylist *primary_header = NULL;
01808 const char *pro_catg = "";
01809 cpl_frame* product_frame = NULL;
01810 const char *fname = NULL;
01811 char *final_name = NULL ;
01812
01813 char* date = NULL ;
01814
01815
01816
01817 XSH_ASSURE_NOT_NULL(frame);
01818 XSH_ASSURE_NOT_NULL(frameset);
01819 XSH_ASSURE_NOT_NULL(parameters);
01820 XSH_ASSURE_NOT_NULL(recipe_id);
01821 XSH_ASSURE_NOT_NULL(instrument);
01822 XSH_ASSURE_NOT_NULL(final_prefix);
01823
01824 check(pro_catg = cpl_frame_get_tag (frame));
01825 XSH_ASSURE_NOT_NULL(pro_catg);
01826
01827
01828 check( fname = cpl_frame_get_filename( frame));
01829 check( primary_header = cpl_propertylist_load( fname, 0));
01830 check( vect = cpl_vector_load( fname, 0));
01831
01832
01833 check( cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT));
01834 check_msg (cpl_dfs_setup_product_header ( primary_header,
01835 frame,frameset,parameters,
01836 recipe_id,
01837 instrument->pipeline_id,
01838 instrument->dictionary,NULL),
01839 "Problem in the product DFS-compliance");
01840
01841
01842 final_name=xsh_create_final_name(final_prefix);
01843 xsh_msg_dbg_low( "Final product name: %s", final_name ) ;
01844
01845
01846 check( cpl_vector_save( vect, final_name, XSH_PRE_QUAL_BPP,
01847 primary_header, CPL_IO_CREATE));
01848
01849
01850 check(product_frame=xsh_frame_product(final_name,pro_catg,
01851 CPL_FRAME_TYPE_IMAGE,
01852 CPL_FRAME_GROUP_PRODUCT,
01853 CPL_FRAME_LEVEL_FINAL));
01854
01855 check(cpl_frameset_insert(frameset, product_frame));
01856 xsh_add_product_file(final_name);
01857
01858 cleanup:
01859 if (cpl_error_get_code () != CPL_ERROR_NONE) {
01860 xsh_free_frame( &product_frame);
01861 product_frame = NULL;
01862 }
01863 XSH_FREE(date);
01864 xsh_free_propertylist(&primary_header);
01865 xsh_free_vector( &vect) ;
01866 XSH_FREE( final_name);
01867 return;
01868 }
01869
01879 void
01880 xsh_add_product_spectrum( cpl_frame *frame,
01881 cpl_frameset *frameset,
01882 const cpl_parameterlist *parameters,
01883 const char *recipe_id,
01884 xsh_instrument* instr)
01885 {
01886
01887 const char *pro_catg = "";
01888 xsh_spectrum *spectrum = NULL;
01889 cpl_frame *product_frame = NULL;
01890 char product_id[256];
01891 char* product_name = NULL;
01892
01893 time_t now ;
01894 char* date = NULL;
01895
01896
01897 XSH_ASSURE_NOT_NULL( frame);
01898 XSH_ASSURE_NOT_NULL( frameset);
01899 XSH_ASSURE_NOT_NULL( parameters);
01900 XSH_ASSURE_NOT_NULL( recipe_id);
01901 XSH_ASSURE_NOT_NULL( instr);
01902
01903 check( pro_catg = cpl_frame_get_tag (frame));
01904
01905 assure( pro_catg != NULL, CPL_ERROR_NULL_INPUT,
01906 "Frame tag has not been set");
01907
01908
01909 check( spectrum = xsh_spectrum_load( frame));
01910
01911
01912 cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT);
01913 check( cpl_dfs_setup_product_header( spectrum->flux_header,
01914 frame, frameset, parameters, recipe_id, instr->pipeline_id,
01915 instr->dictionary, NULL));
01916
01917 if (xsh_time_stamp_get() ){
01918 time( &now );
01919 date = xsh_sdate_utc(&now);
01920 sprintf( product_id, "%s%s_%s", XSH_PRODUCT_PREFIX,
01921 pro_catg, date);
01922 }
01923 else {
01924 sprintf( product_id, "%s%s", XSH_PRODUCT_PREFIX,
01925 pro_catg);
01926 }
01927 product_name = xsh_stringcat_any( product_id, ".fits", NULL);
01928 check( product_frame = xsh_spectrum_save(spectrum, product_name,pro_catg));
01929
01930
01931
01932
01933
01934
01935
01936
01937
01938
01939
01940 cpl_frame_set_type( product_frame, CPL_FRAME_TYPE_IMAGE);
01941 cpl_frame_set_group( product_frame, CPL_FRAME_GROUP_PRODUCT);
01942 cpl_frame_set_level( product_frame, CPL_FRAME_LEVEL_FINAL);
01943 cpl_frame_set_tag( product_frame, pro_catg);
01944 cpl_frameset_insert( frameset, product_frame);
01945 xsh_add_product_file(product_name);
01946
01947 cleanup:
01948 if (cpl_error_get_code () != CPL_ERROR_NONE) {
01949 xsh_free_frame( &product_frame);
01950 product_frame = NULL;
01951 }
01952 XSH_FREE( date);
01953 xsh_spectrum_free( &spectrum);
01954 XSH_FREE( product_name);
01955
01956 return;
01957 }
01958
01959
01984
01985 void
01986 xsh_add_product_pre (cpl_frame * frame,
01987 cpl_frameset * frameset,
01988 const cpl_parameterlist *parameters,
01989 const char *recipe_id,
01990 xsh_instrument* instr)
01991 {
01992 const char *pro_catg = "";
01993 xsh_pre* product_pre = NULL;
01994 cpl_frame* product_frame = NULL;
01995 char product_id[256];
01996 char* product_name = NULL;
01997
01998 time_t now ;
01999 char* date = NULL;
02000 cpl_propertylist* plist=NULL;
02001 char arcfile[256];
02002 bool arcfile_found=false;
02003
02004
02005 XSH_ASSURE_NOT_NULL( frame);
02006 XSH_ASSURE_NOT_NULL( frameset);
02007 XSH_ASSURE_NOT_NULL( parameters);
02008 XSH_ASSURE_NOT_NULL( recipe_id);
02009 XSH_ASSURE_NOT_NULL( instr);
02010
02011 check( pro_catg = cpl_frame_get_tag (frame));
02012
02013 assure( pro_catg != NULL, CPL_ERROR_NULL_INPUT,
02014 "Frame tag has not been set");
02015
02016
02017 check( product_pre = xsh_pre_load( frame,instr));
02018 if(cpl_propertylist_has(product_pre->data_header,"ARCFILE")) {
02019 sprintf(arcfile,"%s",xsh_pfits_get_arcfile(product_pre->data_header));
02020 arcfile_found=true;
02021 }
02022
02023 cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT);
02024 check( cpl_dfs_setup_product_header( product_pre->data_header,
02025 frame, frameset, parameters, recipe_id, instr->pipeline_id,
02026 instr->dictionary,NULL));
02027
02028
02029 if (xsh_time_stamp_get() ){
02030 time( &now );
02031 date = xsh_sdate_utc(&now);
02032 sprintf( product_id, "%s%s_%s", XSH_PRODUCT_PREFIX, pro_catg, date);
02033 }
02034 else {
02035 sprintf( product_id, "%s%s", XSH_PRODUCT_PREFIX, pro_catg);
02036 }
02037 product_name = xsh_stringcat_any( product_id, ".fits", NULL);
02038 xsh_plist_set_extra_keys(product_pre->data_header,"IMAGE","DATA","RMSE",
02039 "FLUX","ERRS","QUAL",0);
02040 xsh_pfits_set_extname( product_pre->errs_header, "ERRS");
02041 xsh_plist_set_extra_keys(product_pre->errs_header,"IMAGE","DATA","RMSE",
02042 "FLUX","ERRS","QUAL",1);
02043 xsh_pfits_set_extname( product_pre->qual_header, "QUAL");
02044 xsh_plist_set_extra_keys(product_pre->qual_header,"IMAGE","DATA","RMSE",
02045 "FLUX","ERRS","QUAL",2);
02046
02047 check( product_frame = xsh_pre_save( product_pre, product_name, pro_catg,0));
02048
02049
02050
02051
02052
02053 check(plist=cpl_propertylist_duplicate(product_pre->data_header));
02054
02055
02056 if(arcfile_found) {
02057
02058 check(cpl_propertylist_append_string(plist,"ARCFILE",arcfile));
02059 check(cpl_propertylist_set_comment(plist,"ARCFILE","Archive File Name"));
02060
02061
02062
02063
02064 } else {
02065
02066
02067
02068
02069
02070 }
02071
02072
02073 cpl_frame_set_type( product_frame, CPL_FRAME_TYPE_IMAGE);
02074 cpl_frame_set_group( product_frame, CPL_FRAME_GROUP_PRODUCT);
02075 cpl_frame_set_level( product_frame, CPL_FRAME_LEVEL_FINAL);
02076 cpl_frame_set_tag( product_frame, pro_catg);
02077 cpl_frameset_insert( frameset, product_frame);
02078 xsh_add_product_file(product_name);
02079
02080 cleanup:
02081 if (cpl_error_get_code () != CPL_ERROR_NONE) {
02082 xsh_free_frame( &product_frame);
02083 product_frame = NULL;
02084 }
02085 XSH_FREE( date);
02086 xsh_pre_free( &product_pre);
02087 xsh_free_propertylist(&plist);
02088 XSH_FREE( product_name);
02089
02090 return;
02091 }
02092
02093
02105
02106 void
02107 xsh_add_product_pre_3d( cpl_frame * frame,
02108 cpl_frameset * frameset,
02109 const cpl_parameterlist *parameters,
02110 const char *recipe_id,
02111 xsh_instrument* instr)
02112 {
02113 const char * pro_catg = "";
02114 xsh_pre_3d * product_pre = NULL;
02115 cpl_frame * product_frame = NULL;
02116 char product_id[256];
02117 char * product_name = NULL;
02118
02119 time_t now ;
02120 char * date = NULL;
02121
02122
02123 XSH_ASSURE_NOT_NULL( frame);
02124 XSH_ASSURE_NOT_NULL( frameset);
02125 XSH_ASSURE_NOT_NULL( parameters);
02126 XSH_ASSURE_NOT_NULL( recipe_id);
02127 XSH_ASSURE_NOT_NULL( instr);
02128
02129 check( pro_catg = cpl_frame_get_tag (frame));
02130
02131 assure( pro_catg != NULL, CPL_ERROR_NULL_INPUT,
02132 "Frame tag has not been set");
02133
02134
02135 check( product_pre = xsh_pre_3d_load( frame));
02136
02137
02138 cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT);
02139 check( cpl_dfs_setup_product_header( product_pre->data_header,
02140 frame, frameset, parameters,
02141 recipe_id, instr->pipeline_id,
02142 instr->dictionary,NULL));
02143
02144
02145 if (xsh_time_stamp_get() ){
02146 time( &now );
02147 date = xsh_sdate_utc(&now);
02148 sprintf( product_id, "%s%s_%s", XSH_PRODUCT_PREFIX, pro_catg, date);
02149 }
02150 else {
02151 sprintf( product_id, "%s%s", XSH_PRODUCT_PREFIX, pro_catg );
02152 }
02153 product_name = xsh_stringcat_any( product_id, ".fits", NULL);
02154 check( product_frame = xsh_pre_3d_save( product_pre, product_name, 0));
02155
02156
02157
02158
02159
02160
02161
02162
02163
02164
02165 cpl_frame_set_type( product_frame, CPL_FRAME_TYPE_IMAGE);
02166 cpl_frame_set_group( product_frame, CPL_FRAME_GROUP_PRODUCT);
02167 cpl_frame_set_level( product_frame, CPL_FRAME_LEVEL_FINAL);
02168 cpl_frame_set_tag( product_frame, pro_catg);
02169 cpl_frameset_insert( frameset, product_frame);
02170 xsh_add_product_file(product_name);
02171
02172 cleanup:
02173 if (cpl_error_get_code () != CPL_ERROR_NONE) {
02174 xsh_free_frame( &product_frame);
02175 product_frame = NULL;
02176 }
02177 XSH_FREE( date);
02178 xsh_pre_3d_free( &product_pre);
02179 XSH_FREE( product_name);
02180
02181 return;
02182 }
02183
02194 void
02195 xsh_add_product_bpmap( cpl_frame *frame,
02196 cpl_frameset * frameset,
02197 const cpl_parameterlist * parameters,
02198 const char *recipe_id,
02199 xsh_instrument* instrument,
02200 const char *final_prefix )
02201 {
02202 cpl_propertylist *primary_header = NULL;
02203 const char* pro_catg=NULL;
02204 cpl_frame* product_frame = NULL;
02205 cpl_image *image = NULL ;
02206 const char *fname = NULL;
02207 char *final_name = NULL ;
02208 char* date = NULL ;
02209
02210
02211
02212
02213 XSH_ASSURE_NOT_NULL(frame);
02214 XSH_ASSURE_NOT_NULL(frameset);
02215 XSH_ASSURE_NOT_NULL(parameters);
02216 XSH_ASSURE_NOT_NULL(recipe_id);
02217 XSH_ASSURE_NOT_NULL(instrument);
02218
02219
02220
02221 pro_catg=xsh_create_final_tag(final_prefix,instrument,frame);
02222
02223
02224 XSH_ASSURE_NOT_NULL(pro_catg);
02225
02226
02227 check(fname = cpl_frame_get_filename( frame ));
02228 check(primary_header = cpl_propertylist_load( fname, 0 ));
02229 check(image = cpl_image_load( fname, CPL_TYPE_INT, 0, 0 ));
02230
02231
02232 check( cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT));
02233 check_msg (cpl_dfs_setup_product_header ( primary_header,
02234 frame,frameset,parameters,
02235 recipe_id,
02236 instrument->pipeline_id,
02237 instrument->dictionary,NULL),
02238 "Problem in the product DFS-compliance");
02239
02240
02241
02242 final_name=xsh_create_final_name(pro_catg);
02243 xsh_msg_dbg_low( "Final product name: %s", final_name ) ;
02244
02245
02246 cpl_image_save( image, final_name, CPL_BPP_32_SIGNED, primary_header,
02247 CPL_IO_DEFAULT ) ;
02248
02249
02250
02251
02252
02253
02254
02255
02256
02257
02258
02259 check(product_frame=xsh_frame_product(final_name,pro_catg,
02260 CPL_FRAME_TYPE_IMAGE,
02261 CPL_FRAME_GROUP_PRODUCT,
02262 CPL_FRAME_LEVEL_FINAL));
02263
02264
02265
02266
02267
02268
02269
02270
02271
02272
02273
02274
02275
02276 check(cpl_frameset_insert(frameset, product_frame));
02277 xsh_add_product_file(final_name);
02278
02279 cleanup:
02280 XSH_FREE(date);
02281 xsh_free_propertylist(&primary_header);
02282 xsh_free_image( &image ) ;
02283 XSH_FREE( final_name ) ;
02284 if(final_prefix!=NULL) {
02285 xsh_free(pro_catg);
02286 }
02287
02288 return;
02289 }
02290
02291
02302
02303 void
02304 xsh_add_product_imagelist( cpl_frame *frame,
02305 cpl_frameset *frameset,
02306 const cpl_parameterlist *parameters,
02307 const char *recipe_id,
02308 xsh_instrument *instrument,
02309 const char *final_prefix)
02310 {
02311 cpl_propertylist *primary_header = NULL;
02312 const char *pro_catg = NULL;
02313 cpl_frame* product_frame = NULL;
02314 const char *fname = NULL;
02315 char *final_name = NULL ;
02316 char* date = NULL ;
02317 int nbext=0;
02318 int i=0;
02319 char cmd[256];
02320 char arcfile[256];
02321
02322 bool arcfile_found=false;
02323 int extension =0;
02324 cpl_imagelist* ext_iml=NULL;
02325 cpl_propertylist* ext_header=NULL;
02326
02327
02328
02329
02330 XSH_ASSURE_NOT_NULL(frame);
02331 XSH_ASSURE_NOT_NULL(frameset);
02332 XSH_ASSURE_NOT_NULL(parameters);
02333 XSH_ASSURE_NOT_NULL(recipe_id);
02334 XSH_ASSURE_NOT_NULL(instrument);
02335
02336
02337 pro_catg=xsh_create_final_tag(final_prefix,instrument,frame);
02338
02339
02340 check(fname = cpl_frame_get_filename( frame ));
02341 nbext = cpl_frame_get_nextensions( frame);
02342 check(primary_header = cpl_propertylist_load( fname, 0 ));
02343 check(ext_iml = cpl_imagelist_load( fname, CPL_TYPE_FLOAT, 0 ));
02344 if(cpl_propertylist_has(primary_header,"ARCFILE")) {
02345 sprintf(arcfile,"%s",xsh_pfits_get_arcfile(primary_header));
02346 arcfile_found=true;
02347 }
02348
02349
02350 check( cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT));
02351 check_msg ( cpl_dfs_setup_product_header ( primary_header,
02352 frame,frameset,parameters,
02353 recipe_id,
02354 instrument->pipeline_id,
02355 instrument->dictionary,NULL),
02356 "Problem in the product DFS-compliance");
02357
02358
02359 final_name=xsh_create_final_name(pro_catg);
02360 xsh_msg( "Final product name: %s", final_name ) ;
02361
02362 if(strcmp(fname,final_name) == 0) {
02363 sprintf(cmd,"mv %s tmp_ima.fits",fname);
02364 system(cmd);
02365 fname="tmp_ima.fits";
02366 xsh_add_temporary_file("tmp_ima.fits");
02367 }
02368
02369
02370 xsh_pfits_set_pcatg(primary_header,pro_catg);
02371 check(cpl_imagelist_save(ext_iml, final_name, CPL_BPP_IEEE_FLOAT,
02372 primary_header,CPL_IO_DEFAULT));
02373
02374 for( i = 0 ; i<=nbext ; i++ ) {
02375 xsh_free_imagelist( &ext_iml) ;
02376 xsh_free_propertylist( &ext_header) ;
02377 check(ext_iml = cpl_imagelist_load( fname, CPL_TYPE_FLOAT, i ));
02378 check(ext_header = cpl_propertylist_load( fname ,i));
02379
02380 if ( i == 0 ) {
02381 extension = CPL_IO_DEFAULT ;
02382 check(cpl_imagelist_save(ext_iml, final_name, CPL_BPP_IEEE_FLOAT,
02383 primary_header,extension));
02384 }
02385 else {
02386 extension = CPL_IO_EXTEND ;
02387 check(cpl_imagelist_save(ext_iml, final_name, CPL_BPP_IEEE_FLOAT,
02388 ext_header,extension));
02389 }
02390 }
02391
02392 if(arcfile_found) {
02393 check(cpl_propertylist_append_string(primary_header,"ARCFILE",arcfile));
02394 check(cpl_propertylist_set_comment(primary_header,"ARCFILE",
02395 "Archive File Name"));
02396 }
02397
02398
02399 check(product_frame=xsh_frame_product(final_name,pro_catg,
02400 CPL_FRAME_TYPE_IMAGE,
02401 CPL_FRAME_GROUP_PRODUCT,
02402 CPL_FRAME_LEVEL_FINAL));
02403
02404
02405 check(cpl_frameset_insert(frameset, product_frame));
02406 xsh_add_product_file(final_name);
02407
02408 cleanup:
02409 xsh_free_imagelist( &ext_iml) ;
02410 xsh_free_propertylist( &ext_header) ;
02411
02412 if(final_prefix!=NULL) {
02413 xsh_free(pro_catg);
02414 }
02415 XSH_FREE(date);
02416 xsh_free_propertylist(&primary_header);
02417 xsh_free_imagelist( &ext_iml ) ;
02418 XSH_FREE( final_name ) ;
02419
02420 return;
02421 }
02422
02423
02434
02435 void
02436 xsh_add_product_image( cpl_frame *frame,
02437 cpl_frameset *frameset,
02438 const cpl_parameterlist *parameters,
02439 const char *recipe_id,
02440 xsh_instrument *instrument,
02441 const char *final_prefix)
02442 {
02443 cpl_propertylist *primary_header = NULL;
02444 const char *pro_catg = NULL;
02445 cpl_frame* product_frame = NULL;
02446 cpl_image *image = NULL ;
02447 const char *fname = NULL;
02448 char *final_name = NULL ;
02449
02450 int i=0;
02451 int nbext=0;
02452 char arcfile[256];
02453 char cmd[256];
02454 bool arcfile_found=false;
02455
02456
02457 XSH_ASSURE_NOT_NULL(frame);
02458 XSH_ASSURE_NOT_NULL(frameset);
02459 XSH_ASSURE_NOT_NULL(parameters);
02460 XSH_ASSURE_NOT_NULL(recipe_id);
02461 XSH_ASSURE_NOT_NULL(instrument);
02462
02463
02464 pro_catg=xsh_create_final_tag(final_prefix,instrument,frame);
02465
02466
02467 check( fname = cpl_frame_get_filename( frame));
02468 nbext = cpl_frame_get_nextensions( frame);
02469
02470 check( primary_header = cpl_propertylist_load( fname, 0));
02471 check( image = cpl_image_load( fname, CPL_TYPE_FLOAT, 0, 0));
02472 if(cpl_propertylist_has(primary_header,"ARCFILE")) {
02473 sprintf(arcfile,"%s",xsh_pfits_get_arcfile(primary_header));
02474 arcfile_found=true;
02475 }
02476
02477
02478 check( cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT));
02479 check_msg (cpl_dfs_setup_product_header ( primary_header,
02480 frame,frameset,parameters,
02481 recipe_id,
02482 instrument->pipeline_id,
02483 instrument->dictionary,NULL),
02484 "Problem in the product DFS-compliance");
02485
02486
02487 final_name=xsh_create_final_name(pro_catg);
02488 xsh_msg( "Final product name: %s", final_name ) ;
02489
02490 if(strcmp(fname,final_name) == 0) {
02491 sprintf(cmd,"mv %s tmp_ima.fits",fname);
02492 system(cmd);
02493 fname="tmp_ima.fits";
02494 xsh_add_temporary_file("tmp_ima.fits");
02495 }
02496
02497 xsh_pfits_set_pcatg(primary_header,pro_catg);
02498 xsh_plist_set_extra_keys(primary_header,"IMAGE","DATA","RMSE",
02499 "FLUX","ERRS","QUAL",0);
02500
02501 check(cpl_image_save( image, final_name, CPL_BPP_IEEE_FLOAT, primary_header,
02502 CPL_IO_DEFAULT )) ;
02503
02504
02505
02506 for( i = 0 ; i<=nbext ; i++ ) {
02507 int extension ;
02508 cpl_image* ext_img=NULL;
02509 cpl_propertylist* ext_header=NULL;
02510
02511 check( ext_img = cpl_image_load( fname, CPL_TYPE_FLOAT,0, i));
02512 check( ext_header = cpl_propertylist_load( fname ,i));
02513
02514
02515 if ( i == 0 ) {
02516 extension = CPL_IO_DEFAULT ;
02517 xsh_pfits_set_pcatg(ext_header,pro_catg);
02518 }
02519 else {
02520 extension = CPL_IO_EXTEND ;
02521 check(xsh_plist_set_extra_keys(ext_header,"IMAGE","DATA","RMSE",
02522 "FLUX","ERRS","QUAL",i));
02523 check(cpl_image_save( ext_img, final_name, CPL_BPP_IEEE_FLOAT,ext_header,
02524 extension));
02525 }
02526 xsh_free_image( &ext_img) ;
02527 xsh_free_propertylist( &ext_header) ;
02528 }
02529
02530
02531
02532
02533 if(arcfile_found) {
02534 check(cpl_propertylist_append_string(primary_header,"ARCFILE",arcfile));
02535 check(cpl_propertylist_set_comment(primary_header,"ARCFILE",
02536 "Archive File Name"));
02537 }
02538
02539
02540
02541
02542
02543
02544
02545 check( product_frame = xsh_frame_product( final_name,pro_catg,
02546 CPL_FRAME_TYPE_IMAGE,
02547 CPL_FRAME_GROUP_PRODUCT,
02548 CPL_FRAME_LEVEL_FINAL));
02549
02550 check(cpl_frameset_insert(frameset, product_frame));
02551 xsh_add_product_file(final_name);
02552
02553 cleanup:
02554 if(final_prefix!=NULL) {
02555 xsh_free(pro_catg);
02556 }
02557
02558 xsh_free_propertylist( &primary_header);
02559 xsh_free_image( &image);
02560 XSH_FREE( final_name);
02561
02562 return;
02563 }
02564
02565
02575
02576 void
02577 xsh_add_product_table( cpl_frame *frame,
02578 cpl_frameset *frameset,
02579 const cpl_parameterlist * parameters,
02580 const char *recipe_id,
02581 xsh_instrument* instrument,
02582 const char *final_prefix)
02583 {
02584 cpl_propertylist *primary_header = NULL;
02585 cpl_propertylist *tbl_header = NULL;
02586 const char *pro_catg =NULL;
02587 cpl_frame* product_frame = NULL;
02588 cpl_table * table = NULL ;
02589 const char *fname = NULL;
02590 char *product_id = NULL;
02591 char *product_name = NULL ;
02592 char *tmp_name = NULL ;
02593 char* date = NULL ;
02594
02595 int nbext, i ;
02596
02597
02598 XSH_ASSURE_NOT_NULL(frame);
02599 XSH_ASSURE_NOT_NULL(frameset);
02600 XSH_ASSURE_NOT_NULL(parameters);
02601 XSH_ASSURE_NOT_NULL(recipe_id);
02602 XSH_ASSURE_NOT_NULL(instrument);
02603
02604
02605 pro_catg=xsh_create_final_tag(final_prefix,instrument,frame);
02606
02607
02608
02609 check( fname = cpl_frame_get_filename( frame));
02610 check( primary_header = cpl_propertylist_load( fname, 0));
02611 XSH_ASSURE_NOT_NULL( primary_header);
02612 check( tbl_header = cpl_propertylist_load( fname, 1));
02613 XSH_ASSURE_NOT_NULL( tbl_header);
02614 nbext = cpl_frame_get_nextensions( frame);
02615
02616
02617 check( cpl_frame_set_group (frame, CPL_FRAME_GROUP_PRODUCT));
02618 check( cpl_dfs_setup_product_header ( primary_header,
02619 frame, frameset, parameters, recipe_id, instrument->pipeline_id,
02620 instrument->dictionary,NULL));
02621
02622
02623 product_name=xsh_create_final_name(pro_catg);
02624
02625
02626 tmp_name=xsh_stringcat_any( "tmp_",product_name, NULL );
02627 for( i = 0 ; i<nbext ; i++ ) {
02628 int extension ;
02629 cpl_table *tbl_ext = NULL;
02630 cpl_propertylist *tbl_ext_header = NULL;
02631
02632
02633
02634 check( tbl_ext = cpl_table_load( fname, i+1, 0));
02635 check( tbl_ext_header = cpl_propertylist_load( fname, i+1));
02636
02637 if ( i == 0 ) extension = CPL_IO_DEFAULT ;
02638 else extension = CPL_IO_EXTEND ;
02639 check(cpl_table_save( tbl_ext, primary_header, tbl_ext_header,
02640 tmp_name, extension));
02641 xsh_free_table( &tbl_ext);
02642 xsh_free_propertylist( &tbl_ext_header);
02643 }
02644
02645 xsh_fileutils_move( tmp_name,product_name );
02646
02647
02648
02649 check(product_frame=xsh_frame_product(product_name,pro_catg,
02650 CPL_FRAME_TYPE_TABLE,
02651 CPL_FRAME_GROUP_PRODUCT,
02652 CPL_FRAME_LEVEL_FINAL));
02653
02654 cpl_frameset_insert(frameset, product_frame);
02655
02656
02657 cleanup:
02658 if(final_prefix!=NULL) {
02659 xsh_free(pro_catg);
02660 }
02661 xsh_free_propertylist(&primary_header);
02662 xsh_free_propertylist(&tbl_header);
02663 XSH_TABLE_FREE( table) ;
02664 XSH_FREE(product_id);
02665 XSH_FREE(tmp_name);
02666 XSH_FREE(product_name);
02667 XSH_FREE(date);
02668
02669 return;
02670 }
02671
02672
02673
02682
02683
02684 cpl_frame *
02685 xsh_find_std_flux (cpl_frameset * frames)
02686 {
02687 const char *tags[] = {
02688 XSH_STD_FLUX_SLIT (XSH_ARM_UVB),
02689 XSH_STD_FLUX_SLIT (XSH_ARM_VIS),
02690 XSH_STD_FLUX_SLIT (XSH_ARM_NIR),
02691 XSH_STD_TELL_SLIT (XSH_ARM_UVB),
02692 XSH_STD_TELL_SLIT (XSH_ARM_VIS),
02693 XSH_STD_TELL_SLIT (XSH_ARM_NIR),
02694 XSH_STD_FLUX_OFFSET (XSH_ARM_UVB),
02695 XSH_STD_FLUX_OFFSET (XSH_ARM_VIS),
02696 XSH_STD_FLUX_OFFSET (XSH_ARM_NIR),
02697 XSH_STD_TELL_OFFSET (XSH_ARM_UVB),
02698 XSH_STD_TELL_OFFSET (XSH_ARM_VIS),
02699 XSH_STD_TELL_OFFSET (XSH_ARM_NIR),
02700 NULL
02701 };
02702
02703 return xsh_find_frame (frames, tags);
02704 }
02705
02714
02715
02716 cpl_frame *
02717 xsh_find_std_star_flux (cpl_frameset * frames)
02718 {
02719 const char *tags[] = { XSH_STD_STAR_FLUX (XSH_ARM_UVB),
02720 XSH_STD_STAR_FLUX (XSH_ARM_VIS),
02721 XSH_STD_STAR_FLUX (XSH_ARM_NIR),
02722 NULL
02723 };
02724
02725 return xsh_find_frame (frames, tags);
02726 }
02727
02728
02739
02740
02741 cpl_frame*
02742 xsh_find_master_bias (cpl_frameset * frames, xsh_instrument* instr)
02743 {
02744 const char *tags[2] ={NULL,NULL};
02745 cpl_frame* result = NULL;
02746
02747 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_MASTER_BIAS, instr);
02748
02749 check(result = xsh_find_frame (frames,(const char**) tags));
02750
02751 cleanup:
02752 return result;
02753 }
02754
02755
02767
02768
02769 cpl_frame*
02770 xsh_find_frame_with_tag (cpl_frameset * frames,
02771 const char* tag,
02772 xsh_instrument* instr)
02773 {
02774 char *tags[2];
02775 cpl_frame* result = NULL;
02776
02777 tags[0] = xsh_get_tag_from_arm( tag, instr);
02778 tags[1] = NULL;
02779 xsh_msg_dbg_high("search for tag %s",tags[0]);
02780 result = xsh_find_frame (frames,(const char**) tags);
02781 cpl_free( tags[0]);
02782 return result;
02783 }
02784
02785
02786
02795
02796
02797 char* xsh_get_tag_from_arm(const char* tag, xsh_instrument* instr){
02798 const char* arm=xsh_instrument_arm_tostring(instr);
02799 char* composed_tag=NULL;
02800
02801 int len = strlen(tag);
02802
02803 if(tag[len-1]=='_') {
02804 composed_tag=cpl_sprintf("%s%s",tag,arm);
02805 } else {
02806 composed_tag=cpl_sprintf("%s%s%s",tag,"_",arm);
02807 }
02808 xsh_msg_dbg_high("composed tag='%s'",composed_tag);
02809
02810 return composed_tag;
02811 }
02812
02813
02814
02825
02826
02827 cpl_frame* xsh_find_master_dark (cpl_frameset * frames, xsh_instrument* instr)
02828 {
02829 const char *tags[2];
02830
02831 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_MASTER_DARK, instr);
02832 tags[1] = NULL;
02833
02834 return xsh_find_frame (frames, tags);
02835 }
02836
02837
02848
02849 cpl_frame* xsh_find_master_flat (cpl_frameset * frames, xsh_instrument* instr)
02850 {
02851 const char *tags[2];
02852
02853 tags[0] = XSH_GET_TAG_FROM_MODE ( XSH_MASTER_FLAT, instr);
02854 tags[1] = NULL;
02855
02856 return xsh_find_frame (frames, tags);
02857 }
02858
02859
02867
02868 cpl_frame *xsh_find_theo_tab_sing( cpl_frameset *frames, xsh_instrument* instr)
02869 {
02870 const char* tags[2] = {NULL, NULL};
02871 cpl_frame* result = NULL;
02872
02873 XSH_ASSURE_NOT_NULL( frames);
02874 XSH_ASSURE_NOT_NULL( instr);
02875 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_THEO_TAB_SING, instr);
02876 check(result = xsh_find_frame (frames, tags));
02877
02878 cleanup:
02879 return result;
02880 }
02881
02882
02890
02891 cpl_frame *xsh_find_theo_tab_mult( cpl_frameset *frames, xsh_instrument* instr)
02892 {
02893 const char *tags[2] = {NULL, NULL};
02894 cpl_frame* result = NULL;
02895
02896 XSH_ASSURE_NOT_NULL( frames);
02897 XSH_ASSURE_NOT_NULL( instr);
02898 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_THEO_TAB_MULT, instr);
02899 check(result = xsh_find_frame (frames, tags));
02900
02901 cleanup:
02902 return result;
02903 }
02904
02912
02913 cpl_frame *xsh_find_theo_tab_mode( cpl_frameset *frames, xsh_instrument* instr)
02914 {
02915 const char *tags[2] = {NULL, NULL};
02916 cpl_frame* result = NULL;
02917
02918 XSH_ASSURE_NOT_NULL( frames);
02919 XSH_ASSURE_NOT_NULL( instr);
02920
02921 if ( instr->mode == XSH_MODE_IFU){
02922 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_THEO_TAB_IFU, instr);
02923 }
02924 else{
02925 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_THEO_TAB_SING, instr);
02926 }
02927 check(result = xsh_find_frame (frames, tags));
02928
02929 cleanup:
02930 return result;
02931 }
02932
02933
02941
02942 cpl_frame *
02943 xsh_find_order_tab_recov( cpl_frameset *frames, xsh_instrument* instr)
02944 {
02945 const char *tags[2] = {NULL, NULL};
02946 cpl_frame* result = NULL;
02947
02948 XSH_ASSURE_NOT_NULL( frames);
02949 XSH_ASSURE_NOT_NULL( instr);
02950
02951 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_ORDER_TAB_RECOV, instr);
02952 check( result = xsh_find_frame (frames, tags));
02953
02954 cleanup:
02955 return result;
02956 }
02957
02958
02966
02967 cpl_frame *
02968 xsh_find_order_tab_guess( cpl_frameset *frames, xsh_instrument* instr)
02969 {
02970 const char *tags[2] = {NULL, NULL};
02971 cpl_frame* result = NULL;
02972
02973 XSH_ASSURE_NOT_NULL( frames);
02974 XSH_ASSURE_NOT_NULL( instr);
02975
02976 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_ORDER_TAB_GUESS, instr);
02977 check(result = xsh_find_frame (frames, tags));
02978
02979 cleanup:
02980 return result;
02981 }
02982
02983
02991
02992 cpl_frame *
02993 xsh_find_order_tab_centr( cpl_frameset *frames, xsh_instrument* instr)
02994 {
02995 const char *tags[2] = {NULL, NULL};
02996 cpl_frame* result = NULL;
02997
02998 XSH_ASSURE_NOT_NULL( frames);
02999 XSH_ASSURE_NOT_NULL( instr);
03000
03001 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_ORDER_TAB_CENTR, instr);
03002 check(result = xsh_find_frame (frames, tags));
03003
03004 cleanup:
03005 return result;
03006 }
03007
03008
03016
03017 cpl_frame *
03018 xsh_find_order_tab_edges( cpl_frameset *frames, xsh_instrument* instr)
03019 {
03020 const char *tags[3] = {NULL, NULL};
03021 cpl_frame* result = NULL;
03022
03023 XSH_ASSURE_NOT_NULL( frames);
03024 XSH_ASSURE_NOT_NULL( instr);
03025
03026 tags[0] = XSH_GET_TAG_FROM_MODE( XSH_ORDER_TAB_AFC, instr);
03027 tags[1] = XSH_GET_TAG_FROM_LAMP( XSH_ORDER_TAB_EDGES, instr);
03028
03029 check(result = xsh_find_frame (frames, tags));
03030
03031 xsh_msg_dbg_medium( "ORDER_TAB => %s", cpl_frame_get_filename( result));
03032 xsh_msg( "Use order tab: %s", cpl_frame_get_tag( result));
03033
03034 cleanup:
03035 return result;
03036 }
03037
03038
03046
03047 cpl_frame *
03048 xsh_find_wave_tab_guess( cpl_frameset *frames, xsh_instrument* instr)
03049 {
03050 const char *tags[2] = {NULL, NULL};
03051 cpl_frame* result = NULL;
03052
03053 XSH_ASSURE_NOT_NULL( frames);
03054 XSH_ASSURE_NOT_NULL( instr);
03055
03056 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_GUESS, instr);
03057 check(result = xsh_find_frame (frames, tags));
03058
03059 cleanup:
03060 return result;
03061 }
03062
03063
03071
03072 cpl_frame *
03073 xsh_find_wave_tab_2d( cpl_frameset *frames, xsh_instrument* instr)
03074 {
03075 const char *tags[2] = {NULL, NULL};
03076 cpl_frame* result = NULL;
03077
03078 XSH_ASSURE_NOT_NULL( frames);
03079 XSH_ASSURE_NOT_NULL( instr);
03080
03081 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_2D, instr);
03082 check(result = xsh_find_frame (frames, tags));
03083
03084 cleanup:
03085 return result;
03086 }
03087
03088
03096 cpl_frame *xsh_find_slitmap( cpl_frameset *frames,
03097 xsh_instrument* instr)
03098 {
03099 const char *tags[3] = {NULL, NULL, NULL};
03100 cpl_frame* result = NULL;
03101
03102 XSH_ASSURE_NOT_NULL( frames);
03103 XSH_ASSURE_NOT_NULL( instr);
03104
03105 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_SLIT_MAP, instr);
03106 tags[1] = XSH_GET_TAG_FROM_ARM( XSH_IFU_MAP, instr);
03107 check(result = xsh_find_frame (frames, tags));
03108
03109 cleanup:
03110 return result;
03111 }
03112
03113
03121
03122 cpl_frame *xsh_find_wave_tab( cpl_frameset *frames,
03123 xsh_instrument* instr)
03124 {
03125 const char *tags[4] = {NULL, NULL};
03126 cpl_frame* result = NULL;
03127
03128 XSH_ASSURE_NOT_NULL( frames);
03129 XSH_ASSURE_NOT_NULL( instr);
03130
03131 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_AFC, instr);
03132 tags[1] = XSH_GET_TAG_FROM_MODE( XSH_WAVE_TAB_ARC, instr);
03133 tags[2] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_2D, instr);
03134 check(result = xsh_find_frame (frames, tags));
03135
03136 cleanup:
03137 return result;
03138 }
03139
03140
03141
03149
03150 cpl_frame *
03151 xsh_find_model_config( cpl_frameset *frames, xsh_instrument* instr)
03152 {
03153 const char *tags[4] = {NULL, NULL};
03154 cpl_frame* result = NULL;
03155
03156 XSH_ASSURE_NOT_NULL( frames);
03157 XSH_ASSURE_NOT_NULL( instr);
03158
03159 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_MOD_CFG_OPT_AFC, instr);
03160 tags[1] = XSH_GET_TAG_FROM_ARM( XSH_MOD_CFG_OPT_2D, instr);
03161 tags[2] = XSH_GET_TAG_FROM_ARM( XSH_MOD_CFG_TAB, instr);
03162 check(result = xsh_find_frame (frames, tags));
03163
03164 cleanup:
03165 return result;
03166 }
03167
03168
03177
03178 cpl_frameset *
03179 xsh_find_wave_tab_ifu( cpl_frameset *frames, xsh_instrument* instrument)
03180 {
03181 const char * tags[3] = { NULL, NULL, NULL} ;
03182 cpl_frameset * result = NULL;
03183 cpl_frame * resframe = NULL ;
03184
03185 XSH_ASSURE_NOT_NULL( frames);
03186 XSH_ASSURE_NOT_NULL( instrument);
03187
03188
03189 check( result = cpl_frameset_new() ) ;
03190
03191
03192
03193
03194
03195
03196 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_AFC, instrument);
03197 tags[1] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_2D, instrument);
03198 resframe = xsh_find_frame (frames, tags) ;
03199 if (resframe != NULL ) {
03200 cpl_frame * down = NULL, * cen = NULL , * up = NULL ;
03201
03202 xsh_msg_warning( "Only one Wave Solution Frame %s, use it for the 3 slitlets",
03203 cpl_frame_get_filename( resframe)) ;
03204 check( down = cpl_frame_duplicate( resframe ) ) ;
03205 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_DOWN_IFU, instrument ) ;
03206 check( cpl_frame_set_tag( down, tags[0] ) ) ;
03207 check( cpl_frameset_insert( result, down ) ) ;
03208
03209 check( cen = cpl_frame_duplicate( resframe ) ) ;
03210 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_CEN_IFU, instrument ) ;
03211 check( cpl_frame_set_tag( cen, tags[0] ) ) ;
03212 check( cpl_frameset_insert( result, cen ) ) ;
03213
03214 check( up = cpl_frame_duplicate( resframe ) ) ;
03215 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_UP_IFU, instrument ) ;
03216 check( cpl_frame_set_tag( up, tags[0] ) ) ;
03217 check( cpl_frameset_insert( result, up ) ) ;
03218 }
03219 else {
03220 xsh_msg( "Three wave solution found" ) ;
03221
03222 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_DOWN_IFU, instrument ) ;
03223 check(resframe = xsh_find_frame (frames, tags));
03224 check( cpl_frameset_insert( result, resframe ) ) ;
03225
03226 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_CEN_IFU, instrument ) ;
03227 check(resframe = xsh_find_frame (frames, tags));
03228 check( cpl_frameset_insert( result, resframe ) ) ;
03229
03230 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_UP_IFU, instrument ) ;
03231 check(resframe = xsh_find_frame (frames, tags));
03232 check( cpl_frameset_insert( result, resframe ) ) ;
03233 }
03234
03235 cleanup:
03236 if ( cpl_error_get_code() != CPL_ERROR_NONE ) {
03237 cpl_frameset_delete( result ) ;
03238 return NULL ;
03239 }
03240 else return result;
03241 }
03242
03243
03244
03253
03254 cpl_frameset *
03255 xsh_find_offset_tab_ifu( cpl_frameset *frames, xsh_instrument* instr)
03256 {
03257 cpl_frameset *result = NULL;
03258 const char *tags[2] = {NULL, NULL};
03259 cpl_frame *down = NULL;
03260 cpl_frame *cen = NULL;
03261 cpl_frame *up = NULL;
03262
03263 XSH_ASSURE_NOT_NULL( frames);
03264 XSH_ASSURE_NOT_NULL( instr);
03265
03266
03267 check( result = cpl_frameset_new());
03268
03269
03270 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_OFFSET_DOWN_IFU, instr);
03271 check( down = xsh_find_frame (frames, tags));
03272 check( cpl_frameset_insert( result, cpl_frame_duplicate(down)));
03273
03274
03275 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_OFFSET_CEN_IFU, instr);
03276 check( cen = xsh_find_frame (frames, tags));
03277 check( cpl_frameset_insert( result, cpl_frame_duplicate(cen)));
03278
03279
03280 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_OFFSET_UP_IFU, instr);
03281 check( up = xsh_find_frame (frames, tags));
03282 check( cpl_frameset_insert( result, cpl_frame_duplicate(up)));
03283
03284 cleanup:
03285 if ( cpl_error_get_code() != CPL_ERROR_NONE ) {
03286 xsh_msg_warning( "No complete OFFSET_TAB dataset is found." \
03287 " The rectified spectra will not be straightened and the resulting" \
03288 " datacube may not be aligned.");
03289 xsh_free_frameset( &result);
03290 }
03291 return result;
03292 }
03293
03294
03295
03303
03304 cpl_frame *
03305 xsh_find_arc_line_list_clean( cpl_frameset *frames, xsh_instrument* instr)
03306 {
03307 const char *tags[2] = {NULL, NULL};
03308 cpl_frame* result = NULL;
03309
03310 XSH_ASSURE_NOT_NULL( frames);
03311 XSH_ASSURE_NOT_NULL( instr);
03312
03313 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_ARC_LINE_LIST, instr);
03314 check(result = xsh_find_frame (frames, tags));
03315
03316 cleanup:
03317 return result;
03318 }
03319
03320
03321
03329
03330 cpl_frame *
03331 xsh_find_arc_line_list( cpl_frameset *frames, xsh_instrument* instr)
03332 {
03333 const char *tags[2] = {NULL, NULL};
03334 cpl_frame* result = NULL;
03335
03336 XSH_ASSURE_NOT_NULL( frames);
03337 XSH_ASSURE_NOT_NULL( instr);
03338
03339 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_ARC_LINE_LIST, instr);
03340 check(result = xsh_find_frame (frames, tags));
03341
03342 cleanup:
03343 return result;
03344 }
03345
03353
03354 cpl_frame *
03355 xsh_find_usr_lines_guess_tab( cpl_frameset *frames, xsh_instrument* instr)
03356 {
03357 const char *tags[2] = {NULL, NULL};
03358 cpl_frame* result = NULL;
03359
03360 XSH_ASSURE_NOT_NULL( frames);
03361 XSH_ASSURE_NOT_NULL( instr);
03362
03363 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_GUESS_LINES_POS, instr);
03364 check(result = xsh_find_frame (frames, tags));
03365
03366 cleanup:
03367 return result;
03368 }
03369
03370
03378
03379 cpl_frame *
03380 xsh_find_model_config_tab( cpl_frameset *frames, xsh_instrument* instr)
03381 {
03382 const char *tags[2] = {NULL, NULL};
03383 cpl_frame* result = NULL;
03384
03385 XSH_ASSURE_NOT_NULL( frames);
03386 XSH_ASSURE_NOT_NULL( instr);
03387
03388 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_MOD_CFG_TAB, instr);
03389 check(result = xsh_find_frame (frames, tags));
03390
03391 cleanup:
03392 return result;
03393 }
03394
03405
03406 cpl_frame * xsh_find_wavemap(cpl_frameset *frames,
03407 xsh_instrument* instr)
03408 {
03409 const char *tags[2] ={NULL,NULL};
03410 cpl_frame* result = NULL;
03411
03412 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_MAP, instr);
03413 check(result = xsh_find_frame (frames,(const char**) tags));
03414
03415 cleanup:
03416 return result;
03417 }
03418
03426
03427
03428 cpl_frame * xsh_find_raw_orderdef_vis_uvb ( cpl_frameset * frames )
03429 {
03430 char *tags[4] ={NULL,NULL, NULL,NULL};
03431 cpl_frame* result = NULL;
03432 const char* tag=NULL;
03433 int nraw=0;
03434 check(tags[0] = xsh_stringcat_any( XSH_ORDERDEF_D2_UVB, NULL )) ;
03435 check(tags[1] = xsh_stringcat_any( XSH_ORDERDEF_QTH_UVB, NULL )) ;
03436 check(tags[2] = xsh_stringcat_any( XSH_ORDERDEF_VIS, NULL )) ;
03437
03438 check(result = xsh_find_frame (frames,(const char**) tags));
03439 tag=cpl_frame_get_tag(result);
03440 nraw=cpl_frameset_get_size(frames);
03441 if(nraw>1){
03442
03443 if(strcmp(tag,XSH_ORDERDEF_D2_UVB)==0) {
03444 cpl_frameset_erase(frames,XSH_ORDERDEF_QTH_UVB );
03445 } else if(strcmp(tag,XSH_ORDERDEF_QTH_UVB)==0){
03446 cpl_frameset_erase(frames,XSH_ORDERDEF_D2_UVB );
03447 }
03448 }
03449 xsh_msg("Use orderdef frame %s",tag);
03450 cleanup:
03451 cpl_free( tags[0]);
03452 cpl_free( tags[1]);
03453 cpl_free( tags[2]);
03454 return result;
03455 }
03456
03464
03465
03466 cpl_frame * xsh_find_raw_orderdef_nir( cpl_frameset * frames )
03467 {
03468 char *tags[] ={NULL,NULL};
03469 cpl_frame* result = NULL;
03470
03471 check(tags[0] = xsh_stringcat_any( XSH_ORDERDEF_NIR, NULL ) );
03472 check(result = xsh_find_frame (frames,(const char**) tags));
03473
03474 cleanup:
03475 cpl_free(tags[0]);
03476 return result;
03477 }
03478
03479
03488
03489 cpl_frame* xsh_find_disp_tab( cpl_frameset *frames,
03490 xsh_instrument* instr)
03491 {
03492 const char *tags[3] ={NULL,NULL};
03493 cpl_frame* result = NULL;
03494
03495 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_DISP_TAB_AFC, instr);
03496 tags[1] = XSH_GET_TAG_FROM_ARM( XSH_DISP_TAB, instr);
03497
03498 check( result = xsh_find_frame( frames,(const char**) tags));
03499
03500 if (result == NULL){
03501 xsh_msg( "No DISP TAB frame found !!");
03502 } else {
03503 xsh_msg( "Use DISP TAB %s",cpl_frame_get_tag(result));
03504 }
03505
03506 cleanup:
03507 return result;
03508 }
03509
03510
03511
03519
03520
03521 cpl_frame * xsh_find_raw_orderdef_nir_off( cpl_frameset * frames )
03522 {
03523 char *tags[] ={NULL,NULL};
03524 cpl_frame* result = NULL;
03525
03526 check(tags[0] = xsh_stringcat_any( XSH_ORDERDEF_OFF, NULL ) ) ;
03527 check(result = xsh_find_frame (frames,(const char**) tags));
03528
03529 cleanup:
03530 cpl_free(tags[0]);
03531 return result;
03532 }
03533
03541 cpl_frame * xsh_find_raw_arc_slit_uvb_vis( cpl_frameset * frames,
03542 XSH_ARM arm )
03543 {
03544 char *tags[] ={NULL,NULL};
03545 cpl_frame* result = NULL;
03546
03547 if ( arm == XSH_ARM_UVB )
03548 check( tags[0] = xsh_stringcat_any( XSH_ARC_SLIT_UVB, NULL ) ) ;
03549 else if ( arm == XSH_ARM_VIS )
03550 check( tags[0] = xsh_stringcat_any( XSH_ARC_SLIT_VIS, NULL ) ) ;
03551 else goto cleanup ;
03552
03553 check(result = xsh_find_frame (frames,(const char**) tags));
03554
03555 cleanup:
03556 cpl_free(tags[0]);
03557 return result;
03558 }
03559
03567 cpl_frame * xsh_find_raw_arc_slit_nir_on( cpl_frameset * frames )
03568 {
03569 char *tags[] ={NULL,NULL};
03570 cpl_frame* result = NULL;
03571
03572 check(tags[0] = xsh_stringcat_any( XSH_ARC_SLIT_NIR, NULL ) ) ;
03573 check(result = xsh_find_frame (frames,(const char**) tags));
03574
03575 cleanup:
03576 cpl_free(tags[0]);
03577 return result;
03578 }
03579
03587 cpl_frame * xsh_find_raw_arc_slit_nir_off( cpl_frameset * frames )
03588 {
03589 char *tags[] ={NULL,NULL};
03590 cpl_frame* result = NULL;
03591
03592 check(tags[0] = xsh_stringcat_any( XSH_ARC_SLIT_OFF, NULL ) ) ;
03593 check(result = xsh_find_frame (frames,(const char**) tags));
03594
03595 cleanup:
03596 cpl_free(tags[0]);
03597 return result;
03598 }
03599
03600
03609 cpl_frame * xsh_find_calpro_model_config( cpl_frameset * frames,
03610 xsh_instrument * instr )
03611 {
03612 char *tags[] ={NULL,NULL};
03613 cpl_frame* result = NULL;
03614
03615 check(tags[0] = xsh_stringcat_any( XSH_MOD_CFG,
03616 xsh_instrument_arm_tostring(instr),
03617 NULL ) ) ;
03618 xsh_msg_debug("tag=%s",tags[0]);
03619 check(result = xsh_find_frame (frames,(const char**) tags));
03620
03621 cleanup:
03622 cpl_free(tags[0]);
03623 return result;
03624 }
03625
03626
03636 cpl_frame * xsh_find_model_config_open( cpl_frameset * frames,
03637 xsh_instrument * instr )
03638 {
03639 char *tags[] ={NULL,NULL};
03640 cpl_frame* result = NULL;
03641
03642 check(tags[0] = xsh_stringcat_any( XSH_MOD_CFG_OPEN,
03643 xsh_instrument_arm_tostring(instr),
03644 NULL ) ) ;
03645 xsh_msg_debug("tag=%s",tags[0]);
03646 check(result = xsh_find_frame (frames,(const char**) tags));
03647
03648 cleanup:
03649 cpl_free(tags[0]);
03650 return result;
03651 }
03652
03653
03663 cpl_frame * xsh_find_calpro_model_meas_coord( cpl_frameset * frames,
03664 xsh_instrument * instr )
03665 {
03666 char *tags[] ={NULL,NULL};
03667 cpl_frame* result = NULL;
03668
03669 check(tags[0] = xsh_stringcat_any( XSH_MEASCOORD,
03670 xsh_instrument_arm_tostring(instr),
03671 NULL ) ) ;
03672 check(result = xsh_find_frame (frames,(const char**) tags));
03673
03674 cleanup:
03675 cpl_free(tags[0]);
03676 return result;
03677 }
03678
03688 cpl_frame * xsh_find_model_wavelist( cpl_frameset * frames,
03689 xsh_instrument * instr )
03690 {
03691 char *tags[] ={NULL,NULL};
03692 cpl_frame* result = NULL;
03693
03694 check(tags[0] = xsh_stringcat_any( XSH_MODEL_WAVE_LIST,
03695 xsh_instrument_arm_tostring(instr),
03696 NULL ) ) ;
03697 check(result = xsh_find_frame (frames,(const char**) tags));
03698
03699 cleanup:
03700 cpl_free(tags[0]);
03701 return result;
03702 }
03703
03704
03705
03715 cpl_frame * xsh_find_model_testpar( cpl_frameset * frames,
03716 xsh_instrument * instr )
03717 {
03718 char *tags[] ={NULL,NULL};
03719 cpl_frame* result = NULL;
03720
03721 check(tags[0] = xsh_stringcat_any( XSH_MODEL_TEST_PAR,
03722 xsh_instrument_arm_tostring(instr),
03723 NULL ) ) ;
03724 check(result = xsh_find_frame (frames,(const char**) tags));
03725
03726 cleanup:
03727 cpl_free(tags[0]);
03728 return result;
03729 }
03730
03731
03741 cpl_frame * xsh_find_spectral_format( cpl_frameset * frames,
03742 xsh_instrument * instr )
03743 {
03744 char *tags[] ={NULL,NULL};
03745 cpl_frame* result = NULL;
03746 if(instr->arm == XSH_ARM_NIR) {
03747 if((result=cpl_frameset_find(frames,XSH_SPECTRAL_FORMAT_JH_NIR)) != NULL){
03748 return result;
03749 }
03750 }
03751 check(tags[0] = xsh_stringcat_any( XSH_SPECTRAL_FORMAT,
03752 xsh_instrument_arm_tostring(instr),
03753 NULL ) ) ;
03754 check(result = xsh_find_frame (frames,(const char**) tags));
03755
03756 cleanup:
03757 cpl_free(tags[0]);
03758 return result;
03759 }
03760
03761
03771
03772 static cpl_frame *
03773 xsh_find_frame( cpl_frameset *frames, const char *tags[])
03774 {
03775 cpl_frame *frame = NULL;
03776 bool found = false;
03777 char *tags_string = NULL;
03778 char *temp = NULL;
03779 int i;
03780
03781 assure (frames != NULL, CPL_ERROR_NULL_INPUT, "Null frameset");
03782 assure (tags != NULL, CPL_ERROR_NULL_INPUT, "Null tags");
03783
03784 tags_string = xsh_stringdup ("");
03785
03786 for (i = 0; !found && tags[i] != NULL; i++) {
03787
03788 cpl_free (temp);
03789 temp = NULL;
03790 temp = xsh_stringdup (tags_string);
03791
03792 if (i == 0) {
03793 cpl_free (tags_string);
03794 tags_string = NULL;
03795 check (tags_string = xsh_stringdup (tags[i]));
03796 }
03797 else {
03798 cpl_free (tags_string);
03799 tags_string = NULL;
03800 check (tags_string = xsh_stringcat_3 (temp, ", ", tags[i]));
03801 }
03802
03803
03804 frame = cpl_frameset_find (frames, tags[i]);
03805
03806 if (frame != NULL) {
03807 found = true;
03808 }
03809 }
03810 if(!found) {
03811
03812
03813
03814
03815 }
03816 cleanup:
03817 cpl_free (tags_string);
03818 cpl_free (temp);
03819
03820 return frame;
03821 }
03822
03823 cpl_propertylist*
03824 xsh_frame_head_extract_qc(cpl_frame* frm) {
03825
03826 cpl_propertylist* qc = NULL;
03827 const char* name = NULL;
03828 name = cpl_frame_get_filename(frm);
03829 qc = cpl_propertylist_load_regexp(name, 0, "^ESO QC *", 0);
03830 return qc;
03831 }
03832
03833 cpl_boolean
03834 xsh_mode_is_physmod(cpl_frameset* set,xsh_instrument* instrument)
03835 {
03836 cpl_boolean found;
03837 cpl_frame* frm1=0;
03838 cpl_frame* frm2=0;
03839 cpl_frame* frm3=0;
03840 cpl_frame* frm4=0;
03841
03842 frm1=xsh_find_frame_with_tag( set, XSH_MOD_CFG_TAB,instrument);
03843 frm2=xsh_find_frame_with_tag( set, XSH_MOD_CFG_OPT_FMT,instrument);
03844 frm3=xsh_find_frame_with_tag( set, XSH_MOD_CFG_OPT_2D,instrument);
03845 frm4=xsh_find_frame_with_tag( set, XSH_MOD_CFG_OPT_AFC,instrument);
03846
03847 if(
03848 (frm1!=NULL) ||
03849 (frm2!=NULL) ||
03850 (frm3!=NULL) ||
03851 (frm4!=NULL)
03852 ) {
03853 found=CPL_TRUE;
03854 } else {
03855 found=CPL_FALSE;
03856 }
03857 return found;
03858 }
03859
03860 cpl_error_code
03861 xsh_dfs_check_binning(cpl_frameset* set,cpl_frameset* calib)
03862 {
03863
03864 cpl_frame* ref=NULL;
03865 cpl_frame* frm=NULL;
03866 const char* namer=NULL;
03867 const char* namef=NULL;
03868 const char* tagr=NULL;
03869 const char* tagf=NULL;
03870
03871
03872 cpl_propertylist* href=NULL;
03873 cpl_propertylist* head=NULL;
03874
03875 int ref_binx=0;
03876 int ref_biny=0;
03877
03878
03879 int frm_binx=0;
03880 int frm_biny=0;
03881 int frm_naxis=0;
03882
03883 int i=0;
03884 int ncal=0;
03885
03886 XSH_ASSURE_NOT_NULL_MSG(set,"Null input raw framest");
03887 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input cal framest");
03888
03889 check(ref=cpl_frameset_get_frame(set,0));
03890 namer=cpl_frame_get_filename(ref);
03891 tagr=cpl_frame_get_tag(ref);
03892
03893 href=cpl_propertylist_load(namer,0);
03894
03895 ref_binx=xsh_pfits_get_binx(href);
03896 ref_biny=xsh_pfits_get_biny(href);
03897
03898
03899 ncal=cpl_frameset_get_size(calib);
03900
03901 for(i=0;i<ncal;i++) {
03902
03903 frm=cpl_frameset_get_frame(calib,i);
03904 namef=cpl_frame_get_filename(frm);
03905 head=cpl_propertylist_load(namef,0);
03906 frm_naxis=xsh_pfits_get_naxis(head);
03907
03908 if(frm_naxis == 2) {
03909
03910 frm_binx=xsh_pfits_get_binx(head);
03911 frm_biny=xsh_pfits_get_biny(head);
03912
03913 if(frm_binx != ref_binx ||
03914 frm_biny != ref_biny )
03915 {
03916 tagf=cpl_frame_get_tag(frm);
03917 xsh_msg_error("Calib frame %s (tag=%s, bin=%d,%d)",
03918 namef,tagf,frm_binx,frm_biny);
03919 xsh_msg_error("mismatch raw frame's bin %s (tag=%s, bin=%d,%d).",
03920 namer,tagr,ref_binx,ref_biny);
03921 cpl_error_set(cpl_func,CPL_ERROR_ILLEGAL_INPUT);
03922 }
03923 }
03924 xsh_free_propertylist(&head);
03925
03926 }
03927 cleanup:
03928
03929 xsh_free_propertylist(&href);
03930 xsh_free_propertylist(&head);
03931 return cpl_error_get_code();
03932 }
03933
03934
03935
03936 static cpl_frame*
03937 xsh_frame_pre_subsample(cpl_frame* frm_i,const int binx, const int biny, const int rescale,xsh_instrument* inst)
03938 {
03939
03940 const char* name=NULL;
03941 xsh_pre* pre_i=NULL;
03942 xsh_pre* pre_o=NULL;
03943
03944 cpl_frame* frm_o=NULL;
03945 const char* tag=NULL;
03946
03947 const char* basename=NULL;
03948 char new_name[256];
03949 cpl_propertylist* plist=NULL;
03950 check(name=cpl_frame_get_filename(frm_i));
03951 check(tag=cpl_frame_get_tag(frm_i));
03952
03953 check(basename=xsh_get_basename(name));
03954
03955 sprintf(new_name,"fctx%d_fcty%d_%s",binx,biny,basename);
03956 pre_i=xsh_pre_load(frm_i,inst);
03957 xsh_msg("new_name=%s",new_name);
03958 plist=pre_i->data_header;
03959 xsh_plist_div_by_fct(&plist,binx,biny);
03960 pre_o=xsh_pre_subsample (pre_i, binx, biny, rescale,inst);
03961 xsh_free_propertylist(&(pre_o->data_header));
03962 xsh_free_propertylist(&(pre_o->errs_header));
03963 xsh_free_propertylist(&(pre_o->qual_header));
03964 pre_o->data_header=cpl_propertylist_duplicate(pre_i->data_header);
03965 pre_o->errs_header=cpl_propertylist_duplicate(pre_i->errs_header);
03966 pre_o->qual_header=cpl_propertylist_duplicate(pre_i->qual_header);
03967
03968 frm_o=xsh_pre_save(pre_o,new_name,tag,1);
03969
03970 cleanup:
03971
03972 xsh_pre_free(&pre_o);
03973 xsh_pre_free(&pre_i);
03974
03975 return frm_o;
03976 }
03977
03978
03979
03980
03981 static cpl_frameset*
03982 xsh_correct_frameset_calib_bin(cpl_frameset* input,const int ref_binx, const int ref_biny,xsh_instrument* inst)
03983 {
03984 cpl_frameset* correct=NULL;
03985 cpl_frame* frm=NULL;
03986 cpl_frame* frm_new=NULL;
03987 cpl_propertylist* plist=NULL;
03988
03989 const char* name=NULL;
03990 const char* tag=NULL;
03991 int inp_binx=1;
03992 int inp_biny=1;
03993 int i=0;
03994 int sz=0;
03995 int fctx=0;
03996 int fcty=0;
03997
03998 sz=cpl_frameset_get_size(input);
03999 correct=cpl_frameset_new();
04000 for(i=0;i<sz;i++) {
04001 frm=cpl_frameset_get_frame(input,i);
04002 name=cpl_frame_get_filename(frm);
04003 tag=cpl_frame_get_tag(frm);
04004 if(strstr(tag,"MASTER") != NULL) {
04005 plist=cpl_propertylist_load(name,0);
04006 inp_binx=xsh_pfits_get_binx(plist);
04007 inp_biny=xsh_pfits_get_biny(plist);
04008
04009 if(inp_binx < ref_binx || inp_biny < ref_biny) {
04010 xsh_msg("rescaling frame %s",cpl_frame_get_tag(frm));
04011 fctx=ref_binx/inp_binx;
04012 fcty=ref_biny/inp_biny;
04013 frm_new=xsh_frame_pre_subsample(frm,fctx,fcty,1,inst);
04014 check(cpl_frameset_insert(correct,frm_new));
04015 } else {
04016
04017 check(cpl_frameset_insert(correct,cpl_frame_duplicate(frm)));
04018 }
04019 } else {
04020 check(cpl_frameset_insert(correct,cpl_frame_duplicate(frm)));
04021 }
04022 xsh_free_propertylist(&plist);
04023
04024 }
04025
04026 cleanup:
04027 return correct;
04028 }
04029
04030
04031
04032 static cpl_frameset*
04033 xsh_correct_frameset_raws_bin(cpl_frameset* input,const int ref_binx, const int ref_biny,xsh_instrument* inst)
04034 {
04035 cpl_frameset* correct=NULL;
04036 cpl_frame* frm=NULL;
04037 cpl_frame* frm_new=NULL;
04038 cpl_propertylist* plist=NULL;
04039
04040 const char* name=NULL;
04041 int inp_binx=1;
04042 int inp_biny=1;
04043 int i=0;
04044 int sz=0;
04045 int fctx=0;
04046 int fcty=0;
04047
04048 sz=cpl_frameset_get_size(input);
04049 correct=cpl_frameset_new();
04050 for(i=0;i<sz;i++) {
04051 frm=cpl_frameset_get_frame(input,i);
04052 name=cpl_frame_get_filename(frm);
04053
04054 plist = cpl_propertylist_load(name, 0);
04055 inp_binx = xsh_pfits_get_binx(plist);
04056 inp_biny = xsh_pfits_get_biny(plist);
04057
04058
04059 xsh_msg("rescaling frame %s", cpl_frame_get_tag(frm));
04060
04061 fctx = ref_binx / inp_binx;
04062 fcty = ref_biny / inp_biny;
04063
04064 frm_new=xsh_frame_pre_subsample(frm,fctx,fcty,0,inst);
04065 check(cpl_frameset_insert(correct,frm_new));
04066
04067 xsh_free_propertylist(&plist);
04068
04069 }
04070
04071 cleanup:
04072 return correct;
04073 }
04074
04075
04076
04077
04078
04079
04080
04081
04082 cpl_error_code
04083 xsh_frameset_uniform_bin(cpl_frameset** raws, cpl_frameset** calib,xsh_instrument* instrument)
04084 {
04085
04086 if((*raws != NULL) && (*calib != NULL) && (xsh_instrument_get_arm(instrument) != XSH_ARM_NIR)) {
04087 int raw_binx=0;
04088 int raw_biny=0;
04089 int cal_binx=0;
04090 int cal_biny=0;
04091 const char* name=NULL;
04092 cpl_propertylist* plist=NULL;
04093
04094
04095
04096 cpl_frame* raw_frm=NULL;
04097 cpl_frame* mflat=NULL;
04098 raw_frm=cpl_frameset_get_frame(*raws,0);
04099
04100 name=cpl_frame_get_filename(raw_frm);
04101 plist=cpl_propertylist_load(name,0);
04102 raw_binx=xsh_pfits_get_binx(plist);
04103 raw_biny=xsh_pfits_get_biny(plist);
04104 xsh_free_propertylist(&plist);
04105
04106 if( (mflat = xsh_find_frame_with_tag(*calib,XSH_MASTER_FLAT_SLIT,instrument)) == NULL) {
04107 xsh_msg_error("Missing required input %s",XSH_GET_TAG_FROM_MODE ( XSH_MASTER_FLAT, instrument));
04108 cpl_error_set(cpl_func, CPL_ERROR_FILE_NOT_FOUND);
04109 goto cleanup;
04110 }
04111
04112 name=cpl_frame_get_filename(mflat);
04113 plist=cpl_propertylist_load(name,0);
04114 cal_binx=xsh_pfits_get_binx(plist);
04115 cal_biny=xsh_pfits_get_biny(plist);
04116 xsh_free_propertylist(&plist);
04117
04118
04119
04120
04121
04122
04123 if ( raw_binx == cal_binx && raw_biny == cal_biny) {
04124 } else if ( raw_binx > cal_binx || raw_biny > cal_biny) {
04125 check(*calib=xsh_correct_frameset_calib_bin(*calib,raw_binx,raw_biny,instrument));
04126 } else {
04127 check(*raws=xsh_correct_frameset_raws_bin(*raws,cal_binx,cal_biny,instrument));
04128
04129 }
04130
04131 }
04132
04133 cleanup:
04134
04135 return cpl_error_get_code();
04136
04137 }
04138
04139
04140 cpl_frameset*
04141 xsh_correct_calib(cpl_frameset* raws, cpl_frameset* calib){
04142 int raw_binx=1;
04143 int raw_biny=1;
04144 int cal_binx=1;
04145 int cal_biny=1;
04146 int fctx=0;
04147 int fcty=0;
04148
04149 cpl_propertylist* plist=NULL;
04150 const char* name=NULL;
04151 cpl_frame* frm=NULL;
04152 cpl_frame* frm_new=NULL;
04153 int i=0;
04154 int sz=0;
04155 const char* tag=NULL;
04156 cpl_frameset* calib_new=NULL;
04157
04158 check(frm=cpl_frameset_get_frame(raws,0));
04159 name=cpl_frame_get_filename(frm);
04160 plist=cpl_propertylist_load(name,0);
04161 raw_binx=xsh_pfits_get_binx(plist);
04162 raw_biny=xsh_pfits_get_biny(plist);
04163 xsh_free_propertylist(&plist);
04164 sz=cpl_frameset_get_size(calib);
04165
04166 calib_new=cpl_frameset_new();
04167 for(i=0;i<sz;i++) {
04168 frm=cpl_frameset_get_frame(calib,i);
04169 name=cpl_frame_get_filename(frm);
04170 tag=cpl_frame_get_tag(frm);
04171 if(strstr(tag,"MASTER") != NULL) {
04172 plist=cpl_propertylist_load(name,0);
04173 cal_binx=xsh_pfits_get_binx(plist);
04174 cal_biny=xsh_pfits_get_biny(plist);
04175
04176 if(cal_binx > raw_binx || cal_biny > raw_biny) {
04177 xsh_msg("rescaling frame %s",cpl_frame_get_tag(frm));
04178 fctx=cal_binx/raw_binx;
04179 fcty=cal_biny/raw_biny;
04180 frm_new=xsh_frame_image_mult_by_fct(frm,fctx,fcty);
04181 cpl_frameset_insert(calib_new,frm_new);
04182 } else if(cal_binx < raw_binx || cal_biny < raw_biny) {
04183 xsh_msg("rescaling frame %s",cpl_frame_get_tag(frm));
04184 fctx=raw_binx/cal_binx;
04185 fcty=raw_biny/cal_biny;
04186 frm_new=xsh_frame_image_div_by_fct(frm,fctx,fcty);
04187 check(cpl_frameset_insert(calib_new,frm_new));
04188 } else {
04189
04190 check(cpl_frameset_insert(calib_new,cpl_frame_duplicate(frm)));
04191 }
04192 } else {
04193 check(cpl_frameset_insert(calib_new,cpl_frame_duplicate(frm)));
04194 }
04195 xsh_free_propertylist(&plist);
04196
04197 }
04198
04199 cleanup:
04200 xsh_free_propertylist(&plist);
04201 xsh_free_frameset(&calib);
04202
04203 return calib_new;
04204
04205 }
04206
04207 static cpl_error_code
04208 xsh_frame_nir_tab_chop_Kband(cpl_frame* frame,const int absordmin,const char* colname)
04209 {
04210
04211 cpl_table* tab=NULL;
04212 cpl_table* ext=NULL;
04213 const char* name=NULL;
04214 const char* basename=NULL;
04215 char new_name[256];
04216 cpl_propertylist* head=NULL;
04217 cpl_propertylist* hext=NULL;
04218 int next=0;
04219 int i=0;
04220
04221 name=cpl_frame_get_filename(frame);
04222 basename=xsh_get_basename(name);
04223 sprintf(new_name,"cut_nir_HJ_%s",basename);
04224 next=cpl_frame_get_nextensions(frame);
04225
04226 head=cpl_propertylist_load(name,0);
04227 for(i=1;i<=next;i++) {
04228 tab=cpl_table_load(name,i,0);
04229 hext=cpl_propertylist_load(name,i);
04230 cpl_table_and_selected_int(tab,colname,CPL_GREATER_THAN,absordmin-1);
04231 ext=cpl_table_extract_selected(tab);
04232 if(i==1) {
04233 check(cpl_table_save(ext,head,hext,new_name,CPL_IO_DEFAULT));
04234 } else {
04235 check(cpl_table_save(ext,head,hext,new_name,CPL_IO_EXTEND));
04236 }
04237 xsh_free_propertylist(&hext);
04238 xsh_free_table(&tab);
04239 xsh_free_table(&ext);
04240 }
04241 cpl_frame_set_filename(frame,new_name);
04242
04243 cleanup:
04244 xsh_free_propertylist(&head);
04245 xsh_free_propertylist(&hext);
04246 xsh_free_table(&tab);
04247 xsh_free_table(&ext);
04248
04249 return cpl_error_get_code();
04250
04251 }
04252
04253
04254
04255 static cpl_error_code
04256 xsh_calib_nir_predict_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04257 {
04258 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04259 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04260
04261 cleanup:
04262 return cpl_error_get_code();
04263
04264 }
04265
04266 static cpl_error_code
04267 xsh_calib_nir_orderpos_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04268 {
04269 int absordmin=instr->config->order_min;
04270 cpl_frame* order_tab_guess=NULL;
04271 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04272 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04273
04274 if(NULL!= (order_tab_guess = xsh_find_frame_with_tag(calib,
04275 XSH_ORDER_TAB_GUESS,
04276 instr)) ) {
04277 xsh_frame_nir_tab_chop_Kband( order_tab_guess,absordmin,"ABSORDER");
04278 }
04279
04280
04281 cleanup:
04282 return cpl_error_get_code();
04283
04284 }
04285
04286
04287
04288 static cpl_error_code
04289 xsh_calib_nir_mflat_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04290 {
04291 cpl_frame* cen_order_tab_frame = NULL;
04292 int absordmin=instr->config->order_min;
04293
04294 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04295 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04296
04297 check( cen_order_tab_frame = xsh_find_order_tab_centr( calib, instr));
04298
04299 xsh_frame_nir_tab_chop_Kband( cen_order_tab_frame,absordmin,"ABSORDER");
04300
04301 cleanup:
04302
04303 return cpl_error_get_code();
04304
04305 }
04306
04307
04308 static cpl_error_code
04309 xsh_calib_nir_2dmap_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04310 {
04311 cpl_frame* order_tab_edges = NULL;
04312 cpl_frame* theo_tab_mult = NULL;
04313 int absordmin=instr->config->order_min;
04314
04315 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04316 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04317
04318 check(order_tab_edges = xsh_find_order_tab_edges( calib, instr));
04319 xsh_frame_nir_tab_chop_Kband(order_tab_edges,absordmin,"ABSORDER");
04320 if(NULL!=(theo_tab_mult = xsh_find_frame_with_tag( calib,XSH_THEO_TAB_MULT,
04321 instr))) {
04322 xsh_frame_nir_tab_chop_Kband(theo_tab_mult,absordmin,"Order");
04323
04324 }
04325
04326 cleanup:
04327
04328 return cpl_error_get_code();
04329
04330 }
04331
04332
04333
04334 static cpl_error_code
04335 xsh_calib_nir_wavecal_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04336 {
04337 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04338 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04339
04340 cpl_frame* order_tab_edges=NULL;
04341 cpl_frame* disp_tab_frame=NULL;
04342 int absordmin=instr->config->order_min;
04343 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04344 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04345
04346 check(order_tab_edges = xsh_find_order_tab_edges( calib, instr));
04347 xsh_frame_nir_tab_chop_Kband(order_tab_edges,absordmin,"ABSORDER");
04348 if(NULL != (disp_tab_frame = xsh_find_disp_tab( calib, instr))) {
04349 xsh_frame_nir_tab_chop_Kband(disp_tab_frame,absordmin,"ORDER");
04350 }
04351
04352
04353 cleanup:
04354 return cpl_error_get_code();
04355
04356 }
04357
04358
04359 static cpl_error_code
04360 xsh_calib_nir_scired_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04361 {
04362
04363 cpl_frame* order_tab_edges=NULL;
04364 cpl_frame* disp_tab_frame=NULL;
04365 cpl_frame* wave_tab_frame=NULL;
04366 int absordmin=instr->config->order_min;
04367 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04368 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04369
04370 check(order_tab_edges = xsh_find_order_tab_edges( calib, instr));
04371 check(xsh_frame_nir_tab_chop_Kband(order_tab_edges,absordmin,"ABSORDER"));
04372 if(NULL != (disp_tab_frame = xsh_find_disp_tab( calib, instr))) {
04373 check(xsh_frame_nir_tab_chop_Kband(disp_tab_frame,absordmin,"ORDER"));
04374 }
04375 if(NULL != (wave_tab_frame = xsh_find_wave_tab( calib, instr))) {
04376
04377 }
04378 cleanup:
04379 return cpl_error_get_code();
04380
04381 }
04382
04383
04384 cpl_error_code
04385 xsh_calib_nir_respon_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04386 {
04387 cpl_frame* edges_order_tab_frame = NULL;
04388 cpl_frame* spectral_format_frame = NULL;
04389 cpl_table* tab_edges=NULL;
04390
04391 const char* fname = NULL;
04392 double min=0;
04393
04394 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04395 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04396
04397 check( edges_order_tab_frame = xsh_find_order_tab_edges( calib, instr));
04398 fname=cpl_frame_get_filename(edges_order_tab_frame);
04399 tab_edges=cpl_table_load(fname,1,0);
04400 min=cpl_table_get_column_min(tab_edges,"ABSORDER");
04401
04402 if(min==13) {
04403 xsh_msg("entrato");
04404 instr->config->order_min=13;
04405 instr->config->order_max=26;
04406 instr->config->orders=14;
04407
04408
04409 check( spectral_format_frame = xsh_find_spectral_format( calib, instr));
04410 xsh_frame_nir_tab_chop_Kband( spectral_format_frame,13,"ORDER");
04411
04412
04413 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04414
04415
04416 }
04417
04418 cleanup:
04419 xsh_free_table(&tab_edges);
04420
04421 return cpl_error_get_code();
04422
04423 }
04424 cpl_error_code
04425 xsh_calib_nir_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr, const char* recid)
04426 {
04427
04428 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04429 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04430 XSH_ASSURE_NOT_NULL_MSG(recid,"Null input recid par");
04431
04432 if( instr->arm == XSH_ARM_NIR &&
04433 instr->config->order_min==13 &&
04434 instr->config->order_max==26 &&
04435 instr->config->orders==14
04436 ) {
04437
04438
04439 if(strcmp(recid,"xsh_predict") == 0) {
04440 check(xsh_calib_nir_predict_corr_if_JH(calib,instr));
04441 } else if(strcmp(recid,"xsh_orderpos") == 0) {
04442 check(xsh_calib_nir_orderpos_corr_if_JH(calib,instr));
04443 } else if(strcmp(recid,"xsh_mflat") == 0) {
04444 check(xsh_calib_nir_mflat_corr_if_JH(calib,instr));
04445 } else if(strcmp(recid,"xsh_2dmap") == 0) {
04446 check(xsh_calib_nir_2dmap_corr_if_JH(calib,instr));
04447 } else if(strcmp(recid,"xsh_wavecal") == 0) {
04448 check(xsh_calib_nir_wavecal_corr_if_JH(calib,instr));
04449 } else if(strcmp(recid,"xsh_flexcomp") == 0) {
04450 check(xsh_calib_nir_wavecal_corr_if_JH(calib,instr));
04451 } else if(strcmp(recid,"xsh_respon_slit_stare") == 0) {
04452 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04453 } else if(strcmp(recid,"xsh_respon_slit_offset") == 0) {
04454 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04455 } else if(strcmp(recid,"xsh_respon_slit_nod") == 0) {
04456 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04457 } else if(strcmp(recid,"xsh_scired_slit_stare") == 0) {
04458 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04459 } else if(strcmp(recid,"xsh_scired_slit_offset") == 0) {
04460 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04461 } else if(strcmp(recid,"xsh_scired_slit_nod") == 0) {
04462 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04463 }
04464
04465 }
04466 cleanup:
04467 return cpl_error_get_code();
04468
04469 }
04470
04471 cpl_error_code
04472 xsh_dfs_check_mflat_is_proper(xsh_instrument* inst,cpl_frameset** calib)
04473 {
04474
04475 cpl_frame* frm_mflat=NULL;
04476 cpl_frame* frm_mflat_new=NULL;
04477 int ref_binx=0;
04478 int ref_biny=0;
04479 int binx=0;
04480 int biny=0;
04481 int fctx=1;
04482 int fcty=1;
04483 cpl_propertylist* plist=NULL;
04484 const char* name=NULL;
04485 char tag[256];
04486
04487
04488 sprintf(tag,"%s_%s",XSH_MASTER_FLAT_SLIT,xsh_instrument_arm_tostring(inst));
04489 ref_binx=inst->binx;
04490 ref_biny=inst->biny;
04491 xsh_msg("tag=%s",tag);
04492 xsh_msg("binx=%d biny=%d",ref_binx,ref_biny);
04493 check(frm_mflat=cpl_frameset_find(*calib,tag));
04494 check(name=cpl_frame_get_filename(frm_mflat));
04495 plist=cpl_propertylist_load(name,0);
04496 binx=xsh_pfits_get_binx(plist);
04497 biny=xsh_pfits_get_biny(plist);
04498
04499 if(binx > ref_binx ||biny > ref_biny) {
04500 xsh_msg("compute syntetic frame by division");
04501 fctx=binx/ref_binx;
04502 fcty=biny/ref_biny;
04503 frm_mflat_new=xsh_frame_image_div_by_fct(frm_mflat,fctx,fcty);
04504 cpl_frameset_erase_frame(*calib,frm_mflat);
04505 cpl_frameset_insert(*calib,frm_mflat_new);
04506
04507 } else if(binx < ref_binx ||biny < ref_biny) {
04508 xsh_msg("compute syntetic frame by multiplication");
04509 fctx=ref_binx/binx;
04510 fcty=ref_biny/biny;
04511 frm_mflat_new=xsh_frame_image_mult_by_fct(frm_mflat,fctx,fcty);
04512 cpl_frameset_erase_frame(*calib,frm_mflat);
04513 cpl_frameset_insert(*calib,frm_mflat_new);
04514 } else {
04515 xsh_msg("keep same frame binx=%d ref_binx=%d biny=%d ref_biny=%d",
04516 binx,ref_binx,biny,ref_biny);
04517
04518 }
04519
04520
04521 cleanup:
04522 xsh_free_propertylist(&plist);
04523 return cpl_error_get_code();
04524
04525 }
04526
04527
04528 cpl_error_code
04529 xsh_frameset_check_uniform_exptime(cpl_frameset* raws, xsh_instrument* inst)
04530 {
04531 int i=0;
04532 int sz=0;
04533 cpl_frame* frm=NULL;
04534 cpl_propertylist* plist=NULL;
04535 const char* name=NULL;
04536 double ref_exptime=0;
04537 double tmp_exptime=0;
04538 XSH_ARM arm;
04539 arm=xsh_instrument_get_arm(inst);
04540 const char* info=NULL;
04541 if(arm==XSH_ARM_NIR) {
04542 info="DIT";
04543 } else {
04544 info="EXPTIME";
04545 }
04546 sz=cpl_frameset_get_size(raws);
04547 for(i=0;i<sz;i++){
04548 check(frm=cpl_frameset_get_frame(raws,i));
04549 name=cpl_frame_get_filename(frm);
04550 plist=cpl_propertylist_load(name,0);
04551
04552 if(i==0) {
04553 if(arm==XSH_ARM_NIR) {
04554 ref_exptime=xsh_pfits_get_dit(plist);
04555 } else {
04556 ref_exptime=xsh_pfits_get_det_win1_uit1(plist);
04557 }
04558 tmp_exptime=ref_exptime;
04559 } else {
04560 if(arm==XSH_ARM_NIR) {
04561 tmp_exptime=xsh_pfits_get_dit(plist);
04562 } else {
04563 tmp_exptime=xsh_pfits_get_det_win1_uit1(plist);
04564 }
04565 if( fabs(tmp_exptime-ref_exptime) > 0.001) {
04566 xsh_msg_error("Some dark has %s different from others.",info);
04567 xsh_msg("%s(%d)=%g %s(0)=%g",info,i,tmp_exptime,info,ref_exptime);
04568 cpl_error_set(cpl_func, CPL_ERROR_ILLEGAL_INPUT);
04569 }
04570 }
04571 xsh_free_propertylist(&plist);
04572 }
04573
04574 cleanup:
04575 xsh_free_propertylist(&plist);
04576 return cpl_error_get_code();
04577 }
04578
04579
04580 cpl_error_code
04581 xsh_table_save(cpl_table* t, cpl_propertylist* ph, cpl_propertylist* xh, const char* fname, const int ext) {
04582
04583 if (ext==0) {
04584 cpl_table_save(t,ph,xh,fname,CPL_IO_DEFAULT);
04585 } else {
04586 cpl_table_save(t,ph,xh,fname,CPL_IO_EXTEND);
04587 }
04588
04589 return cpl_error_get_code();
04590
04591 }
04592
04593 cpl_error_code
04594 xsh_vector_save(cpl_vector* v, cpl_propertylist* ph, const char* fname, const int ext) {
04595
04596 if (ext==0) {
04597 cpl_vector_save(v,fname,CPL_BPP_IEEE_FLOAT,ph,CPL_IO_DEFAULT);
04598 } else {
04599 cpl_vector_save(v,fname,CPL_BPP_IEEE_FLOAT,ph,CPL_IO_EXTEND);
04600 }
04601
04602 return cpl_error_get_code();
04603
04604 }
04605
04606 cpl_error_code
04607 xsh_add_afc_info(cpl_frame* frm_m, cpl_frame* frm_o) {
04608
04609 double yshift=0;
04610 double xshift=0;
04611 cpl_propertylist* head_m=NULL;
04612 cpl_propertylist* head_o=NULL;
04613 const char* name_m=NULL;
04614 const char* name_o=NULL;
04615 cpl_image* ima=NULL;
04616
04617 name_m=cpl_frame_get_filename(frm_m);
04618 name_o=cpl_frame_get_filename(frm_o);
04619 head_m=cpl_propertylist_load(name_m,0);
04620 head_o=cpl_propertylist_load(name_o,0);
04621 ima=cpl_image_load(name_o,XSH_PRE_DATA_TYPE,0,0);
04622
04623 if(cpl_propertylist_has(head_m,XSH_QC_AFC_XSHIFT)) {
04624 xshift=cpl_propertylist_get_double(head_m,XSH_QC_AFC_XSHIFT);
04625 cpl_propertylist_append_double(head_o,XSH_QC_AFC_XSHIFT,xshift);
04626 cpl_propertylist_set_comment(head_o,XSH_QC_AFC_XSHIFT,XSH_QC_AFC_XSHIFT_C);
04627 }
04628
04629 if(cpl_propertylist_has(head_m,XSH_QC_AFC_YSHIFT)) {
04630 yshift=cpl_propertylist_get_double(head_m,XSH_QC_AFC_YSHIFT);
04631 cpl_propertylist_append_double(head_o,XSH_QC_AFC_YSHIFT,yshift);
04632 cpl_propertylist_set_comment(head_o,XSH_QC_AFC_YSHIFT,XSH_QC_AFC_YSHIFT_C);
04633 }
04634
04635
04636 cpl_image_save(ima,name_o,XSH_PRE_DATA_BPP,head_o,CPL_IO_DEFAULT);
04637
04638 xsh_free_image(&ima);
04639 xsh_free_propertylist(&head_m);
04640 xsh_free_propertylist(&head_o);
04641
04642 return cpl_error_get_code();
04643
04644 }
04645
04646