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 cpl_propertylist* raw_header=NULL;
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 raw_header=cpl_propertylist_load(mod_name,0);
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
00753 check(nraws=cpl_frameset_get_size(raws));
00754 if ( (nraws % 2) != 0 ) {
00755 xsh_msg_warning("odd number of frames: nraws=%d",nraws);
00756 check(frame1=cpl_frameset_get_frame(raws,0));
00757 check(frame2=cpl_frameset_get_frame(raws,1));
00758 check(frameN=cpl_frameset_get_frame(raws,nraws-1));
00759 check(name1=cpl_frame_get_filename(frame1));
00760 check(name2=cpl_frame_get_filename(frame2));
00761 check(nameN=cpl_frame_get_filename(frameN));
00762 check(plist1=cpl_propertylist_load(name1,0));
00763 check(plist2=cpl_propertylist_load(name2,0));
00764 check(plistN=cpl_propertylist_load(nameN,0));
00765 check(yshift1=xsh_get_offsety(plist1));
00766 check(yshift2=xsh_get_offsety(plist2));
00767 check(yshiftN=xsh_get_offsety(plistN));
00768 if(yshift1 == yshiftN) {
00769 xsh_msg_warning("yshift(Frame1)==yshift(FrameN)");
00770 if ( fabs(yshift1-yshift2) <= DBL_MIN ) {
00771 xsh_msg_warning("yshift(Frame1)!=yshift(Frame2)");
00772 xsh_msg_warning("Remove last from list. Frame %s",
00773 cpl_frame_get_filename(frameN));
00774 cpl_frameset_erase_frame(raws,frameN);
00775 } else {
00776 xsh_msg_warning("yshift(Frame1)==yshift(Frame2)");
00777 xsh_msg_warning("Remove last from list. Frame %s",
00778 cpl_frame_get_filename(frameN));
00779 cpl_frameset_erase_frame(raws,frameN);
00780 }
00781 } else {
00782 xsh_msg_warning("yshift(Frame1)!=yshift(FrameN)");
00783 if (fabs(yshift1 - yshift2) <= DBL_MIN) {
00784 xsh_msg_warning("yshift(Frame1)!=yshift(Frame2)");
00785 xsh_msg_warning("Remove last from list. Frame %s",
00786 cpl_frame_get_filename(frameN));
00787 cpl_frameset_erase_frame(raws,frameN);
00788 } else {
00789 xsh_msg_warning("yshift(Frame1)==yshift(Frame2)");
00790 xsh_msg_warning("Remove first from list. Frame %s",
00791 cpl_frame_get_filename(frame1));
00792 cpl_frameset_erase_frame(raws,frame1);
00793 }
00794 }
00795 }
00796
00797 cleanup:
00798 xsh_free_propertylist(&plist1);
00799 xsh_free_propertylist(&plist2);
00800 xsh_free_propertylist(&plistN);
00801
00802 return cpl_error_get_code();
00803
00804 }
00810 int
00811 xsh_print_rec_status(const int val) {
00812 if(cpl_error_get_code() != CPL_ERROR_NONE) {
00813 xsh_msg_error("Recipe status at %d",val);
00814 xsh_msg_error("%s",(const char*) cpl_error_get_message());
00815 xsh_msg_error("%s",(const char*) cpl_error_get_where());
00816 return -1;
00817 }
00818 return 0;
00819 }
00820
00821
00833 void
00834 xsh_frame_config(const char* fname,
00835 const char* tag,
00836 cpl_frame_type type,
00837 cpl_frame_group group,
00838 cpl_frame_level level,
00839 cpl_frame** frame)
00840 {
00841
00842 check(cpl_frame_set_filename(*frame,fname));
00843 check(cpl_frame_set_tag(*frame,tag));
00844 check(cpl_frame_set_type(*frame,type));
00845 check(cpl_frame_set_group(*frame,group));
00846 check(cpl_frame_set_level(*frame,level));
00847
00848 cleanup:
00849
00850 return;
00851
00852 }
00863 cpl_frame*
00864 xsh_frame_product(const char* fname, const char* tag, cpl_frame_type type,
00865 cpl_frame_group group,cpl_frame_level level)
00866 {
00867 cpl_frame* frame=NULL;
00868 check(frame=cpl_frame_new());
00869
00870 check(xsh_frame_config(fname,tag,type,group,level,&frame));
00871
00872 return frame;
00873
00874 cleanup:
00875 xsh_free_frame(&frame);
00876
00877 return NULL;
00878 }
00879
00890
00891
00892
00893 int xsh_file_exists(const char * filename)
00894 {
00895 int exists=0;
00896 FILE* fo=NULL;
00897 if ((fo=fopen(filename,"r"))==NULL) {
00898 exists=0;
00899 } else {
00900 exists=1;
00901 }
00902 fclose(fo);
00903 return exists;
00904 }
00905
00906
00913
00914 cpl_frameset *
00915 xsh_frameset_extract(const cpl_frameset *frames,
00916 const char *tag)
00917 {
00918 cpl_frameset *subset = NULL;
00919 const cpl_frame *f;
00920
00921
00922
00923 assure( frames != NULL, CPL_ERROR_ILLEGAL_INPUT, "Null frameset" );
00924 assure( tag != NULL, CPL_ERROR_ILLEGAL_INPUT, "Null tag" );
00925
00926 subset = cpl_frameset_new();
00927
00928 for (f = cpl_frameset_find_const(frames, tag);
00929 f != NULL;
00930 f = cpl_frameset_find_const(frames, NULL)) {
00931
00932 cpl_frameset_insert(subset, cpl_frame_duplicate(f));
00933 }
00934 cleanup:
00935 return subset;
00936 }
00937
00944
00945 cpl_error_code
00946 xsh_frameset_merge(cpl_frameset * set1, cpl_frameset* set2)
00947 {
00948
00949 cpl_frame* frm_tmp=NULL;
00950 cpl_frame* frm_dup=NULL;
00951
00952 passure(set1 != NULL, "Wrong input set");
00953
00954 check(frm_tmp = cpl_frameset_get_first(set2));
00955 while (frm_tmp != NULL)
00956 {
00957 frm_dup=cpl_frame_duplicate(frm_tmp);
00958 cpl_frameset_insert(set1,frm_dup);
00959 frm_tmp = cpl_frameset_get_next(set2);
00960 }
00961
00962 cleanup:
00963 return cpl_error_get_code();
00964 }
00965
00966
00973
00974 xsh_instrument* xsh_dfs_set_groups (cpl_frameset * set)
00975 {
00976 cpl_frame * cur_frame = NULL;
00977 xsh_instrument* instrument = NULL;
00978
00979
00980 assure (set != NULL, CPL_ERROR_NULL_INPUT, "Null frame set");
00981 assure (!cpl_frameset_is_empty(set),CPL_ERROR_ILLEGAL_INPUT,
00982 "Empty frame set");
00983
00984
00985 instrument = xsh_instrument_new();
00986
00987
00988 for (cur_frame = cpl_frameset_get_first (set);
00989 cur_frame != NULL;
00990 cur_frame = cpl_frameset_get_next (set)) {
00991 const char *tag = NULL;
00992
00993 check(tag = cpl_frame_get_tag (cur_frame));
00994
00995
00996
00997 check(cpl_frame_set_group (cur_frame, CPL_FRAME_GROUP_NONE));
00998
00999
01000 if (XSH_IS_RAW (tag)) {
01001 check(cpl_frame_set_group (cur_frame, CPL_FRAME_GROUP_RAW));
01002 }
01003
01004 else if (XSH_IS_CALIB (tag)) {
01005 check(cpl_frame_set_group (cur_frame, CPL_FRAME_GROUP_CALIB));
01006 }
01007
01008 else {
01009 xsh_msg_error("Unrecognized frame tag '%s'",tag);
01010 check(cpl_error_set(cpl_func,CPL_ERROR_ILLEGAL_INPUT ));
01011
01012
01013 }
01014
01015
01016
01017 check_msg(xsh_instrument_parse_tag(instrument,tag),
01018 "invalid tag %s in file %s",
01019 tag, cpl_frame_get_filename (cur_frame));
01020 }
01021
01022 assure(xsh_instrument_get_arm(instrument)!=XSH_ARM_UNDEFINED,
01023 CPL_ERROR_TYPE_MISMATCH,"Arm is undefined");
01024 xsh_instrument_get_config( instrument ) ;
01025 xsh_msg( "Arm %s, Mode %s Nb Orders %d, min: %d, max: %d",
01026 xsh_instrument_arm_tostring(instrument),
01027 xsh_instrument_mode_tostring( instrument),
01028 instrument->config->orders, instrument->config->order_min,
01029 instrument->config->order_max ) ;
01030 cleanup:
01031 if (cpl_error_get_code () != CPL_ERROR_NONE){
01032 xsh_instrument_free(&instrument);
01033 instrument = NULL;
01034 }
01035 return instrument;
01036 }
01037
01044
01045 cpl_error_code
01046 xsh_dfs_extract_raw_frames (cpl_frameset * input, cpl_frameset * raws)
01047 {
01048 cpl_frame *cur_frame = NULL;
01049
01050
01051 for (cur_frame = cpl_frameset_get_first (input);
01052 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01053
01054 if (cpl_frame_get_group (cur_frame) == CPL_FRAME_GROUP_RAW) {
01055 cpl_frameset_insert (raws, cpl_frame_duplicate(cur_frame));
01056 }
01057 }
01058
01059 return cpl_error_get_code();
01060
01061 }
01062
01069
01070 cpl_error_code
01071 xsh_dfs_extract_calib_frames (cpl_frameset * input, cpl_frameset * calib)
01072 {
01073 cpl_frame *cur_frame = NULL;
01074
01075
01076 for (cur_frame = cpl_frameset_get_first (input);
01077 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01078
01079 if (cpl_frame_get_group (cur_frame) == CPL_FRAME_GROUP_CALIB) {
01080 cpl_frameset_insert (calib, cpl_frame_duplicate(cur_frame));
01081 }
01082 }
01083
01084 return cpl_error_get_code();
01085
01086 }
01087
01088
01095
01096 cpl_error_code
01097 xsh_dfs_extract_pro_frames (cpl_frameset * input, cpl_frameset * pros)
01098 {
01099 cpl_frame *cur_frame = NULL;
01100 XSH_ASSURE_NOT_NULL_MSG(pros,"Null pros frameset. Alllocated it outside!");
01101
01102 for (cur_frame = cpl_frameset_get_first (input);
01103 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01104
01105 if (cpl_frame_get_group (cur_frame) == CPL_FRAME_GROUP_PRODUCT) {
01106 cpl_frameset_insert (pros, cpl_frame_duplicate(cur_frame));
01107 }
01108 }
01109 cleanup:
01110 return cpl_error_get_code();
01111
01112 }
01113
01114
01121
01122 void
01123 xsh_dfs_split_in_group (cpl_frameset * input, cpl_frameset * raws,
01124 cpl_frameset * calib)
01125 {
01126 cpl_frame *cur_frame = NULL;
01127
01128
01129 for (cur_frame = cpl_frameset_get_first (input);
01130 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01131
01132 if (cpl_frame_get_group (cur_frame) == CPL_FRAME_GROUP_RAW) {
01133
01134 cpl_frameset_insert (raws, cpl_frame_duplicate(cur_frame));
01135 }
01136
01137 else if (cpl_frame_get_group (cur_frame) == CPL_FRAME_GROUP_CALIB) {
01138 cpl_frameset_insert (calib, cpl_frame_duplicate(cur_frame));
01139 }
01140
01141 else {
01142 xsh_msg_error ("Unrecognized group for frame %s",
01143 cpl_frame_get_filename (cur_frame));
01144 }
01145 }
01146 }
01147
01148
01149
01157
01158 void
01159 xsh_dfs_split_qth_d2(cpl_frameset * input,
01160 cpl_frameset** qth,
01161 cpl_frameset** d2)
01162 {
01163 cpl_frame* cur_frame = NULL;
01164 cpl_frame* temp =NULL;
01165
01166
01167 XSH_ASSURE_NOT_NULL( input);
01168 XSH_ASSURE_NOT_NULL( qth);
01169 XSH_ASSURE_NOT_NULL( d2);
01170
01171
01172 XSH_NEW_FRAMESET( *qth);
01173 XSH_NEW_FRAMESET( *d2);
01174
01175
01176 for (cur_frame = cpl_frameset_get_first (input);
01177 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01178 const char* tag = NULL;
01179
01180 check(tag = cpl_frame_get_tag(cur_frame));
01181
01182 if ( strstr(tag,"D2") != NULL) {
01183 check(temp = cpl_frame_duplicate(cur_frame));
01184 check(cpl_frameset_insert(*d2, temp));
01185 }
01186
01187 else if ( strstr(tag, "QTH") != NULL) {
01188 check(temp = cpl_frame_duplicate(cur_frame));
01189 check(cpl_frameset_insert(*qth, temp));
01190 }
01191
01192 else {
01193 xsh_msg_error ("Invalid tag %s for frame %s",tag,
01194 cpl_frame_get_filename (cur_frame));
01195 }
01196 }
01197
01198 cleanup:
01199 if (cpl_error_get_code() != CPL_ERROR_NONE){
01200 xsh_free_frame(&temp);
01201 xsh_free_frameset(d2);
01202 xsh_free_frameset(qth);
01203 }
01204 return;
01205 }
01206
01213
01214 void xsh_dfs_split_nir(cpl_frameset * input, cpl_frameset** on,
01215 cpl_frameset** off)
01216 {
01217 cpl_frame* cur_frame = NULL;
01218 cpl_frame* temp =NULL;
01219
01220
01221 XSH_ASSURE_NOT_NULL(input);
01222 XSH_ASSURE_NOT_NULL(on);
01223 XSH_ASSURE_NOT_NULL(off);
01224
01225
01226 XSH_NEW_FRAMESET(*on);
01227 XSH_NEW_FRAMESET(*off);
01228
01229
01230 for (cur_frame = cpl_frameset_get_first (input);
01231 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01232 const char* tag = NULL;
01233
01234 check(tag = cpl_frame_get_tag(cur_frame));
01235
01236 if ( strstr(tag,"ON") != NULL) {
01237 check(temp = cpl_frame_duplicate(cur_frame));
01238 check(cpl_frameset_insert(*on, temp));
01239 }
01240
01241 else if ( strstr(tag, "OFF") != NULL) {
01242 check(temp = cpl_frame_duplicate(cur_frame));
01243 check(cpl_frameset_insert(*off, temp));
01244 }
01245
01246 else {
01247 xsh_msg_error ("Invalid tag %s for frame %s",tag,
01248 cpl_frame_get_filename (cur_frame));
01249 }
01250 }
01251
01252 cleanup:
01253 if (cpl_error_get_code() != CPL_ERROR_NONE){
01254 xsh_free_frame(&temp);
01255 xsh_free_frameset(on);
01256 xsh_free_frameset(off);
01257 }
01258 return;
01259 }
01260
01261
01272
01273 int
01274 xsh_dfs_split_offset(cpl_frameset * input,
01275 const char * object_tag,
01276 const char * sky_tag,
01277 cpl_frameset ** object,
01278 cpl_frameset ** sky)
01279 {
01280 cpl_frame* cur_frame = NULL;
01281 cpl_frame* temp =NULL;
01282 int nobj = 0, nsky = 0 ;
01283
01284
01285 XSH_ASSURE_NOT_NULL(input);
01286 XSH_ASSURE_NOT_NULL(object);
01287 XSH_ASSURE_NOT_NULL(sky);
01288
01289
01290 *object=cpl_frameset_new();
01291 *sky=cpl_frameset_new();
01292
01293
01294 for (cur_frame = cpl_frameset_get_first (input);
01295 cur_frame != NULL; cur_frame = cpl_frameset_get_next (input)) {
01296 const char* tag = NULL;
01297
01298 check(tag = cpl_frame_get_tag(cur_frame));
01299
01300 xsh_msg_dbg_medium( "Tag: %s", tag ) ;
01301
01302 if ( strstr(tag, object_tag) != NULL) {
01303 check(temp = cpl_frame_duplicate(cur_frame));
01304 check(cpl_frameset_insert(*object, temp));
01305 nobj++ ;
01306 }
01307
01308 else if ( strstr(tag, sky_tag) != NULL) {
01309 check(temp = cpl_frame_duplicate(cur_frame));
01310 check(cpl_frameset_insert(*sky, temp));
01311 nsky++ ;
01312 }
01313
01314 else {
01315 xsh_msg_error ("Invalid tag %s for frame %s",tag,
01316 cpl_frame_get_filename (cur_frame));
01317 }
01318
01319 }
01320
01321 xsh_msg_dbg_medium( "Nobj: %d, Nsky: %d", nobj, nsky ) ;
01322 XSH_ASSURE_NOT_ILLEGAL( nobj == nsky ) ;
01323
01324 cleanup:
01325 if (cpl_error_get_code() != CPL_ERROR_NONE){
01326 xsh_print_rec_status(0);
01327 xsh_free_frame(&temp);
01328 return 0 ;
01329 }
01330 return nobj ;
01331 }
01332
01333
01334
01335
01342 static const char*
01343 xsh_create_final_tag(const char* pcatg_prefix, xsh_instrument* inst,
01344 const cpl_frame* frame)
01345 {
01346
01347
01348 const char* pro_catg=NULL;
01349
01350 if(pcatg_prefix==NULL) {
01351 pro_catg = cpl_frame_get_tag (frame);
01352 } else {
01353 pro_catg=xsh_stringcat_any(pcatg_prefix,"_",xsh_instrument_arm_tostring(inst),"" ) ;
01354 }
01355
01356 return pro_catg;
01357 }
01358
01364 static char*
01365 xsh_create_final_name(const char* final_prefix)
01366 {
01367 char* final_name=NULL;
01368 time_t now ;
01369 char* date = NULL ;
01370 if ( xsh_time_stamp_get() ) {
01371 time( &now ) ;
01372 date = xsh_sdate_utc( &now ) ;
01373 final_name = xsh_stringcat_any( XSH_PRODUCT_PREFIX,
01374 final_prefix, "_", date, ".fits", "" ) ;
01375 } else if ( strstr( final_prefix, ".fits" ) == NULL ) {
01376 final_name=xsh_stringcat_any(XSH_PRODUCT_PREFIX,final_prefix,".fits","");
01377 } else {
01378 final_name=xsh_stringcat_any(XSH_PRODUCT_PREFIX,final_prefix, "" );
01379 }
01380
01381 XSH_FREE(date);
01382
01383 return final_name;
01384 }
01385
01386
01398
01399 static bool
01400 xsh_dfs_tag_check( const char* tag, const char* tag_list[], int size)
01401 {
01402 int i;
01403
01404 for( i=0; i< size; i++){
01405 if ( strstr( tag, tag_list[i])!=NULL){
01406 return true;
01407 }
01408 }
01409 return false;
01410 }
01411
01412
01423
01424 void
01425 xsh_dfs_filter( cpl_frameset * set, const char* tags[], int size){
01426 cpl_frame *cur_frame = NULL;
01427
01428 XSH_ASSURE_NOT_NULL( set);
01429 XSH_ASSURE_NOT_NULL( tags);
01430 XSH_ASSURE_NOT_ILLEGAL( size > 0);
01431
01432
01433 check( cur_frame = cpl_frameset_get_first (set));
01434
01435 while(cur_frame != NULL){
01436 const char* ftag = NULL;
01437
01438 check( ftag = cpl_frame_get_tag( cur_frame));
01439 if (!xsh_dfs_tag_check( ftag, tags, size)){
01440 cpl_frame *del_frame = NULL;
01441
01442 del_frame = cur_frame;
01443 check( cur_frame = cpl_frameset_get_next( set));
01444 check( cpl_frameset_erase_frame( set, del_frame));
01445 }
01446 else{
01447 check(cur_frame = cpl_frameset_get_next (set));
01448 }
01449 }
01450
01451 cleanup:
01452 return;
01453 }
01454
01455
01463
01464 cpl_frameset *
01465 xsh_frameset_extract_pre(cpl_frameset * frameset, const char* prefix)
01466 {
01467 cpl_frameset* set=NULL;
01468 cpl_frame* current=NULL;
01469 cpl_frame* found=NULL;
01470 int sz=0;
01471 int i=0;
01472 char tag[80];
01473 char name[80];
01474
01475 check(sz=cpl_frameset_get_size(frameset));
01476
01477 check(set=cpl_frameset_new());
01478 for(i=0;i<sz;i++) {
01479 check( current = cpl_frameset_get_frame(frameset, i));
01480 sprintf(name, "%s_PRE_%d.fits", prefix, i);
01481 sprintf(tag, "%s_PRE_%d", prefix, i);
01482
01483 if(xsh_file_exists(name) == 1) {
01484 check(found=cpl_frame_duplicate(current));
01485 check( cpl_frame_set_filename(found, name) );
01486 cpl_frameset_insert(set,found);
01487 }
01488
01489 }
01490 cleanup:
01491
01492 return set;
01493
01494 }
01495
01496
01502
01503 cpl_frame *
01504 xsh_find_bpmap (cpl_frameset * set)
01505 {
01506 cpl_frame *cur_frame = NULL;
01507
01508
01509 for (cur_frame = cpl_frameset_get_first (set);
01510 cur_frame != NULL; cur_frame = cpl_frameset_get_next (set)) {
01511 if (strstr (cpl_frame_get_tag (cur_frame), "BADPIXEL_MAP")) {
01512 return cur_frame;
01513 }
01514 }
01515 return NULL;
01516 }
01517
01518
01519
01525
01526 cpl_frame *
01527 xsh_find_master_bpmap (cpl_frameset * set)
01528 {
01529 cpl_frame *cur_frame = NULL;
01530
01531
01532 for (cur_frame = cpl_frameset_get_first (set);
01533 cur_frame != NULL; cur_frame = cpl_frameset_get_next (set)) {
01534 if (strstr (cpl_frame_get_tag (cur_frame), XSH_MASTER_BP_MAP)) {
01535 return cur_frame;
01536 }
01537 }
01538 return NULL;
01539 }
01540
01541
01547
01548 cpl_frame * xsh_find_off(cpl_frameset* set)
01549 {
01550 cpl_frame *cur_frame = NULL;
01551
01552
01553 for (cur_frame = cpl_frameset_get_first (set);
01554 cur_frame != NULL; cur_frame = cpl_frameset_get_next (set)) {
01555 if (strstr (cpl_frame_get_tag (cur_frame), "OFF")) {
01556 return cur_frame;
01557 }
01558 }
01559 return NULL;
01560 }
01561
01562
01568
01569 cpl_frame * xsh_find_on(cpl_frameset* set)
01570 {
01571 cpl_frame *cur_frame = NULL;
01572
01573
01574 for (cur_frame = cpl_frameset_get_first (set);
01575 cur_frame != NULL; cur_frame = cpl_frameset_get_next (set)) {
01576 if (strstr (cpl_frame_get_tag (cur_frame), "ON")) {
01577 return cur_frame;
01578 }
01579 }
01580 return NULL;
01581 }
01582
01589
01590 void
01591 xsh_dfs_find_flat(cpl_frameset* raws,cpl_frameset* flat)
01592 {
01593 cpl_frame *cur_frame = NULL;
01594 const char* tag = NULL;
01595
01596 assure (raws != NULL, CPL_ERROR_NULL_INPUT, "Null frameset");
01597 assure (flat != NULL, CPL_ERROR_NULL_INPUT, "Null frameset");
01598
01599
01600 tag = cpl_frame_get_tag(cpl_frameset_get_first(raws));
01601
01602
01603 for (cur_frame = cpl_frameset_get_first (raws);
01604 cur_frame != NULL; cur_frame = cpl_frameset_get_next (raws))
01605 {
01606 tag = cpl_frame_get_tag (cur_frame);
01607 if (strstr(tag,"FLAT")!=NULL)
01608 cpl_frameset_insert (flat, cur_frame);
01609 }
01610
01611 cleanup:
01612 return;
01613
01614 }
01615
01616
01631
01632 char *
01633 xsh_unique_filename (const char *context, const char *caller_id,
01634 const char *pro_catg)
01635 {
01636 if (context != NULL) {
01637
01638 return xsh_stringcat_6 (context, "-", caller_id, "-", pro_catg, ".fits");
01639 }
01640 else {
01641 return xsh_stringcat_4 (caller_id, "-", pro_catg, ".fits");
01642 }
01643 }
01644
01645
01657 void xsh_add_product(cpl_frame *frame,
01658 cpl_frameset * frameset,
01659 const cpl_parameterlist * parameters,
01660 const char *recipe_id,
01661 xsh_instrument* instrument,
01662 const char *final_prefix ,
01663 const char* type)
01664 {
01665 cpl_propertylist *primary_header = NULL;
01666 cpl_propertylist *tbl_header = NULL;
01667 int extension=0;
01668 const char *pro_catg = NULL;
01669 cpl_frame* product_frame = NULL;
01670
01671 cpl_table *table = NULL ;
01672 cpl_image *image = NULL ;
01673 cpl_imagelist *imagelist = NULL ;
01674
01675
01676 const char *fname = NULL;
01677 char *final_name = NULL ;
01678 char* date = NULL ;
01679
01680
01681
01682 XSH_ASSURE_NOT_NULL(frame);
01683 XSH_ASSURE_NOT_NULL(frameset);
01684 XSH_ASSURE_NOT_NULL(parameters);
01685 XSH_ASSURE_NOT_NULL(recipe_id);
01686 XSH_ASSURE_NOT_NULL(instrument);
01687 XSH_ASSURE_NOT_NULL(final_prefix);
01688
01689 check(pro_catg = cpl_frame_get_tag (frame));
01690 XSH_ASSURE_NOT_NULL(pro_catg);
01691
01692
01693 check(fname = cpl_frame_get_filename( frame ));
01694 check(primary_header = cpl_propertylist_load( fname, 0 ));
01695
01696 if(strcmp(type,"imagelist") == 0) {
01697 check(imagelist = cpl_imagelist_load( fname, CPL_TYPE_FLOAT, 0 ));
01698 } else if(strcmp(type,"image") == 0) {
01699 check(image = cpl_image_load( fname, CPL_TYPE_FLOAT, 0,0 ));
01700 } else if(strcmp(type,"table") == 0) {
01701 check(table = cpl_table_load( fname, 1,0 ));
01702 } else {
01703 xsh_msg_error("Frame type %s not supported",type);
01704 }
01705
01706
01707 check( cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT));
01708 check_msg (cpl_dfs_setup_product_header ( primary_header,
01709 frame,frameset,parameters,
01710 recipe_id,
01711 instrument->pipeline_id,
01712 instrument->dictionary,NULL),
01713 "Problem in the product DFS-compliance");
01714
01715
01716 final_name=xsh_create_final_name(final_prefix);
01717
01718 xsh_msg_dbg_low( "Final product name: %s", final_name ) ;
01719
01720
01721
01722
01723 if(strcmp(type,"imagelist") == 0) {
01724 cpl_imagelist_save(imagelist, final_name, CPL_BPP_IEEE_FLOAT,
01725 primary_header,CPL_IO_DEFAULT ) ;
01726 } else if(strcmp(type,"image") == 0) {
01727 cpl_image_save(image, final_name, CPL_BPP_IEEE_FLOAT,
01728 primary_header,CPL_IO_DEFAULT ) ;
01729 } else if(strcmp(type,"table") == 0) {
01730 check(cpl_table_save( table, primary_header, tbl_header,
01731 final_name, extension ));
01732 }
01733
01734
01735
01736
01737
01738
01739
01740
01741
01742
01743
01744
01745
01746
01747
01748
01749
01750 if(strcmp(type,"imagelist") == 0) {
01751 check(product_frame=xsh_frame_product(final_name,pro_catg,
01752 CPL_FRAME_TYPE_IMAGE,
01753 CPL_FRAME_GROUP_PRODUCT,
01754 CPL_FRAME_LEVEL_FINAL));
01755 } else if(strcmp(type,"image") == 0) {
01756 check(product_frame=xsh_frame_product(final_name,pro_catg,
01757 CPL_FRAME_TYPE_IMAGE,
01758 CPL_FRAME_GROUP_PRODUCT,
01759 CPL_FRAME_LEVEL_FINAL));
01760 } else if(strcmp(type,"table") == 0) {
01761 check(product_frame=xsh_frame_product(final_name,pro_catg,
01762 CPL_FRAME_TYPE_TABLE,
01763 CPL_FRAME_GROUP_PRODUCT,
01764 CPL_FRAME_LEVEL_FINAL));
01765
01766 }
01767
01768 check(cpl_frameset_insert(frameset, product_frame));
01769 xsh_add_product_file(final_name);
01770 cleanup:
01771 XSH_FREE(date);
01772 xsh_free_propertylist(&primary_header);
01773 xsh_free_image( &image ) ;
01774 xsh_free_imagelist( &imagelist ) ;
01775 xsh_free_table( &table ) ;
01776 XSH_FREE( final_name ) ;
01777
01778 return;
01779 }
01780
01790 void
01791 xsh_add_product_vector( cpl_frame *frame,
01792 cpl_frameset *frameset,
01793 const cpl_parameterlist *parameters,
01794 const char *recipe_id,
01795 xsh_instrument* instrument,
01796 const char * final_prefix)
01797 {
01798
01799 cpl_vector *vect = NULL;
01800 cpl_propertylist *primary_header = NULL;
01801 const char *pro_catg = "";
01802 cpl_frame* product_frame = NULL;
01803 const char *fname = NULL;
01804 char *final_name = NULL ;
01805
01806 char* date = NULL ;
01807
01808
01809
01810 XSH_ASSURE_NOT_NULL(frame);
01811 XSH_ASSURE_NOT_NULL(frameset);
01812 XSH_ASSURE_NOT_NULL(parameters);
01813 XSH_ASSURE_NOT_NULL(recipe_id);
01814 XSH_ASSURE_NOT_NULL(instrument);
01815 XSH_ASSURE_NOT_NULL(final_prefix);
01816
01817 check(pro_catg = cpl_frame_get_tag (frame));
01818 XSH_ASSURE_NOT_NULL(pro_catg);
01819
01820
01821 check( fname = cpl_frame_get_filename( frame));
01822 check( primary_header = cpl_propertylist_load( fname, 0));
01823 check( vect = cpl_vector_load( fname, 0));
01824
01825
01826 check( cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT));
01827 check_msg (cpl_dfs_setup_product_header ( primary_header,
01828 frame,frameset,parameters,
01829 recipe_id,
01830 instrument->pipeline_id,
01831 instrument->dictionary,NULL),
01832 "Problem in the product DFS-compliance");
01833
01834
01835 final_name=xsh_create_final_name(final_prefix);
01836 xsh_msg_dbg_low( "Final product name: %s", final_name ) ;
01837
01838
01839 check( cpl_vector_save( vect, final_name, XSH_PRE_QUAL_BPP,
01840 primary_header, CPL_IO_CREATE));
01841
01842
01843 check(product_frame=xsh_frame_product(final_name,pro_catg,
01844 CPL_FRAME_TYPE_IMAGE,
01845 CPL_FRAME_GROUP_PRODUCT,
01846 CPL_FRAME_LEVEL_FINAL));
01847
01848 check(cpl_frameset_insert(frameset, product_frame));
01849 xsh_add_product_file(final_name);
01850
01851 cleanup:
01852 if (cpl_error_get_code () != CPL_ERROR_NONE) {
01853 xsh_free_frame( &product_frame);
01854 product_frame = NULL;
01855 }
01856 XSH_FREE(date);
01857 xsh_free_propertylist(&primary_header);
01858 xsh_free_vector( &vect) ;
01859 XSH_FREE( final_name);
01860 return;
01861 }
01862
01872 void
01873 xsh_add_product_spectrum( cpl_frame *frame,
01874 cpl_frameset *frameset,
01875 const cpl_parameterlist *parameters,
01876 const char *recipe_id,
01877 xsh_instrument* instr)
01878 {
01879
01880 const char *pro_catg = "";
01881 xsh_spectrum *spectrum = NULL;
01882 cpl_frame *product_frame = NULL;
01883 char product_id[256];
01884 char* product_name = NULL;
01885
01886 time_t now ;
01887 char* date = NULL;
01888
01889
01890 XSH_ASSURE_NOT_NULL( frame);
01891 XSH_ASSURE_NOT_NULL( frameset);
01892 XSH_ASSURE_NOT_NULL( parameters);
01893 XSH_ASSURE_NOT_NULL( recipe_id);
01894 XSH_ASSURE_NOT_NULL( instr);
01895
01896 check( pro_catg = cpl_frame_get_tag (frame));
01897
01898 assure( pro_catg != NULL, CPL_ERROR_NULL_INPUT,
01899 "Frame tag has not been set");
01900
01901
01902 check( spectrum = xsh_spectrum_load( frame));
01903
01904
01905 cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT);
01906 check( cpl_dfs_setup_product_header( spectrum->flux_header,
01907 frame, frameset, parameters, recipe_id, instr->pipeline_id,
01908 instr->dictionary, NULL));
01909
01910 if (xsh_time_stamp_get() ){
01911 time( &now );
01912 date = xsh_sdate_utc(&now);
01913 sprintf( product_id, "%s%s_%s", XSH_PRODUCT_PREFIX,
01914 pro_catg, date);
01915 }
01916 else {
01917 sprintf( product_id, "%s%s", XSH_PRODUCT_PREFIX,
01918 pro_catg);
01919 }
01920 product_name = xsh_stringcat_any( product_id, ".fits", NULL);
01921 check( product_frame = xsh_spectrum_save(spectrum, product_name,pro_catg));
01922
01923
01924
01925
01926
01927
01928
01929
01930
01931
01932
01933 cpl_frame_set_type( product_frame, CPL_FRAME_TYPE_IMAGE);
01934 cpl_frame_set_group( product_frame, CPL_FRAME_GROUP_PRODUCT);
01935 cpl_frame_set_level( product_frame, CPL_FRAME_LEVEL_FINAL);
01936 cpl_frame_set_tag( product_frame, pro_catg);
01937 cpl_frameset_insert( frameset, product_frame);
01938 xsh_add_product_file(product_name);
01939
01940 cleanup:
01941 if (cpl_error_get_code () != CPL_ERROR_NONE) {
01942 xsh_free_frame( &product_frame);
01943 product_frame = NULL;
01944 }
01945 XSH_FREE( date);
01946 xsh_spectrum_free( &spectrum);
01947 XSH_FREE( product_name);
01948
01949 return;
01950 }
01951
01952
01977
01978 void
01979 xsh_add_product_pre (cpl_frame * frame,
01980 cpl_frameset * frameset,
01981 const cpl_parameterlist *parameters,
01982 const char *recipe_id,
01983 xsh_instrument* instr)
01984 {
01985 const char *pro_catg = "";
01986 xsh_pre* product_pre = NULL;
01987 cpl_frame* product_frame = NULL;
01988 char product_id[256];
01989 char* product_name = NULL;
01990
01991 time_t now ;
01992 char* date = NULL;
01993 cpl_propertylist* plist=NULL;
01994 char arcfile[80];
01995 bool arcfile_found=false;
01996
01997
01998 XSH_ASSURE_NOT_NULL( frame);
01999 XSH_ASSURE_NOT_NULL( frameset);
02000 XSH_ASSURE_NOT_NULL( parameters);
02001 XSH_ASSURE_NOT_NULL( recipe_id);
02002 XSH_ASSURE_NOT_NULL( instr);
02003
02004 check( pro_catg = cpl_frame_get_tag (frame));
02005
02006 assure( pro_catg != NULL, CPL_ERROR_NULL_INPUT,
02007 "Frame tag has not been set");
02008
02009
02010 check( product_pre = xsh_pre_load( frame,instr));
02011 if(cpl_propertylist_has(product_pre->data_header,"ARCFILE")) {
02012 sprintf(arcfile,"%s",xsh_pfits_get_arcfile(product_pre->data_header));
02013 arcfile_found=true;
02014 }
02015
02016 cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT);
02017 check( cpl_dfs_setup_product_header( product_pre->data_header,
02018 frame, frameset, parameters, recipe_id, instr->pipeline_id,
02019 instr->dictionary,NULL));
02020
02021
02022 if (xsh_time_stamp_get() ){
02023 time( &now );
02024 date = xsh_sdate_utc(&now);
02025 sprintf( product_id, XSH_PRODUCT_PREFIX, "%s%s_%s",
02026 pro_catg, product_pre->binx, product_pre->biny, date);
02027 }
02028 else {
02029 sprintf( product_id, "%s%s", XSH_PRODUCT_PREFIX,
02030 pro_catg, product_pre->binx, product_pre->biny);
02031 }
02032 product_name = xsh_stringcat_any( product_id, ".fits", NULL);
02033 check( product_frame = xsh_pre_save( product_pre, product_name, pro_catg,0));
02034
02035
02036
02037
02038
02039 check(plist=cpl_propertylist_duplicate(product_pre->data_header));
02040 if(arcfile_found) {
02041
02042 check(cpl_propertylist_append_string(plist,"ARCFILE",arcfile));
02043 check(cpl_propertylist_set_comment(plist,"ARCFILE","Archive File Name"));
02044
02045
02046
02047
02048 } else {
02049
02050
02051
02052
02053
02054 }
02055
02056
02057 cpl_frame_set_type( product_frame, CPL_FRAME_TYPE_IMAGE);
02058 cpl_frame_set_group( product_frame, CPL_FRAME_GROUP_PRODUCT);
02059 cpl_frame_set_level( product_frame, CPL_FRAME_LEVEL_FINAL);
02060 cpl_frame_set_tag( product_frame, pro_catg);
02061 cpl_frameset_insert( frameset, product_frame);
02062 xsh_add_product_file(product_name);
02063
02064 cleanup:
02065 if (cpl_error_get_code () != CPL_ERROR_NONE) {
02066 xsh_free_frame( &product_frame);
02067 product_frame = NULL;
02068 }
02069 XSH_FREE( date);
02070 xsh_pre_free( &product_pre);
02071 xsh_free_propertylist(&plist);
02072 XSH_FREE( product_name);
02073
02074 return;
02075 }
02076
02077
02089
02090 void
02091 xsh_add_product_pre_3d( cpl_frame * frame,
02092 cpl_frameset * frameset,
02093 const cpl_parameterlist *parameters,
02094 const char *recipe_id,
02095 xsh_instrument* instr)
02096 {
02097 const char * pro_catg = "";
02098 xsh_pre_3d * product_pre = NULL;
02099 cpl_frame * product_frame = NULL;
02100 char product_id[256];
02101 char * product_name = NULL;
02102
02103 time_t now ;
02104 char * date = NULL;
02105
02106
02107 XSH_ASSURE_NOT_NULL( frame);
02108 XSH_ASSURE_NOT_NULL( frameset);
02109 XSH_ASSURE_NOT_NULL( parameters);
02110 XSH_ASSURE_NOT_NULL( recipe_id);
02111 XSH_ASSURE_NOT_NULL( instr);
02112
02113 check( pro_catg = cpl_frame_get_tag (frame));
02114
02115 assure( pro_catg != NULL, CPL_ERROR_NULL_INPUT,
02116 "Frame tag has not been set");
02117
02118
02119 check( product_pre = xsh_pre_3d_load( frame));
02120
02121
02122 cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT);
02123 check( cpl_dfs_setup_product_header( product_pre->data_header,
02124 frame, frameset, parameters,
02125 recipe_id, instr->pipeline_id,
02126 instr->dictionary,NULL));
02127
02128
02129 if (xsh_time_stamp_get() ){
02130 time( &now );
02131 date = xsh_sdate_utc(&now);
02132 sprintf( product_id, XSH_PRODUCT_PREFIX, "%s%s_%s",
02133 pro_catg, date);
02134 }
02135 else {
02136 sprintf( product_id, "%s%s", XSH_PRODUCT_PREFIX, pro_catg );
02137 }
02138 product_name = xsh_stringcat_any( product_id, ".fits", NULL);
02139 check( product_frame = xsh_pre_3d_save( product_pre, product_name, 0));
02140
02141
02142
02143
02144
02145
02146
02147
02148
02149
02150 cpl_frame_set_type( product_frame, CPL_FRAME_TYPE_IMAGE);
02151 cpl_frame_set_group( product_frame, CPL_FRAME_GROUP_PRODUCT);
02152 cpl_frame_set_level( product_frame, CPL_FRAME_LEVEL_FINAL);
02153 cpl_frame_set_tag( product_frame, pro_catg);
02154 cpl_frameset_insert( frameset, product_frame);
02155 xsh_add_product_file(product_name);
02156
02157 cleanup:
02158 if (cpl_error_get_code () != CPL_ERROR_NONE) {
02159 xsh_free_frame( &product_frame);
02160 product_frame = NULL;
02161 }
02162 XSH_FREE( date);
02163 xsh_pre_3d_free( &product_pre);
02164 XSH_FREE( product_name);
02165
02166 return;
02167 }
02168
02179 void
02180 xsh_add_product_bpmap( cpl_frame *frame,
02181 cpl_frameset * frameset,
02182 const cpl_parameterlist * parameters,
02183 const char *recipe_id,
02184 xsh_instrument* instrument,
02185 const char *final_prefix )
02186 {
02187 cpl_propertylist *primary_header = NULL;
02188 const char* pro_catg=NULL;
02189 cpl_frame* product_frame = NULL;
02190 cpl_image *image = NULL ;
02191 const char *fname = NULL;
02192 char *final_name = NULL ;
02193 char* date = NULL ;
02194
02195
02196
02197
02198 XSH_ASSURE_NOT_NULL(frame);
02199 XSH_ASSURE_NOT_NULL(frameset);
02200 XSH_ASSURE_NOT_NULL(parameters);
02201 XSH_ASSURE_NOT_NULL(recipe_id);
02202 XSH_ASSURE_NOT_NULL(instrument);
02203
02204
02205
02206 pro_catg=xsh_create_final_tag(final_prefix,instrument,frame);
02207
02208
02209 XSH_ASSURE_NOT_NULL(pro_catg);
02210
02211
02212 check(fname = cpl_frame_get_filename( frame ));
02213 check(primary_header = cpl_propertylist_load( fname, 0 ));
02214 check(image = cpl_image_load( fname, CPL_TYPE_INT, 0, 0 ));
02215
02216
02217 check( cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT));
02218 check_msg (cpl_dfs_setup_product_header ( primary_header,
02219 frame,frameset,parameters,
02220 recipe_id,
02221 instrument->pipeline_id,
02222 instrument->dictionary,NULL),
02223 "Problem in the product DFS-compliance");
02224
02225
02226
02227 final_name=xsh_create_final_name(pro_catg);
02228 xsh_msg_dbg_low( "Final product name: %s", final_name ) ;
02229
02230
02231 cpl_image_save( image, final_name, CPL_BPP_32_SIGNED, primary_header,
02232 CPL_IO_DEFAULT ) ;
02233
02234
02235
02236
02237
02238
02239
02240
02241
02242
02243
02244 check(product_frame=xsh_frame_product(final_name,pro_catg,
02245 CPL_FRAME_TYPE_IMAGE,
02246 CPL_FRAME_GROUP_PRODUCT,
02247 CPL_FRAME_LEVEL_FINAL));
02248
02249
02250
02251
02252
02253
02254
02255
02256
02257
02258
02259
02260
02261 check(cpl_frameset_insert(frameset, product_frame));
02262 xsh_add_product_file(final_name);
02263
02264 cleanup:
02265 XSH_FREE(date);
02266 xsh_free_propertylist(&primary_header);
02267 xsh_free_image( &image ) ;
02268 XSH_FREE( final_name ) ;
02269 if(final_prefix!=NULL) {
02270 xsh_free(pro_catg);
02271 }
02272
02273 return;
02274 }
02275
02276
02287
02288 void
02289 xsh_add_product_imagelist( cpl_frame *frame,
02290 cpl_frameset *frameset,
02291 const cpl_parameterlist *parameters,
02292 const char *recipe_id,
02293 xsh_instrument *instrument,
02294 const char *final_prefix)
02295 {
02296 cpl_propertylist *primary_header = NULL;
02297 const char *pro_catg = NULL;
02298 cpl_frame* product_frame = NULL;
02299 const char *fname = NULL;
02300 char *final_name = NULL ;
02301 char* date = NULL ;
02302 int nbext=0;
02303 int i=0;
02304 char cmd[80];
02305 char arcfile[80];
02306
02307 bool arcfile_found=false;
02308 int extension =0;
02309 cpl_imagelist* ext_iml=NULL;
02310 cpl_propertylist* ext_header=NULL;
02311
02312
02313
02314
02315 XSH_ASSURE_NOT_NULL(frame);
02316 XSH_ASSURE_NOT_NULL(frameset);
02317 XSH_ASSURE_NOT_NULL(parameters);
02318 XSH_ASSURE_NOT_NULL(recipe_id);
02319 XSH_ASSURE_NOT_NULL(instrument);
02320
02321
02322 pro_catg=xsh_create_final_tag(final_prefix,instrument,frame);
02323
02324
02325 check(fname = cpl_frame_get_filename( frame ));
02326 nbext = cpl_frame_get_nextensions( frame);
02327 check(primary_header = cpl_propertylist_load( fname, 0 ));
02328 check(ext_iml = cpl_imagelist_load( fname, CPL_TYPE_FLOAT, 0 ));
02329 if(cpl_propertylist_has(primary_header,"ARCFILE")) {
02330 sprintf(arcfile,"%s",xsh_pfits_get_arcfile(primary_header));
02331 arcfile_found=true;
02332 }
02333
02334
02335 check( cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT));
02336 check_msg ( cpl_dfs_setup_product_header ( primary_header,
02337 frame,frameset,parameters,
02338 recipe_id,
02339 instrument->pipeline_id,
02340 instrument->dictionary,NULL),
02341 "Problem in the product DFS-compliance");
02342
02343
02344 final_name=xsh_create_final_name(pro_catg);
02345 xsh_msg( "Final product name: %s", final_name ) ;
02346
02347 if(strcmp(fname,final_name) == 0) {
02348 sprintf(cmd,"mv %s tmp_ima.fits",fname);
02349 system(cmd);
02350 fname="tmp_ima.fits";
02351 xsh_add_temporary_file("tmp_ima.fits");
02352 }
02353
02354
02355 xsh_pfits_set_pcatg(primary_header,pro_catg);
02356 check(cpl_imagelist_save(ext_iml, final_name, CPL_BPP_IEEE_FLOAT,
02357 primary_header,CPL_IO_DEFAULT));
02358
02359 for( i = 0 ; i<=nbext ; i++ ) {
02360 check(ext_iml = cpl_imagelist_load( fname, CPL_TYPE_FLOAT, i ));
02361 check(ext_header = cpl_propertylist_load( fname ,i));
02362
02363 if ( i == 0 ) {
02364 extension = CPL_IO_DEFAULT ;
02365 check(cpl_imagelist_save(ext_iml, final_name, CPL_BPP_IEEE_FLOAT,
02366 primary_header,extension));
02367 }
02368 else {
02369 extension = CPL_IO_EXTEND ;
02370 check(cpl_imagelist_save(ext_iml, final_name, CPL_BPP_IEEE_FLOAT,
02371 ext_header,extension));
02372 }
02373 xsh_free_imagelist( &ext_iml) ;
02374 xsh_free_propertylist( &ext_header) ;
02375 }
02376 if(arcfile_found) {
02377 check(cpl_propertylist_append_string(primary_header,"ARCFILE",arcfile));
02378 check(cpl_propertylist_set_comment(primary_header,"ARCFILE",
02379 "Archive File Name"));
02380 }
02381
02382
02383 check(product_frame=xsh_frame_product(final_name,pro_catg,
02384 CPL_FRAME_TYPE_IMAGE,
02385 CPL_FRAME_GROUP_PRODUCT,
02386 CPL_FRAME_LEVEL_FINAL));
02387
02388
02389 check(cpl_frameset_insert(frameset, product_frame));
02390 xsh_add_product_file(final_name);
02391
02392 cleanup:
02393 if(final_prefix!=NULL) {
02394 xsh_free(pro_catg);
02395 }
02396 XSH_FREE(date);
02397 xsh_free_propertylist(&primary_header);
02398 xsh_free_imagelist( &ext_iml ) ;
02399 XSH_FREE( final_name ) ;
02400
02401 return;
02402 }
02403
02404
02415
02416 void
02417 xsh_add_product_image( cpl_frame *frame,
02418 cpl_frameset *frameset,
02419 const cpl_parameterlist *parameters,
02420 const char *recipe_id,
02421 xsh_instrument *instrument,
02422 const char *final_prefix)
02423 {
02424 cpl_propertylist *primary_header = NULL;
02425 const char *pro_catg = NULL;
02426 cpl_frame* product_frame = NULL;
02427 cpl_image *image = NULL ;
02428 const char *fname = NULL;
02429 char *final_name = NULL ;
02430
02431 int i=0;
02432 int nbext=0;
02433 char arcfile[80];
02434 char cmd[80];
02435 bool arcfile_found=false;
02436
02437
02438 XSH_ASSURE_NOT_NULL(frame);
02439 XSH_ASSURE_NOT_NULL(frameset);
02440 XSH_ASSURE_NOT_NULL(parameters);
02441 XSH_ASSURE_NOT_NULL(recipe_id);
02442 XSH_ASSURE_NOT_NULL(instrument);
02443
02444
02445 pro_catg=xsh_create_final_tag(final_prefix,instrument,frame);
02446
02447
02448 check( fname = cpl_frame_get_filename( frame));
02449 nbext = cpl_frame_get_nextensions( frame);
02450 xsh_msg("fname=%s",fname);
02451 check( primary_header = cpl_propertylist_load( fname, 0));
02452 check( image = cpl_image_load( fname, CPL_TYPE_FLOAT, 0, 0));
02453 if(cpl_propertylist_has(primary_header,"ARCFILE")) {
02454 sprintf(arcfile,"%s",xsh_pfits_get_arcfile(primary_header));
02455 arcfile_found=true;
02456 }
02457
02458
02459 check( cpl_frame_set_group( frame, CPL_FRAME_GROUP_PRODUCT));
02460 check_msg (cpl_dfs_setup_product_header ( primary_header,
02461 frame,frameset,parameters,
02462 recipe_id,
02463 instrument->pipeline_id,
02464 instrument->dictionary,NULL),
02465 "Problem in the product DFS-compliance");
02466
02467
02468 final_name=xsh_create_final_name(pro_catg);
02469 xsh_msg( "Final product name: %s", final_name ) ;
02470
02471 if(strcmp(fname,final_name) == 0) {
02472 sprintf(cmd,"mv %s tmp_ima.fits",fname);
02473 system(cmd);
02474 fname="tmp_ima.fits";
02475 xsh_add_temporary_file("tmp_ima.fits");
02476 }
02477
02478 xsh_pfits_set_pcatg(primary_header,pro_catg);
02479 check(cpl_image_save( image, final_name, CPL_BPP_IEEE_FLOAT, primary_header,
02480 CPL_IO_DEFAULT )) ;
02481
02482
02483
02484 for( i = 0 ; i<=nbext ; i++ ) {
02485 int extension ;
02486 cpl_image* ext_img=NULL;
02487 cpl_propertylist* ext_header=NULL;
02488
02489 check( ext_img = cpl_image_load( fname, CPL_TYPE_FLOAT,0, i));
02490 check( ext_header = cpl_propertylist_load( fname ,i));
02491
02492 if ( i == 0 ) {
02493 extension = CPL_IO_DEFAULT ;
02494 xsh_pfits_set_pcatg(ext_header,pro_catg);
02495 }
02496 else {
02497 extension = CPL_IO_EXTEND ;
02498 check(cpl_image_save( ext_img, final_name, CPL_BPP_IEEE_FLOAT,ext_header,
02499 extension));
02500 }
02501 xsh_free_image( &ext_img) ;
02502 xsh_free_propertylist( &ext_header) ;
02503 }
02504
02505
02506
02507
02508 if(arcfile_found) {
02509 check(cpl_propertylist_append_string(primary_header,"ARCFILE",arcfile));
02510 check(cpl_propertylist_set_comment(primary_header,"ARCFILE",
02511 "Archive File Name"));
02512 }
02513
02514
02515
02516
02517
02518
02519
02520 check( product_frame = xsh_frame_product( final_name,pro_catg,
02521 CPL_FRAME_TYPE_IMAGE,
02522 CPL_FRAME_GROUP_PRODUCT,
02523 CPL_FRAME_LEVEL_FINAL));
02524
02525 check(cpl_frameset_insert(frameset, product_frame));
02526 xsh_add_product_file(final_name);
02527
02528 cleanup:
02529 if(final_prefix!=NULL) {
02530 xsh_free(pro_catg);
02531 }
02532
02533 xsh_free_propertylist( &primary_header);
02534 xsh_free_image( &image);
02535 XSH_FREE( final_name);
02536
02537 return;
02538 }
02539
02540
02550
02551 void
02552 xsh_add_product_table( cpl_frame *frame,
02553 cpl_frameset *frameset,
02554 const cpl_parameterlist * parameters,
02555 const char *recipe_id,
02556 xsh_instrument* instrument,
02557 const char *final_prefix)
02558 {
02559 cpl_propertylist *primary_header = NULL;
02560 cpl_propertylist *tbl_header = NULL;
02561 const char *pro_catg =NULL;
02562 cpl_frame* product_frame = NULL;
02563 cpl_table * table = NULL ;
02564 const char *fname = NULL;
02565 char *product_id = NULL;
02566 char *product_name = NULL ;
02567 char *tmp_name = NULL ;
02568 char* date = NULL ;
02569
02570 int nbext, i ;
02571
02572
02573 XSH_ASSURE_NOT_NULL(frame);
02574 XSH_ASSURE_NOT_NULL(frameset);
02575 XSH_ASSURE_NOT_NULL(parameters);
02576 XSH_ASSURE_NOT_NULL(recipe_id);
02577 XSH_ASSURE_NOT_NULL(instrument);
02578
02579
02580 pro_catg=xsh_create_final_tag(final_prefix,instrument,frame);
02581
02582
02583
02584 check( fname = cpl_frame_get_filename( frame));
02585 check( primary_header = cpl_propertylist_load( fname, 0));
02586 XSH_ASSURE_NOT_NULL( primary_header);
02587 check( tbl_header = cpl_propertylist_load( fname, 1));
02588 XSH_ASSURE_NOT_NULL( tbl_header);
02589 nbext = cpl_frame_get_nextensions( frame);
02590
02591
02592 check( cpl_frame_set_group (frame, CPL_FRAME_GROUP_PRODUCT));
02593 check( cpl_dfs_setup_product_header ( primary_header,
02594 frame, frameset, parameters, recipe_id, instrument->pipeline_id,
02595 instrument->dictionary,NULL));
02596
02597
02598 product_name=xsh_create_final_name(pro_catg);
02599
02600
02601
02602 tmp_name=xsh_stringcat_any( "tmp_",product_name, NULL );
02603 for( i = 0 ; i<nbext ; i++ ) {
02604 int extension ;
02605 cpl_table *tbl_ext = NULL;
02606 cpl_propertylist *tbl_ext_header = NULL;
02607
02608
02609
02610 check( tbl_ext = cpl_table_load( fname, i+1, 0));
02611 check( tbl_ext_header = cpl_propertylist_load( fname, i+1));
02612
02613 if ( i == 0 ) extension = CPL_IO_DEFAULT ;
02614 else extension = CPL_IO_EXTEND ;
02615 check(cpl_table_save( tbl_ext, primary_header, tbl_ext_header,
02616 tmp_name, extension));
02617 xsh_free_table( &tbl_ext);
02618 xsh_free_propertylist( &tbl_ext_header);
02619 }
02620
02621 xsh_fileutils_move( tmp_name,product_name );
02622
02623
02624
02625
02626
02627
02628
02629
02630
02631
02632
02633
02634 check(product_frame=xsh_frame_product(product_name,pro_catg,
02635 CPL_FRAME_TYPE_IMAGE,
02636 CPL_FRAME_GROUP_PRODUCT,
02637 CPL_FRAME_LEVEL_FINAL));
02638
02639 cpl_frameset_insert(frameset, product_frame);
02640
02641
02642 cleanup:
02643 if(final_prefix!=NULL) {
02644 xsh_free(pro_catg);
02645 }
02646 xsh_free_propertylist(&primary_header);
02647 xsh_free_propertylist(&tbl_header);
02648 XSH_TABLE_FREE( table) ;
02649 XSH_FREE(product_id);
02650 XSH_FREE(tmp_name);
02651 XSH_FREE(product_name);
02652 XSH_FREE(date);
02653
02654 return;
02655 }
02656
02657
02658
02667
02668
02669 cpl_frame *
02670 xsh_find_std_flux (cpl_frameset * frames)
02671 {
02672 const char *tags[] = {
02673 XSH_STD_FLUX_SLIT (XSH_ARM_UVB),
02674 XSH_STD_FLUX_SLIT (XSH_ARM_VIS),
02675 XSH_STD_FLUX_SLIT (XSH_ARM_NIR),
02676 XSH_STD_TELL_SLIT (XSH_ARM_UVB),
02677 XSH_STD_TELL_SLIT (XSH_ARM_VIS),
02678 XSH_STD_TELL_SLIT (XSH_ARM_NIR),
02679 XSH_STD_FLUX_OFFSET (XSH_ARM_UVB),
02680 XSH_STD_FLUX_OFFSET (XSH_ARM_VIS),
02681 XSH_STD_FLUX_OFFSET (XSH_ARM_NIR),
02682 XSH_STD_TELL_OFFSET (XSH_ARM_UVB),
02683 XSH_STD_TELL_OFFSET (XSH_ARM_VIS),
02684 XSH_STD_TELL_OFFSET (XSH_ARM_NIR),
02685 NULL
02686 };
02687
02688 return xsh_find_frame (frames, tags);
02689 }
02690
02699
02700
02701 cpl_frame *
02702 xsh_find_std_star_flux (cpl_frameset * frames)
02703 {
02704 const char *tags[] = { XSH_STD_STAR_FLUX (XSH_ARM_UVB),
02705 XSH_STD_STAR_FLUX (XSH_ARM_VIS),
02706 XSH_STD_STAR_FLUX (XSH_ARM_NIR),
02707 NULL
02708 };
02709
02710 return xsh_find_frame (frames, tags);
02711 }
02712
02713
02724
02725
02726 cpl_frame*
02727 xsh_find_master_bias (cpl_frameset * frames, xsh_instrument* instr)
02728 {
02729 const char *tags[2] ={NULL,NULL};
02730 cpl_frame* result = NULL;
02731
02732 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_MASTER_BIAS, instr);
02733
02734 check(result = xsh_find_frame (frames,(const char**) tags));
02735
02736 cleanup:
02737 return result;
02738 }
02739
02740
02752
02753
02754 cpl_frame*
02755 xsh_find_frame_with_tag (cpl_frameset * frames,
02756 const char* tag,
02757 xsh_instrument* instr)
02758 {
02759 char *tags[2];
02760 cpl_frame* result = NULL;
02761
02762 tags[0] = xsh_get_tag_from_arm( tag, instr);
02763 tags[1] = NULL;
02764 xsh_msg_dbg_high("search for tag %s",tags[0]);
02765 result = xsh_find_frame (frames,(const char**) tags);
02766 cpl_free( tags[0]);
02767 return result;
02768 }
02769
02770
02771
02780
02781
02782 char* xsh_get_tag_from_arm(const char* tag, xsh_instrument* instr){
02783 const char* arm=xsh_instrument_arm_tostring(instr);
02784 char* composed_tag=NULL;
02785
02786 int len = strlen(tag);
02787
02788 if(tag[len-1]=='_') {
02789 composed_tag=cpl_sprintf("%s%s",tag,arm);
02790 } else {
02791 composed_tag=cpl_sprintf("%s%s%s",tag,"_",arm);
02792 }
02793 xsh_msg_dbg_high("composed tag='%s'",composed_tag);
02794
02795 return composed_tag;
02796 }
02797
02798
02799
02810
02811
02812 cpl_frame* xsh_find_master_dark (cpl_frameset * frames, xsh_instrument* instr)
02813 {
02814 const char *tags[2];
02815
02816 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_MASTER_DARK, instr);
02817 tags[1] = NULL;
02818
02819 return xsh_find_frame (frames, tags);
02820 }
02821
02822
02833
02834 cpl_frame* xsh_find_master_flat (cpl_frameset * frames, xsh_instrument* instr)
02835 {
02836 const char *tags[2];
02837
02838 tags[0] = XSH_GET_TAG_FROM_MODE ( XSH_MASTER_FLAT, instr);
02839 tags[1] = NULL;
02840
02841 return xsh_find_frame (frames, tags);
02842 }
02843
02844
02852
02853 cpl_frame *xsh_find_theo_tab_sing( cpl_frameset *frames, xsh_instrument* instr)
02854 {
02855 const char* tags[2] = {NULL, NULL};
02856 cpl_frame* result = NULL;
02857
02858 XSH_ASSURE_NOT_NULL( frames);
02859 XSH_ASSURE_NOT_NULL( instr);
02860 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_THEO_TAB_SING, instr);
02861 check(result = xsh_find_frame (frames, tags));
02862
02863 cleanup:
02864 return result;
02865 }
02866
02867
02875
02876 cpl_frame *xsh_find_theo_tab_mult( cpl_frameset *frames, xsh_instrument* instr)
02877 {
02878 const char *tags[2] = {NULL, NULL};
02879 cpl_frame* result = NULL;
02880
02881 XSH_ASSURE_NOT_NULL( frames);
02882 XSH_ASSURE_NOT_NULL( instr);
02883 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_THEO_TAB_MULT, instr);
02884 check(result = xsh_find_frame (frames, tags));
02885
02886 cleanup:
02887 return result;
02888 }
02889
02897
02898 cpl_frame *xsh_find_theo_tab_mode( cpl_frameset *frames, xsh_instrument* instr)
02899 {
02900 const char *tags[2] = {NULL, NULL};
02901 cpl_frame* result = NULL;
02902
02903 XSH_ASSURE_NOT_NULL( frames);
02904 XSH_ASSURE_NOT_NULL( instr);
02905
02906 if ( instr->mode == XSH_MODE_IFU){
02907 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_THEO_TAB_IFU, instr);
02908 }
02909 else{
02910 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_THEO_TAB_SING, instr);
02911 }
02912 check(result = xsh_find_frame (frames, tags));
02913
02914 cleanup:
02915 return result;
02916 }
02917
02918
02926
02927 cpl_frame *
02928 xsh_find_order_tab_recov( cpl_frameset *frames, xsh_instrument* instr)
02929 {
02930 const char *tags[2] = {NULL, NULL};
02931 cpl_frame* result = NULL;
02932
02933 XSH_ASSURE_NOT_NULL( frames);
02934 XSH_ASSURE_NOT_NULL( instr);
02935
02936 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_ORDER_TAB_RECOV, instr);
02937 check( result = xsh_find_frame (frames, tags));
02938
02939 cleanup:
02940 return result;
02941 }
02942
02943
02951
02952 cpl_frame *
02953 xsh_find_order_tab_guess( cpl_frameset *frames, xsh_instrument* instr)
02954 {
02955 const char *tags[2] = {NULL, NULL};
02956 cpl_frame* result = NULL;
02957
02958 XSH_ASSURE_NOT_NULL( frames);
02959 XSH_ASSURE_NOT_NULL( instr);
02960
02961 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_ORDER_TAB_GUESS, instr);
02962 check(result = xsh_find_frame (frames, tags));
02963
02964 cleanup:
02965 return result;
02966 }
02967
02968
02976
02977 cpl_frame *
02978 xsh_find_order_tab_centr( cpl_frameset *frames, xsh_instrument* instr)
02979 {
02980 const char *tags[2] = {NULL, NULL};
02981 cpl_frame* result = NULL;
02982
02983 XSH_ASSURE_NOT_NULL( frames);
02984 XSH_ASSURE_NOT_NULL( instr);
02985
02986 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_ORDER_TAB_CENTR, instr);
02987 check(result = xsh_find_frame (frames, tags));
02988
02989 cleanup:
02990 return result;
02991 }
02992
02993
03001
03002 cpl_frame *
03003 xsh_find_order_tab_edges( cpl_frameset *frames, xsh_instrument* instr)
03004 {
03005 const char *tags[3] = {NULL, NULL};
03006 cpl_frame* result = NULL;
03007
03008 XSH_ASSURE_NOT_NULL( frames);
03009 XSH_ASSURE_NOT_NULL( instr);
03010
03011 tags[0] = XSH_GET_TAG_FROM_MODE( XSH_ORDER_TAB_AFC, instr);
03012 tags[1] = XSH_GET_TAG_FROM_LAMP( XSH_ORDER_TAB_EDGES, instr);
03013
03014 check(result = xsh_find_frame (frames, tags));
03015
03016 xsh_msg_dbg_medium( "ORDER_TAB => %s", cpl_frame_get_filename( result));
03017
03018 cleanup:
03019 return result;
03020 }
03021
03022
03030
03031 cpl_frame *
03032 xsh_find_wave_tab_guess( cpl_frameset *frames, xsh_instrument* instr)
03033 {
03034 const char *tags[2] = {NULL, NULL};
03035 cpl_frame* result = NULL;
03036
03037 XSH_ASSURE_NOT_NULL( frames);
03038 XSH_ASSURE_NOT_NULL( instr);
03039
03040 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_GUESS, instr);
03041 check(result = xsh_find_frame (frames, tags));
03042
03043 cleanup:
03044 return result;
03045 }
03046
03047
03055
03056 cpl_frame *
03057 xsh_find_wave_tab_2d( cpl_frameset *frames, xsh_instrument* instr)
03058 {
03059 const char *tags[2] = {NULL, NULL};
03060 cpl_frame* result = NULL;
03061
03062 XSH_ASSURE_NOT_NULL( frames);
03063 XSH_ASSURE_NOT_NULL( instr);
03064
03065 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_2D, instr);
03066 check(result = xsh_find_frame (frames, tags));
03067
03068 cleanup:
03069 return result;
03070 }
03071
03072
03080 cpl_frame *xsh_find_slitmap( cpl_frameset *frames,
03081 xsh_instrument* instr)
03082 {
03083 const char *tags[3] = {NULL, NULL, NULL};
03084 cpl_frame* result = NULL;
03085
03086 XSH_ASSURE_NOT_NULL( frames);
03087 XSH_ASSURE_NOT_NULL( instr);
03088
03089 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_SLIT_MAP, instr);
03090 tags[1] = XSH_GET_TAG_FROM_ARM( XSH_IFU_MAP, instr);
03091 check(result = xsh_find_frame (frames, tags));
03092
03093 cleanup:
03094 return result;
03095 }
03096
03097
03105
03106 cpl_frame *xsh_find_wave_tab( cpl_frameset *frames,
03107 xsh_instrument* instr)
03108 {
03109 const char *tags[4] = {NULL, NULL};
03110 cpl_frame* result = NULL;
03111
03112 XSH_ASSURE_NOT_NULL( frames);
03113 XSH_ASSURE_NOT_NULL( instr);
03114
03115 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_AFC, instr);
03116 tags[1] = XSH_GET_TAG_FROM_MODE( XSH_WAVE_TAB_ARC, instr);
03117 tags[2] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_2D, instr);
03118 check(result = xsh_find_frame (frames, tags));
03119
03120 cleanup:
03121 return result;
03122 }
03123
03124
03125
03133
03134 cpl_frame *
03135 xsh_find_model_config( cpl_frameset *frames, xsh_instrument* instr)
03136 {
03137 const char *tags[4] = {NULL, NULL};
03138 cpl_frame* result = NULL;
03139
03140 XSH_ASSURE_NOT_NULL( frames);
03141 XSH_ASSURE_NOT_NULL( instr);
03142
03143 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_MOD_CFG_OPT_AFC, instr);
03144 tags[1] = XSH_GET_TAG_FROM_ARM( XSH_MOD_CFG_OPT_2D, instr);
03145 tags[2] = XSH_GET_TAG_FROM_ARM( XSH_MOD_CFG_TAB, instr);
03146 check(result = xsh_find_frame (frames, tags));
03147
03148 cleanup:
03149 return result;
03150 }
03151
03152
03161
03162 cpl_frameset *
03163 xsh_find_wave_tab_ifu( cpl_frameset *frames, xsh_instrument* instrument)
03164 {
03165 const char * tags[3] = { NULL, NULL, NULL} ;
03166 cpl_frameset * result = NULL;
03167 cpl_frame * resframe = NULL ;
03168
03169 XSH_ASSURE_NOT_NULL( frames);
03170 XSH_ASSURE_NOT_NULL( instrument);
03171
03172
03173 check( result = cpl_frameset_new() ) ;
03174
03175
03176
03177
03178
03179
03180 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_AFC, instrument);
03181 tags[1] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_2D, instrument);
03182 resframe = xsh_find_frame (frames, tags) ;
03183 if (resframe != NULL ) {
03184 cpl_frame * down = NULL, * cen = NULL , * up = NULL ;
03185
03186 xsh_msg_warning( "Only one Wave Solution Frame %s, use it for the 3 slitlets",
03187 cpl_frame_get_filename( resframe)) ;
03188 check( down = cpl_frame_duplicate( resframe ) ) ;
03189 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_DOWN_IFU, instrument ) ;
03190 check( cpl_frame_set_tag( down, tags[0] ) ) ;
03191 check( cpl_frameset_insert( result, down ) ) ;
03192
03193 check( cen = cpl_frame_duplicate( resframe ) ) ;
03194 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_CEN_IFU, instrument ) ;
03195 check( cpl_frame_set_tag( cen, tags[0] ) ) ;
03196 check( cpl_frameset_insert( result, cen ) ) ;
03197
03198 check( up = cpl_frame_duplicate( resframe ) ) ;
03199 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_UP_IFU, instrument ) ;
03200 check( cpl_frame_set_tag( up, tags[0] ) ) ;
03201 check( cpl_frameset_insert( result, up ) ) ;
03202 }
03203 else {
03204 xsh_msg( "Three wave solution found" ) ;
03205
03206 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_DOWN_IFU, instrument ) ;
03207 check(resframe = xsh_find_frame (frames, tags));
03208 check( cpl_frameset_insert( result, resframe ) ) ;
03209
03210 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_CEN_IFU, instrument ) ;
03211 check(resframe = xsh_find_frame (frames, tags));
03212 check( cpl_frameset_insert( result, resframe ) ) ;
03213
03214 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_TAB_ARC_UP_IFU, instrument ) ;
03215 check(resframe = xsh_find_frame (frames, tags));
03216 check( cpl_frameset_insert( result, resframe ) ) ;
03217 }
03218
03219 cleanup:
03220 if ( cpl_error_get_code() != CPL_ERROR_NONE ) {
03221 cpl_frameset_delete( result ) ;
03222 return NULL ;
03223 }
03224 else return result;
03225 }
03226
03227
03228
03237
03238 cpl_frameset *
03239 xsh_find_offset_tab_ifu( cpl_frameset *frames, xsh_instrument* instr)
03240 {
03241 cpl_frameset *result = NULL;
03242 const char *tags[2] = {NULL, NULL};
03243 cpl_frame *down = NULL;
03244 cpl_frame *cen = NULL;
03245 cpl_frame *up = NULL;
03246
03247 XSH_ASSURE_NOT_NULL( frames);
03248 XSH_ASSURE_NOT_NULL( instr);
03249
03250
03251 check( result = cpl_frameset_new());
03252
03253
03254 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_OFFSET_DOWN_IFU, instr);
03255 check( down = xsh_find_frame (frames, tags));
03256 check( cpl_frameset_insert( result, cpl_frame_duplicate(down)));
03257
03258
03259 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_OFFSET_CEN_IFU, instr);
03260 check( cen = xsh_find_frame (frames, tags));
03261 check( cpl_frameset_insert( result, cpl_frame_duplicate(cen)));
03262
03263
03264 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_OFFSET_UP_IFU, instr);
03265 check( up = xsh_find_frame (frames, tags));
03266 check( cpl_frameset_insert( result, cpl_frame_duplicate(up)));
03267
03268 cleanup:
03269 if ( cpl_error_get_code() != CPL_ERROR_NONE ) {
03270 xsh_msg_warning( "No complete OFFSET_TAB dataset is found." \
03271 " The rectified spectra will not be straightened and the resulting" \
03272 " datacube may not be aligned.");
03273 xsh_free_frameset( &result);
03274 }
03275 return result;
03276 }
03277
03278
03279
03287
03288 cpl_frame *
03289 xsh_find_arc_line_list_clean( cpl_frameset *frames, xsh_instrument* instr)
03290 {
03291 const char *tags[2] = {NULL, NULL};
03292 cpl_frame* result = NULL;
03293
03294 XSH_ASSURE_NOT_NULL( frames);
03295 XSH_ASSURE_NOT_NULL( instr);
03296
03297 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_ARC_LINE_LIST, instr);
03298 check(result = xsh_find_frame (frames, tags));
03299
03300 cleanup:
03301 return result;
03302 }
03303
03304
03305
03313
03314 cpl_frame *
03315 xsh_find_arc_line_list( cpl_frameset *frames, xsh_instrument* instr)
03316 {
03317 const char *tags[2] = {NULL, NULL};
03318 cpl_frame* result = NULL;
03319
03320 XSH_ASSURE_NOT_NULL( frames);
03321 XSH_ASSURE_NOT_NULL( instr);
03322
03323 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_ARC_LINE_LIST, instr);
03324 check(result = xsh_find_frame (frames, tags));
03325
03326 cleanup:
03327 return result;
03328 }
03329
03337
03338 cpl_frame *
03339 xsh_find_usr_lines_guess_tab( cpl_frameset *frames, xsh_instrument* instr)
03340 {
03341 const char *tags[2] = {NULL, NULL};
03342 cpl_frame* result = NULL;
03343
03344 XSH_ASSURE_NOT_NULL( frames);
03345 XSH_ASSURE_NOT_NULL( instr);
03346
03347 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_GUESS_LINES_POS, instr);
03348 check(result = xsh_find_frame (frames, tags));
03349
03350 cleanup:
03351 return result;
03352 }
03353
03354
03362
03363 cpl_frame *
03364 xsh_find_model_config_tab( cpl_frameset *frames, xsh_instrument* instr)
03365 {
03366 const char *tags[2] = {NULL, NULL};
03367 cpl_frame* result = NULL;
03368
03369 XSH_ASSURE_NOT_NULL( frames);
03370 XSH_ASSURE_NOT_NULL( instr);
03371
03372 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_MOD_CFG_TAB, instr);
03373 check(result = xsh_find_frame (frames, tags));
03374
03375 cleanup:
03376 return result;
03377 }
03378
03389
03390 cpl_frame * xsh_find_wavemap(cpl_frameset *frames,
03391 xsh_instrument* instr)
03392 {
03393 const char *tags[2] ={NULL,NULL};
03394 cpl_frame* result = NULL;
03395
03396 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_WAVE_MAP, instr);
03397 check(result = xsh_find_frame (frames,(const char**) tags));
03398
03399 cleanup:
03400 return result;
03401 }
03402
03410
03411
03412 cpl_frame * xsh_find_raw_orderdef_vis_uvb ( cpl_frameset * frames )
03413 {
03414 char *tags[4] ={NULL,NULL, NULL,NULL};
03415 cpl_frame* result = NULL;
03416
03417 check(tags[0] = xsh_stringcat_any( XSH_ORDERDEF_D2_UVB, NULL )) ;
03418 check(tags[1] = xsh_stringcat_any( XSH_ORDERDEF_QTH_UVB, NULL )) ;
03419 check(tags[2] = xsh_stringcat_any( XSH_ORDERDEF_VIS, NULL )) ;
03420
03421 check(result = xsh_find_frame (frames,(const char**) tags));
03422
03423 cleanup:
03424 cpl_free( tags[0]);
03425 cpl_free( tags[1]);
03426 cpl_free( tags[2]);
03427 return result;
03428 }
03429
03437
03438
03439 cpl_frame * xsh_find_raw_orderdef_nir( cpl_frameset * frames )
03440 {
03441 char *tags[] ={NULL,NULL};
03442 cpl_frame* result = NULL;
03443
03444 check(tags[0] = xsh_stringcat_any( XSH_ORDERDEF_NIR, NULL ) );
03445 check(result = xsh_find_frame (frames,(const char**) tags));
03446
03447 cleanup:
03448 cpl_free(tags[0]);
03449 return result;
03450 }
03451
03452
03461
03462 cpl_frame* xsh_find_disp_tab( cpl_frameset *frames,
03463 xsh_instrument* instr)
03464 {
03465 const char *tags[3] ={NULL,NULL};
03466 cpl_frame* result = NULL;
03467
03468 tags[0] = XSH_GET_TAG_FROM_ARM( XSH_DISP_TAB_AFC, instr);
03469 tags[1] = XSH_GET_TAG_FROM_ARM( XSH_DISP_TAB, instr);
03470
03471 check( result = xsh_find_frame( frames,(const char**) tags));
03472
03473 if (result == NULL){
03474 xsh_msg( "No DISP TAB frame found !!");
03475 }
03476
03477 cleanup:
03478 return result;
03479 }
03480
03481
03482
03490
03491
03492 cpl_frame * xsh_find_raw_orderdef_nir_off( cpl_frameset * frames )
03493 {
03494 char *tags[] ={NULL,NULL};
03495 cpl_frame* result = NULL;
03496
03497 check(tags[0] = xsh_stringcat_any( XSH_ORDERDEF_OFF, NULL ) ) ;
03498 check(result = xsh_find_frame (frames,(const char**) tags));
03499
03500 cleanup:
03501 cpl_free(tags[0]);
03502 return result;
03503 }
03504
03512 cpl_frame * xsh_find_raw_arc_slit_uvb_vis( cpl_frameset * frames,
03513 XSH_ARM arm )
03514 {
03515 char *tags[] ={NULL,NULL};
03516 cpl_frame* result = NULL;
03517
03518 if ( arm == XSH_ARM_UVB )
03519 check( tags[0] = xsh_stringcat_any( XSH_ARC_SLIT_UVB, NULL ) ) ;
03520 else if ( arm == XSH_ARM_VIS )
03521 check( tags[0] = xsh_stringcat_any( XSH_ARC_SLIT_VIS, NULL ) ) ;
03522 else goto cleanup ;
03523
03524 check(result = xsh_find_frame (frames,(const char**) tags));
03525
03526 cleanup:
03527 cpl_free(tags[0]);
03528 return result;
03529 }
03530
03538 cpl_frame * xsh_find_raw_arc_slit_nir_on( cpl_frameset * frames )
03539 {
03540 char *tags[] ={NULL,NULL};
03541 cpl_frame* result = NULL;
03542
03543 check(tags[0] = xsh_stringcat_any( XSH_ARC_SLIT_NIR, NULL ) ) ;
03544 check(result = xsh_find_frame (frames,(const char**) tags));
03545
03546 cleanup:
03547 cpl_free(tags[0]);
03548 return result;
03549 }
03550
03558 cpl_frame * xsh_find_raw_arc_slit_nir_off( cpl_frameset * frames )
03559 {
03560 char *tags[] ={NULL,NULL};
03561 cpl_frame* result = NULL;
03562
03563 check(tags[0] = xsh_stringcat_any( XSH_ARC_SLIT_OFF, NULL ) ) ;
03564 check(result = xsh_find_frame (frames,(const char**) tags));
03565
03566 cleanup:
03567 cpl_free(tags[0]);
03568 return result;
03569 }
03570
03571
03580 cpl_frame * xsh_find_calpro_model_config( cpl_frameset * frames,
03581 xsh_instrument * instr )
03582 {
03583 char *tags[] ={NULL,NULL};
03584 cpl_frame* result = NULL;
03585
03586 check(tags[0] = xsh_stringcat_any( XSH_MOD_CFG,
03587 xsh_instrument_arm_tostring(instr),
03588 NULL ) ) ;
03589 xsh_msg_debug("tag=%s",tags[0]);
03590 check(result = xsh_find_frame (frames,(const char**) tags));
03591
03592 cleanup:
03593 cpl_free(tags[0]);
03594 return result;
03595 }
03596
03597
03607 cpl_frame * xsh_find_model_config_open( cpl_frameset * frames,
03608 xsh_instrument * instr )
03609 {
03610 char *tags[] ={NULL,NULL};
03611 cpl_frame* result = NULL;
03612
03613 check(tags[0] = xsh_stringcat_any( XSH_MOD_CFG_OPEN,
03614 xsh_instrument_arm_tostring(instr),
03615 NULL ) ) ;
03616 xsh_msg_debug("tag=%s",tags[0]);
03617 check(result = xsh_find_frame (frames,(const char**) tags));
03618
03619 cleanup:
03620 cpl_free(tags[0]);
03621 return result;
03622 }
03623
03624
03634 cpl_frame * xsh_find_calpro_model_meas_coord( cpl_frameset * frames,
03635 xsh_instrument * instr )
03636 {
03637 char *tags[] ={NULL,NULL};
03638 cpl_frame* result = NULL;
03639
03640 check(tags[0] = xsh_stringcat_any( XSH_MEASCOORD,
03641 xsh_instrument_arm_tostring(instr),
03642 NULL ) ) ;
03643 check(result = xsh_find_frame (frames,(const char**) tags));
03644
03645 cleanup:
03646 cpl_free(tags[0]);
03647 return result;
03648 }
03649
03659 cpl_frame * xsh_find_model_wavelist( cpl_frameset * frames,
03660 xsh_instrument * instr )
03661 {
03662 char *tags[] ={NULL,NULL};
03663 cpl_frame* result = NULL;
03664
03665 check(tags[0] = xsh_stringcat_any( XSH_MODEL_WAVE_LIST,
03666 xsh_instrument_arm_tostring(instr),
03667 NULL ) ) ;
03668 check(result = xsh_find_frame (frames,(const char**) tags));
03669
03670 cleanup:
03671 cpl_free(tags[0]);
03672 return result;
03673 }
03674
03675
03676
03686 cpl_frame * xsh_find_model_testpar( cpl_frameset * frames,
03687 xsh_instrument * instr )
03688 {
03689 char *tags[] ={NULL,NULL};
03690 cpl_frame* result = NULL;
03691
03692 check(tags[0] = xsh_stringcat_any( XSH_MODEL_TEST_PAR,
03693 xsh_instrument_arm_tostring(instr),
03694 NULL ) ) ;
03695 check(result = xsh_find_frame (frames,(const char**) tags));
03696
03697 cleanup:
03698 cpl_free(tags[0]);
03699 return result;
03700 }
03701
03702
03712 cpl_frame * xsh_find_spectral_format( cpl_frameset * frames,
03713 xsh_instrument * instr )
03714 {
03715 char *tags[] ={NULL,NULL};
03716 cpl_frame* result = NULL;
03717 if(instr->arm == XSH_ARM_NIR) {
03718 if((result=cpl_frameset_find(frames,XSH_SPECTRAL_FORMAT_JH_NIR)) != NULL){
03719 return result;
03720 }
03721 }
03722 check(tags[0] = xsh_stringcat_any( XSH_SPECTRAL_FORMAT,
03723 xsh_instrument_arm_tostring(instr),
03724 NULL ) ) ;
03725 check(result = xsh_find_frame (frames,(const char**) tags));
03726
03727 cleanup:
03728 cpl_free(tags[0]);
03729 return result;
03730 }
03731
03732
03742
03743 static cpl_frame *
03744 xsh_find_frame( cpl_frameset *frames, const char *tags[])
03745 {
03746 cpl_frame *frame = NULL;
03747 bool found = false;
03748 char *tags_string = NULL;
03749 char *temp = NULL;
03750 int i;
03751
03752 assure (frames != NULL, CPL_ERROR_NULL_INPUT, "Null frameset");
03753 assure (tags != NULL, CPL_ERROR_NULL_INPUT, "Null tags");
03754
03755 tags_string = xsh_stringdup ("");
03756
03757 for (i = 0; !found && tags[i] != NULL; i++) {
03758
03759 cpl_free (temp);
03760 temp = NULL;
03761 temp = xsh_stringdup (tags_string);
03762
03763 if (i == 0) {
03764 cpl_free (tags_string);
03765 tags_string = NULL;
03766 check (tags_string = xsh_stringdup (tags[i]));
03767 }
03768 else {
03769 cpl_free (tags_string);
03770 tags_string = NULL;
03771 check (tags_string = xsh_stringcat_3 (temp, ", ", tags[i]));
03772 }
03773
03774
03775 frame = cpl_frameset_find (frames, tags[i]);
03776
03777 if (frame != NULL) {
03778 found = true;
03779 }
03780 }
03781 if(!found) {
03782
03783
03784
03785
03786 }
03787 cleanup:
03788 cpl_free (tags_string);
03789 cpl_free (temp);
03790
03791 return frame;
03792 }
03793
03794 cpl_propertylist*
03795 xsh_frame_head_extract_qc(cpl_frame* frm) {
03796
03797 cpl_propertylist* qc = NULL;
03798 const char* name = NULL;
03799 name = cpl_frame_get_filename(frm);
03800 qc = cpl_propertylist_load_regexp(name, 0, "^ESO QC *", 0);
03801 return qc;
03802 }
03803
03804 cpl_boolean
03805 xsh_mode_is_physmod(cpl_frameset* set,xsh_instrument* instrument)
03806 {
03807 cpl_boolean found;
03808 cpl_frame* frm1=0;
03809 cpl_frame* frm2=0;
03810 cpl_frame* frm3=0;
03811 cpl_frame* frm4=0;
03812
03813 frm1=xsh_find_frame_with_tag( set, XSH_MOD_CFG_TAB,instrument);
03814 frm2=xsh_find_frame_with_tag( set, XSH_MOD_CFG_OPT_FMT,instrument);
03815 frm3=xsh_find_frame_with_tag( set, XSH_MOD_CFG_OPT_2D,instrument);
03816 frm4=xsh_find_frame_with_tag( set, XSH_MOD_CFG_OPT_AFC,instrument);
03817
03818 if(
03819 (frm1!=NULL) ||
03820 (frm2!=NULL) ||
03821 (frm3!=NULL) ||
03822 (frm4!=NULL)
03823 ) {
03824 found=CPL_TRUE;
03825 } else {
03826 found=CPL_FALSE;
03827 }
03828 return found;
03829 }
03830
03831 cpl_error_code
03832 xsh_dfs_check_binning(cpl_frameset* set,cpl_frameset* calib)
03833 {
03834
03835 cpl_frame* ref=NULL;
03836 cpl_frame* frm=NULL;
03837 const char* namer=NULL;
03838 const char* namef=NULL;
03839 const char* tagr=NULL;
03840 const char* tagf=NULL;
03841
03842
03843 cpl_propertylist* href=NULL;
03844 cpl_propertylist* head=NULL;
03845
03846 int ref_binx=0;
03847 int ref_biny=0;
03848 int ref_naxis=0;
03849
03850 int frm_binx=0;
03851 int frm_biny=0;
03852 int frm_naxis=0;
03853
03854 int i=0;
03855 int ncal=0;
03856
03857 XSH_ASSURE_NOT_NULL_MSG(set,"Null input raw framest");
03858 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input cal framest");
03859
03860 check(ref=cpl_frameset_get_frame(set,0));
03861 namer=cpl_frame_get_filename(ref);
03862 tagr=cpl_frame_get_tag(ref);
03863
03864 href=cpl_propertylist_load(namer,0);
03865
03866 ref_binx=xsh_pfits_get_binx(href);
03867 ref_biny=xsh_pfits_get_biny(href);
03868 ref_naxis=xsh_pfits_get_naxis(href);
03869
03870 ncal=cpl_frameset_get_size(calib);
03871
03872 for(i=0;i<ncal;i++) {
03873
03874 frm=cpl_frameset_get_frame(calib,i);
03875 namef=cpl_frame_get_filename(frm);
03876 head=cpl_propertylist_load(namef,0);
03877 frm_naxis=xsh_pfits_get_naxis(head);
03878
03879 if(frm_naxis == 2) {
03880
03881 frm_binx=xsh_pfits_get_binx(head);
03882 frm_biny=xsh_pfits_get_biny(head);
03883
03884 if(frm_binx != ref_binx ||
03885 frm_biny != ref_biny )
03886 {
03887 tagf=cpl_frame_get_tag(frm);
03888 xsh_msg_error("Calib frame %s (tag=%s, bin=%d,%d)",
03889 namef,tagf,frm_binx,frm_biny);
03890 xsh_msg_error("mismatch raw frame's bin %s (tag=%s, bin=%d,%d).",
03891 namer,tagr,ref_binx,ref_biny);
03892 cpl_error_set(cpl_func,CPL_ERROR_ILLEGAL_INPUT);
03893 }
03894 }
03895 xsh_free_propertylist(&head);
03896
03897 }
03898 cleanup:
03899
03900 xsh_free_propertylist(&href);
03901 xsh_free_propertylist(&head);
03902 return cpl_error_get_code();
03903 }
03904
03905 cpl_frameset*
03906 xsh_correct_calib(cpl_frameset* raws, cpl_frameset* calib){
03907 int raw_binx=1;
03908 int raw_biny=1;
03909 int cal_binx=1;
03910 int cal_biny=1;
03911 int fctx=0;
03912 int fcty=0;
03913
03914 cpl_propertylist* plist=NULL;
03915 const char* name=NULL;
03916 cpl_frame* frm=NULL;
03917 cpl_frame* frm_new=NULL;
03918 int i=0;
03919 int sz=0;
03920 const char* tag=NULL;
03921 cpl_frameset* calib_new=NULL;
03922
03923 check(frm=cpl_frameset_get_frame(raws,0));
03924 name=cpl_frame_get_filename(frm);
03925 plist=cpl_propertylist_load(name,0);
03926 raw_binx=xsh_pfits_get_binx(plist);
03927 raw_biny=xsh_pfits_get_biny(plist);
03928 xsh_free_propertylist(&plist);
03929 sz=cpl_frameset_get_size(calib);
03930
03931 calib_new=cpl_frameset_new();
03932 for(i=0;i<sz;i++) {
03933 frm=cpl_frameset_get_frame(calib,i);
03934 name=cpl_frame_get_filename(frm);
03935 tag=cpl_frame_get_tag(frm);
03936 if(strstr(tag,"MASTER") != NULL) {
03937 plist=cpl_propertylist_load(name,0);
03938 cal_binx=xsh_pfits_get_binx(plist);
03939 cal_biny=xsh_pfits_get_biny(plist);
03940
03941 if(cal_binx > raw_binx || cal_biny > raw_biny) {
03942 xsh_msg("rescaling frame %s",cpl_frame_get_tag(frm));
03943 fctx=cal_binx/raw_binx;
03944 fcty=cal_biny/raw_biny;
03945 frm_new=xsh_frame_image_mult_by_fct(frm,fctx,fcty);
03946 cpl_frameset_insert(calib_new,frm_new);
03947 } else if(cal_binx < raw_binx || cal_biny < raw_biny) {
03948 xsh_msg("rescaling frame %s",cpl_frame_get_tag(frm));
03949 fctx=raw_binx/cal_binx;
03950 fcty=raw_biny/cal_biny;
03951 frm_new=xsh_frame_image_div_by_fct(frm,fctx,fcty);
03952 check(cpl_frameset_insert(calib_new,frm_new));
03953 } else {
03954
03955 check(cpl_frameset_insert(calib_new,cpl_frame_duplicate(frm)));
03956 }
03957 } else {
03958 check(cpl_frameset_insert(calib_new,cpl_frame_duplicate(frm)));
03959 }
03960 xsh_free_propertylist(&plist);
03961
03962 }
03963
03964 cleanup:
03965 xsh_free_propertylist(&plist);
03966 xsh_free_frameset(&calib);
03967
03968 return calib_new;
03969
03970 }
03971
03972 static cpl_error_code
03973 xsh_frame_nir_tab_chop_Kband(cpl_frame* frame,const int absordmin,const char* colname)
03974 {
03975
03976 cpl_table* tab=NULL;
03977 cpl_table* ext=NULL;
03978 const char* name=NULL;
03979 const char* basename=NULL;
03980 char new_name[256];
03981 cpl_propertylist* head=NULL;
03982 cpl_propertylist* hext=NULL;
03983 int next=0;
03984 int i=0;
03985
03986 name=cpl_frame_get_filename(frame);
03987 basename=xsh_get_basename(name);
03988 sprintf(new_name,"cut_nir_HJ_%s",basename);
03989 next=cpl_frame_get_nextensions(frame);
03990
03991 head=cpl_propertylist_load(name,0);
03992 for(i=1;i<=next;i++) {
03993 tab=cpl_table_load(name,i,0);
03994 hext=cpl_propertylist_load(name,i);
03995 cpl_table_and_selected_int(tab,colname,CPL_GREATER_THAN,absordmin-1);
03996 ext=cpl_table_extract_selected(tab);
03997 if(i==1) {
03998 check(cpl_table_save(ext,head,hext,new_name,CPL_IO_DEFAULT));
03999 } else {
04000 check(cpl_table_save(ext,head,hext,new_name,CPL_IO_EXTEND));
04001 }
04002 xsh_free_propertylist(&hext);
04003 xsh_free_table(&tab);
04004 xsh_free_table(&ext);
04005 }
04006 cpl_frame_set_filename(frame,new_name);
04007
04008 cleanup:
04009 xsh_free_propertylist(&head);
04010 xsh_free_propertylist(&hext);
04011 xsh_free_table(&tab);
04012 xsh_free_table(&ext);
04013
04014 return cpl_error_get_code();
04015
04016 }
04017
04018
04019
04020 static cpl_error_code
04021 xsh_calib_nir_predict_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04022 {
04023 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04024 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04025
04026 cleanup:
04027 return cpl_error_get_code();
04028
04029 }
04030
04031 static cpl_error_code
04032 xsh_calib_nir_orderpos_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04033 {
04034 int absordmin=instr->config->order_min;
04035 cpl_frame* order_tab_guess=NULL;
04036 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04037 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04038
04039 if(NULL!= (order_tab_guess = xsh_find_frame_with_tag(calib,
04040 XSH_ORDER_TAB_GUESS,
04041 instr)) ) {
04042 xsh_frame_nir_tab_chop_Kband( order_tab_guess,absordmin,"ABSORDER");
04043 }
04044
04045
04046 cleanup:
04047 return cpl_error_get_code();
04048
04049 }
04050
04051
04052
04053 static cpl_error_code
04054 xsh_calib_nir_mflat_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04055 {
04056 cpl_frame* cen_order_tab_frame = NULL;
04057 int absordmin=instr->config->order_min;
04058
04059 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04060 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04061
04062 check( cen_order_tab_frame = xsh_find_order_tab_centr( calib, instr));
04063 xsh_frame_nir_tab_chop_Kband( cen_order_tab_frame,absordmin,"ABSORDER");
04064
04065 cleanup:
04066
04067 return cpl_error_get_code();
04068
04069 }
04070
04071
04072 static cpl_error_code
04073 xsh_calib_nir_2dmap_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04074 {
04075 cpl_frame* order_tab_edges = NULL;
04076 cpl_frame* theo_tab_mult = NULL;
04077 int absordmin=instr->config->order_min;
04078
04079 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04080 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04081
04082 check(order_tab_edges = xsh_find_order_tab_edges( calib, instr));
04083 xsh_frame_nir_tab_chop_Kband(order_tab_edges,absordmin,"ABSORDER");
04084 if(NULL!=(theo_tab_mult = xsh_find_frame_with_tag( calib,XSH_THEO_TAB_MULT,
04085 instr))) {
04086 xsh_frame_nir_tab_chop_Kband(theo_tab_mult,absordmin,"Order");
04087
04088 }
04089
04090 cleanup:
04091
04092 return cpl_error_get_code();
04093
04094 }
04095
04096
04097
04098 static cpl_error_code
04099 xsh_calib_nir_wavecal_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04100 {
04101 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04102 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04103
04104 cpl_frame* order_tab_edges=NULL;
04105 cpl_frame* disp_tab_frame=NULL;
04106 int absordmin=instr->config->order_min;
04107 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04108 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04109
04110 check(order_tab_edges = xsh_find_order_tab_edges( calib, instr));
04111 xsh_frame_nir_tab_chop_Kband(order_tab_edges,absordmin,"ABSORDER");
04112 if(NULL != (disp_tab_frame = xsh_find_disp_tab( calib, instr))) {
04113 xsh_frame_nir_tab_chop_Kband(disp_tab_frame,absordmin,"ORDER");
04114 }
04115
04116
04117 cleanup:
04118 return cpl_error_get_code();
04119
04120 }
04121
04122
04123 static cpl_error_code
04124 xsh_calib_nir_scired_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr)
04125 {
04126
04127 cpl_frame* order_tab_edges=NULL;
04128 cpl_frame* disp_tab_frame=NULL;
04129 cpl_frame* wave_tab_frame=NULL;
04130 int absordmin=instr->config->order_min;
04131 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04132 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04133
04134 check(order_tab_edges = xsh_find_order_tab_edges( calib, instr));
04135 check(xsh_frame_nir_tab_chop_Kband(order_tab_edges,absordmin,"ABSORDER"));
04136 if(NULL != (disp_tab_frame = xsh_find_disp_tab( calib, instr))) {
04137 check(xsh_frame_nir_tab_chop_Kband(disp_tab_frame,absordmin,"ORDER"));
04138 }
04139 if(NULL != (wave_tab_frame = xsh_find_wave_tab( calib, instr))) {
04140
04141 }
04142 cleanup:
04143 return cpl_error_get_code();
04144
04145 }
04146
04147 cpl_error_code
04148 xsh_calib_nir_corr_if_JH(cpl_frameset* calib,xsh_instrument* instr, const char* recid)
04149 {
04150
04151 XSH_ASSURE_NOT_NULL_MSG(calib,"Null input calib par");
04152 XSH_ASSURE_NOT_NULL_MSG(instr,"Null input instr par");
04153 XSH_ASSURE_NOT_NULL_MSG(recid,"Null input recid par");
04154
04155 if( instr->arm == XSH_ARM_NIR &&
04156 instr->config->order_min==13 &&
04157 instr->config->order_max==26 &&
04158 instr->config->orders==14
04159 ) {
04160
04161
04162 if(strcmp(recid,"xsh_predict") == 0) {
04163 check(xsh_calib_nir_predict_corr_if_JH(calib,instr));
04164 } else if(strcmp(recid,"xsh_orderpos") == 0) {
04165 check(xsh_calib_nir_orderpos_corr_if_JH(calib,instr));
04166 } else if(strcmp(recid,"xsh_mflat") == 0) {
04167 check(xsh_calib_nir_mflat_corr_if_JH(calib,instr));
04168 } else if(strcmp(recid,"xsh_2dmap") == 0) {
04169 check(xsh_calib_nir_2dmap_corr_if_JH(calib,instr));
04170 } else if(strcmp(recid,"xsh_wavecal") == 0) {
04171 check(xsh_calib_nir_wavecal_corr_if_JH(calib,instr));
04172 } else if(strcmp(recid,"xsh_flexcomp") == 0) {
04173 check(xsh_calib_nir_wavecal_corr_if_JH(calib,instr));
04174 } else if(strcmp(recid,"xsh_respon_slit_stare") == 0) {
04175 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04176 } else if(strcmp(recid,"xsh_respon_slit_offset") == 0) {
04177 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04178 } else if(strcmp(recid,"xsh_respon_slit_nod") == 0) {
04179 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04180 } else if(strcmp(recid,"xsh_scired_slit_stare") == 0) {
04181 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04182 } else if(strcmp(recid,"xsh_scired_slit_offset") == 0) {
04183 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04184 } else if(strcmp(recid,"xsh_scired_slit_nod") == 0) {
04185 check(xsh_calib_nir_scired_corr_if_JH(calib,instr));
04186 }
04187
04188 }
04189 cleanup:
04190 return cpl_error_get_code();
04191
04192 }
04193
04194 cpl_error_code
04195 xsh_dfs_check_mflat_is_proper(xsh_instrument* inst,cpl_frameset** calib)
04196 {
04197
04198 cpl_frame* frm_mflat=NULL;
04199 cpl_frame* frm_mflat_new=NULL;
04200 int ref_binx=0;
04201 int ref_biny=0;
04202 int binx=0;
04203 int biny=0;
04204 int fctx=1;
04205 int fcty=1;
04206 cpl_propertylist* plist=NULL;
04207 const char* name=NULL;
04208 char tag[80];
04209
04210
04211 sprintf(tag,"%s_%s",XSH_MASTER_FLAT_SLIT,xsh_instrument_arm_tostring(inst));
04212 ref_binx=inst->binx;
04213 ref_biny=inst->biny;
04214 xsh_msg("tag=%s",tag);
04215 xsh_msg("binx=%d biny=%d",ref_binx,ref_biny);
04216 check(frm_mflat=cpl_frameset_find(*calib,tag));
04217 check(name=cpl_frame_get_filename(frm_mflat));
04218 plist=cpl_propertylist_load(name,0);
04219 binx=xsh_pfits_get_binx(plist);
04220 biny=xsh_pfits_get_biny(plist);
04221
04222 if(binx > ref_binx ||biny > ref_biny) {
04223 xsh_msg("compute syntetic frame by division");
04224 fctx=binx/ref_binx;
04225 fcty=biny/ref_biny;
04226 frm_mflat_new=xsh_frame_image_div_by_fct(frm_mflat,fctx,fcty);
04227 cpl_frameset_erase_frame(*calib,frm_mflat);
04228 cpl_frameset_insert(*calib,frm_mflat_new);
04229
04230 } else if(binx < ref_binx ||biny < ref_biny) {
04231 xsh_msg("compute syntetic frame by multiplication");
04232 fctx=ref_binx/binx;
04233 fcty=ref_biny/biny;
04234 frm_mflat_new=xsh_frame_image_mult_by_fct(frm_mflat,fctx,fcty);
04235 cpl_frameset_erase_frame(*calib,frm_mflat);
04236 cpl_frameset_insert(*calib,frm_mflat_new);
04237 } else {
04238 xsh_msg("keep same frame binx=%d ref_binx=%d biny=%d ref_biny=%d",
04239 binx,ref_binx,biny,ref_biny);
04240
04241 }
04242
04243
04244 cleanup:
04245 xsh_free_propertylist(&plist);
04246 return cpl_error_get_code();
04247
04248 }