29#include "crires_recipe.h"
31#include "crires_model_kernel.h"
32#include "crires_combine.h"
33#include "crires_extract.h"
34#include "crires_photom.h"
35#include "crires_wlcalib.h"
36#include "crires_wlestimate.h"
37#include "irplib_utils.h"
43#define RECIPE_STRING "crires_win_jitter"
49static int crires_win_jitter_save(
const cpl_imagelist **,
50 const cpl_imagelist *,
const cpl_imagelist *,
const cpl_table **,
51 const cpl_imagelist *,
const cpl_imagelist *,
52 const cpl_parameterlist *, cpl_frameset *) ;
54static char crires_win_jitter_description[] =
55"crires_win_jitter -- Observation recipe in Windowing mode\n"
56"The files listed in the Set Of Frames (sof-file) must be tagged:\n"
57" raw-file.fits "CRIRES_WIN_NODDING_OBJECT_RAW
" or\n"
58" raw-file.fits "CRIRES_WIN_NODDING_SKY_RAW
" or\n"
59" raw-file.fits "CRIRES_WIN_NODDING_RAW
" or\n"
60" raw-file.fits "CRIRES_WIN_NODDING_J_RAW
" or\n"
61" raw-file.fits "CRIRES_WIN_NODDING_STD_RAW
" or\n"
62" raw-file.fits "CRIRES_WIN_NODDING_J_STD_RAW
" or\n"
63" flat-file.fits "CRIRES_CALPRO_FLAT_WIN
" or\n"
64" bpm-file.fits "CRIRES_CALPRO_BPM_WIN
" or\n"
65" detlin-file.fits "CRIRES_CALPRO_COEFFS_CUBE
" or\n"
66" dark-file.fits "CRIRES_CALPRO_DARK_WIN
" or\n"
67" wavecal-file.fits "CRIRES_CALPRO_WAVE
" or\n"
68" stdstar-file.fits "CRIRES_CALPRO_STD_PHOTOFLUX
" or\n"
69" model-config-file.fits "CRIRES_CALPRO_MODEL_CONFIG
".\n"
71"In the case of a nodding observation (currently, this recipe only\n"
72" supports nodding observations), in order not to degrade the \n"
73" instrument high resolution, the combined images using only NODA\n"
74" or NODB nodding positions can be produced on request. (see --onlyA/B)\n"
75" In this case, the following spectrum extraction can be applied \n"
76" either on the usual combined image or on those NODA/B combined\n"
77" images (see --comb_used).\n"
79"This recipe produces 6 to 11 files:\n"
80" The combined image (PRO TYPE = "CRIRES_PROTYPE_COMBINED
")\n"
81" The contribution map (PRO TYPE = "CRIRES_PROTYPE_CONTRIB
")\n"
82" The combined image using only Nodding A frames (optional)\n"
83" (PRO TYPE = "CRIRES_PROTYPE_COMBINED
")\n"
84" The contribution map using only Nodding A frames (optional)\n"
85" (PRO TYPE = "CRIRES_PROTYPE_CONTRIB
")\n"
86" The combined image using only Nodding B frames (optional)\n"
87" (PRO TYPE = "CRIRES_PROTYPE_COMBINED
")\n"
88" The contribution map using only Nodding B frames (optional)\n"
89" (PRO TYPE = "CRIRES_PROTYPE_CONTRIB
")\n"
90" The table with the extracted spectrum\n"
91" (PRO TYPE = "CRIRES_PROTYPE_SPEC_WL
") or\n"
92" (PRO TYPE = "CRIRES_PROTYPE_SENSIT
") or\n"
93" (PRO TYPE = "CRIRES_PROTYPE_CONVERS
")\n"
94" The profile image (PRO TYPE = "CRIRES_PROTYPE_PROFILE
")\n"
95" The background map (PRO TYPE = "CRIRES_PROTYPE_BGD_MAP
")\n"
96" The wavelength map (PRO TYPE = "CRIRES_PROTYPE_WL_MAP
")\n"
97" The wavelength map from the model (optional)\n"
98" (PRO TYPE = "CRIRES_PROTYPE_WL_MAP
")\n" ;
100CRIRES_RECIPE_DEFINE(crires_win_jitter,
101 CRIRES_PARAM_DISPLAY |
102 CRIRES_PARAM_REFINE |
105 CRIRES_PARAM_COMB_USED |
106 CRIRES_PARAM_HOR_SIZE |
107 CRIRES_PARAM_SPEC_HSIZE |
109 CRIRES_PARAM_CLOSING_HSIZE |
110 CRIRES_PARAM_CLEAN_RATE |
111 CRIRES_PARAM_REJECT |
112 CRIRES_PARAM_Y_SPEC_ZONE_CHIP1 |
113 CRIRES_PARAM_Y_SPEC_ZONE_CHIP2 |
114 CRIRES_PARAM_Y_SPEC_ZONE_CHIP3 |
115 CRIRES_PARAM_Y_SPEC_ZONE_CHIP4 |
117 "Observation recipe in Windowing mode",
118 crires_win_jitter_description) ;
129 crires_comb_method comb_used ;
130 int extr_box_hor_size ;
131 int extr_spec_hsize ;
133 int extr_closing_hs ;
134 int extr_clean_rate ;
137 const char * extr_y_spec_zone_c1 ;
138 const char * extr_y_spec_zone_c2 ;
139 const char * extr_y_spec_zone_c3 ;
140 const char * extr_y_spec_zone_c4 ;
144 double qc_wlcent[CRIRES_NB_DETECTORS] ;
145 double qc_wldisp[CRIRES_NB_DETECTORS] ;
146 int qc_specpos[CRIRES_NB_DETECTORS] ;
147 int qc_specwrec[CRIRES_NB_DETECTORS] ;
148 int qc_specwopt[CRIRES_NB_DETECTORS] ;
149 double qc_specoptmed[CRIRES_NB_DETECTORS] ;
150 double qc_s2nmed[CRIRES_NB_DETECTORS] ;
151 double qc_sensmed[CRIRES_NB_DETECTORS] ;
152 double qc_convmed[CRIRES_NB_DETECTORS] ;
153 double qc_thromed[CRIRES_NB_DETECTORS] ;
154 double qc_fwhm_comb_pix[CRIRES_NB_DETECTORS] ;
155 double qc_fwhm_comb_as[CRIRES_NB_DETECTORS] ;
156 double qc_fwhm_prof_pix[CRIRES_NB_DETECTORS] ;
157 double qc_fwhm_prof_as[CRIRES_NB_DETECTORS] ;
158 double qc_fwhm_diff[CRIRES_NB_DETECTORS] ;
159} crires_win_jitter_config ;
173static int crires_win_jitter(
174 cpl_frameset * frameset,
175 const cpl_parameterlist * parlist)
179 cpl_frameset * rawframes ;
186 const char * detlin ;
187 const char * wavecal ;
188 const char * std_star ;
189 const char * cfg_model ;
190 cpl_table * std_star_tab ;
191 cpl_bivector * std_star_biv ;
192 cpl_imagelist ** comblist ;
193 int comblist_offset ;
194 int pix, extr_spec_starty, extr_spec_stopy ;
195 cpl_polynomial * wave_poly ;
196 cpl_table * wave_tab[CRIRES_NB_DETECTORS] ;
197 cpl_table * extr_tab[CRIRES_NB_DETECTORS] ;
198 cpl_image * profiles[CRIRES_NB_DETECTORS] ;
199 cpl_image * bg_maps[CRIRES_NB_DETECTORS] ;
200 cpl_imagelist * prof_list ;
201 cpl_imagelist * bgmap_list ;
202 cpl_image * profile_empty ;
203 cpl_image * bgmap_empty ;
204 cpl_table * extr_tab_empty ;
205 cpl_imagelist * wl_map ;
206 cpl_imagelist * wl_map_model ;
207 cpl_vector ** wavelengths ;
211 setlocale(LC_NUMERIC,
"C");
215 comblist_offset = -1 ;
216 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
217 crires_win_jitter_config.qc_wlcent[i] = -1 ;
218 crires_win_jitter_config.qc_wldisp[i] = -1 ;
219 crires_win_jitter_config.qc_specpos[i] = -1 ;
220 crires_win_jitter_config.qc_specwrec[i] = -1 ;
221 crires_win_jitter_config.qc_specwopt[i] = -1 ;
222 crires_win_jitter_config.qc_specoptmed[i] = -1.0 ;
223 crires_win_jitter_config.qc_s2nmed[i] = -1.0 ;
224 crires_win_jitter_config.qc_sensmed[i] = -1.0 ;
225 crires_win_jitter_config.qc_convmed[i] = -1.0 ;
226 crires_win_jitter_config.qc_thromed[i] = -1.0 ;
227 crires_win_jitter_config.qc_fwhm_comb_pix[i] = -1.0 ;
228 crires_win_jitter_config.qc_fwhm_comb_as[i] = -1.0 ;
229 crires_win_jitter_config.qc_fwhm_prof_pix[i] = -1.0 ;
230 crires_win_jitter_config.qc_fwhm_prof_as[i] = -1.0 ;
231 crires_win_jitter_config.qc_fwhm_diff[i] = -1.0 ;
235 crires_win_jitter_config.display = crires_parameterlist_get_int(parlist,
236 RECIPE_STRING, CRIRES_PARAM_DISPLAY) ;
237 crires_win_jitter_config.comb_refine = crires_parameterlist_get_bool(
238 parlist, RECIPE_STRING, CRIRES_PARAM_REFINE) ;
239 crires_win_jitter_config.comb_onlyA = crires_parameterlist_get_bool(
240 parlist, RECIPE_STRING, CRIRES_PARAM_ONLYA) ;
241 crires_win_jitter_config.comb_onlyB = crires_parameterlist_get_bool(
242 parlist, RECIPE_STRING, CRIRES_PARAM_ONLYB) ;
243 sval = crires_parameterlist_get_string(parlist, RECIPE_STRING,
244 CRIRES_PARAM_COMB_USED) ;
245 if (!strcmp(sval,
"NODA"))
246 crires_win_jitter_config.comb_used = CRIRES_COMB_METHOD_NODA ;
247 else if (!strcmp(sval,
"NODB"))
248 crires_win_jitter_config.comb_used = CRIRES_COMB_METHOD_NODB ;
249 else if (!strcmp(sval,
"COMB"))
250 crires_win_jitter_config.comb_used = CRIRES_COMB_METHOD_COMB ;
252 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
253 cpl_msg_error(__func__,
"Invalid combination method specified");
256 crires_win_jitter_config.extr_box_hor_size = crires_parameterlist_get_int(
257 parlist, RECIPE_STRING, CRIRES_PARAM_HOR_SIZE) ;
258 crires_win_jitter_config.extr_spec_hsize = crires_parameterlist_get_int(
259 parlist, RECIPE_STRING, CRIRES_PARAM_SPEC_HSIZE) ;
260 crires_win_jitter_config.extr_kappa = crires_parameterlist_get_double(
261 parlist, RECIPE_STRING, CRIRES_PARAM_KAPPA) ;
262 crires_win_jitter_config.extr_closing_hs = crires_parameterlist_get_int(
263 parlist, RECIPE_STRING, CRIRES_PARAM_CLOSING_HSIZE) ;
264 crires_win_jitter_config.extr_clean_rate = crires_parameterlist_get_double(
265 parlist, RECIPE_STRING, CRIRES_PARAM_CLEAN_RATE) ;
266 sval = crires_parameterlist_get_string(parlist, RECIPE_STRING,
267 CRIRES_PARAM_REJECT) ;
268 if (sscanf(sval,
"%d,%d",
269 &crires_win_jitter_config.extr_rej_left,
270 &crires_win_jitter_config.extr_rej_right)!=2) {
271 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
274 crires_win_jitter_config.extr_y_spec_zone_c1 =
275 crires_parameterlist_get_string(parlist, RECIPE_STRING,
276 CRIRES_PARAM_Y_SPEC_ZONE_CHIP1) ;
277 crires_win_jitter_config.extr_y_spec_zone_c2 =
278 crires_parameterlist_get_string(parlist, RECIPE_STRING,
279 CRIRES_PARAM_Y_SPEC_ZONE_CHIP2) ;
280 crires_win_jitter_config.extr_y_spec_zone_c3 =
281 crires_parameterlist_get_string(parlist, RECIPE_STRING,
282 CRIRES_PARAM_Y_SPEC_ZONE_CHIP3) ;
283 crires_win_jitter_config.extr_y_spec_zone_c4 =
284 crires_parameterlist_get_string(parlist, RECIPE_STRING,
285 CRIRES_PARAM_Y_SPEC_ZONE_CHIP4) ;
288 if (crires_dfs_set_groups(frameset,
"crires_win_jitter")) {
289 cpl_msg_error(__func__,
"Cannot identify RAW and CALIB frames") ;
290 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
295 flat = crires_extract_filename(frameset, CRIRES_CALPRO_FLAT_WIN) ;
296 dark = crires_extract_filename(frameset, CRIRES_CALPRO_DARK_WIN) ;
297 bpm = crires_extract_filename(frameset, CRIRES_CALPRO_BPM_WIN) ;
298 detlin = crires_extract_filename(frameset, CRIRES_CALPRO_COEFFS_CUBE) ;
299 wavecal = crires_extract_filename(frameset, CRIRES_CALPRO_WAVE) ;
300 std_star = crires_extract_filename(frameset,CRIRES_CALPRO_STD_PHOTOFLUX);
301 cfg_model = crires_extract_filename(frameset, CRIRES_CALPRO_MODEL_CONFIG);
304 if ((rawframes = crires_extract_frameset(frameset,
305 CRIRES_WIN_NODDING_OBJECT_RAW)) != NULL) {
306 crires_win_jitter_config.std_mode = 0 ;
307 }
else if ((rawframes = crires_extract_frameset(frameset,
308 CRIRES_WIN_NODDING_RAW)) != NULL) {
309 crires_win_jitter_config.std_mode = 0 ;
310 }
else if ((rawframes = crires_extract_frameset(frameset,
311 CRIRES_WIN_NODDING_J_RAW)) != NULL) {
312 crires_win_jitter_config.std_mode = 0 ;
313 }
else if ((rawframes = crires_extract_frameset(frameset,
314 CRIRES_WIN_NODDING_STD_RAW)) != NULL) {
315 crires_win_jitter_config.std_mode = 1 ;
316 }
else if ((rawframes = crires_extract_frameset(frameset,
317 CRIRES_WIN_NODDING_J_STD_RAW)) != NULL) {
318 crires_win_jitter_config.std_mode = 1 ;
320 cpl_msg_error(__func__,
"No raw frame in input") ;
321 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
326 fname = cpl_frame_get_filename(cpl_frameset_get_position(rawframes,0)) ;
328 if (crire_stripe_keys_mismatch(fname, flat)) {
329 cpl_msg_error(__func__,
330 "Mismatch of STRIPE keys with the flat frame") ;
331 cpl_frameset_delete(rawframes) ;
332 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
337 if (crire_stripe_keys_mismatch(fname, bpm)) {
338 cpl_msg_error(__func__,
339 "Mismatch of STRIPE keys with the bpm frame") ;
340 cpl_frameset_delete(rawframes) ;
341 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
346 if (crire_stripe_keys_mismatch(fname, dark)) {
347 cpl_msg_error(__func__,
348 "Mismatch of STRIPE keys with the dark frame") ;
349 cpl_frameset_delete(rawframes) ;
350 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
356 if ((crires_win_jitter_config.comb_used == CRIRES_COMB_METHOD_NODA)
357 && (crires_win_jitter_config.comb_onlyA == 0)) {
358 cpl_msg_warning(__func__,
359 "You forgot to require the NODA image to be produced !") ;
360 crires_win_jitter_config.comb_onlyA = 1 ;
362 if ((crires_win_jitter_config.comb_used == CRIRES_COMB_METHOD_NODB)
363 && (crires_win_jitter_config.comb_onlyB == 0)) {
364 cpl_msg_warning(__func__,
365 "You forgot to require the NODB image to be produced !") ;
366 crires_win_jitter_config.comb_onlyB = 1 ;
370 if (crires_win_jitter_config.comb_used == CRIRES_COMB_METHOD_COMB)
371 comblist_offset = 0 ;
372 else if (crires_win_jitter_config.comb_used == CRIRES_COMB_METHOD_NODA)
373 comblist_offset = 1 ;
374 else if (crires_win_jitter_config.comb_used == CRIRES_COMB_METHOD_NODB)
375 comblist_offset = 2 ;
378 fr = cpl_frameset_get_position(rawframes, 0);
379 tot_ndit = crires_get_totndit(cpl_frame_get_filename(fr)) ;
381 cpl_msg_error(__func__,
"Cannot get the total number of NDIT") ;
382 cpl_frameset_delete(rawframes) ;
383 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
386 tot_ndit *= cpl_frameset_get_size(rawframes) ;
389 cpl_msg_info(__func__,
"Images combination") ;
390 cpl_msg_indent_more() ;
391 if ((comblist = crires_combine_imagelist_win(rawframes,
392 flat, dark, bpm, detlin,
393 crires_win_jitter_config.comb_refine,
394 crires_win_jitter_config.comb_onlyA,
395 crires_win_jitter_config.comb_onlyB)) == NULL) {
396 cpl_msg_error(__func__,
"Cannot combine the images") ;
397 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
398 cpl_frameset_delete(rawframes) ;
399 cpl_msg_indent_less() ;
402 cpl_msg_indent_less() ;
405 cpl_msg_info(__func__,
"Spectrum extraction") ;
406 cpl_msg_indent_more() ;
407 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
408 cpl_msg_info(__func__,
"Chip number %d extraction", i+1) ;
409 cpl_msg_indent_more() ;
413 if (i == 1) y_pos = crires_win_jitter_config.extr_y_spec_zone_c1 ;
414 if (i == 2) y_pos = crires_win_jitter_config.extr_y_spec_zone_c2 ;
415 if (i == 3) y_pos = crires_win_jitter_config.extr_y_spec_zone_c3 ;
416 if (i == 4) y_pos = crires_win_jitter_config.extr_y_spec_zone_c4 ;
417 if (sscanf(y_pos,
"%d,%d", &extr_spec_starty, &extr_spec_stopy)!=2) {
418 cpl_msg_warning(__func__,
"Wrong Spectral Zone specified: %s",
420 extr_spec_starty = extr_spec_stopy = -1 ;
422 if ((extr_tab[i] = crires_extract_spectrum(
423 cpl_imagelist_get(comblist[0+2*comblist_offset], i),
424 cpl_imagelist_get(comblist[1+2*comblist_offset], i),
425 crires_win_jitter_config.extr_box_hor_size,
426 crires_win_jitter_config.extr_spec_hsize,
427 crires_win_jitter_config.extr_kappa,
428 crires_win_jitter_config.extr_closing_hs,
429 crires_win_jitter_config.extr_clean_rate,
430 crires_win_jitter_config.extr_rej_left,
431 crires_win_jitter_config.extr_rej_right,
432 extr_spec_starty, extr_spec_stopy, i+1, tot_ndit,
433 CRIRES_ILLUM_FULL_DETECTOR,
434 &(crires_win_jitter_config.qc_specpos[i]),
435 &(crires_win_jitter_config.qc_specwrec[i]),
436 &(crires_win_jitter_config.qc_specwopt[i]),
437 &(crires_win_jitter_config.qc_specoptmed[i]),
438 &(crires_win_jitter_config.qc_s2nmed[i]),
440 &(bg_maps[i]))) == NULL) {
441 cpl_msg_error(__func__,
"Cannot extract the spectrum") ;
442 cpl_msg_indent_less() ;
443 cpl_msg_indent_less() ;
444 for (j=1 ; j<i ; j++)
445 cpl_table_delete(extr_tab[j]) ;
446 for (j=1 ; j<i ; j++)
447 cpl_image_delete(profiles[j]) ;
448 for (j=1 ; j<i ; j++)
449 cpl_image_delete(bg_maps[j]) ;
450 cpl_imagelist_delete(comblist[0]) ;
451 cpl_imagelist_delete(comblist[1]) ;
452 if (crires_win_jitter_config.comb_onlyA) {
453 cpl_imagelist_delete(comblist[2]) ;
454 cpl_imagelist_delete(comblist[3]) ;
456 if (crires_win_jitter_config.comb_onlyB) {
457 cpl_imagelist_delete(comblist[4]) ;
458 cpl_imagelist_delete(comblist[5]) ;
461 cpl_frameset_delete(rawframes) ;
464 cpl_msg_info(__func__,
"Chip number %d FWHM Computation", i+1) ;
465 if (crires_extract_qc_fwhm(
466 cpl_imagelist_get(comblist[0+2*comblist_offset], i),
468 &(crires_win_jitter_config.qc_fwhm_comb_pix[i]),
469 &(crires_win_jitter_config.qc_fwhm_comb_as[i]),
470 &(crires_win_jitter_config.qc_fwhm_prof_pix[i]),
471 &(crires_win_jitter_config.qc_fwhm_prof_as[i]),
472 &(crires_win_jitter_config.qc_fwhm_diff[i])) == -1) {
473 cpl_msg_warning(__func__,
"Failed for FWHM computation") ;
474 crires_win_jitter_config.qc_fwhm_comb_pix[i] = -1.0 ;
475 crires_win_jitter_config.qc_fwhm_comb_as[i] = -1.0 ;
476 crires_win_jitter_config.qc_fwhm_prof_pix[i] = -1.0 ;
477 crires_win_jitter_config.qc_fwhm_prof_as[i] = -1.0 ;
478 crires_win_jitter_config.qc_fwhm_diff[i] = -1.0 ;
480 cpl_msg_indent_less() ;
484 prof_list = cpl_imagelist_new() ;
485 bgmap_list = cpl_imagelist_new() ;
486 profile_empty = cpl_image_duplicate(profiles[1]) ;
487 bgmap_empty = cpl_image_duplicate(bg_maps[1]) ;
488 cpl_image_multiply_scalar(profile_empty, 0.0) ;
489 cpl_image_multiply_scalar(bgmap_empty, 0.0) ;
490 cpl_imagelist_set(prof_list, cpl_image_duplicate(profile_empty), 0) ;
491 cpl_imagelist_set(bgmap_list, cpl_image_duplicate(bgmap_empty), 0) ;
492 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
493 cpl_imagelist_set(prof_list, profiles[i], i) ;
494 cpl_imagelist_set(bgmap_list, bg_maps[i], i) ;
496 cpl_imagelist_set(prof_list, cpl_image_duplicate(profile_empty),
497 CRIRES_NB_DETECTORS-1) ;
498 cpl_imagelist_set(bgmap_list, cpl_image_duplicate(bgmap_empty),
499 CRIRES_NB_DETECTORS-1) ;
500 cpl_image_delete(profile_empty) ;
501 cpl_image_delete(bgmap_empty) ;
504 if (crires_win_jitter_config.qc_specpos[1] > 0 &&
505 crires_win_jitter_config.qc_specpos[2] > 0 &&
506 fabs(crires_win_jitter_config.qc_specpos[1] -
507 crires_win_jitter_config.qc_specpos[2]) >
508 CRIRES_SPEC_POS_TOLERANCE) {
509 cpl_msg_warning(__func__,
510"The spectrum positions in chip 1 and chip 2 are too different: %d -> %d",
511 crires_win_jitter_config.qc_specpos[1],
512 crires_win_jitter_config.qc_specpos[2]) ;
514 cpl_msg_indent_less() ;
517 cpl_msg_info(__func__,
"Wavelength Calibration") ;
518 cpl_msg_indent_more() ;
519 if (wavecal != NULL) {
521 cpl_msg_info(__func__,
"Use the provided solution") ;
522 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
523 if ((wave_tab[i] = crires_load_table_check(wavecal, i+1,
524 CRIRES_PROTYPE_WL_POLY, -1, -1, 0)) == NULL) {
525 cpl_msg_error(__func__,
"Cannot load the wavelength table") ;
526 cpl_msg_indent_less() ;
527 cpl_frameset_delete(rawframes) ;
528 cpl_imagelist_delete(comblist[0]) ;
529 cpl_imagelist_delete(comblist[1]) ;
530 if (crires_win_jitter_config.comb_onlyA) {
531 cpl_imagelist_delete(comblist[2]) ;
532 cpl_imagelist_delete(comblist[3]) ;
534 if (crires_win_jitter_config.comb_onlyB) {
535 cpl_imagelist_delete(comblist[4]) ;
536 cpl_imagelist_delete(comblist[5]) ;
539 for (j=1 ; j<CRIRES_NB_DETECTORS-1 ; j++)
540 cpl_table_delete(extr_tab[j]) ;
541 cpl_imagelist_delete(prof_list) ;
542 cpl_imagelist_delete(bgmap_list) ;
548 cpl_msg_info(__func__,
"Use the keywords for the wavelength") ;
551 fname = cpl_frame_get_filename(cpl_frameset_get_position(rawframes,0)) ;
554 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
555 cpl_msg_info(__func__,
"Calibrate chip number %d", i+1) ;
556 cpl_msg_indent_more() ;
557 wave_poly = crires_wlestimate_get(fname, i+1) ;
558 wave_tab[i] = crires_wlcalib_gen_wltab_one(wave_poly, -1, -1.0) ;
559 cpl_polynomial_delete(wave_poly) ;
560 cpl_msg_indent_less() ;
565 if ((wl_map = crires_wlcalib_gen_wlmap((
const cpl_table **)wave_tab))
567 cpl_msg_error(__func__,
"Cannot compute the Wavelength Map") ;
568 cpl_frameset_delete(rawframes) ;
569 cpl_imagelist_delete(comblist[0]) ;
570 cpl_imagelist_delete(comblist[1]) ;
571 if (crires_win_jitter_config.comb_onlyA) {
572 cpl_imagelist_delete(comblist[2]) ;
573 cpl_imagelist_delete(comblist[3]) ;
575 if (crires_win_jitter_config.comb_onlyB) {
576 cpl_imagelist_delete(comblist[4]) ;
577 cpl_imagelist_delete(comblist[5]) ;
580 cpl_imagelist_delete(prof_list) ;
581 cpl_imagelist_delete(bgmap_list) ;
582 for (j=1 ; j<CRIRES_NB_DETECTORS-1 ; j++)
583 cpl_table_delete(extr_tab[j]) ;
584 for (j=0 ; j<CRIRES_NB_DETECTORS ; j++)
585 if (wave_tab[j] != NULL) cpl_table_delete(wave_tab[j]);
588 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
589 if (wave_tab[i] != NULL) cpl_table_delete(wave_tab[i]);
592 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
593 crires_win_jitter_config.qc_wlcent[i] =
594 cpl_image_get(cpl_imagelist_get(wl_map, i),
595 512, crires_win_jitter_config.qc_specpos[i], &pix) ;
596 crires_win_jitter_config.qc_wldisp[i] =
597 ((cpl_image_get(cpl_imagelist_get(wl_map, i), 1024,
598 crires_win_jitter_config.qc_specpos[i], &pix)) -
599 (cpl_image_get(cpl_imagelist_get(wl_map, i), 1,
600 crires_win_jitter_config.qc_specpos[i], &pix)))
605 fname = cpl_frame_get_filename(cpl_frameset_get_position(rawframes,0)) ;
606 if ((cfg_model != NULL) && (!crires_model_off()) &&
607 (crires_model_config_check(cfg_model, fname) == 0)) {
608 cpl_msg_info(__func__,
"Call the model to get the wavelength map") ;
609 cpl_msg_indent_more() ;
610 wl_map_model = crires_model_wavpix(fname, cfg_model, -1) ;
611 if (wl_map_model == NULL) {
612 cpl_msg_warning(__func__,
"Model function returns NULL") ;
615 cpl_msg_indent_less() ;
617 wl_map_model = NULL ;
621 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
622 cpl_table_new_column(extr_tab[i], CRIRES_COL_WAVELENGTH,
624 for (j=0 ; j<cpl_table_get_nrow(extr_tab[i]) ; j++) {
625 cpl_table_set_double(extr_tab[i], CRIRES_COL_WAVELENGTH, j,
626 cpl_image_get(cpl_imagelist_get_const(wl_map, i), j+1,
627 crires_win_jitter_config.qc_specpos[i], &pix));
632 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
633 cpl_table_new_column(extr_tab[i], CRIRES_COL_WAVELENGTH_MODEL,
635 cpl_table_fill_column_window_double(extr_tab[i],
636 CRIRES_COL_WAVELENGTH_MODEL, 0,
637 cpl_table_get_nrow(extr_tab[i]), -1.0) ;
639 if ((cfg_model != NULL) && (!crires_model_off()) && (1)) {
640 cpl_msg_info(__func__,
"Call the model to get the wavelengths") ;
641 cpl_msg_indent_more() ;
642 wavelengths = crires_model_wavelengths(
643 cpl_frame_get_filename(cpl_frameset_get_position(rawframes,0)),
645 (
double)(crires_win_jitter_config.qc_specpos[0]),
647 if (wavelengths != NULL) {
649 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
651 for (j=0 ; j<cpl_vector_get_size(wavelengths[i]) ; j++) {
652 cpl_table_set_double(extr_tab[i],
653 CRIRES_COL_WAVELENGTH_MODEL, j,
654 cpl_vector_get(wavelengths[i], j)) ;
657 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
658 cpl_vector_delete(wavelengths[i]) ;
659 cpl_free(wavelengths) ;
661 cpl_msg_warning(__func__,
"Model function returns NULL") ;
664 cpl_msg_indent_less() ;
668 if (crires_win_jitter_config.std_mode) {
669 cpl_msg_info(__func__,
670 "Sensitivity / Conversion / Throughput computation") ;
671 cpl_msg_indent_more() ;
673 if ((std_star_tab = crires_load_table_check(std_star, 1,
674 CRIRES_PROTYPE_PHO_FLUX, -1, -1, 0)) == NULL) {
675 cpl_msg_error(__func__,
"Cannot load the std star flux") ;
678 if ((std_star_biv = crires_photom_conv_get_star(std_star_tab,
679 cpl_frame_get_filename(cpl_frameset_get_position(rawframes,0))))
681 cpl_msg_error(__func__,
"Cannot find the star flux") ;
682 cpl_table_delete(std_star_tab) ;
684 cpl_table_delete(std_star_tab) ;
686 for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
687 if (crires_photom_conv_engine(extr_tab[i], std_star_biv,
688 i+1, (i+1==crires_win_jitter_config.display))==0){
689 crires_win_jitter_config.qc_convmed[i] =
690 cpl_table_get_column_median(extr_tab[i],
691 CRIRES_COL_CONVERSION_RECT) ;
692 crires_win_jitter_config.qc_thromed[i] =
693 cpl_table_get_column_median(extr_tab[i],
694 CRIRES_COL_THROUGHPUT) ;
696 if (crires_photom_sens_engine(extr_tab[i],
697 cpl_frame_get_filename(cpl_frameset_get_position(
699 (i+1==crires_win_jitter_config.display))>0) {
700 crires_win_jitter_config.qc_sensmed[i] =
701 cpl_table_get_column_median(extr_tab[i],
702 CRIRES_COL_SENSITIVITY) ; ;
706 cpl_bivector_delete(std_star_biv) ;
709 cpl_msg_indent_less() ;
711 cpl_frameset_delete(rawframes) ;
714 extr_tab_empty = cpl_table_duplicate(extr_tab[1]) ;
715 cpl_table_set_size(extr_tab_empty, 0) ;
716 extr_tab[0] = cpl_table_duplicate(extr_tab_empty) ;
717 extr_tab[CRIRES_NB_DETECTORS-1] = cpl_table_duplicate(extr_tab_empty) ;
718 cpl_table_delete(extr_tab_empty) ;
721 cpl_msg_info(__func__,
"Save the product") ;
722 cpl_msg_indent_more() ;
723 if (crires_win_jitter_save((
const cpl_imagelist **)comblist,
724 prof_list, bgmap_list,
725 (
const cpl_table **)extr_tab, wl_map, wl_map_model, parlist,
727 cpl_msg_error(__func__,
"Cannot save the product") ;
728 cpl_imagelist_delete(prof_list) ;
729 cpl_imagelist_delete(bgmap_list) ;
730 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
731 if (extr_tab[i] != NULL) cpl_table_delete(extr_tab[i]) ;
732 cpl_imagelist_delete(comblist[0]) ;
733 cpl_imagelist_delete(comblist[1]) ;
734 if (crires_win_jitter_config.comb_onlyA) {
735 cpl_imagelist_delete(comblist[2]) ;
736 cpl_imagelist_delete(comblist[3]) ;
738 if (crires_win_jitter_config.comb_onlyB) {
739 cpl_imagelist_delete(comblist[4]) ;
740 cpl_imagelist_delete(comblist[5]) ;
743 cpl_imagelist_delete(wl_map) ;
744 if (wl_map_model) cpl_imagelist_delete(wl_map_model) ;
745 cpl_msg_indent_less() ;
748 cpl_imagelist_delete(wl_map) ;
749 if (wl_map_model) cpl_imagelist_delete(wl_map_model) ;
750 cpl_imagelist_delete(comblist[0]) ;
751 cpl_imagelist_delete(comblist[1]) ;
752 if (crires_win_jitter_config.comb_onlyA) {
753 cpl_imagelist_delete(comblist[2]) ;
754 cpl_imagelist_delete(comblist[3]) ;
756 if (crires_win_jitter_config.comb_onlyB) {
757 cpl_imagelist_delete(comblist[4]) ;
758 cpl_imagelist_delete(comblist[5]) ;
761 cpl_imagelist_delete(prof_list) ;
762 cpl_imagelist_delete(bgmap_list) ;
763 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
764 if (extr_tab[i] != NULL) cpl_table_delete(extr_tab[i]) ;
765 cpl_msg_indent_less() ;
768 if (cpl_error_get_code())
return -1 ;
787static int crires_win_jitter_save(
788 const cpl_imagelist ** images,
789 const cpl_imagelist * prof,
790 const cpl_imagelist * bgmap,
791 const cpl_table ** extr_tab,
792 const cpl_imagelist * wl_map,
793 const cpl_imagelist * wl_map_model,
794 const cpl_parameterlist * parlist,
797 cpl_propertylist ** qclists ;
798 const cpl_frame * ref_frame ;
799 const char * procat ;
800 const char * protype ;
801 cpl_propertylist * inputlist ;
802 const char * recipe_name =
"crires_win_jitter" ;
806 ref_frame = irplib_frameset_get_first_from_group(set, CPL_FRAME_GROUP_RAW) ;
809 qclists = cpl_malloc(CRIRES_NB_DETECTORS *
sizeof(cpl_propertylist*)) ;
810 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
811 qclists[i] = cpl_propertylist_new() ;
812 cpl_propertylist_append_int(qclists[i],
"ESO QC SPECPOS",
813 crires_win_jitter_config.qc_specpos[i]) ;
814 cpl_propertylist_append_int(qclists[i],
"ESO QC SPECWREC",
815 crires_win_jitter_config.qc_specwrec[i]) ;
816 cpl_propertylist_append_int(qclists[i],
"ESO QC SPECWOPT",
817 crires_win_jitter_config.qc_specwopt[i]) ;
818 cpl_propertylist_append_double(qclists[i],
"ESO QC SIGNAL MED",
819 crires_win_jitter_config.qc_specoptmed[i]) ;
820 cpl_propertylist_append_double(qclists[i],
"ESO QC S2NMED",
821 crires_win_jitter_config.qc_s2nmed[i]) ;
822 cpl_propertylist_append_double(qclists[i],
"ESO QC CENTWL",
823 crires_win_jitter_config.qc_wlcent[i]) ;
824 cpl_propertylist_append_double(qclists[i],
"ESO QC DISPWL",
825 crires_win_jitter_config.qc_wldisp[i]) ;
826 cpl_propertylist_append_double(qclists[i],
"ESO QC SENSMED",
827 crires_win_jitter_config.qc_sensmed[i]) ;
828 cpl_propertylist_append_double(qclists[i],
"ESO QC CONVMED",
829 crires_win_jitter_config.qc_convmed[i]) ;
830 cpl_propertylist_append_double(qclists[i],
"ESO QC THROMED",
831 crires_win_jitter_config.qc_thromed[i]) ;
832 cpl_propertylist_append_double(qclists[i],
"ESO QC FWHMPIX COMBINED",
833 crires_win_jitter_config.qc_fwhm_comb_pix[i]) ;
834 cpl_propertylist_append_double(qclists[i],
"ESO QC FWHMARC COMBINED",
835 crires_win_jitter_config.qc_fwhm_comb_as[i]) ;
836 cpl_propertylist_append_double(qclists[i],
"ESO QC FWHMPIX PROFILE",
837 crires_win_jitter_config.qc_fwhm_prof_pix[i]) ;
838 cpl_propertylist_append_double(qclists[i],
"ESO QC FWHMARC PROFILE",
839 crires_win_jitter_config.qc_fwhm_prof_as[i]) ;
840 cpl_propertylist_append_double(qclists[i],
"ESO QC FWHM DIFF",
841 crires_win_jitter_config.qc_fwhm_diff[i]) ;
843 inputlist = cpl_propertylist_load_regexp(
844 cpl_frame_get_filename(ref_frame), i+1,
845 CRIRES_HEADER_EXT_FORWARD, 0) ;
846 cpl_propertylist_copy_property_regexp(qclists[i], inputlist,
847 CRIRES_HEADER_EXT_FORWARD, 0) ;
848 cpl_propertylist_delete(inputlist) ;
852 if (crires_win_jitter_config.std_mode == 1) {
853 procat = CRIRES_STD_WIN_COMBINED_IMA ;
855 procat = CRIRES_OBS_WIN_COMBINED_IMA ;
859 crires_image_save(set,
865 CRIRES_PROTYPE_COMBINED,
866 CRIRES_ILLUM_FULL_DETECTOR,
868 (
const cpl_propertylist **)qclists,
869 PACKAGE
"/" PACKAGE_VERSION,
870 "crires_win_jitter_comb.fits") ;
873 if (crires_win_jitter_config.std_mode == 1) {
874 procat = CRIRES_STD_WIN_CONTRIBUTION_IMA ;
876 procat = CRIRES_OBS_WIN_CONTRIBUTION_IMA ;
880 crires_image_save(set,
886 CRIRES_PROTYPE_CONTRIB,
887 CRIRES_ILLUM_FULL_DETECTOR,
889 (
const cpl_propertylist **)qclists,
890 PACKAGE
"/" PACKAGE_VERSION,
891 "crires_win_jitter_contrib.fits") ;
894 if (crires_win_jitter_config.comb_onlyA) {
896 if (crires_win_jitter_config.std_mode == 1) {
897 procat = CRIRES_STD_WIN_COMBINED_NA_IMA ;
899 procat = CRIRES_OBS_WIN_COMBINED_NA_IMA ;
903 crires_image_save(set,
909 CRIRES_PROTYPE_COMBINED,
910 CRIRES_ILLUM_FULL_DETECTOR,
912 (
const cpl_propertylist **)qclists,
913 PACKAGE
"/" PACKAGE_VERSION,
914 "crires_win_jitter_comb_noddedA.fits") ;
917 if (crires_win_jitter_config.std_mode == 1) {
918 procat = CRIRES_STD_WIN_CONTRIBUTION_NA_IMA ;
920 procat = CRIRES_OBS_WIN_CONTRIBUTION_NA_IMA ;
924 crires_image_save(set,
930 CRIRES_PROTYPE_CONTRIB,
931 CRIRES_ILLUM_FULL_DETECTOR,
933 (
const cpl_propertylist **)qclists,
934 PACKAGE
"/" PACKAGE_VERSION,
935 "crires_win_jitter_contrib_noddedA.fits") ;
939 if (crires_win_jitter_config.comb_onlyB) {
941 if (crires_win_jitter_config.std_mode == 1) {
942 procat = CRIRES_STD_WIN_COMBINED_NB_IMA ;
944 procat = CRIRES_OBS_WIN_COMBINED_NB_IMA ;
948 crires_image_save(set,
954 CRIRES_PROTYPE_COMBINED,
955 CRIRES_ILLUM_FULL_DETECTOR,
957 (
const cpl_propertylist **)qclists,
958 PACKAGE
"/" PACKAGE_VERSION,
959 "crires_win_jitter_comb_noddedB.fits") ;
962 if (crires_win_jitter_config.std_mode == 1) {
963 procat = CRIRES_STD_WIN_CONTRIBUTION_NB_IMA ;
965 procat = CRIRES_OBS_WIN_CONTRIBUTION_NB_IMA ;
969 crires_image_save(set,
975 CRIRES_PROTYPE_CONTRIB,
976 CRIRES_ILLUM_FULL_DETECTOR,
978 (
const cpl_propertylist **)qclists,
979 PACKAGE
"/" PACKAGE_VERSION,
980 "crires_win_jitter_contrib_noddedB.fits") ;
984 if (crires_win_jitter_config.std_mode == 1) {
985 procat = CRIRES_STD_WIN_EXTRACT_PROFILE_IMA ;
987 procat = CRIRES_OBS_WIN_EXTRACT_PROFILE_IMA ;
991 crires_image_save(set,
997 CRIRES_PROTYPE_PROFILE,
998 CRIRES_ILLUM_FULL_DETECTOR,
1000 (
const cpl_propertylist **)qclists,
1001 PACKAGE
"/" PACKAGE_VERSION,
1002 "crires_win_jitter_prof.fits") ;
1005 if (crires_win_jitter_config.std_mode == 1) {
1006 procat = CRIRES_STD_WIN_EXTRACT_BGMAP_IMA ;
1008 procat = CRIRES_OBS_WIN_EXTRACT_BGMAP_IMA ;
1012 crires_image_save(set,
1018 CRIRES_PROTYPE_BGD_MAP,
1019 CRIRES_ILLUM_FULL_DETECTOR,
1021 (
const cpl_propertylist **)qclists,
1022 PACKAGE
"/" PACKAGE_VERSION,
1023 "crires_win_jitter_bgmap.fits") ;
1026 if (crires_win_jitter_config.std_mode == 1) {
1027 procat = CRIRES_STD_WIN_WL_MAP_IMA ;
1029 procat = CRIRES_OBS_WIN_WL_MAP_IMA ;
1033 crires_image_save(set,
1039 CRIRES_PROTYPE_WL_MAP,
1040 CRIRES_ILLUM_FULL_DETECTOR,
1042 (
const cpl_propertylist **)qclists,
1043 PACKAGE
"/" PACKAGE_VERSION,
1044 "crires_win_jitter_wlmap.fits") ;
1046 if (wl_map_model != NULL) {
1048 if (crires_win_jitter_config.std_mode == 1) {
1049 procat = CRIRES_STD_WIN_WL_MAP_MODEL_IMA ;
1051 procat = CRIRES_OBS_WIN_WL_MAP_MODEL_IMA ;
1055 crires_image_save(set,
1061 CRIRES_PROTYPE_WL_MAP,
1062 CRIRES_ILLUM_FULL_DETECTOR,
1064 (
const cpl_propertylist **)qclists,
1065 PACKAGE
"/" PACKAGE_VERSION,
1066 "crires_win_jitter_wlmap_model.fits") ;
1071 if (cpl_table_has_column(extr_tab[0], CRIRES_COL_SENSITIVITY)) {
1072 procat = CRIRES_WIN_EXTRACT_SENS_TAB ;
1073 protype = CRIRES_PROTYPE_SENSIT ;
1074 }
else if (cpl_table_has_column(extr_tab[0],CRIRES_COL_CONVERSION_OPT)){
1075 procat = CRIRES_WIN_EXTRACT_CONV_TAB ;
1076 protype = CRIRES_PROTYPE_CONVERS ;
1077 }
else if (crires_win_jitter_config.std_mode == 1) {
1078 procat = CRIRES_STD_WIN_EXTRACT_WL_TAB ;
1079 protype = CRIRES_PROTYPE_SPEC_WL ;
1081 procat = CRIRES_OBS_WIN_EXTRACT_WL_TAB ;
1082 protype = CRIRES_PROTYPE_SPEC_WL ;
1084 crires_table_save(set,
1092 (
const cpl_propertylist **)qclists,
1093 PACKAGE
"/" PACKAGE_VERSION,
1094 "crires_win_jitter_extracted.fits") ;
1097 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
1098 cpl_propertylist_delete(qclists[i]) ;