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
00028 #ifdef HAVE_CONFIG_H
00029 #include <config.h>
00030 #endif
00031
00032
00033
00034
00035
00036 #include "crires_recipe.h"
00037
00038 #include "crires_model_kernel.h"
00039 #include "crires_combine.h"
00040 #include "crires_extract.h"
00041 #include "crires_photom.h"
00042 #include "crires_wlcalib.h"
00043 #include "crires_wlestimate.h"
00044
00045
00046
00047
00048
00049 #define RECIPE_STRING "crires_win_jitter"
00050
00051
00052
00053
00054
00055 static int crires_win_jitter_save(const cpl_imagelist **,
00056 const cpl_imagelist *, const cpl_imagelist *, const cpl_table **,
00057 const cpl_imagelist *, const cpl_imagelist *,
00058 const cpl_parameterlist *, cpl_frameset *) ;
00059
00060 static char crires_win_jitter_description[] =
00061 "crires_win_jitter -- Observation recipe in Windowing mode\n"
00062 "The files listed in the Set Of Frames (sof-file) must be tagged:\n"
00063 " raw-file.fits "CRIRES_WIN_NODDING_OBJECT_RAW" or\n"
00064 " raw-file.fits "CRIRES_WIN_NODDING_SKY_RAW" or\n"
00065 " raw-file.fits "CRIRES_WIN_NODDING_RAW" or\n"
00066 " raw-file.fits "CRIRES_WIN_NODDING_J_RAW" or\n"
00067 " raw-file.fits "CRIRES_WIN_NODDING_STD_RAW" or\n"
00068 " raw-file.fits "CRIRES_WIN_NODDING_J_STD_RAW" or\n"
00069 " flat-file.fits "CRIRES_CALPRO_FLAT_WIN" or\n"
00070 " bpm-file.fits "CRIRES_CALPRO_BPM_WIN" or\n"
00071 " detlin-file.fits "CRIRES_CALPRO_COEFFS_CUBE" or\n"
00072 " dark-file.fits "CRIRES_CALPRO_DARK_WIN" or\n"
00073 " wavecal-file.fits "CRIRES_CALPRO_WAVE" or\n"
00074 " stdstar-file.fits "CRIRES_CALPRO_STD_PHOTOFLUX" or\n"
00075 " model-config-file.fits "CRIRES_CALPRO_MODEL_CONFIG".\n"
00076 "\n"
00077 "In the case of a nodding observation (currently, this recipe only\n"
00078 " supports nodding observations), in order not to degrade the \n"
00079 " instrument high resolution, the combined images using only NODA\n"
00080 " or NODB nodding positions can be produced on request. (see --onlyA/B)\n"
00081 " In this case, the following spectrum extraction can be applied \n"
00082 " either on the usual combined image or on those NODA/B combined\n"
00083 " images (see --comb_used).\n"
00084 "\n"
00085 "This recipe produces 6 to 11 files:\n"
00086 " The combined image (PRO TYPE = "CRIRES_PROTYPE_COMBINED")\n"
00087 " The contribution map (PRO TYPE = "CRIRES_PROTYPE_CONTRIB")\n"
00088 " The combined image using only Nodding A frames (optional)\n"
00089 " (PRO TYPE = "CRIRES_PROTYPE_COMBINED")\n"
00090 " The contribution map using only Nodding A frames (optional)\n"
00091 " (PRO TYPE = "CRIRES_PROTYPE_CONTRIB")\n"
00092 " The combined image using only Nodding B frames (optional)\n"
00093 " (PRO TYPE = "CRIRES_PROTYPE_COMBINED")\n"
00094 " The contribution map using only Nodding B frames (optional)\n"
00095 " (PRO TYPE = "CRIRES_PROTYPE_CONTRIB")\n"
00096 " The table with the extracted spectrum\n"
00097 " (PRO TYPE = "CRIRES_PROTYPE_SPEC_WL") or\n"
00098 " (PRO TYPE = "CRIRES_PROTYPE_SENSIT") or\n"
00099 " (PRO TYPE = "CRIRES_PROTYPE_CONVERS")\n"
00100 " The profile image (PRO TYPE = "CRIRES_PROTYPE_PROFILE")\n"
00101 " The background map (PRO TYPE = "CRIRES_PROTYPE_BGD_MAP")\n"
00102 " The wavelength map (PRO TYPE = "CRIRES_PROTYPE_WL_MAP")\n"
00103 " The wavelength map from the model (optional)\n"
00104 " (PRO TYPE = "CRIRES_PROTYPE_WL_MAP")\n" ;
00105
00106 CRIRES_RECIPE_DEFINE(crires_win_jitter,
00107 CRIRES_PARAM_DISPLAY |
00108 CRIRES_PARAM_REFINE |
00109 CRIRES_PARAM_ONLYA |
00110 CRIRES_PARAM_ONLYB |
00111 CRIRES_PARAM_COMB_USED |
00112 CRIRES_PARAM_HOR_SIZE |
00113 CRIRES_PARAM_SPEC_HSIZE |
00114 CRIRES_PARAM_KAPPA |
00115 CRIRES_PARAM_CLOSING_HSIZE |
00116 CRIRES_PARAM_CLEAN_RATE |
00117 CRIRES_PARAM_REJECT |
00118 CRIRES_PARAM_SPEC_ZONE |
00119 CRIRES_PARAM_DEGREE,
00120 "Observation recipe in Windowing mode",
00121 crires_win_jitter_description) ;
00122
00123
00124
00125
00126
00127 static struct {
00128
00129 int comb_refine ;
00130 int comb_onlyA ;
00131 int comb_onlyB ;
00132 crires_comb_method comb_used ;
00133 int extr_box_hor_size ;
00134 int extr_spec_hsize ;
00135 double extr_kappa ;
00136 int extr_closing_hs ;
00137 int extr_clean_rate ;
00138 int extr_rej_left ;
00139 int extr_rej_right ;
00140 int extr_spec_starty ;
00141 int extr_spec_stopy ;
00142 int display ;
00143
00144 int std_mode ;
00145 double qc_wlcent[CRIRES_NB_DETECTORS] ;
00146 double qc_wldisp[CRIRES_NB_DETECTORS] ;
00147 int qc_specpos[CRIRES_NB_DETECTORS] ;
00148 int qc_specwrec[CRIRES_NB_DETECTORS] ;
00149 int qc_specwopt[CRIRES_NB_DETECTORS] ;
00150 double qc_specoptmed[CRIRES_NB_DETECTORS] ;
00151 double qc_s2nmed[CRIRES_NB_DETECTORS] ;
00152 double qc_sensmed[CRIRES_NB_DETECTORS] ;
00153 double qc_convmed[CRIRES_NB_DETECTORS] ;
00154 double qc_thromed[CRIRES_NB_DETECTORS] ;
00155 double qc_fwhm_comb_pix[CRIRES_NB_DETECTORS] ;
00156 double qc_fwhm_comb_as[CRIRES_NB_DETECTORS] ;
00157 double qc_fwhm_prof_pix[CRIRES_NB_DETECTORS] ;
00158 double qc_fwhm_prof_as[CRIRES_NB_DETECTORS] ;
00159 double qc_fwhm_diff[CRIRES_NB_DETECTORS] ;
00160 } crires_win_jitter_config ;
00161
00162
00163
00164
00165
00166
00173
00174 static int crires_win_jitter(
00175 cpl_frameset * frameset,
00176 const cpl_parameterlist * parlist)
00177 {
00178 const char * sval ;
00179 cpl_frameset * rawframes ;
00180 const char * fname ;
00181 cpl_frame * fr ;
00182 double tot_ndit ;
00183 const char * flat ;
00184 const char * dark ;
00185 const char * bpm ;
00186 const char * detlin ;
00187 const char * wavecal ;
00188 const char * std_star ;
00189 const char * cfg_model ;
00190 cpl_table * std_star_tab ;
00191 cpl_bivector * std_star_biv ;
00192 cpl_imagelist ** comblist ;
00193 int comblist_offset ;
00194 int pix ;
00195 cpl_polynomial * wave_poly ;
00196 cpl_table * wave_tab[CRIRES_NB_DETECTORS] ;
00197 cpl_table * extr_tab[CRIRES_NB_DETECTORS] ;
00198 cpl_image * profiles[CRIRES_NB_DETECTORS] ;
00199 cpl_image * bg_maps[CRIRES_NB_DETECTORS] ;
00200 cpl_imagelist * prof_list ;
00201 cpl_imagelist * bgmap_list ;
00202 cpl_image * profile_empty ;
00203 cpl_image * bgmap_empty ;
00204 cpl_table * extr_tab_empty ;
00205 cpl_imagelist * wl_map ;
00206 cpl_imagelist * wl_map_model ;
00207 cpl_vector ** wavelengths ;
00208 int i, j ;
00209
00210
00211 rawframes = NULL ;
00212 comblist_offset = -1 ;
00213 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00214 crires_win_jitter_config.qc_wlcent[i] = -1 ;
00215 crires_win_jitter_config.qc_wldisp[i] = -1 ;
00216 crires_win_jitter_config.qc_specpos[i] = -1 ;
00217 crires_win_jitter_config.qc_specwrec[i] = -1 ;
00218 crires_win_jitter_config.qc_specwopt[i] = -1 ;
00219 crires_win_jitter_config.qc_specoptmed[i] = -1.0 ;
00220 crires_win_jitter_config.qc_s2nmed[i] = -1.0 ;
00221 crires_win_jitter_config.qc_sensmed[i] = -1.0 ;
00222 crires_win_jitter_config.qc_convmed[i] = -1.0 ;
00223 crires_win_jitter_config.qc_thromed[i] = -1.0 ;
00224 crires_win_jitter_config.qc_fwhm_comb_pix[i] = -1.0 ;
00225 crires_win_jitter_config.qc_fwhm_comb_as[i] = -1.0 ;
00226 crires_win_jitter_config.qc_fwhm_prof_pix[i] = -1.0 ;
00227 crires_win_jitter_config.qc_fwhm_prof_as[i] = -1.0 ;
00228 crires_win_jitter_config.qc_fwhm_diff[i] = -1.0 ;
00229 }
00230
00231
00232 crires_win_jitter_config.display = crires_parameterlist_get_int(parlist,
00233 RECIPE_STRING, CRIRES_PARAM_DISPLAY) ;
00234 crires_win_jitter_config.comb_refine = crires_parameterlist_get_bool(
00235 parlist, RECIPE_STRING, CRIRES_PARAM_REFINE) ;
00236 crires_win_jitter_config.comb_onlyA = crires_parameterlist_get_bool(
00237 parlist, RECIPE_STRING, CRIRES_PARAM_ONLYA) ;
00238 crires_win_jitter_config.comb_onlyB = crires_parameterlist_get_bool(
00239 parlist, RECIPE_STRING, CRIRES_PARAM_ONLYB) ;
00240 sval = crires_parameterlist_get_string(parlist, RECIPE_STRING,
00241 CRIRES_PARAM_COMB_USED) ;
00242 if (!strcmp(sval, "NODA"))
00243 crires_win_jitter_config.comb_used = CRIRES_COMB_METHOD_NODA ;
00244 else if (!strcmp(sval, "NODB"))
00245 crires_win_jitter_config.comb_used = CRIRES_COMB_METHOD_NODB ;
00246 else if (!strcmp(sval, "COMB"))
00247 crires_win_jitter_config.comb_used = CRIRES_COMB_METHOD_COMB ;
00248 else {
00249 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00250 cpl_msg_error(__func__, "Invalid combination method specified");
00251 return -1;
00252 }
00253 crires_win_jitter_config.extr_box_hor_size = crires_parameterlist_get_int(
00254 parlist, RECIPE_STRING, CRIRES_PARAM_HOR_SIZE) ;
00255 crires_win_jitter_config.extr_spec_hsize = crires_parameterlist_get_int(
00256 parlist, RECIPE_STRING, CRIRES_PARAM_SPEC_HSIZE) ;
00257 crires_win_jitter_config.extr_kappa = crires_parameterlist_get_double(
00258 parlist, RECIPE_STRING, CRIRES_PARAM_KAPPA) ;
00259 crires_win_jitter_config.extr_closing_hs = crires_parameterlist_get_int(
00260 parlist, RECIPE_STRING, CRIRES_PARAM_CLOSING_HSIZE) ;
00261 crires_win_jitter_config.extr_clean_rate = crires_parameterlist_get_double(
00262 parlist, RECIPE_STRING, CRIRES_PARAM_CLEAN_RATE) ;
00263 sval = crires_parameterlist_get_string(parlist, RECIPE_STRING,
00264 CRIRES_PARAM_REJECT) ;
00265 if (sscanf(sval, "%d,%d",
00266 &crires_win_jitter_config.extr_rej_left,
00267 &crires_win_jitter_config.extr_rej_right)!=2) {
00268 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00269 return -1 ;
00270 }
00271 sval = crires_parameterlist_get_string(parlist, RECIPE_STRING,
00272 CRIRES_PARAM_SPEC_ZONE) ;
00273 if (sscanf(sval, "%d,%d",
00274 &crires_win_jitter_config.extr_spec_starty,
00275 &crires_win_jitter_config.extr_spec_stopy)!=2) {
00276 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00277 return -1 ;
00278 }
00279
00280
00281 if (crires_dfs_set_groups(frameset, "crires_win_jitter")) {
00282 cpl_msg_error(__func__, "Cannot identify RAW and CALIB frames") ;
00283 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00284 return -1 ;
00285 }
00286
00287
00288 flat = crires_extract_filename(frameset, CRIRES_CALPRO_FLAT_WIN) ;
00289 dark = crires_extract_filename(frameset, CRIRES_CALPRO_DARK_WIN) ;
00290 bpm = crires_extract_filename(frameset, CRIRES_CALPRO_BPM_WIN) ;
00291 detlin = crires_extract_filename(frameset, CRIRES_CALPRO_COEFFS_CUBE) ;
00292 wavecal = crires_extract_filename(frameset, CRIRES_CALPRO_WAVE) ;
00293 std_star = crires_extract_filename(frameset,CRIRES_CALPRO_STD_PHOTOFLUX);
00294 cfg_model = crires_extract_filename(frameset, CRIRES_CALPRO_MODEL_CONFIG);
00295
00296
00297 if ((rawframes = crires_extract_frameset(frameset,
00298 CRIRES_WIN_NODDING_OBJECT_RAW)) != NULL) {
00299 crires_win_jitter_config.std_mode = 0 ;
00300 } else if ((rawframes = crires_extract_frameset(frameset,
00301 CRIRES_WIN_NODDING_RAW)) != NULL) {
00302 crires_win_jitter_config.std_mode = 0 ;
00303 } else if ((rawframes = crires_extract_frameset(frameset,
00304 CRIRES_WIN_NODDING_J_RAW)) != NULL) {
00305 crires_win_jitter_config.std_mode = 0 ;
00306 } else if ((rawframes = crires_extract_frameset(frameset,
00307 CRIRES_WIN_NODDING_STD_RAW)) != NULL) {
00308 crires_win_jitter_config.std_mode = 1 ;
00309 } else if ((rawframes = crires_extract_frameset(frameset,
00310 CRIRES_WIN_NODDING_J_STD_RAW)) != NULL) {
00311 crires_win_jitter_config.std_mode = 1 ;
00312 } else {
00313 cpl_msg_error(__func__, "No raw frame in input") ;
00314 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00315 return -1 ;
00316 }
00317
00318
00319 fname = cpl_frame_get_filename(cpl_frameset_get_frame(rawframes,0)) ;
00320 if (flat != NULL) {
00321 if (crire_stripe_keys_mismatch(fname, flat)) {
00322 cpl_msg_error(__func__,
00323 "Mismatch of STRIPE keys with the flat frame") ;
00324 cpl_frameset_delete(rawframes) ;
00325 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00326 return -1 ;
00327 }
00328 }
00329 if (bpm != NULL) {
00330 if (crire_stripe_keys_mismatch(fname, bpm)) {
00331 cpl_msg_error(__func__,
00332 "Mismatch of STRIPE keys with the bpm frame") ;
00333 cpl_frameset_delete(rawframes) ;
00334 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00335 return -1 ;
00336 }
00337 }
00338 if (dark != NULL) {
00339 if (crire_stripe_keys_mismatch(fname, dark)) {
00340 cpl_msg_error(__func__,
00341 "Mismatch of STRIPE keys with the dark frame") ;
00342 cpl_frameset_delete(rawframes) ;
00343 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00344 return -1 ;
00345 }
00346 }
00347
00348
00349 if ((crires_win_jitter_config.comb_used == CRIRES_COMB_METHOD_NODA)
00350 && (crires_win_jitter_config.comb_onlyA == 0)) {
00351 cpl_msg_warning(__func__,
00352 "You forgot to require the NODA image to be produced !") ;
00353 crires_win_jitter_config.comb_onlyA = 1 ;
00354 }
00355 if ((crires_win_jitter_config.comb_used == CRIRES_COMB_METHOD_NODB)
00356 && (crires_win_jitter_config.comb_onlyB == 0)) {
00357 cpl_msg_warning(__func__,
00358 "You forgot to require the NODB image to be produced !") ;
00359 crires_win_jitter_config.comb_onlyB = 1 ;
00360 }
00361
00362
00363 if (crires_win_jitter_config.comb_used == CRIRES_COMB_METHOD_COMB)
00364 comblist_offset = 0 ;
00365 else if (crires_win_jitter_config.comb_used == CRIRES_COMB_METHOD_NODA)
00366 comblist_offset = 1 ;
00367 else if (crires_win_jitter_config.comb_used == CRIRES_COMB_METHOD_NODB)
00368 comblist_offset = 2 ;
00369
00370
00371 fr = cpl_frameset_get_frame(rawframes, 0);
00372 tot_ndit = crires_get_totndit(cpl_frame_get_filename(fr)) ;
00373 if (tot_ndit < 0) {
00374 cpl_msg_error(__func__, "Cannot get the total number of NDIT") ;
00375 cpl_frameset_delete(rawframes) ;
00376 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00377 return -1 ;
00378 }
00379 tot_ndit *= cpl_frameset_get_size(rawframes) ;
00380
00381
00382 cpl_msg_info(__func__, "Images combination") ;
00383 cpl_msg_indent_more() ;
00384 if ((comblist = crires_combine_imagelist_win(rawframes,
00385 flat, dark, bpm, detlin,
00386 crires_win_jitter_config.comb_refine,
00387 crires_win_jitter_config.comb_onlyA,
00388 crires_win_jitter_config.comb_onlyB)) == NULL) {
00389 cpl_msg_error(__func__, "Cannot combine the images") ;
00390 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00391 cpl_frameset_delete(rawframes) ;
00392 cpl_msg_indent_less() ;
00393 return -1 ;
00394 }
00395 cpl_msg_indent_less() ;
00396
00397
00398 cpl_msg_info(__func__, "Spectrum extraction") ;
00399 cpl_msg_indent_more() ;
00400 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
00401 cpl_msg_info(__func__, "Chip number %d extraction", i+1) ;
00402 cpl_msg_indent_more() ;
00403 if ((extr_tab[i] = crires_extract_spectrum(
00404 cpl_imagelist_get(comblist[0+2*comblist_offset], i),
00405 cpl_imagelist_get(comblist[1+2*comblist_offset], i),
00406 crires_win_jitter_config.extr_box_hor_size,
00407 crires_win_jitter_config.extr_spec_hsize,
00408 crires_win_jitter_config.extr_kappa,
00409 crires_win_jitter_config.extr_closing_hs,
00410 crires_win_jitter_config.extr_clean_rate,
00411 crires_win_jitter_config.extr_rej_left,
00412 crires_win_jitter_config.extr_rej_right,
00413 crires_win_jitter_config.extr_spec_starty,
00414 crires_win_jitter_config.extr_spec_stopy,
00415 i+1,
00416 tot_ndit,
00417 CRIRES_ILLUM_FULL_DETECTOR,
00418 &(crires_win_jitter_config.qc_specpos[i]),
00419 &(crires_win_jitter_config.qc_specwrec[i]),
00420 &(crires_win_jitter_config.qc_specwopt[i]),
00421 &(crires_win_jitter_config.qc_specoptmed[i]),
00422 &(crires_win_jitter_config.qc_s2nmed[i]),
00423 &(profiles[i]),
00424 &(bg_maps[i]))) == NULL) {
00425 cpl_msg_error(__func__, "Cannot extract the spectrum") ;
00426 cpl_msg_indent_less() ;
00427 cpl_msg_indent_less() ;
00428 for (j=1 ; j<i ; j++)
00429 cpl_table_delete(extr_tab[j]) ;
00430 for (j=1 ; j<i ; j++)
00431 cpl_image_delete(profiles[j]) ;
00432 for (j=1 ; j<i ; j++)
00433 cpl_image_delete(bg_maps[j]) ;
00434 cpl_imagelist_delete(comblist[0]) ;
00435 cpl_imagelist_delete(comblist[1]) ;
00436 if (crires_win_jitter_config.comb_onlyA) {
00437 cpl_imagelist_delete(comblist[2]) ;
00438 cpl_imagelist_delete(comblist[3]) ;
00439 }
00440 if (crires_win_jitter_config.comb_onlyB) {
00441 cpl_imagelist_delete(comblist[4]) ;
00442 cpl_imagelist_delete(comblist[5]) ;
00443 }
00444 cpl_free(comblist) ;
00445 cpl_frameset_delete(rawframes) ;
00446 return -1 ;
00447 }
00448 cpl_msg_info(__func__, "Chip number %d FWHM Computation", i+1) ;
00449 if (crires_extract_qc_fwhm(
00450 cpl_imagelist_get(comblist[0+2*comblist_offset], i),
00451 profiles[i],
00452 &(crires_win_jitter_config.qc_fwhm_comb_pix[i]),
00453 &(crires_win_jitter_config.qc_fwhm_comb_as[i]),
00454 &(crires_win_jitter_config.qc_fwhm_prof_pix[i]),
00455 &(crires_win_jitter_config.qc_fwhm_prof_as[i]),
00456 &(crires_win_jitter_config.qc_fwhm_diff[i])) == -1) {
00457 cpl_msg_warning(__func__, "Failed for FWHM computation") ;
00458 crires_win_jitter_config.qc_fwhm_comb_pix[i] = -1.0 ;
00459 crires_win_jitter_config.qc_fwhm_comb_as[i] = -1.0 ;
00460 crires_win_jitter_config.qc_fwhm_prof_pix[i] = -1.0 ;
00461 crires_win_jitter_config.qc_fwhm_prof_as[i] = -1.0 ;
00462 crires_win_jitter_config.qc_fwhm_diff[i] = -1.0 ;
00463 }
00464 cpl_msg_indent_less() ;
00465 }
00466
00467
00468 prof_list = cpl_imagelist_new() ;
00469 bgmap_list = cpl_imagelist_new() ;
00470 profile_empty = cpl_image_duplicate(profiles[1]) ;
00471 bgmap_empty = cpl_image_duplicate(bg_maps[1]) ;
00472 cpl_image_multiply_scalar(profile_empty, 0.0) ;
00473 cpl_image_multiply_scalar(bgmap_empty, 0.0) ;
00474 cpl_imagelist_set(prof_list, cpl_image_duplicate(profile_empty), 0) ;
00475 cpl_imagelist_set(bgmap_list, cpl_image_duplicate(bgmap_empty), 0) ;
00476 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
00477 cpl_imagelist_set(prof_list, profiles[i], i) ;
00478 cpl_imagelist_set(bgmap_list, bg_maps[i], i) ;
00479 }
00480 cpl_imagelist_set(prof_list, cpl_image_duplicate(profile_empty),
00481 CRIRES_NB_DETECTORS-1) ;
00482 cpl_imagelist_set(bgmap_list, cpl_image_duplicate(bgmap_empty),
00483 CRIRES_NB_DETECTORS-1) ;
00484 cpl_image_delete(profile_empty) ;
00485 cpl_image_delete(bgmap_empty) ;
00486
00487
00488 if (crires_win_jitter_config.qc_specpos[1] > 0 &&
00489 crires_win_jitter_config.qc_specpos[2] > 0 &&
00490 fabs(crires_win_jitter_config.qc_specpos[1] -
00491 crires_win_jitter_config.qc_specpos[2]) >
00492 CRIRES_SPEC_POS_TOLERANCE) {
00493 cpl_msg_warning(__func__,
00494 "The spectrum positions in chip 1 and chip 2 are too different: %d -> %d",
00495 crires_win_jitter_config.qc_specpos[1],
00496 crires_win_jitter_config.qc_specpos[2]) ;
00497 }
00498 cpl_msg_indent_less() ;
00499
00500
00501 cpl_msg_info(__func__, "Wavelength Calibration") ;
00502 cpl_msg_indent_more() ;
00503 if (wavecal != NULL) {
00504
00505 cpl_msg_info(__func__, "Use the provided solution") ;
00506 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00507 if ((wave_tab[i] = crires_load_table_check(wavecal, i+1,
00508 CRIRES_PROTYPE_WL_POLY, -1, -1, 0)) == NULL) {
00509 cpl_msg_error(__func__, "Cannot load the wavelength table") ;
00510 cpl_msg_indent_less() ;
00511 cpl_frameset_delete(rawframes) ;
00512 cpl_imagelist_delete(comblist[0]) ;
00513 cpl_imagelist_delete(comblist[1]) ;
00514 if (crires_win_jitter_config.comb_onlyA) {
00515 cpl_imagelist_delete(comblist[2]) ;
00516 cpl_imagelist_delete(comblist[3]) ;
00517 }
00518 if (crires_win_jitter_config.comb_onlyB) {
00519 cpl_imagelist_delete(comblist[4]) ;
00520 cpl_imagelist_delete(comblist[5]) ;
00521 }
00522 cpl_free(comblist) ;
00523 for (j=1 ; j<CRIRES_NB_DETECTORS-1 ; j++)
00524 cpl_table_delete(extr_tab[j]) ;
00525 cpl_imagelist_delete(prof_list) ;
00526 cpl_imagelist_delete(bgmap_list) ;
00527 return -1 ;
00528 }
00529 }
00530 } else {
00531
00532 cpl_msg_info(__func__, "Use the keywords for the wavelength") ;
00533
00534
00535 fname = cpl_frame_get_filename(cpl_frameset_get_frame(rawframes,0)) ;
00536
00537
00538 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00539 cpl_msg_info(__func__, "Calibrate chip number %d", i+1) ;
00540 cpl_msg_indent_more() ;
00541 wave_poly = crires_wlestimate_get(fname, i+1) ;
00542 wave_tab[i] = crires_wlcalib_gen_wltab_one(wave_poly, -1, -1.0) ;
00543 cpl_polynomial_delete(wave_poly) ;
00544 cpl_msg_indent_less() ;
00545 }
00546 }
00547
00548
00549 if ((wl_map = crires_wlcalib_gen_wlmap((const cpl_table **)wave_tab))
00550 == NULL) {
00551 cpl_msg_error(__func__, "Cannot compute the Wavelength Map") ;
00552 cpl_frameset_delete(rawframes) ;
00553 cpl_imagelist_delete(comblist[0]) ;
00554 cpl_imagelist_delete(comblist[1]) ;
00555 if (crires_win_jitter_config.comb_onlyA) {
00556 cpl_imagelist_delete(comblist[2]) ;
00557 cpl_imagelist_delete(comblist[3]) ;
00558 }
00559 if (crires_win_jitter_config.comb_onlyB) {
00560 cpl_imagelist_delete(comblist[4]) ;
00561 cpl_imagelist_delete(comblist[5]) ;
00562 }
00563 cpl_free(comblist) ;
00564 cpl_imagelist_delete(prof_list) ;
00565 cpl_imagelist_delete(bgmap_list) ;
00566 for (j=1 ; j<CRIRES_NB_DETECTORS-1 ; j++)
00567 cpl_table_delete(extr_tab[j]) ;
00568 for (j=0 ; j<CRIRES_NB_DETECTORS ; j++)
00569 if (wave_tab[j] != NULL) cpl_table_delete(wave_tab[j]);
00570 return -1 ;
00571 }
00572 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
00573 if (wave_tab[i] != NULL) cpl_table_delete(wave_tab[i]);
00574
00575
00576 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
00577 crires_win_jitter_config.qc_wlcent[i] =
00578 cpl_image_get(cpl_imagelist_get(wl_map, i),
00579 512, crires_win_jitter_config.qc_specpos[i], &pix) ;
00580 crires_win_jitter_config.qc_wldisp[i] =
00581 ((cpl_image_get(cpl_imagelist_get(wl_map, i), 1024,
00582 crires_win_jitter_config.qc_specpos[i], &pix)) -
00583 (cpl_image_get(cpl_imagelist_get(wl_map, i), 1,
00584 crires_win_jitter_config.qc_specpos[i], &pix)))
00585 / 1023 ;
00586 }
00587
00588
00589 fname = cpl_frame_get_filename(cpl_frameset_get_frame(rawframes,0)) ;
00590 if ((cfg_model != NULL) && (!crires_model_off()) &&
00591 (crires_model_config_check(cfg_model, fname) == 0)) {
00592 cpl_msg_info(__func__, "Call the model to get the wavelength map") ;
00593 cpl_msg_indent_more() ;
00594 wl_map_model = crires_model_wavpix(fname, cfg_model, -1) ;
00595 if (wl_map_model == NULL) {
00596 cpl_msg_warning(__func__, "Model function returns NULL") ;
00597 cpl_error_reset() ;
00598 }
00599 cpl_msg_indent_less() ;
00600 } else {
00601 wl_map_model = NULL ;
00602 }
00603
00604
00605 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
00606 cpl_table_new_column(extr_tab[i], CRIRES_COL_WAVELENGTH,
00607 CPL_TYPE_DOUBLE) ;
00608 for (j=0 ; j<cpl_table_get_nrow(extr_tab[i]) ; j++) {
00609 cpl_table_set_double(extr_tab[i], CRIRES_COL_WAVELENGTH, j,
00610 cpl_image_get(cpl_imagelist_get_const(wl_map, i), j+1,
00611 crires_win_jitter_config.qc_specpos[i], &pix));
00612 }
00613 }
00614
00615
00616 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
00617 cpl_table_new_column(extr_tab[i], CRIRES_COL_WAVELENGTH_MODEL,
00618 CPL_TYPE_DOUBLE) ;
00619 cpl_table_fill_column_window_double(extr_tab[i],
00620 CRIRES_COL_WAVELENGTH_MODEL, 0,
00621 cpl_table_get_nrow(extr_tab[i]), -1.0) ;
00622 }
00623 if ((cfg_model != NULL) && (!crires_model_off()) && (1)) {
00624 cpl_msg_info(__func__, "Call the model to get the wavelengths") ;
00625 cpl_msg_indent_more() ;
00626 wavelengths = crires_model_wavelengths(
00627 cpl_frame_get_filename(cpl_frameset_get_frame(rawframes,0)),
00628 cfg_model, -1,
00629 (double)(crires_win_jitter_config.qc_specpos[0]),
00630 wl_map_model) ;
00631 if (wavelengths != NULL) {
00632
00633 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
00634
00635 for (j=0 ; j<cpl_vector_get_size(wavelengths[i]) ; j++) {
00636 cpl_table_set_double(extr_tab[i],
00637 CRIRES_COL_WAVELENGTH_MODEL, j,
00638 cpl_vector_get(wavelengths[i], j)) ;
00639 }
00640 }
00641 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
00642 cpl_vector_delete(wavelengths[i]) ;
00643 cpl_free(wavelengths) ;
00644 } else {
00645 cpl_msg_warning(__func__, "Model function returns NULL") ;
00646 cpl_error_reset() ;
00647 }
00648 cpl_msg_indent_less() ;
00649 }
00650
00651
00652 if (crires_win_jitter_config.std_mode) {
00653 cpl_msg_info(__func__,
00654 "Sensitivity / Conversion / Throughput computation") ;
00655 cpl_msg_indent_more() ;
00656
00657 if ((std_star_tab = crires_load_table_check(std_star, 1,
00658 CRIRES_PROTYPE_PHO_FLUX, -1, -1, 0)) == NULL) {
00659 cpl_msg_error(__func__, "Cannot load the std star flux") ;
00660 } else {
00661
00662 if ((std_star_biv = crires_photom_conv_get_star(std_star_tab,
00663 cpl_frame_get_filename(cpl_frameset_get_frame(rawframes,0))))
00664 == NULL) {
00665 cpl_msg_error(__func__, "Cannot find the star flux") ;
00666 cpl_table_delete(std_star_tab) ;
00667 } else {
00668 cpl_table_delete(std_star_tab) ;
00669
00670 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
00671 if (crires_photom_conv_engine(extr_tab[i], std_star_biv,
00672 i+1, (i+1==crires_win_jitter_config.display))==0){
00673 crires_win_jitter_config.qc_convmed[i] =
00674 cpl_table_get_column_median(extr_tab[i],
00675 CRIRES_COL_CONVERSION_RECT) ;
00676 crires_win_jitter_config.qc_thromed[i] =
00677 cpl_table_get_column_median(extr_tab[i],
00678 CRIRES_COL_THROUGHPUT) ;
00679
00680 if (crires_photom_sens_engine(extr_tab[i],
00681 cpl_frame_get_filename(cpl_frameset_get_frame(
00682 rawframes,0)), -1.0,
00683 (i+1==crires_win_jitter_config.display))>0) {
00684 crires_win_jitter_config.qc_sensmed[i] =
00685 cpl_table_get_column_median(extr_tab[i],
00686 CRIRES_COL_SENSITIVITY) ; ;
00687 }
00688 }
00689 }
00690 cpl_bivector_delete(std_star_biv) ;
00691 }
00692 }
00693 cpl_msg_indent_less() ;
00694 }
00695 cpl_frameset_delete(rawframes) ;
00696
00697
00698 extr_tab_empty = cpl_table_duplicate(extr_tab[1]) ;
00699 cpl_table_set_size(extr_tab_empty, 0) ;
00700 extr_tab[0] = cpl_table_duplicate(extr_tab_empty) ;
00701 extr_tab[CRIRES_NB_DETECTORS-1] = cpl_table_duplicate(extr_tab_empty) ;
00702 cpl_table_delete(extr_tab_empty) ;
00703
00704
00705 cpl_msg_info(__func__, "Save the product") ;
00706 cpl_msg_indent_more() ;
00707 if (crires_win_jitter_save((const cpl_imagelist **)comblist,
00708 prof_list, bgmap_list,
00709 (const cpl_table **)extr_tab, wl_map, wl_map_model, parlist,
00710 frameset)) {
00711 cpl_msg_error(__func__, "Cannot save the product") ;
00712 cpl_imagelist_delete(prof_list) ;
00713 cpl_imagelist_delete(bgmap_list) ;
00714 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
00715 if (extr_tab[i] != NULL) cpl_table_delete(extr_tab[i]) ;
00716 cpl_imagelist_delete(comblist[0]) ;
00717 cpl_imagelist_delete(comblist[1]) ;
00718 if (crires_win_jitter_config.comb_onlyA) {
00719 cpl_imagelist_delete(comblist[2]) ;
00720 cpl_imagelist_delete(comblist[3]) ;
00721 }
00722 if (crires_win_jitter_config.comb_onlyB) {
00723 cpl_imagelist_delete(comblist[4]) ;
00724 cpl_imagelist_delete(comblist[5]) ;
00725 }
00726 cpl_free(comblist) ;
00727 cpl_imagelist_delete(wl_map) ;
00728 if (wl_map_model) cpl_imagelist_delete(wl_map_model) ;
00729 cpl_msg_indent_less() ;
00730 return -1 ;
00731 }
00732 cpl_imagelist_delete(wl_map) ;
00733 if (wl_map_model) cpl_imagelist_delete(wl_map_model) ;
00734 cpl_imagelist_delete(comblist[0]) ;
00735 cpl_imagelist_delete(comblist[1]) ;
00736 if (crires_win_jitter_config.comb_onlyA) {
00737 cpl_imagelist_delete(comblist[2]) ;
00738 cpl_imagelist_delete(comblist[3]) ;
00739 }
00740 if (crires_win_jitter_config.comb_onlyB) {
00741 cpl_imagelist_delete(comblist[4]) ;
00742 cpl_imagelist_delete(comblist[5]) ;
00743 }
00744 cpl_free(comblist) ;
00745 cpl_imagelist_delete(prof_list) ;
00746 cpl_imagelist_delete(bgmap_list) ;
00747 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
00748 if (extr_tab[i] != NULL) cpl_table_delete(extr_tab[i]) ;
00749 cpl_msg_indent_less() ;
00750
00751
00752 if (cpl_error_get_code()) return -1 ;
00753 else return 0 ;
00754 }
00755
00756
00770
00771 static int crires_win_jitter_save(
00772 const cpl_imagelist ** images,
00773 const cpl_imagelist * prof,
00774 const cpl_imagelist * bgmap,
00775 const cpl_table ** extr_tab,
00776 const cpl_imagelist * wl_map,
00777 const cpl_imagelist * wl_map_model,
00778 const cpl_parameterlist * parlist,
00779 cpl_frameset * set)
00780 {
00781 cpl_propertylist ** qclists ;
00782 const cpl_frame * ref_frame ;
00783 const char * procat ;
00784 const char * protype ;
00785 cpl_propertylist * inputlist ;
00786 const char * recipe_name = "crires_win_jitter" ;
00787 int i ;
00788
00789
00790 ref_frame = irplib_frameset_get_first_from_group(set, CPL_FRAME_GROUP_RAW) ;
00791
00792
00793 qclists = cpl_malloc(CRIRES_NB_DETECTORS * sizeof(cpl_propertylist*)) ;
00794 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00795 qclists[i] = cpl_propertylist_new() ;
00796 cpl_propertylist_append_int(qclists[i], "ESO QC SPECPOS",
00797 crires_win_jitter_config.qc_specpos[i]) ;
00798 cpl_propertylist_append_int(qclists[i], "ESO QC SPECWREC",
00799 crires_win_jitter_config.qc_specwrec[i]) ;
00800 cpl_propertylist_append_int(qclists[i], "ESO QC SPECWOPT",
00801 crires_win_jitter_config.qc_specwopt[i]) ;
00802 cpl_propertylist_append_double(qclists[i], "ESO QC SIGNAL MED",
00803 crires_win_jitter_config.qc_specoptmed[i]) ;
00804 cpl_propertylist_append_double(qclists[i], "ESO QC S2NMED",
00805 crires_win_jitter_config.qc_s2nmed[i]) ;
00806 cpl_propertylist_append_double(qclists[i], "ESO QC CENTWL",
00807 crires_win_jitter_config.qc_wlcent[i]) ;
00808 cpl_propertylist_append_double(qclists[i], "ESO QC DISPWL",
00809 crires_win_jitter_config.qc_wldisp[i]) ;
00810 cpl_propertylist_append_double(qclists[i], "ESO QC SENSMED",
00811 crires_win_jitter_config.qc_sensmed[i]) ;
00812 cpl_propertylist_append_double(qclists[i], "ESO QC CONVMED",
00813 crires_win_jitter_config.qc_convmed[i]) ;
00814 cpl_propertylist_append_double(qclists[i], "ESO QC THROMED",
00815 crires_win_jitter_config.qc_thromed[i]) ;
00816 cpl_propertylist_append_double(qclists[i], "ESO QC FWHMPIX COMBINED",
00817 crires_win_jitter_config.qc_fwhm_comb_pix[i]) ;
00818 cpl_propertylist_append_double(qclists[i], "ESO QC FWHMARC COMBINED",
00819 crires_win_jitter_config.qc_fwhm_comb_as[i]) ;
00820 cpl_propertylist_append_double(qclists[i], "ESO QC FWHMPIX PROFILE",
00821 crires_win_jitter_config.qc_fwhm_prof_pix[i]) ;
00822 cpl_propertylist_append_double(qclists[i], "ESO QC FWHMARC PROFILE",
00823 crires_win_jitter_config.qc_fwhm_prof_as[i]) ;
00824 cpl_propertylist_append_double(qclists[i], "ESO QC FWHM DIFF",
00825 crires_win_jitter_config.qc_fwhm_diff[i]) ;
00826
00827 inputlist = cpl_propertylist_load_regexp(
00828 cpl_frame_get_filename(ref_frame), i+1,
00829 CRIRES_HEADER_EXT_FORWARD, 0) ;
00830 cpl_propertylist_copy_property_regexp(qclists[i], inputlist,
00831 CRIRES_HEADER_EXT_FORWARD, 0) ;
00832 cpl_propertylist_delete(inputlist) ;
00833 }
00834
00835
00836 if (crires_win_jitter_config.std_mode == 1) {
00837 procat = CRIRES_STD_WIN_COMBINED_IMA ;
00838 } else {
00839 procat = CRIRES_OBS_WIN_COMBINED_IMA ;
00840 }
00841
00842
00843 crires_image_save(set,
00844 parlist,
00845 set,
00846 images[0],
00847 recipe_name,
00848 procat,
00849 CRIRES_PROTYPE_COMBINED,
00850 CRIRES_ILLUM_FULL_DETECTOR,
00851 NULL,
00852 (const cpl_propertylist **)qclists,
00853 PACKAGE "/" PACKAGE_VERSION,
00854 "crires_win_jitter_comb.fits") ;
00855
00856
00857 if (crires_win_jitter_config.std_mode == 1) {
00858 procat = CRIRES_STD_WIN_CONTRIBUTION_IMA ;
00859 } else {
00860 procat = CRIRES_OBS_WIN_CONTRIBUTION_IMA ;
00861 }
00862
00863
00864 crires_image_save(set,
00865 parlist,
00866 set,
00867 images[1],
00868 recipe_name,
00869 procat,
00870 CRIRES_PROTYPE_CONTRIB,
00871 CRIRES_ILLUM_FULL_DETECTOR,
00872 NULL,
00873 (const cpl_propertylist **)qclists,
00874 PACKAGE "/" PACKAGE_VERSION,
00875 "crires_win_jitter_contrib.fits") ;
00876
00877
00878 if (crires_win_jitter_config.comb_onlyA) {
00879
00880 if (crires_win_jitter_config.std_mode == 1) {
00881 procat = CRIRES_STD_WIN_COMBINED_NA_IMA ;
00882 } else {
00883 procat = CRIRES_OBS_WIN_COMBINED_NA_IMA ;
00884 }
00885
00886
00887 crires_image_save(set,
00888 parlist,
00889 set,
00890 images[2],
00891 recipe_name,
00892 procat,
00893 CRIRES_PROTYPE_COMBINED,
00894 CRIRES_ILLUM_FULL_DETECTOR,
00895 NULL,
00896 (const cpl_propertylist **)qclists,
00897 PACKAGE "/" PACKAGE_VERSION,
00898 "crires_win_jitter_comb_noddedA.fits") ;
00899
00900
00901 if (crires_win_jitter_config.std_mode == 1) {
00902 procat = CRIRES_STD_WIN_CONTRIBUTION_NA_IMA ;
00903 } else {
00904 procat = CRIRES_OBS_WIN_CONTRIBUTION_NA_IMA ;
00905 }
00906
00907
00908 crires_image_save(set,
00909 parlist,
00910 set,
00911 images[3],
00912 recipe_name,
00913 procat,
00914 CRIRES_PROTYPE_CONTRIB,
00915 CRIRES_ILLUM_FULL_DETECTOR,
00916 NULL,
00917 (const cpl_propertylist **)qclists,
00918 PACKAGE "/" PACKAGE_VERSION,
00919 "crires_win_jitter_contrib_noddedA.fits") ;
00920 }
00921
00922
00923 if (crires_win_jitter_config.comb_onlyB) {
00924
00925 if (crires_win_jitter_config.std_mode == 1) {
00926 procat = CRIRES_STD_WIN_COMBINED_NB_IMA ;
00927 } else {
00928 procat = CRIRES_OBS_WIN_COMBINED_NB_IMA ;
00929 }
00930
00931
00932 crires_image_save(set,
00933 parlist,
00934 set,
00935 images[4],
00936 recipe_name,
00937 procat,
00938 CRIRES_PROTYPE_COMBINED,
00939 CRIRES_ILLUM_FULL_DETECTOR,
00940 NULL,
00941 (const cpl_propertylist **)qclists,
00942 PACKAGE "/" PACKAGE_VERSION,
00943 "crires_win_jitter_comb_noddedB.fits") ;
00944
00945
00946 if (crires_win_jitter_config.std_mode == 1) {
00947 procat = CRIRES_STD_WIN_CONTRIBUTION_NB_IMA ;
00948 } else {
00949 procat = CRIRES_OBS_WIN_CONTRIBUTION_NB_IMA ;
00950 }
00951
00952
00953 crires_image_save(set,
00954 parlist,
00955 set,
00956 images[5],
00957 recipe_name,
00958 procat,
00959 CRIRES_PROTYPE_CONTRIB,
00960 CRIRES_ILLUM_FULL_DETECTOR,
00961 NULL,
00962 (const cpl_propertylist **)qclists,
00963 PACKAGE "/" PACKAGE_VERSION,
00964 "crires_win_jitter_contrib_noddedB.fits") ;
00965 }
00966
00967
00968 if (crires_win_jitter_config.std_mode == 1) {
00969 procat = CRIRES_STD_WIN_EXTRACT_PROFILE_IMA ;
00970 } else {
00971 procat = CRIRES_OBS_WIN_EXTRACT_PROFILE_IMA ;
00972 }
00973
00974
00975 crires_image_save(set,
00976 parlist,
00977 set,
00978 prof,
00979 recipe_name,
00980 procat,
00981 CRIRES_PROTYPE_PROFILE,
00982 CRIRES_ILLUM_FULL_DETECTOR,
00983 NULL,
00984 (const cpl_propertylist **)qclists,
00985 PACKAGE "/" PACKAGE_VERSION,
00986 "crires_win_jitter_prof.fits") ;
00987
00988
00989 if (crires_win_jitter_config.std_mode == 1) {
00990 procat = CRIRES_STD_WIN_EXTRACT_BGMAP_IMA ;
00991 } else {
00992 procat = CRIRES_OBS_WIN_EXTRACT_BGMAP_IMA ;
00993 }
00994
00995
00996 crires_image_save(set,
00997 parlist,
00998 set,
00999 bgmap,
01000 recipe_name,
01001 procat,
01002 CRIRES_PROTYPE_BGD_MAP,
01003 CRIRES_ILLUM_FULL_DETECTOR,
01004 NULL,
01005 (const cpl_propertylist **)qclists,
01006 PACKAGE "/" PACKAGE_VERSION,
01007 "crires_win_jitter_bgmap.fits") ;
01008
01009
01010 if (crires_win_jitter_config.std_mode == 1) {
01011 procat = CRIRES_STD_WIN_WL_MAP_IMA ;
01012 } else {
01013 procat = CRIRES_OBS_WIN_WL_MAP_IMA ;
01014 }
01015
01016
01017 crires_image_save(set,
01018 parlist,
01019 set,
01020 wl_map,
01021 recipe_name,
01022 procat,
01023 CRIRES_PROTYPE_WL_MAP,
01024 CRIRES_ILLUM_FULL_DETECTOR,
01025 NULL,
01026 (const cpl_propertylist **)qclists,
01027 PACKAGE "/" PACKAGE_VERSION,
01028 "crires_win_jitter_wlmap.fits") ;
01029
01030 if (wl_map_model != NULL) {
01031
01032 if (crires_win_jitter_config.std_mode == 1) {
01033 procat = CRIRES_STD_WIN_WL_MAP_MODEL_IMA ;
01034 } else {
01035 procat = CRIRES_OBS_WIN_WL_MAP_MODEL_IMA ;
01036 }
01037
01038
01039 crires_image_save(set,
01040 parlist,
01041 set,
01042 wl_map_model,
01043 recipe_name,
01044 procat,
01045 CRIRES_PROTYPE_WL_MAP,
01046 CRIRES_ILLUM_FULL_DETECTOR,
01047 NULL,
01048 (const cpl_propertylist **)qclists,
01049 PACKAGE "/" PACKAGE_VERSION,
01050 "crires_win_jitter_wlmap_model.fits") ;
01051 }
01052
01053
01054
01055 if (cpl_table_has_column(extr_tab[0], CRIRES_COL_SENSITIVITY)) {
01056 procat = CRIRES_WIN_EXTRACT_SENS_TAB ;
01057 protype = CRIRES_PROTYPE_SENSIT ;
01058 } else if (cpl_table_has_column(extr_tab[0],CRIRES_COL_CONVERSION_OPT)){
01059 procat = CRIRES_WIN_EXTRACT_CONV_TAB ;
01060 protype = CRIRES_PROTYPE_CONVERS ;
01061 } else if (crires_win_jitter_config.std_mode == 1) {
01062 procat = CRIRES_STD_WIN_EXTRACT_WL_TAB ;
01063 protype = CRIRES_PROTYPE_SPEC_WL ;
01064 } else {
01065 procat = CRIRES_OBS_WIN_EXTRACT_WL_TAB ;
01066 protype = CRIRES_PROTYPE_SPEC_WL ;
01067 }
01068 crires_table_save(set,
01069 parlist,
01070 set,
01071 extr_tab,
01072 recipe_name,
01073 procat,
01074 protype,
01075 NULL,
01076 (const cpl_propertylist **)qclists,
01077 PACKAGE "/" PACKAGE_VERSION,
01078 "crires_win_jitter_extracted.fits") ;
01079
01080
01081 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
01082 cpl_propertylist_delete(qclists[i]) ;
01083 }
01084 cpl_free(qclists) ;
01085 return 0;
01086 }
01087