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
00044
00045
00046
00047
00048 #define RECIPE_STRING "crires_spec_jitter"
00049
00050
00051
00052
00053
00054 static int crires_spec_jitter_save(const cpl_imagelist **,
00055 const cpl_imagelist *, const cpl_imagelist *, const cpl_table **,
00056 const cpl_imagelist *, const cpl_imagelist *,
00057 const cpl_parameterlist *, cpl_frameset *) ;
00058
00059 static char crires_spec_jitter_description[] =
00060 "crires_spec_jitter -- Observation recipe with or without nodding/jittering\n"
00061 "The files listed in the Set Of Frames (sof-file) must be tagged:\n"
00062 " raw-file.fits "CRIRES_SPEC_JITTER_RAW" or\n"
00063 " raw-file.fits "CRIRES_SPEC_JITTER_J_RAW" or\n"
00064 " raw-file.fits "CRIRES_SPEC_JITTER_STD_RAW" or\n"
00065 " raw-file.fits "CRIRES_SPEC_JITTER_J_STD_RAW" or\n"
00066 " raw-file.fits "CRIRES_SPEC_NODDING_OBJECT_RAW" or\n"
00067 " raw-file.fits "CRIRES_SPEC_NODDING_SKY_RAW" or\n"
00068 " raw-file.fits "CRIRES_SPEC_GENERIC_OBJECT_RAW" or\n"
00069 " raw-file.fits "CRIRES_SPEC_GENERIC_SKY_RAW" or\n"
00070 " raw-file.fits "CRIRES_SPEC_NODDING_RAW" or\n"
00071 " raw-file.fits "CRIRES_SPEC_NODDING_J_RAW" or\n"
00072 " raw-file.fits "CRIRES_SPEC_NODDING_STD_RAW" or\n"
00073 " raw-file.fits "CRIRES_SPEC_NODDING_J_STD_RAW" or\n"
00074 " flat-file.fits "CRIRES_CALPRO_FLAT" or\n"
00075 " bpm-file.fits "CRIRES_CALPRO_BPM" or\n"
00076 " dark-file.fits "CRIRES_CALPRO_DARK" or\n"
00077 " detlin-file.fits "CRIRES_CALPRO_COEFFS_CUBE" or\n"
00078 " wavecal-file.fits "CRIRES_CALPRO_WAVE" or\n"
00079 " catalog-file.fits "CRIRES_CALPRO_OH_CAT" or\n"
00080 " catalog-file.fits "CRIRES_CALPRO_HITRAN_CAT" or\n"
00081 " stdstar-file.fits "CRIRES_CALPRO_STD_PHOTOFLUX" or\n"
00082 " model-config-file.fits "CRIRES_CALPRO_MODEL_CONFIG".\n"
00083 "\n"
00084 "In the case of a nodding observation, in order not to degrade the \n"
00085 " instrument high resolution, the combined images using only NODA\n"
00086 " or NODB nodding positions can be produced on request. (see --onlyA/B)\n"
00087 " In this case, the following spectrum extraction can be applied \n"
00088 " either on the usual combined image or on those NODA/B combined\n"
00089 " images (see --comb_used).\n"
00090 "\n"
00091 "This recipe produces 6 to 11 files:\n"
00092 " The combined image (PRO TYPE = "CRIRES_PROTYPE_COMBINED")\n"
00093 " The contribution map (PRO TYPE = "CRIRES_PROTYPE_CONTRIB")\n"
00094 " The combined image using only Nodding A frames (optional)\n"
00095 " (PRO TYPE = "CRIRES_PROTYPE_COMBINED")\n"
00096 " The contribution map using only Nodding A frames (optional)\n"
00097 " (PRO TYPE = "CRIRES_PROTYPE_CONTRIB")\n"
00098 " The combined image using only Nodding B frames (optional)\n"
00099 " (PRO TYPE = "CRIRES_PROTYPE_COMBINED")\n"
00100 " The contribution map using only Nodding B frames (optional)\n"
00101 " (PRO TYPE = "CRIRES_PROTYPE_CONTRIB")\n"
00102 " The table with the extracted spectrum\n"
00103 " (PRO TYPE = "CRIRES_PROTYPE_SPEC_WL") or\n"
00104 " (PRO TYPE = "CRIRES_PROTYPE_SENSIT") or\n"
00105 " (PRO TYPE = "CRIRES_PROTYPE_CONVERS")\n"
00106 " The profile image (PRO TYPE = "CRIRES_PROTYPE_PROFILE")\n"
00107 " The background map (PRO TYPE = "CRIRES_PROTYPE_BGD_MAP")\n"
00108 " The wavelength map (PRO TYPE = "CRIRES_PROTYPE_WL_MAP")\n"
00109 " The wavelength map from the model (optional)\n"
00110 " (PRO TYPE = "CRIRES_PROTYPE_WL_MAP")\n" ;
00111
00112 CRIRES_RECIPE_DEFINE(crires_spec_jitter,
00113 CRIRES_PARAM_WAVES |
00114 CRIRES_PARAM_DISPLAY |
00115 CRIRES_PARAM_REFINE |
00116 CRIRES_PARAM_ONLYA |
00117 CRIRES_PARAM_ONLYB |
00118 CRIRES_PARAM_COMB_USED |
00119 CRIRES_PARAM_BLIND |
00120 CRIRES_PARAM_HOR_SIZE |
00121 CRIRES_PARAM_SPEC_HSIZE |
00122 CRIRES_PARAM_KAPPA |
00123 CRIRES_PARAM_CLOSING_HSIZE |
00124 CRIRES_PARAM_CLEAN_RATE |
00125 CRIRES_PARAM_REJECT |
00126 CRIRES_PARAM_SPEC_ZONE |
00127 CRIRES_PARAM_WL_ERROR |
00128 CRIRES_PARAM_XC_LIMIT |
00129 CRIRES_PARAM_WL_LOG |
00130 CRIRES_PARAM_WL_NOLIMIT |
00131 CRIRES_PARAM_WL_NBSAMPLES |
00132 CRIRES_PARAM_WL_STARTY |
00133 CRIRES_PARAM_WL_STOPY |
00134 CRIRES_PARAM_DEGREE |
00135 CRIRES_PARAM_WL_CLEAN,
00136 "Observation recipe",
00137 crires_spec_jitter_description) ;
00138
00139
00140
00141
00142
00143 static struct {
00144
00145 int comb_blind ;
00146 int comb_refine ;
00147 int comb_onlyA ;
00148 int comb_onlyB ;
00149 crires_comb_method comb_used ;
00150 double wstart[CRIRES_NB_DETECTORS] ;
00151 double wstop[CRIRES_NB_DETECTORS] ;
00152 int wl_nolimit ;
00153 int wl_log ;
00154 int wl_starty ;
00155 int wl_stopy ;
00156 double wl_fwhm ;
00157 double wl_slitw ;
00158 int wl_degree ;
00159 double wl_err ;
00160 int wl_samples ;
00161 int wl_clean ;
00162 double wl_xclimit ;
00163 int wl_ppm ;
00164 int extr_box_hor_size ;
00165 int extr_spec_hsize ;
00166 double extr_kappa ;
00167 int extr_closing_hs ;
00168 int extr_clean_rate ;
00169 int extr_rej_left ;
00170 int extr_rej_right ;
00171 int extr_spec_starty ;
00172 int extr_spec_stopy ;
00173 int display ;
00174
00175 crires_illum_period period ;
00176 int std_mode ;
00177 int nodding ;
00178 int qc_specpos[CRIRES_NB_DETECTORS] ;
00179 int qc_specwrec[CRIRES_NB_DETECTORS] ;
00180 int qc_specwopt[CRIRES_NB_DETECTORS] ;
00181 double qc_specoptmed[CRIRES_NB_DETECTORS] ;
00182 double qc_s2nmed[CRIRES_NB_DETECTORS] ;
00183 double qc_wlxc[CRIRES_NB_DETECTORS] ;
00184 double qc_wlcent[CRIRES_NB_DETECTORS] ;
00185 double qc_wldisp[CRIRES_NB_DETECTORS] ;
00186 double qc_sensmed[CRIRES_NB_DETECTORS] ;
00187 double qc_convmed[CRIRES_NB_DETECTORS] ;
00188 double qc_thromed[CRIRES_NB_DETECTORS] ;
00189 double qc_fwhm_comb_pix[CRIRES_NB_DETECTORS] ;
00190 double qc_fwhm_comb_as[CRIRES_NB_DETECTORS] ;
00191 double qc_fwhm_prof_pix[CRIRES_NB_DETECTORS] ;
00192 double qc_fwhm_prof_as[CRIRES_NB_DETECTORS] ;
00193 double qc_fwhm_diff[CRIRES_NB_DETECTORS] ;
00194 } crires_spec_jitter_config ;
00195
00196
00197
00198
00199
00200
00207
00208 static int crires_spec_jitter(
00209 cpl_frameset * frameset,
00210 const cpl_parameterlist * parlist)
00211 {
00212 const char * sval ;
00213 cpl_frameset * rawframes ;
00214 cpl_frameset * skyframes ;
00215 const char * fname ;
00216 cpl_frame * fr ;
00217 double tot_ndit ;
00218 const char * flat ;
00219 const char * dark ;
00220 const char * bpm ;
00221 const char * detlin ;
00222 const char * wavecal ;
00223 const char * oh_cat ;
00224 const char * hitran_cat ;
00225 const char * std_star ;
00226 const char * cfg_model ;
00227 cpl_propertylist * plist ;
00228 double wmin, wmax ;
00229 cpl_table * std_star_tab ;
00230 cpl_bivector * std_star_biv ;
00231 cpl_imagelist ** comblist ;
00232 int comblist_offset ;
00233 cpl_table * wave_tab ;
00234 cpl_polynomial * wave_poly[CRIRES_NB_DETECTORS] ;
00235 cpl_table * extr_tab[CRIRES_NB_DETECTORS] ;
00236 cpl_image * profiles[CRIRES_NB_DETECTORS] ;
00237 cpl_image * bg_maps[CRIRES_NB_DETECTORS] ;
00238 cpl_imagelist * prof_list ;
00239 cpl_imagelist * bgmap_list ;
00240 cpl_table ** wl_tab ;
00241 cpl_imagelist * wl_map ;
00242 cpl_imagelist * wl_map_model ;
00243 int power ;
00244 double wl_dx1, wl_dx2 ;
00245 cpl_vector ** wavelengths ;
00246 int i, j ;
00247
00248
00249 rawframes = NULL ;
00250 skyframes = NULL ;
00251 comblist_offset = -1 ;
00252 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00253 crires_spec_jitter_config.qc_specpos[i] = -1 ;
00254 crires_spec_jitter_config.qc_specwrec[i] = -1 ;
00255 crires_spec_jitter_config.qc_specwopt[i] = -1 ;
00256 crires_spec_jitter_config.qc_specoptmed[i] = -1.0 ;
00257 crires_spec_jitter_config.qc_s2nmed[i] = -1.0 ;
00258 crires_spec_jitter_config.qc_wlxc[i] = -1.0 ;
00259 crires_spec_jitter_config.qc_wlcent[i] = -1.0 ;
00260 crires_spec_jitter_config.qc_wldisp[i] = -1.0 ;
00261 crires_spec_jitter_config.qc_sensmed[i] = -1.0 ;
00262 crires_spec_jitter_config.qc_convmed[i] = -1.0 ;
00263 crires_spec_jitter_config.qc_thromed[i] = -1.0 ;
00264 crires_spec_jitter_config.qc_fwhm_comb_pix[i] = -1.0 ;
00265 crires_spec_jitter_config.qc_fwhm_comb_as[i] = -1.0 ;
00266 crires_spec_jitter_config.qc_fwhm_prof_pix[i] = -1.0 ;
00267 crires_spec_jitter_config.qc_fwhm_prof_as[i] = -1.0 ;
00268 crires_spec_jitter_config.qc_fwhm_diff[i] = -1.0 ;
00269 }
00270 crires_spec_jitter_config.wl_ppm = 0 ;
00271 crires_spec_jitter_config.wl_slitw = 2.0 ;
00272 crires_spec_jitter_config.wl_fwhm = 2.0 ;
00273
00274
00275 crires_spec_jitter_config.display = crires_parameterlist_get_int(parlist,
00276 RECIPE_STRING, CRIRES_PARAM_DISPLAY) ;
00277 crires_spec_jitter_config.comb_refine = crires_parameterlist_get_bool(
00278 parlist, RECIPE_STRING, CRIRES_PARAM_REFINE) ;
00279 crires_spec_jitter_config.comb_onlyA = crires_parameterlist_get_bool(
00280 parlist, RECIPE_STRING, CRIRES_PARAM_ONLYA) ;
00281 crires_spec_jitter_config.comb_onlyB = crires_parameterlist_get_bool(
00282 parlist, RECIPE_STRING, CRIRES_PARAM_ONLYB) ;
00283 sval = crires_parameterlist_get_string(parlist, RECIPE_STRING,
00284 CRIRES_PARAM_COMB_USED) ;
00285 if (!strcmp(sval, "NODA"))
00286 crires_spec_jitter_config.comb_used = CRIRES_COMB_METHOD_NODA ;
00287 else if (!strcmp(sval, "NODB"))
00288 crires_spec_jitter_config.comb_used = CRIRES_COMB_METHOD_NODB ;
00289 else if (!strcmp(sval, "COMB"))
00290 crires_spec_jitter_config.comb_used = CRIRES_COMB_METHOD_COMB ;
00291 else {
00292 cpl_msg_error(__func__, "Invalid combination method specified");
00293 return -1;
00294 }
00295 crires_spec_jitter_config.comb_blind = crires_parameterlist_get_bool(
00296 parlist, RECIPE_STRING, CRIRES_PARAM_BLIND) ;
00297 sval = crires_parameterlist_get_string(parlist, RECIPE_STRING,
00298 CRIRES_PARAM_WAVES) ;
00299 if (sscanf(sval, "%lg,%lg,%lg,%lg,%lg,%lg,%lg,%lg",
00300 &crires_spec_jitter_config.wstart[0],
00301 &crires_spec_jitter_config.wstop[0],
00302 &crires_spec_jitter_config.wstart[1],
00303 &crires_spec_jitter_config.wstop[1],
00304 &crires_spec_jitter_config.wstart[2],
00305 &crires_spec_jitter_config.wstop[2],
00306 &crires_spec_jitter_config.wstart[3],
00307 &crires_spec_jitter_config.wstop[3])!=2*CRIRES_NB_DETECTORS){
00308 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00309 return -1 ;
00310 }
00311 crires_spec_jitter_config.wl_log = crires_parameterlist_get_bool(parlist,
00312 RECIPE_STRING, CRIRES_PARAM_WL_LOG) ;
00313 crires_spec_jitter_config.wl_nolimit = crires_parameterlist_get_bool(
00314 parlist, RECIPE_STRING, CRIRES_PARAM_WL_NOLIMIT) ;
00315 crires_spec_jitter_config.wl_degree = crires_parameterlist_get_int(parlist,
00316 RECIPE_STRING, CRIRES_PARAM_DEGREE) ;
00317 crires_spec_jitter_config.wl_err = crires_parameterlist_get_double(parlist,
00318 RECIPE_STRING, CRIRES_PARAM_WL_ERROR) ;
00319 crires_spec_jitter_config.wl_xclimit = crires_parameterlist_get_double(
00320 parlist, RECIPE_STRING, CRIRES_PARAM_XC_LIMIT) ;
00321 crires_spec_jitter_config.wl_samples = crires_parameterlist_get_int(parlist,
00322 RECIPE_STRING, CRIRES_PARAM_WL_NBSAMPLES) ;
00323 crires_spec_jitter_config.wl_clean = crires_parameterlist_get_bool(parlist,
00324 RECIPE_STRING, CRIRES_PARAM_WL_CLEAN) ;
00325 crires_spec_jitter_config.wl_starty = crires_parameterlist_get_int(parlist,
00326 RECIPE_STRING, CRIRES_PARAM_WL_STARTY) ;
00327 crires_spec_jitter_config.wl_stopy = crires_parameterlist_get_int(parlist,
00328 RECIPE_STRING, CRIRES_PARAM_WL_STOPY) ;
00329 crires_spec_jitter_config.extr_box_hor_size = crires_parameterlist_get_int(
00330 parlist, RECIPE_STRING, CRIRES_PARAM_HOR_SIZE) ;
00331 crires_spec_jitter_config.extr_spec_hsize = crires_parameterlist_get_int(
00332 parlist, RECIPE_STRING, CRIRES_PARAM_SPEC_HSIZE) ;
00333 crires_spec_jitter_config.extr_kappa = crires_parameterlist_get_double(
00334 parlist, RECIPE_STRING, CRIRES_PARAM_KAPPA) ;
00335 crires_spec_jitter_config.extr_closing_hs = crires_parameterlist_get_int(
00336 parlist, RECIPE_STRING, CRIRES_PARAM_CLOSING_HSIZE) ;
00337 crires_spec_jitter_config.extr_clean_rate = crires_parameterlist_get_double(
00338 parlist, RECIPE_STRING, CRIRES_PARAM_CLEAN_RATE) ;
00339 sval = crires_parameterlist_get_string(parlist, RECIPE_STRING,
00340 CRIRES_PARAM_REJECT) ;
00341 if (sscanf(sval, "%d,%d",
00342 &crires_spec_jitter_config.extr_rej_left,
00343 &crires_spec_jitter_config.extr_rej_right)!=2) {
00344 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00345 return -1 ;
00346 }
00347 sval = crires_parameterlist_get_string(parlist, RECIPE_STRING,
00348 CRIRES_PARAM_SPEC_ZONE) ;
00349 if (sscanf(sval, "%d,%d",
00350 &crires_spec_jitter_config.extr_spec_starty,
00351 &crires_spec_jitter_config.extr_spec_stopy)!=2) {
00352 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00353 return -1 ;
00354 }
00355
00356
00357 if (crires_dfs_set_groups(frameset, "crires_spec_jitter")) {
00358 cpl_msg_error(__func__, "Cannot identify RAW and CALIB frames") ;
00359 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00360 return -1 ;
00361 }
00362
00363
00364 flat = crires_extract_filename(frameset, CRIRES_CALPRO_FLAT) ;
00365 dark = crires_extract_filename(frameset, CRIRES_CALPRO_DARK) ;
00366 bpm = crires_extract_filename(frameset, CRIRES_CALPRO_BPM) ;
00367 detlin = crires_extract_filename(frameset, CRIRES_CALPRO_COEFFS_CUBE) ;
00368 wavecal = crires_extract_filename(frameset, CRIRES_CALPRO_WAVE) ;
00369 oh_cat = crires_extract_filename(frameset, CRIRES_CALPRO_OH_CAT) ;
00370 hitran_cat = crires_extract_filename(frameset, CRIRES_CALPRO_HITRAN_CAT) ;
00371 std_star = crires_extract_filename(frameset,CRIRES_CALPRO_STD_PHOTOFLUX);
00372 cfg_model = crires_extract_filename(frameset, CRIRES_CALPRO_MODEL_CONFIG);
00373
00374
00375 if ((rawframes = crires_extract_frameset(frameset,
00376 CRIRES_SPEC_JITTER_RAW)) != NULL) {
00377 crires_spec_jitter_config.nodding = 0 ;
00378 crires_spec_jitter_config.std_mode = 0 ;
00379 } else if ((rawframes = crires_extract_frameset(frameset,
00380 CRIRES_SPEC_JITTER_J_RAW)) != NULL) {
00381 crires_spec_jitter_config.nodding = 0 ;
00382 crires_spec_jitter_config.std_mode = 0 ;
00383 } else if ((rawframes = crires_extract_frameset(frameset,
00384 CRIRES_SPEC_NODDING_OBJECT_RAW)) != NULL) {
00385 crires_spec_jitter_config.nodding = 1 ;
00386 crires_spec_jitter_config.std_mode = 0 ;
00387 } else if ((rawframes = crires_extract_frameset(frameset,
00388 CRIRES_SPEC_GENERIC_OBJECT_RAW)) != NULL) {
00389 crires_spec_jitter_config.nodding = 0 ;
00390 crires_spec_jitter_config.std_mode = 0 ;
00391 } else if ((rawframes = crires_extract_frameset(frameset,
00392 CRIRES_SPEC_NODDING_RAW)) != NULL) {
00393 crires_spec_jitter_config.nodding = 1 ;
00394 crires_spec_jitter_config.std_mode = 0 ;
00395 } else if ((rawframes = crires_extract_frameset(frameset,
00396 CRIRES_SPEC_NODDING_J_RAW)) != NULL) {
00397 crires_spec_jitter_config.nodding = 1 ;
00398 crires_spec_jitter_config.std_mode = 0 ;
00399 } else if ((rawframes = crires_extract_frameset(frameset,
00400 CRIRES_SPEC_JITTER_STD_RAW)) != NULL) {
00401 crires_spec_jitter_config.nodding = 0 ;
00402 crires_spec_jitter_config.std_mode = 1 ;
00403 } else if ((rawframes = crires_extract_frameset(frameset,
00404 CRIRES_SPEC_JITTER_J_STD_RAW)) != NULL) {
00405 crires_spec_jitter_config.nodding = 0 ;
00406 crires_spec_jitter_config.std_mode = 1 ;
00407 } else if ((rawframes = crires_extract_frameset(frameset,
00408 CRIRES_SPEC_NODDING_STD_RAW)) != NULL) {
00409 crires_spec_jitter_config.nodding = 1 ;
00410 crires_spec_jitter_config.std_mode = 1 ;
00411 } else if ((rawframes = crires_extract_frameset(frameset,
00412 CRIRES_SPEC_NODDING_J_STD_RAW)) != NULL) {
00413 crires_spec_jitter_config.nodding = 1 ;
00414 crires_spec_jitter_config.std_mode = 1 ;
00415 } else {
00416 cpl_msg_error(__func__, "No raw frame in input") ;
00417 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00418 return -1 ;
00419 }
00420
00421
00422 if (crires_spec_jitter_config.nodding == 0) {
00423
00424 if (crires_spec_jitter_config.comb_used != CRIRES_COMB_METHOD_COMB) {
00425 cpl_msg_warning(__func__,
00426 "NODA or NODB can only be used in nodding mode") ;
00427 crires_spec_jitter_config.comb_used = CRIRES_COMB_METHOD_COMB ;
00428 }
00429
00430
00431 if (crires_spec_jitter_config.comb_onlyA) {
00432 cpl_msg_warning(__func__, "onlyA only possible in nodding mode") ;
00433 crires_spec_jitter_config.comb_onlyA = 0 ;
00434 }
00435 if (crires_spec_jitter_config.comb_onlyB) {
00436 cpl_msg_warning(__func__, "onlyB only possible in nodding mode") ;
00437 crires_spec_jitter_config.comb_onlyB = 0 ;
00438 }
00439 }
00440 if ((crires_spec_jitter_config.comb_used == CRIRES_COMB_METHOD_NODA)
00441 && (crires_spec_jitter_config.comb_onlyA == 0)) {
00442 cpl_msg_warning(__func__,
00443 "You forgot to require the NODA image to be produced !") ;
00444 crires_spec_jitter_config.comb_onlyA = 1 ;
00445 }
00446 if ((crires_spec_jitter_config.comb_used == CRIRES_COMB_METHOD_NODB)
00447 && (crires_spec_jitter_config.comb_onlyB == 0)) {
00448 cpl_msg_warning(__func__,
00449 "You forgot to require the NODB image to be produced !") ;
00450 crires_spec_jitter_config.comb_onlyB = 1 ;
00451 }
00452
00453
00454 if (crires_spec_jitter_config.comb_used == CRIRES_COMB_METHOD_COMB)
00455 comblist_offset = 0 ;
00456 else if (crires_spec_jitter_config.comb_used == CRIRES_COMB_METHOD_NODA)
00457 comblist_offset = 1 ;
00458 else if (crires_spec_jitter_config.comb_used == CRIRES_COMB_METHOD_NODB)
00459 comblist_offset = 2 ;
00460
00461
00462 skyframes = crires_extract_frameset(frameset, CRIRES_SPEC_NODDING_SKY_RAW) ;
00463 if (skyframes == NULL) {
00464 skyframes = crires_extract_frameset(frameset,
00465 CRIRES_SPEC_GENERIC_SKY_RAW) ;
00466 }
00467
00468
00469 crires_spec_jitter_config.period =
00470 crires_get_detector_illum_period(
00471 cpl_frame_get_filename(cpl_frameset_get_frame(rawframes, 0))) ;
00472 if (crires_spec_jitter_config.period == CRIRES_ILLUM_UNKNOWN) {
00473 cpl_msg_error(__func__,
00474 "Cannot determine the detector illumination period") ;
00475 cpl_frameset_delete(rawframes) ;
00476 if (skyframes != NULL) cpl_frameset_delete(skyframes) ;
00477 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00478 return -1 ;
00479 } else {
00480 crires_display_detector_illum(crires_spec_jitter_config.period) ;
00481 }
00482
00483
00484 fr = cpl_frameset_get_frame(rawframes, 0);
00485 tot_ndit = crires_get_totndit(cpl_frame_get_filename(fr)) ;
00486 if (tot_ndit < 0) {
00487 cpl_msg_error(__func__, "Cannot get the total number of NDIT") ;
00488 cpl_frameset_delete(rawframes) ;
00489 if (skyframes != NULL) cpl_frameset_delete(skyframes) ;
00490 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00491 return -1 ;
00492 }
00493 tot_ndit *= cpl_frameset_get_size(rawframes) ;
00494
00495
00496 cpl_msg_info(__func__, "Images combination") ;
00497 cpl_msg_indent_more() ;
00498 if ((comblist = crires_combine_imagelist(rawframes, skyframes,
00499 crires_spec_jitter_config.period,
00500 flat, dark, bpm, detlin,
00501 crires_spec_jitter_config.nodding,
00502 crires_spec_jitter_config.comb_blind,
00503 crires_spec_jitter_config.comb_refine,
00504 crires_spec_jitter_config.comb_onlyA,
00505 crires_spec_jitter_config.comb_onlyB)) == NULL) {
00506 cpl_msg_error(__func__, "Cannot combine the images") ;
00507 cpl_frameset_delete(rawframes) ;
00508 if (skyframes != NULL) cpl_frameset_delete(skyframes) ;
00509 cpl_msg_indent_less() ;
00510 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00511 return -1 ;
00512 }
00513 if (skyframes != NULL) cpl_frameset_delete(skyframes) ;
00514 cpl_msg_indent_less() ;
00515
00516
00517 cpl_msg_info(__func__, "Wavelength Calibration") ;
00518 cpl_msg_indent_more() ;
00519 if (wavecal != NULL) {
00520
00521 cpl_msg_info(__func__, "Use the provided solution") ;
00522 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00523 if ((wave_tab = crires_load_table_check(wavecal, i+1,
00524 CRIRES_PROTYPE_WL_POLY, -1, -1, 0)) == NULL) {
00525 cpl_msg_error(__func__, "Cannot load the wavelength table") ;
00526 cpl_msg_indent_less() ;
00527 cpl_frameset_delete(rawframes) ;
00528 cpl_imagelist_delete(comblist[0]) ;
00529 cpl_imagelist_delete(comblist[1]) ;
00530 if (crires_spec_jitter_config.comb_onlyA) {
00531 cpl_imagelist_delete(comblist[2]) ;
00532 cpl_imagelist_delete(comblist[3]) ;
00533 }
00534 if (crires_spec_jitter_config.comb_onlyB) {
00535 cpl_imagelist_delete(comblist[4]) ;
00536 cpl_imagelist_delete(comblist[5]) ;
00537 }
00538 cpl_free(comblist) ;
00539 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00540 return -1 ;
00541 }
00542
00543 wave_poly[i] = crires_wlcalib_gen_wlpoly(wave_tab) ;
00544 cpl_table_delete(wave_tab) ;
00545 }
00546 } else {
00547
00548 cpl_msg_info(__func__, "Use the science frame sky to calibrate") ;
00549
00550
00551 fname = cpl_frame_get_filename(cpl_frameset_get_frame(rawframes,0)) ;
00552
00553
00554 if (crires_spec_jitter_config.wl_nolimit == 0) {
00555 plist = cpl_propertylist_load(fname, 0) ;
00556 wmin = crires_pfits_get_wlen_min(plist) ;
00557 wmax = crires_pfits_get_wlen_max(plist) ;
00558 cpl_propertylist_delete(plist) ;
00559 if (cpl_error_get_code()) {
00560 wmin = wmax = -1.0 ;
00561 cpl_error_reset() ;
00562 }
00563 } else {
00564 wmin = wmax = -1.0 ;
00565 }
00566
00567
00568 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00569 cpl_msg_info(__func__, "Calibrate chip number %d", i+1) ;
00570 cpl_msg_indent_more() ;
00571 wave_poly[i] = crires_wlcalib_sky(fname,
00572 crires_spec_jitter_config.period,
00573 oh_cat, flat, dark, bpm, detlin,
00574 crires_spec_jitter_config.wstart[i],
00575 crires_spec_jitter_config.wstop[i],
00576 wmin, wmax,
00577 crires_spec_jitter_config.wl_log,
00578 hitran_cat, i+1,
00579 crires_spec_jitter_config.wl_starty,
00580 crires_spec_jitter_config.wl_stopy,
00581 crires_spec_jitter_config.wl_degree,
00582 crires_spec_jitter_config.wl_slitw,
00583 crires_spec_jitter_config.wl_fwhm,
00584 crires_spec_jitter_config.wl_err,
00585 crires_spec_jitter_config.wl_samples,
00586 crires_spec_jitter_config.wl_clean,
00587 crires_spec_jitter_config.wl_xclimit,
00588 crires_spec_jitter_config.wl_ppm,
00589 (i+1==crires_spec_jitter_config.display),
00590 &(crires_spec_jitter_config.qc_wlxc[i])) ;
00591 cpl_msg_indent_less() ;
00592 }
00593 }
00594
00595
00596 for (i=1 ; i<CRIRES_NB_DETECTORS ; i++) {
00597 if (wave_poly[i-1] != NULL && wave_poly[i] != NULL) {
00598 power = 1 ;
00599 wl_dx1 = cpl_polynomial_get_coeff(wave_poly[i-1], &power) ;
00600 wl_dx2 = cpl_polynomial_get_coeff(wave_poly[i], &power) ;
00601 if (wl_dx1<wl_dx2) {
00602 cpl_msg_warning(__func__,
00603 "The linear coefficient is increasing from chip %d to chip %d : %g -> %g",
00604 i, i+1, wl_dx1, wl_dx2) ;
00605 }
00606 }
00607 }
00608 cpl_msg_indent_less() ;
00609
00610
00611 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00612 if (wave_poly[i] != NULL) {
00613 crires_spec_jitter_config.qc_wlcent[i] =
00614 cpl_polynomial_eval_1d(wave_poly[i], (double)512, NULL) ;
00615 crires_spec_jitter_config.qc_wldisp[i] =
00616 (cpl_polynomial_eval_1d(wave_poly[i], (double)1024, NULL) -
00617 cpl_polynomial_eval_1d(wave_poly[i], (double)1, NULL)) / 1024 ;
00618 }
00619 }
00620
00621
00622 wl_tab = crires_wlcalib_gen_wltab((const cpl_polynomial **)wave_poly) ;
00623 wl_map = crires_wlcalib_gen_wlmap((const cpl_table **)wl_tab) ;
00624 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) cpl_table_delete(wl_tab[i]) ;
00625 cpl_free(wl_tab) ;
00626
00627
00628 fname = cpl_frame_get_filename(cpl_frameset_get_frame(rawframes,0)) ;
00629 if ((cfg_model != NULL) && (!crires_model_off()) &&
00630 (crires_model_config_check(cfg_model, fname) == 0)) {
00631 cpl_msg_info(__func__, "Call the model to get the wavelength map") ;
00632 cpl_msg_indent_more() ;
00633 wl_map_model = crires_model_wavpix(fname, cfg_model, -1) ;
00634 if (wl_map_model == NULL) {
00635 cpl_msg_warning(__func__, "Model function returns NULL") ;
00636 cpl_error_reset() ;
00637 }
00638 cpl_msg_indent_less() ;
00639 } else {
00640 wl_map_model = NULL ;
00641 }
00642
00643
00644 cpl_msg_info(__func__, "Spectrum extraction") ;
00645 cpl_msg_indent_more() ;
00646 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00647 cpl_msg_info(__func__, "Chip number %d extraction", i+1) ;
00648 cpl_msg_indent_more() ;
00649 if ((extr_tab[i] = crires_extract_spectrum(
00650 cpl_imagelist_get(comblist[0+2*comblist_offset], i),
00651 cpl_imagelist_get(comblist[1+2*comblist_offset], i),
00652 crires_spec_jitter_config.extr_box_hor_size,
00653 crires_spec_jitter_config.extr_spec_hsize,
00654 crires_spec_jitter_config.extr_kappa,
00655 crires_spec_jitter_config.extr_closing_hs,
00656 crires_spec_jitter_config.extr_clean_rate,
00657 crires_spec_jitter_config.extr_rej_left,
00658 crires_spec_jitter_config.extr_rej_right,
00659 crires_spec_jitter_config.extr_spec_starty,
00660 crires_spec_jitter_config.extr_spec_stopy,
00661 i+1,
00662 tot_ndit,
00663 crires_spec_jitter_config.period,
00664 &(crires_spec_jitter_config.qc_specpos[i]),
00665 &(crires_spec_jitter_config.qc_specwrec[i]),
00666 &(crires_spec_jitter_config.qc_specwopt[i]),
00667 &(crires_spec_jitter_config.qc_specoptmed[i]),
00668 &(crires_spec_jitter_config.qc_s2nmed[i]),
00669 &(profiles[i]),
00670 &(bg_maps[i]))) == NULL) {
00671 cpl_msg_error(__func__, "Cannot extract the spectrum") ;
00672 cpl_msg_indent_less() ;
00673 cpl_msg_indent_less() ;
00674 for (j=0 ; j<CRIRES_NB_DETECTORS ; j++)
00675 if (wave_poly[j] != NULL) cpl_polynomial_delete(wave_poly[j]);
00676 for (j=0 ; j<i ; j++)
00677 cpl_table_delete(extr_tab[j]) ;
00678 for (j=0 ; j<i ; j++)
00679 cpl_image_delete(profiles[j]) ;
00680 for (j=0 ; j<i ; j++)
00681 cpl_image_delete(bg_maps[j]) ;
00682 cpl_imagelist_delete(comblist[0]) ;
00683 cpl_imagelist_delete(comblist[1]) ;
00684 if (crires_spec_jitter_config.comb_onlyA) {
00685 cpl_imagelist_delete(comblist[2]) ;
00686 cpl_imagelist_delete(comblist[3]) ;
00687 }
00688 if (crires_spec_jitter_config.comb_onlyB) {
00689 cpl_imagelist_delete(comblist[4]) ;
00690 cpl_imagelist_delete(comblist[5]) ;
00691 }
00692 cpl_free(comblist) ;
00693 cpl_frameset_delete(rawframes) ;
00694 cpl_imagelist_delete(wl_map) ;
00695 if (wl_map_model) cpl_imagelist_delete(wl_map_model) ;
00696 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00697 return -1 ;
00698 }
00699 cpl_msg_info(__func__, "Chip number %d FWHM Computation", i+1) ;
00700 if (crires_extract_qc_fwhm(
00701 cpl_imagelist_get(comblist[0+2*comblist_offset], i),
00702 profiles[i],
00703 &(crires_spec_jitter_config.qc_fwhm_comb_pix[i]),
00704 &(crires_spec_jitter_config.qc_fwhm_comb_as[i]),
00705 &(crires_spec_jitter_config.qc_fwhm_prof_pix[i]),
00706 &(crires_spec_jitter_config.qc_fwhm_prof_as[i]),
00707 &(crires_spec_jitter_config.qc_fwhm_diff[i])) == -1) {
00708 cpl_msg_warning(__func__, "Failed for FWHM computation") ;
00709 crires_spec_jitter_config.qc_fwhm_comb_pix[i] = -1.0 ;
00710 crires_spec_jitter_config.qc_fwhm_comb_as[i] = -1.0 ;
00711 crires_spec_jitter_config.qc_fwhm_prof_pix[i] = -1.0 ;
00712 crires_spec_jitter_config.qc_fwhm_prof_as[i] = -1.0 ;
00713 crires_spec_jitter_config.qc_fwhm_diff[i] = -1.0 ;
00714 }
00715 cpl_msg_indent_less() ;
00716 }
00717
00718
00719 prof_list = cpl_imagelist_new() ;
00720 bgmap_list = cpl_imagelist_new() ;
00721 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00722 cpl_imagelist_set(prof_list, profiles[i], i) ;
00723 cpl_imagelist_set(bgmap_list, bg_maps[i], i) ;
00724 }
00725
00726
00727 for (i=1 ; i<CRIRES_NB_DETECTORS ; i++) {
00728 if (crires_spec_jitter_config.qc_specpos[i-1] > 0 &&
00729 crires_spec_jitter_config.qc_specpos[i] > 0 &&
00730 fabs(crires_spec_jitter_config.qc_specpos[i-1] -
00731 crires_spec_jitter_config.qc_specpos[i]) >
00732 CRIRES_SPEC_POS_TOLERANCE) {
00733 cpl_msg_warning(__func__,
00734 "The spectrum positions in chip %d and chip %d are too different: %d -> %d",
00735 i, i+1, crires_spec_jitter_config.qc_specpos[i-1],
00736 crires_spec_jitter_config.qc_specpos[i]) ;
00737 }
00738 }
00739 cpl_msg_indent_less() ;
00740
00741
00742 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00743 cpl_table_new_column(extr_tab[i], CRIRES_COL_WAVELENGTH,
00744 CPL_TYPE_DOUBLE) ;
00745 for (j=0 ; j<cpl_table_get_nrow(extr_tab[i]) ; j++) {
00746 if (wave_poly[i] != NULL) {
00747 cpl_table_set_double(extr_tab[i], CRIRES_COL_WAVELENGTH, j,
00748 cpl_polynomial_eval_1d(wave_poly[i], (double)(j+1), NULL));
00749 } else {
00750 cpl_table_set_double(extr_tab[i], CRIRES_COL_WAVELENGTH,j,0.0);
00751 }
00752 }
00753 }
00754 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
00755 if (wave_poly[i] != NULL) cpl_polynomial_delete(wave_poly[i]);
00756
00757
00758 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00759 cpl_table_new_column(extr_tab[i], CRIRES_COL_WAVELENGTH_MODEL,
00760 CPL_TYPE_DOUBLE) ;
00761 cpl_table_fill_column_window_double(extr_tab[i],
00762 CRIRES_COL_WAVELENGTH_MODEL, 0,
00763 cpl_table_get_nrow(extr_tab[i]), -1.0) ;
00764 }
00765 if ((cfg_model != NULL) && (!crires_model_off()) && (1)) {
00766 cpl_msg_info(__func__, "Call the model to get the wavelengths") ;
00767 cpl_msg_indent_more() ;
00768 wavelengths = crires_model_wavelengths(
00769 cpl_frame_get_filename(cpl_frameset_get_frame(rawframes,0)),
00770 cfg_model, -1,
00771 (double)(crires_spec_jitter_config.qc_specpos[0]),
00772 wl_map_model) ;
00773 if (wavelengths != NULL) {
00774
00775 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00776
00777 for (j=0 ; j<cpl_vector_get_size(wavelengths[i]) ; j++) {
00778 cpl_table_set_double(extr_tab[i],
00779 CRIRES_COL_WAVELENGTH_MODEL, j,
00780 cpl_vector_get(wavelengths[i], j)) ;
00781 }
00782 }
00783 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
00784 cpl_vector_delete(wavelengths[i]) ;
00785 cpl_free(wavelengths) ;
00786 } else {
00787 cpl_msg_warning(__func__, "Model function returns NULL") ;
00788 cpl_error_reset() ;
00789 }
00790 cpl_msg_indent_less() ;
00791 }
00792
00793
00794 if (crires_spec_jitter_config.std_mode) {
00795 cpl_msg_info(__func__,
00796 "Sensitivity / Conversion / Throughput computation") ;
00797 cpl_msg_indent_more() ;
00798
00799 if ((std_star_tab = crires_load_table_check(std_star, 1,
00800 CRIRES_PROTYPE_PHO_FLUX, -1, -1, 0)) == NULL) {
00801 cpl_msg_error(__func__, "Cannot load the std star flux") ;
00802 } else {
00803
00804 if ((std_star_biv = crires_photom_conv_get_star(std_star_tab,
00805 cpl_frame_get_filename(cpl_frameset_get_frame(rawframes,0))))
00806 == NULL) {
00807 cpl_msg_error(__func__, "Cannot find the star flux") ;
00808 cpl_table_delete(std_star_tab) ;
00809 } else {
00810 cpl_table_delete(std_star_tab) ;
00811
00812 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00813 if (crires_photom_conv_engine(extr_tab[i], std_star_biv,
00814 i+1, (i+1==crires_spec_jitter_config.display))==0){
00815 crires_spec_jitter_config.qc_convmed[i] =
00816 cpl_table_get_column_median(extr_tab[i],
00817 CRIRES_COL_CONVERSION_RECT) ;
00818 crires_spec_jitter_config.qc_thromed[i] =
00819 cpl_table_get_column_median(extr_tab[i],
00820 CRIRES_COL_THROUGHPUT) ;
00821
00822 if (crires_photom_sens_engine(extr_tab[i],
00823 cpl_frame_get_filename(cpl_frameset_get_frame(
00824 rawframes,0)), -1.0,
00825 (i+1==crires_spec_jitter_config.display))>0) {
00826 crires_spec_jitter_config.qc_sensmed[i] =
00827 cpl_table_get_column_median(extr_tab[i],
00828 CRIRES_COL_SENSITIVITY) ; ;
00829 }
00830 }
00831 }
00832 cpl_bivector_delete(std_star_biv) ;
00833 }
00834 }
00835 cpl_msg_indent_less() ;
00836 }
00837 cpl_frameset_delete(rawframes) ;
00838
00839
00840 cpl_msg_info(__func__, "Save the product") ;
00841 cpl_msg_indent_more() ;
00842 if (crires_spec_jitter_save((const cpl_imagelist **)comblist,
00843 prof_list, bgmap_list,
00844 (const cpl_table **)extr_tab, wl_map, wl_map_model, parlist,
00845 frameset)) {
00846 cpl_msg_error(__func__, "Cannot save the product") ;
00847 cpl_imagelist_delete(prof_list) ;
00848 cpl_imagelist_delete(bgmap_list) ;
00849 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
00850 if (extr_tab[i] != NULL) cpl_table_delete(extr_tab[i]) ;
00851 cpl_imagelist_delete(comblist[0]) ;
00852 cpl_imagelist_delete(comblist[1]) ;
00853 if (crires_spec_jitter_config.comb_onlyA) {
00854 cpl_imagelist_delete(comblist[2]) ;
00855 cpl_imagelist_delete(comblist[3]) ;
00856 }
00857 if (crires_spec_jitter_config.comb_onlyB) {
00858 cpl_imagelist_delete(comblist[4]) ;
00859 cpl_imagelist_delete(comblist[5]) ;
00860 }
00861 cpl_free(comblist) ;
00862 cpl_imagelist_delete(wl_map) ;
00863 if (wl_map_model) cpl_imagelist_delete(wl_map_model) ;
00864 cpl_msg_indent_less() ;
00865 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT) ;
00866 return -1 ;
00867 }
00868 cpl_imagelist_delete(wl_map) ;
00869 if (wl_map_model) cpl_imagelist_delete(wl_map_model) ;
00870 cpl_imagelist_delete(comblist[0]) ;
00871 cpl_imagelist_delete(comblist[1]) ;
00872 if (crires_spec_jitter_config.comb_onlyA) {
00873 cpl_imagelist_delete(comblist[2]) ;
00874 cpl_imagelist_delete(comblist[3]) ;
00875 }
00876 if (crires_spec_jitter_config.comb_onlyB) {
00877 cpl_imagelist_delete(comblist[4]) ;
00878 cpl_imagelist_delete(comblist[5]) ;
00879 }
00880 cpl_free(comblist) ;
00881 cpl_imagelist_delete(prof_list) ;
00882 cpl_imagelist_delete(bgmap_list) ;
00883 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++)
00884 if (extr_tab[i] != NULL) cpl_table_delete(extr_tab[i]) ;
00885 cpl_msg_indent_less() ;
00886
00887
00888 if (cpl_error_get_code()) return -1 ;
00889 else return 0 ;
00890 }
00891
00892
00906
00907 static int crires_spec_jitter_save(
00908 const cpl_imagelist ** images,
00909 const cpl_imagelist * prof,
00910 const cpl_imagelist * bgmap,
00911 const cpl_table ** extr_tab,
00912 const cpl_imagelist * wl_map,
00913 const cpl_imagelist * wl_map_model,
00914 const cpl_parameterlist * parlist,
00915 cpl_frameset * set)
00916 {
00917 cpl_propertylist ** qclists ;
00918 const cpl_frame * ref_frame ;
00919 const char * procat ;
00920 const char * protype ;
00921 cpl_propertylist * inputlist ;
00922 const char * recipe_name = "crires_spec_jitter" ;
00923 int i ;
00924
00925
00926 ref_frame = irplib_frameset_get_first_from_group(set, CPL_FRAME_GROUP_RAW) ;
00927
00928
00929 qclists = cpl_malloc(CRIRES_NB_DETECTORS * sizeof(cpl_propertylist*)) ;
00930 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
00931 qclists[i] = cpl_propertylist_new() ;
00932 cpl_propertylist_append_int(qclists[i], "ESO QC SPECPOS",
00933 crires_spec_jitter_config.qc_specpos[i]) ;
00934 cpl_propertylist_append_int(qclists[i], "ESO QC SPECWREC",
00935 crires_spec_jitter_config.qc_specwrec[i]) ;
00936 cpl_propertylist_append_int(qclists[i], "ESO QC SPECWOPT",
00937 crires_spec_jitter_config.qc_specwopt[i]) ;
00938 cpl_propertylist_append_double(qclists[i], "ESO QC SIGNAL MED",
00939 crires_spec_jitter_config.qc_specoptmed[i]) ;
00940 cpl_propertylist_append_double(qclists[i], "ESO QC S2NMED",
00941 crires_spec_jitter_config.qc_s2nmed[i]) ;
00942 cpl_propertylist_append_double(qclists[i], "ESO QC XCORR",
00943 crires_spec_jitter_config.qc_wlxc[i]) ;
00944 cpl_propertylist_append_double(qclists[i], "ESO QC CENTWL",
00945 crires_spec_jitter_config.qc_wlcent[i]) ;
00946 cpl_propertylist_append_double(qclists[i], "ESO QC DISPWL",
00947 crires_spec_jitter_config.qc_wldisp[i]) ;
00948 cpl_propertylist_append_double(qclists[i], "ESO QC SENSMED",
00949 crires_spec_jitter_config.qc_sensmed[i]) ;
00950 cpl_propertylist_append_double(qclists[i], "ESO QC CONVMED",
00951 crires_spec_jitter_config.qc_convmed[i]) ;
00952 cpl_propertylist_append_double(qclists[i], "ESO QC THROMED",
00953 crires_spec_jitter_config.qc_thromed[i]) ;
00954 cpl_propertylist_append_double(qclists[i], "ESO QC FWHMPIX COMBINED",
00955 crires_spec_jitter_config.qc_fwhm_comb_pix[i]) ;
00956 cpl_propertylist_append_double(qclists[i], "ESO QC FWHMARC COMBINED",
00957 crires_spec_jitter_config.qc_fwhm_comb_as[i]) ;
00958 cpl_propertylist_append_double(qclists[i], "ESO QC FWHMPIX PROFILE",
00959 crires_spec_jitter_config.qc_fwhm_prof_pix[i]) ;
00960 cpl_propertylist_append_double(qclists[i], "ESO QC FWHMARC PROFILE",
00961 crires_spec_jitter_config.qc_fwhm_prof_as[i]) ;
00962 cpl_propertylist_append_double(qclists[i], "ESO QC FWHM DIFF",
00963 crires_spec_jitter_config.qc_fwhm_diff[i]) ;
00964
00965 inputlist = cpl_propertylist_load_regexp(
00966 cpl_frame_get_filename(ref_frame), i+1,
00967 CRIRES_HEADER_EXT_FORWARD, 0) ;
00968 cpl_propertylist_copy_property_regexp(qclists[i], inputlist,
00969 CRIRES_HEADER_EXT_FORWARD, 0) ;
00970 cpl_propertylist_delete(inputlist) ;
00971 }
00972
00973
00974 if (crires_spec_jitter_config.std_mode == 1) {
00975 procat = CRIRES_STD_COMBINED_IMA ;
00976 } else {
00977 procat = CRIRES_OBS_COMBINED_IMA ;
00978 }
00979
00980
00981 crires_image_save(set,
00982 parlist,
00983 set,
00984 images[0],
00985 recipe_name,
00986 procat,
00987 CRIRES_PROTYPE_COMBINED,
00988 crires_spec_jitter_config.period,
00989 NULL,
00990 (const cpl_propertylist **)qclists,
00991 PACKAGE "/" PACKAGE_VERSION,
00992 "crires_spec_jitter_comb.fits") ;
00993
00994
00995 if (crires_spec_jitter_config.std_mode == 1) {
00996 procat = CRIRES_STD_CONTRIBUTION_IMA ;
00997 } else {
00998 procat = CRIRES_OBS_CONTRIBUTION_IMA ;
00999 }
01000
01001
01002 crires_image_save(set,
01003 parlist,
01004 set,
01005 images[1],
01006 recipe_name,
01007 procat,
01008 CRIRES_PROTYPE_CONTRIB,
01009 crires_spec_jitter_config.period,
01010 NULL,
01011 (const cpl_propertylist **)qclists,
01012 PACKAGE "/" PACKAGE_VERSION,
01013 "crires_spec_jitter_contrib.fits") ;
01014
01015
01016 if (crires_spec_jitter_config.comb_onlyA) {
01017
01018 if (crires_spec_jitter_config.std_mode == 1) {
01019 procat = CRIRES_STD_COMBINED_NA_IMA ;
01020 } else {
01021 procat = CRIRES_OBS_COMBINED_NA_IMA ;
01022 }
01023
01024
01025 crires_image_save(set,
01026 parlist,
01027 set,
01028 images[2],
01029 recipe_name,
01030 procat,
01031 CRIRES_PROTYPE_COMBINED,
01032 crires_spec_jitter_config.period,
01033 NULL,
01034 (const cpl_propertylist **)qclists,
01035 PACKAGE "/" PACKAGE_VERSION,
01036 "crires_spec_jitter_comb_noddedA.fits") ;
01037
01038
01039 if (crires_spec_jitter_config.std_mode == 1) {
01040 procat = CRIRES_STD_CONTRIBUTION_NA_IMA ;
01041 } else {
01042 procat = CRIRES_OBS_CONTRIBUTION_NA_IMA ;
01043 }
01044
01045
01046 crires_image_save(set,
01047 parlist,
01048 set,
01049 images[3],
01050 recipe_name,
01051 procat,
01052 CRIRES_PROTYPE_CONTRIB,
01053 crires_spec_jitter_config.period,
01054 NULL,
01055 (const cpl_propertylist **)qclists,
01056 PACKAGE "/" PACKAGE_VERSION,
01057 "crires_spec_jitter_contrib_noddedA.fits") ;
01058 }
01059
01060
01061 if (crires_spec_jitter_config.comb_onlyB) {
01062
01063 if (crires_spec_jitter_config.std_mode == 1) {
01064 procat = CRIRES_STD_COMBINED_NB_IMA ;
01065 } else {
01066 procat = CRIRES_OBS_COMBINED_NB_IMA ;
01067 }
01068
01069
01070 crires_image_save(set,
01071 parlist,
01072 set,
01073 images[4],
01074 recipe_name,
01075 procat,
01076 CRIRES_PROTYPE_COMBINED,
01077 crires_spec_jitter_config.period,
01078 NULL,
01079 (const cpl_propertylist **)qclists,
01080 PACKAGE "/" PACKAGE_VERSION,
01081 "crires_spec_jitter_comb_noddedB.fits") ;
01082
01083
01084 if (crires_spec_jitter_config.std_mode == 1) {
01085 procat = CRIRES_STD_CONTRIBUTION_NB_IMA ;
01086 } else {
01087 procat = CRIRES_OBS_CONTRIBUTION_NB_IMA ;
01088 }
01089
01090
01091 crires_image_save(set,
01092 parlist,
01093 set,
01094 images[5],
01095 recipe_name,
01096 procat,
01097 CRIRES_PROTYPE_CONTRIB,
01098 crires_spec_jitter_config.period,
01099 NULL,
01100 (const cpl_propertylist **)qclists,
01101 PACKAGE "/" PACKAGE_VERSION,
01102 "crires_spec_jitter_contrib_noddedB.fits") ;
01103 }
01104
01105
01106 if (crires_spec_jitter_config.std_mode == 1) {
01107 procat = CRIRES_STD_EXTRACT_PROFILE_IMA ;
01108 } else {
01109 procat = CRIRES_OBS_EXTRACT_PROFILE_IMA ;
01110 }
01111
01112
01113 crires_image_save(set,
01114 parlist,
01115 set,
01116 prof,
01117 recipe_name,
01118 procat,
01119 CRIRES_PROTYPE_PROFILE,
01120 crires_spec_jitter_config.period,
01121 NULL,
01122 (const cpl_propertylist **)qclists,
01123 PACKAGE "/" PACKAGE_VERSION,
01124 "crires_spec_jitter_prof.fits") ;
01125
01126
01127 if (crires_spec_jitter_config.std_mode == 1) {
01128 procat = CRIRES_STD_EXTRACT_BGMAP_IMA ;
01129 } else {
01130 procat = CRIRES_OBS_EXTRACT_BGMAP_IMA ;
01131 }
01132
01133
01134 crires_image_save(set,
01135 parlist,
01136 set,
01137 bgmap,
01138 recipe_name,
01139 procat,
01140 CRIRES_PROTYPE_BGD_MAP,
01141 crires_spec_jitter_config.period,
01142 NULL,
01143 (const cpl_propertylist **)qclists,
01144 PACKAGE "/" PACKAGE_VERSION,
01145 "crires_spec_jitter_bgmap.fits") ;
01146
01147
01148 if (crires_spec_jitter_config.std_mode == 1) {
01149 procat = CRIRES_STD_WL_MAP_IMA ;
01150 } else {
01151 procat = CRIRES_OBS_WL_MAP_IMA ;
01152 }
01153
01154
01155 crires_image_save(set,
01156 parlist,
01157 set,
01158 wl_map,
01159 recipe_name,
01160 procat,
01161 CRIRES_PROTYPE_WL_MAP,
01162 crires_spec_jitter_config.period,
01163 NULL,
01164 (const cpl_propertylist **)qclists,
01165 PACKAGE "/" PACKAGE_VERSION,
01166 "crires_spec_jitter_wlmap.fits") ;
01167
01168 if (wl_map_model != NULL) {
01169
01170 if (crires_spec_jitter_config.std_mode == 1) {
01171 procat = CRIRES_STD_WL_MAP_MODEL_IMA ;
01172 } else {
01173 procat = CRIRES_OBS_WL_MAP_MODEL_IMA ;
01174 }
01175
01176
01177 crires_image_save(set,
01178 parlist,
01179 set,
01180 wl_map_model,
01181 recipe_name,
01182 procat,
01183 CRIRES_PROTYPE_WL_MAP,
01184 crires_spec_jitter_config.period,
01185 NULL,
01186 (const cpl_propertylist **)qclists,
01187 PACKAGE "/" PACKAGE_VERSION,
01188 "crires_spec_jitter_wlmap_model.fits") ;
01189 }
01190
01191
01192
01193 if (cpl_table_has_column(extr_tab[0], CRIRES_COL_SENSITIVITY)) {
01194 procat = CRIRES_EXTRACT_SENS_TAB ;
01195 protype = CRIRES_PROTYPE_SENSIT ;
01196 } else if (cpl_table_has_column(extr_tab[0],CRIRES_COL_CONVERSION_OPT)){
01197 procat = CRIRES_EXTRACT_CONV_TAB ;
01198 protype = CRIRES_PROTYPE_CONVERS ;
01199 } else if (crires_spec_jitter_config.std_mode == 1) {
01200 procat = CRIRES_STD_EXTRACT_WL_TAB ;
01201 protype = CRIRES_PROTYPE_SPEC_WL ;
01202 } else {
01203 procat = CRIRES_OBS_EXTRACT_WL_TAB ;
01204 protype = CRIRES_PROTYPE_SPEC_WL ;
01205 }
01206 crires_table_save(set,
01207 parlist,
01208 set,
01209 extr_tab,
01210 recipe_name,
01211 procat,
01212 protype,
01213 NULL,
01214 (const cpl_propertylist **)qclists,
01215 PACKAGE "/" PACKAGE_VERSION,
01216 "crires_spec_jitter_extracted.fits") ;
01217
01218
01219 for (i=0 ; i<CRIRES_NB_DETECTORS ; i++) {
01220 cpl_propertylist_delete(qclists[i]) ;
01221 }
01222 cpl_free(qclists) ;
01223 return 0;
01224 }
01225