crires_win_jitter.c

00001 /* $Id: crires_win_jitter.c,v 1.9 2011/03/22 09:17:12 yjung Exp $
00002  *
00003  * This file is part of the CRIRES Pipeline
00004  * Copyright (C) 2002,2003 European Southern Observatory
00005  *
00006  * This program is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * This program is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this program; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019  */
00020 
00021 /*
00022  * $Author: yjung $
00023  * $Date: 2011/03/22 09:17:12 $
00024  * $Revision: 1.9 $
00025  * $Name: crire-2_1_1 $
00026  */
00027 
00028 #ifdef HAVE_CONFIG_H
00029 #include <config.h>
00030 #endif
00031 
00032 /*-----------------------------------------------------------------------------
00033                                 Includes
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                                 Define
00047  -----------------------------------------------------------------------------*/
00048 
00049 #define RECIPE_STRING "crires_win_jitter"
00050 
00051 /*-----------------------------------------------------------------------------
00052                             Functions prototypes
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                             Static variables
00124  -----------------------------------------------------------------------------*/
00125 
00126 static struct {
00127     /* Inputs */
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     /* Outputs */
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                                 Functions code
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     /* Initialise */
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     /* Retrieve input parameters */
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     /* Identify the RAW and CALIB frames in the input frameset */
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     /* Retrieve calibration data */
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     /* Retrieve raw frames */
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    /* Verify the STRIPE keys conformity */
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     /* Checks on the parameters validity */
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     /* Set comblist_offset */
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     /* Get the total number of NDIT */
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     /* Images recombination */
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     /* Wavelength calibration */
00397     cpl_msg_info(__func__, "Wavelength Calibration") ;
00398     cpl_msg_indent_more() ;
00399     if (wavecal != NULL) {
00400         /* Wavelength solution is provided */
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             /* Create the polynomial */
00422             wave_poly[i] = crires_wlcalib_gen_wlpoly(wave_tab) ;
00423             cpl_table_delete(wave_tab) ;
00424         }
00425     } else {
00426         /* Calibrate from the keywords */
00427         cpl_msg_info(__func__, "Use the keywords for the wavelength") ;
00428 
00429         /* Reduce the first raw frame */
00430         fname = cpl_frame_get_filename(cpl_frameset_get_frame(rawframes,0)) ;
00431 
00432         /* Loop on the detectors */
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     /* Check the global wavelength calibration */
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     /* Compute the QC parameters */
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     /* Create the wave map */
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     /* Get the wl map from the model */
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     /* Spectrum extraction */
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     /* Create the profile and bg maps */
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     /* Test that the spectrum is at the same place in all detectors */
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     /* Apply the wavelength */
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     /* Add the Model Wavelength and Call the model to fill it */
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             /* Loop on the detectors */
00632             for (i=1 ; i<CRIRES_NB_DETECTORS-1 ; i++) {
00633                 /* Loop on the x values */
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     /* Conversion factor / Sensitivity */
00651     if (crires_win_jitter_config.std_mode) {
00652         cpl_msg_info(__func__, 
00653                 "Sensitivity / Conversion / Throughput computation") ;
00654         cpl_msg_indent_more() ;
00655         /* Load std star */
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             /* Get the wished std star */
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                 /* Apply the conversion  */
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                         /* Apply the sensitivity */
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     /* Create empty extr_tab for non-processed chips  */
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     /* Save the product */
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     /* Return */
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     /* Get the reference frame */
00789     ref_frame = irplib_frameset_get_first_from_group(set, CPL_FRAME_GROUP_RAW) ;
00790 
00791     /* Create the QC lists */
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         /* Propagate some keywords from input raw frame extensions */
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     /* PRO.CATG */
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     /* Write the combined image */
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     /* PRO.CATG */
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     /* Write the contribution map */
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     /* Nodded A support */
00877     if (crires_win_jitter_config.comb_onlyA) {
00878         /* PRO.CATG */
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         /* Write the combined Nodded A image */
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          /* PRO.CATG */
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         /* Write the contribution Nodded A image */
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     /* Nodded B support */
00922     if (crires_win_jitter_config.comb_onlyB) {
00923         /* PRO.CATG */
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         /* Write the combined Nodded B image */
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          /* PRO.CATG */
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         /* Write the contribution Nodded B image */
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     /* PRO.CATG */
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     /* Write the profile image */
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     /* PRO.CATG */
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     /* Write the background image */
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     /* PRO.CATG */
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     /* Write the map */
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         /* PRO.CATG */
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         /* Write the model map */
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     /* Write the extracted spectra */
01053     /* Get the PRO.CATG */
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     /* Free and return */
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 

Generated on 22 Mar 2011 for CRIRES Pipeline Reference Manual by  doxygen 1.6.1