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