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