crires_spec_jitter.c

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

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