uves_reduce_scired.c

00001 /*                                                                              *
00002  *   This file is part of the ESO UVES Pipeline                                 *
00003  *   Copyright (C) 2004,2005 European Southern Observatory                      *
00004  *                                                                              *
00005  *   This library is free software; you can redistribute it and/or modify       *
00006  *   it under the terms of the GNU General Public License as published by       *
00007  *   the Free Software Foundation; either version 2 of the License, or          *
00008  *   (at your option) any later version.                                        *
00009  *                                                                              *
00010  *   This program is distributed in the hope that it will be useful,            *
00011  *   but WITHOUT ANY WARRANTY; without even the implied warranty of             *
00012  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
00013  *   GNU General Public License for more details.                               *
00014  *                                                                              *
00015  *   You should have received a copy of the GNU General Public License          *
00016  *   along with this program; if not, write to the Free Software                *
00017  *   Foundation, 51 Franklin St, Fifth Floor, Boston, MA  02111-1307  USA       *
00018  *                                                                              */
00019 
00020 /*
00021  * $Author: amodigli $
00022  * $Date: 2008/03/04 15:24:10 $
00023  * $Revision: 1.42 $
00024  * $Name: uves-3_9_0 $
00025  * $Log: uves_reduce_scired.c,v $
00026  * Revision 1.42  2008/03/04 15:24:10  amodigli
00027  * fixed redchain problem with clean_traps parameter
00028  *
00029  * Revision 1.41  2008/03/04 07:36:53  amodigli
00030  * fix bug retriving clean_traps parameter
00031  *
00032  * Revision 1.40  2008/03/03 16:36:23  amodigli
00033  * added call to uves_corr_traps_define_parameters
00034  *
00035  * Revision 1.39  2008/02/15 12:43:49  amodigli
00036  * allow lower/upper chip for parameter process_chip
00037  *
00038  * Revision 1.38  2008/02/15 11:52:05  amodigli
00039  * use parameter clean_trap to clean detector traps
00040  *
00041  * Revision 1.37  2007/10/05 16:01:45  amodigli
00042  * using proces_chip parameter to process or not a given RED chip
00043  *
00044  * Revision 1.36  2007/09/06 14:16:03  amodigli
00045  * fixed '_' on 2D products
00046  *
00047  * Revision 1.35  2007/08/23 13:04:17  amodigli
00048  * fixed typo in FLUXCAL pro.catg
00049  *
00050  * Revision 1.34  2007/08/21 13:08:26  jmlarsen
00051  * Removed irplib_access module, largely deprecated by CPL-4
00052  *
00053  * Revision 1.33  2007/08/17 10:09:09  amodigli
00054  * added error image in case of 2d extraction
00055  *
00056  * Revision 1.32  2007/08/10 12:10:07  amodigli
00057  * changed 2d extraction product file names as by DFS04196
00058  *
00059  * Revision 1.31  2007/08/06 11:09:57  amodigli
00060  * changed pro.catg 2D extraction as DFO asked
00061  *
00062  * Revision 1.30  2007/07/23 06:28:47  amodigli
00063  * added SLIT1.NAME to tflat QCLOG
00064  *
00065  * Revision 1.29  2007/06/06 08:17:33  amodigli
00066  * replace tab with 4 spaces
00067  *
00068  * Revision 1.28  2007/05/25 11:50:32  jmlarsen
00069  * Re-added ORDER_TRACE_TABLE
00070  *
00071  * Revision 1.27  2007/05/22 11:44:02  jmlarsen
00072  * Removed ORDER_TRACE_xxxx recipe product
00073  *
00074  * Revision 1.26  2007/05/14 08:09:48  amodigli
00075  * updated input frames and tag description in recipe man page
00076  *
00077  * Revision 1.25  2007/05/11 06:39:35  jmlarsen
00078  * Added missing factor 10**(-16) to BUNIT
00079  *
00080  * Revision 1.24  2007/05/03 15:25:15  jmlarsen
00081  * Fixed const bugs
00082  *
00083  * Revision 1.23  2007/04/24 16:45:17  amodigli
00084  * changed interface of calls to uves_load_ordertable to match new interface
00085  *
00086  * Revision 1.22  2007/04/24 12:50:29  jmlarsen
00087  * Replaced cpl_propertylist -> uves_propertylist which is much faster
00088  *
00089  * Revision 1.21  2007/04/20 14:45:12  jmlarsen
00090  * Updated comment
00091  *
00092  * Revision 1.20  2007/04/10 07:09:28  jmlarsen
00093  * Changed interface of uves_spline_hermite()
00094  *
00095  * Revision 1.19  2007/04/03 06:29:39  amodigli
00096  * changed interface to uves_load_ordertable
00097  *
00098  * Revision 1.18  2007/03/05 10:19:20  jmlarsen
00099  * Changed EXT2D_SCIENCE -> EXT_2D_SCIENCE
00100  *
00101  * Revision 1.17  2007/02/14 14:07:57  jmlarsen
00102  * Fixed bug in tflat QC computation causing execution failure
00103  *
00104  * Revision 1.16  2007/02/09 13:41:33  jmlarsen
00105  * Enable calling from uves_obs_spatred
00106  *
00107  * Revision 1.15  2007/01/29 12:12:45  jmlarsen
00108  * Log QC parameters (pos, fwhm, s/n) also for simple extraction
00109  *
00110  * Revision 1.14  2007/01/15 08:47:33  jmlarsen
00111  * Warn about optimally extracting extended objects
00112  *
00113  * Revision 1.13  2006/12/07 08:26:59  jmlarsen
00114  * Factored some common QC parameters
00115  *
00116  * Revision 1.12  2006/12/01 12:30:36  jmlarsen
00117  * Load FLAMES order table oshift/yshift
00118  *
00119  * Revision 1.11  2006/11/22 12:42:21  jmlarsen
00120  * Changed message
00121  *
00122  * Revision 1.10  2006/11/15 15:02:15  jmlarsen
00123  * Implemented const safe workarounds for CPL functions
00124  *
00125  * Revision 1.8  2006/11/15 14:04:08  jmlarsen
00126  * Removed non-const version of parameterlist_get_first/last/next which is 
00127  * already in CPL, added const-safe wrapper, unwrapper and deallocator functions
00128  *
00129  * Revision 1.7  2006/11/06 15:19:41  jmlarsen
00130  * Removed unused include directives
00131  *
00132  * Revision 1.6  2006/10/24 14:08:13  jmlarsen
00133  * Added flames flag when loading frames
00134  *
00135  * Revision 1.5  2006/10/09 13:04:58  jmlarsen
00136  * Use macro to define recipe interface functions
00137  *
00138  * Revision 1.4  2006/10/04 10:59:04  jmlarsen
00139  * Implemented QC.VRAD parameters
00140  *
00141  * Revision 1.3  2006/10/02 08:39:14  jmlarsen
00142  * Implemented tflat QC computation
00143  *
00144  * Revision 1.2  2006/09/27 15:08:45  jmlarsen
00145  * Fixed doc. bug
00146  *
00147  * Revision 1.1  2006/09/27 13:22:16  jmlarsen
00148  * Factored out scired body to enable calling it from other recipes
00149  *
00150  * Revision 1.4  2006/08/17 13:56:52  jmlarsen
00151  * Reduced max line length
00152  *
00153  * Revision 1.3  2005/12/19 16:17:56  jmlarsen
00154  * Replaced bool -> int
00155  *
00156  */
00157 
00158 #ifdef HAVE_CONFIG_H
00159 #  include <config.h>
00160 #endif
00161 
00162 /*----------------------------------------------------------------------------*/
00167 /*----------------------------------------------------------------------------*/
00171 /*-----------------------------------------------------------------------------
00172                                 Includes
00173  -----------------------------------------------------------------------------*/
00174 #include <uves_reduce_scired.h>
00175 
00176 #include <uves_reduce.h>
00177 #include <uves_reduce_utils.h>
00178 #include <uves_corrbadpix.h>
00179 
00180 #include <uves_chip.h>
00181 #include <uves_plot.h>
00182 #include <uves_dfs.h>
00183 #include <uves_pfits.h>
00184 #include <uves_parameters.h>
00185 #include <uves_msg.h>
00186 #include <uves_utils.h>
00187 #include <uves_utils_wrappers.h>
00188 #include <uves_qclog.h>
00189 #include <uves_error.h>
00190 #include <uves.h>
00191 
00192 #include <cpl.h>
00193 
00194 /*-----------------------------------------------------------------------------
00195                             Functions prototypes
00196  -----------------------------------------------------------------------------*/
00197 
00198 static void
00199 scired_qclog(const cpl_table* info_tbl, 
00200          const uves_propertylist *raw_header,
00201          const cpl_image *raw_image,
00202          double slit,
00203          cpl_table* qclog);
00204 
00205 static void
00206 tflat_qclog(const cpl_image* ima,
00207         const uves_propertylist *raw_header,
00208         cpl_table* qclog);
00209 
00210 
00211 /*-----------------------------------------------------------------------------
00212                             Implementation
00213  -----------------------------------------------------------------------------*/
00214 const char * const uves_scired_desc_short = "Reduces a science frame";
00215 const char * const uves_scired_desc =
00216 "This recipe reduces a science frame (SCIENCE_BLUE or SCIENCE_RED, or\n"
00217 "UVES_SCI_POINT_BLUE or UVES_SCI_POINT_RED, or \n"
00218 "UVES_SCI_EXTND_BLUE or UVES_SCI_EXTND_RED or \n"
00219 "UVES_SCI_SLICER_BLUE or UVES_SCI_SLICER_RED) using "
00220 "a combination (depending on recipe parameters and provided input frames) of "
00221 "the steps:\n"
00222 " - bias subtraction,\n"
00223 " - dark subtraction,\n"
00224 " - background subtraction,\n"
00225 " - extraction/cosmic ray removal,\n"
00226 " - flat field correction,\n"
00227 " - wavelength rebinning,\n"
00228 " - sky subtraction,\n"
00229 " - order merging,\n"
00230 " - response correction (if response curve is provided).\n"
00231 "\n"
00232 "Additional input for this recipe are: \n"
00233 "order table(s) for each chip, ORDER_TABLE_xxxx (where xxxx=BLUE, REDL, REDU),\n"
00234 "line table(s) for each chip, LINE_TABLE_xxxx, a master bias frame,\n"
00235 "MASTER_BIAS_xxxx, a master flat, MASTER_FLAT_xxxx, \n"
00236 "optionally an instrument  response table, INSTR_RESPONSE_xxx\n"
00237 "optionally a table describing the atmospheric extintion,\n"
00238 "EXTCOEFF_TABLE. \n"
00239 "For each chip (xxxx = BLUE, REDL, REDU) the recipe produces a combination of "
00240 "the products:\n"
00241 " 'RED_SCIENCE_xxxx'        Reduced science spectrum\n"
00242 " 'MERGED_SCIENCE_xxxx'     Merged spectrum, no sky subtraction\n"
00243 " 'WCALIB_SCIENCE_xxxx'     Extracted, wavelength calibrated frame in\n"
00244 "                           (wavelength, order) space\n"
00245 " 'WCALIB_FF_SCIENCE_xxxx'  Extracted, flat-fielded, wave.cal. frame in\n"
00246 "                           (wavelength, order) space\n"
00247 "                           (Only if flatfielding done)\n"
00248 " 'WCALIB_FLAT_OBJ_xxxx'    Extracted, wavelength calibrated flat field\n"
00249 "                           in (wavelength, order) space\n"
00250 "                           (Only if flatfielding done)\n"
00251 " 'ERRORBAR_SCIENCE_xxxx'   Error bars of 'RED_SCIENCE_xxxx'\n"
00252 " 'VARIANCE_SCIENCE_xxxx'   Variance of extracted, flatfielded object in\n"
00253 "                           (pixel, order) space\n"
00254 " 'ORDER_TRACE_xxxx'        Table describing the spatial profile\n"
00255 " 'FLUXCAL_SCIENCE_xxxx'    Flux-calibrated science spectrum\n"
00256 " 'FLUXCAL_ERROR_xxxx'      Error bars of 'FLUXCAL_SCIENCE_xxxx'\n"
00257 " 'BKG_SCI_xxxx'            The subtracted background image\n"
00258 " 'CRMASK_xxxx'             List of cosmic ray hits\n"
00259 " 'MERGED_SKY_xxxx'         The merged sky spectrum\n"
00260 " 'EXT_2D_SCIENCE_xxxx'     The 2d extracted spectrum\n"
00261 " 'FF2D_SCIENCE_xxxx'       The 2d extracted, flat-fielded spectrum\n"
00262 " 'WCAL2D_SCIENCE_xxxx'     The 2d extracted, flat-fielded, wave.cal. spectrum\n"
00263 " 'MER2D_SCIENCE_xxxx'      The 2d reduced, flux-calibrated (if possible) \n"
00264 "                           science spectrum\n";
00265 
00266 /*----------------------------------------------------------------------------*/
00273 /*----------------------------------------------------------------------------*/
00274 int uves_scired_define_parameters_body(cpl_parameterlist *parameters,
00275                        const char *recipe_id)
00276 {
00277 
00278     /*****************
00279      *    General    *
00280      *****************/
00281     if (uves_define_global_parameters(parameters) != CPL_ERROR_NONE)
00282         {
00283             return -1;
00284         }
00285 
00286     /**************************************
00287      *  detector's trap correction        *
00288      **************************************/
00289  
00290     if (uves_corr_traps_define_parameters(parameters,recipe_id) 
00291         != CPL_ERROR_NONE)
00292         {
00293             return -1;
00294         }
00295 
00296     /*******************
00297      *  Reduce.        *
00298      ******************/
00299     if (uves_propagate_parameters_step(UVES_REDUCE_ID, parameters,
00300                                        recipe_id, NULL) != 0)
00301         {
00302             return -1;
00303         }
00304     
00305     return (cpl_error_get_code() != CPL_ERROR_NONE);
00306 }
00307 
00308 
00309 /*----------------------------------------------------------------------------*/
00315 /*----------------------------------------------------------------------------*/
00316 static cpl_frame **
00317 set_all_raw_none(cpl_frameset *frames)
00318 {
00319     cpl_frame **result = NULL;
00320     cpl_frame *f;
00321     int i;
00322 
00323     result = cpl_calloc( cpl_frameset_get_size(frames) + 1,
00324                          sizeof(*result) );
00325     
00326     for (f = cpl_frameset_get_first(frames), i = 0;
00327          f != NULL;
00328          f = cpl_frameset_get_next(frames))
00329         {
00330             if (cpl_frame_get_group(f) == CPL_FRAME_GROUP_RAW)
00331                 {
00332                     /* Change + remember this frame */
00333                     cpl_frame_set_group(f, CPL_FRAME_GROUP_NONE);
00334                     result[i] = f;
00335                     i++;
00336                 }
00337         }
00338 
00339     /* 'result' is now a NULL-terminated array of the frames that were changed */
00340 
00341     return result;
00342 }
00343 
00344 /*----------------------------------------------------------------------------*/
00414 /*----------------------------------------------------------------------------*/
00415 
00416 static cpl_error_code
00417 uves_scired_process_chip(const cpl_image *raw_image, 
00418                          const uves_propertylist *raw_header,
00419                          const uves_propertylist *rotated_header,
00420                          const cpl_image *master_bias,
00421                          const cpl_image *master_dark, 
00422                          const uves_propertylist *mdark_header,
00423                          const cpl_image *master_flat, 
00424                          const uves_propertylist *mflat_header,
00425                          const cpl_table *ordertable, 
00426                          const polynomial *order_locations,
00427                          const cpl_table *linetable[3], 
00428                          const uves_propertylist *linetable_header[3], 
00429                          const polynomial *dispersion_relation[3],
00430                          const cpl_image *response_curve, 
00431              const cpl_table *master_response,
00432                          const uves_propertylist *response_curve_header,
00433                          const cpl_table *atm_extinction,
00434                          enum uves_chip chip,
00435                          /* General */
00436                          bool   DEBUG,
00437                          /* Backsub */
00438                          /* Flat fielding */
00439                          /* Extraction */
00440                          /* Rebinning  */
00441                          const cpl_parameterlist *parameters,
00442              const char *recipe_id,
00443                          /* Output     */
00444                          cpl_image **x2d, uves_propertylist **x2d_header,
00445                          cpl_image **fx2d,
00446                          cpl_image **background,
00447                          cpl_image **flatfielded_variance,
00448                          uves_propertylist **flatfielded_variance_header,
00449                          cpl_image **resampled_science,
00450                          cpl_image **resampled_mf,
00451                          cpl_image **rebinned_science, 
00452                          uves_propertylist **rebinned_header,
00453                          cpl_image **merged_sky,
00454                          cpl_image **merged_science, 
00455                          uves_propertylist **merged_header,
00456                          cpl_image **reduced_science,
00457                          cpl_image **reduced_science_error,
00458                          cpl_table **cosmic_mask,
00459                          cpl_image **fluxcal_science,
00460                          cpl_image **fluxcal_error,
00461                          uves_propertylist **fluxcal_header,
00462                          cpl_table **info_tbl,
00463              double *extraction_slit,
00464                          cpl_table **order_trace)
00465 {
00466     cpl_image *rebinned_noise = NULL;
00467     cpl_image *merged_noise   = NULL;
00468 
00469     cpl_image *reduced_rebinned = NULL;
00470     cpl_image *reduced_rebinned_noise = NULL;
00471 
00472     cpl_table *response_table = NULL;
00473 
00474     /* Do the science reduction. Produces wave.cal. spectra. */
00475     uves_msg("Reducing science object");
00476 
00477     check( uves_reduce(raw_image, 
00478                        raw_header, 
00479                        rotated_header,
00480                        master_bias,
00481                        master_dark, 
00482                        mdark_header,
00483                        master_flat, 
00484                        mflat_header, 
00485                        ordertable, 
00486                        order_locations,
00487                        linetable, 
00488                        linetable_header, 
00489                        dispersion_relation,
00490                        chip,
00491                        DEBUG, 
00492                        parameters, 
00493                        recipe_id,
00494                        /* Output */
00495                        x2d, 
00496                        x2d_header, 
00497                        fx2d,
00498                        cosmic_mask,
00499                        background,
00500                        flatfielded_variance, 
00501                        flatfielded_variance_header,
00502                        resampled_science,
00503                        resampled_mf,
00504                        merged_sky,
00505                        rebinned_science, 
00506                        &rebinned_noise, 
00507                        rebinned_header,
00508                        merged_science, 
00509                        &merged_noise, 
00510                        merged_header,
00511                        &reduced_rebinned, 
00512                        &reduced_rebinned_noise,
00513                        reduced_science, 
00514                        reduced_science_error,
00515                        info_tbl,
00516                extraction_slit,
00517                        order_trace),
00518            "Could not reduce frame");
00519 
00520     /* Plot middle row */
00521     check( uves_plot_image_rows(*reduced_science, 
00522                 1 + cpl_image_get_size_y(*reduced_science)/2,
00523                 1 + cpl_image_get_size_y(*reduced_science)/2, 1,
00524                 "Wavelength (arbitrary units)", "Relative flux",
00525                 "Reduced science spectrum"),
00526        "Plotting failed");
00527     
00528 
00529     /*
00530      * Flux calibrate the reduced spectrum
00531      * (which is an image of height 1, or more if extract.method=2d)
00532      */
00533 
00534     if (response_curve != NULL || master_response != NULL)
00535         {
00536             double lambda_start;
00537             double dlambda;
00538             int bin;
00539 
00540             /* Number of spatial traces (> 1 for 2d extraction) */
00541             int n_traces = cpl_image_get_size_y(*reduced_science);
00542             
00543             uves_msg("Flux calibrating spectrum");
00544 
00545             /* We cannot be certain that the formats (wavelength start, bin width)
00546                of the science spectrum and the response curve are identical.
00547                Therefore we interpolate the response curve at the wavelengths 
00548                defined by the bins of the science spectrum. */
00549                 
00550 
00551 
00552             /* If the response curve is an image, convert to table.
00553            This is needed for the interpolation */
00554         if (response_curve != NULL) {
00555                 response_table = cpl_table_new(cpl_image_get_size_x(response_curve));
00556                 cpl_table_new_column(response_table, "LAMBDA", CPL_TYPE_DOUBLE);
00557                 cpl_table_new_column(response_table, "FLUX_CONV", CPL_TYPE_DOUBLE);
00558                 
00559                 check( lambda_start = uves_pfits_get_crval1(response_curve_header),
00560                        "Error reading response curve start wavelength from header");
00561                 
00562                 check( dlambda = uves_pfits_get_cdelt1(response_curve_header),
00563                        "Error reading bin width from header");
00564                 
00565                 for (bin = 1; bin <= cpl_image_get_size_x(response_curve); bin++) {
00566                     double lambda;
00567                     double response;
00568                     int pis_rejected;
00569                     
00570                     lambda = lambda_start + (bin-1) * dlambda;
00571                     
00572                     check( response = cpl_image_get(response_curve, bin, 1, &pis_rejected),
00573                            "Error reading response curve bin = %d", bin);
00574                     
00575                     check((cpl_table_set_double(response_table, "LAMBDA", bin - 1, lambda),
00576                            cpl_table_set_double(response_table, "FLUX_CONV", bin - 1, response)),
00577                           "Error updating response table at row %d", bin - 1);
00578                 }
00579             } 
00580         else {
00581         response_table = cpl_table_duplicate( master_response );
00582         } /* Response table created */        
00583             
00584             /*
00585              * Correct for exposure time, gain, binning, atm. ext.
00586              */
00587             
00588             check( *fluxcal_science = uves_normalize_spectrum(*reduced_science,
00589                                                               *reduced_science_error,
00590                                                               *merged_header,
00591                                                               raw_header,
00592                                                               n_traces,
00593                                                               chip,
00594                                                               atm_extinction,
00595                                                               true,    /* Divide by binning? */
00596                                                               fluxcal_error), 
00597                    "Error normalizing reduced spectrum");
00598             
00599             /* 
00600              * Flux calibrate reduced spectrum 
00601              *  flux := flux * response
00602              */
00603             uves_msg("Multiplying by response function");
00604             {
00605                 int nbins   = cpl_image_get_size_x(*fluxcal_science);
00606                 int ntraces = cpl_image_get_size_y(*fluxcal_science);
00607                 double *fluxcal_science_data  = cpl_image_get_data_double(*fluxcal_science);
00608                 double *fluxcal_science_noise = cpl_image_get_data_double(*fluxcal_error);
00609                 
00610                 check( lambda_start = uves_pfits_get_crval1(*merged_header),
00611                        "Error reading start wavelength from reduced science header");
00612                 
00613                 check( dlambda = uves_pfits_get_cdelt1(*merged_header),
00614                        "Error reading bin width from header");
00615                 
00616                 for (bin = 1; bin <= nbins; bin++)
00617                     {
00618                         double lambda;
00619                         double response;
00620                         int trace;       /* Spatial traces (for 2d extracted spectra) */
00621                         int istart = 0;
00622 
00623                         lambda = lambda_start + (bin-1) * dlambda;
00624                         
00625                         check( response = 
00626                                uves_spline_hermite_table(lambda, response_table, 
00627                            "LAMBDA", "FLUX_CONV", &istart),
00628                                "Error interpolating response curve at lambda = %f wlu", lambda);
00629                         
00630                         for (trace = 1; trace <= ntraces; trace++)
00631                             {
00632                 /* Don't check for bad pixels here, also correct those.
00633                  * The fluxcal image has the same bad pixels as the reduced_science
00634                  * image */
00635 
00636                 fluxcal_science_data [(bin-1) + (trace-1)*nbins] *= response;
00637                 fluxcal_science_noise[(bin-1) + (trace-1)*nbins] *= response;
00638 
00639                 /* Do not propagate the error of the response 
00640                    curve which is negligibly small (and unknown at this point!).
00641                 */
00642                 }
00643             }
00644                 
00645                 /* Plot middle row */
00646                 check( uves_plot_image_rows(*fluxcal_science, 
00647                                             1 + cpl_image_get_size_y(*fluxcal_science)/2,
00648                                             1 + cpl_image_get_size_y(*fluxcal_science)/2, 1,
00649                                             "Wavelength (arbitrary units)", 
00650                                             "Flux (10^-16 erg/cm^2/A/sec)", 
00651                                             "Flux calibrated science spectrum"),
00652                        "Plotting failed");
00653                 
00654                 check( *fluxcal_header = uves_initialize_image_header("WAVELENGTH (A)", " ", 
00655                                                                       "FLUX (10^-16 erg/cm^2/A/sec)",
00656                                                                       lambda_start, 1.0,
00657                                                                       1.0, 1.0,
00658                                                                       dlambda, 1.0),
00659                        "Error initializing flux calibrated spectrum header");
00660             } /* Done multiplying by response curve */
00661         }
00662     else
00663         {
00664             uves_msg("Skipping absolute flux calibration");
00665         }
00666     
00667   cleanup:
00668     uves_free_image(&rebinned_noise);
00669     uves_free_image(&merged_noise);
00670     uves_free_image(&reduced_rebinned_noise);
00671     uves_free_image(&reduced_rebinned);
00672     uves_free_table(&response_table);
00673 
00674     if (cpl_error_get_code() != CPL_ERROR_NONE)
00675         {
00676         }
00677 
00678     return cpl_error_get_code();
00679 }
00680 
00681 /*----------------------------------------------------------------------------*/
00690 /*----------------------------------------------------------------------------*/
00691 void uves_reduce_scired(cpl_frameset *frames, const cpl_parameterlist *parameters, 
00692             const char *recipe_id, const char *starttime)
00693 {
00694     /* Recipe parameters */
00695     bool DEBUG;
00696     bool CLEAN_TRAPS;
00697     bool extract_is_2d = false;     /* Are we doing a 2d reduction? */
00698 
00699     /* Input, raw */
00700     cpl_image        *raw_image[2]      = {NULL, NULL};
00701     uves_propertylist *raw_header[2]     = {NULL, NULL};
00702     uves_propertylist *rotated_header[2] = {NULL, NULL};
00703 
00704     /* Input, calib */
00705     cpl_image        *master_bias        = NULL;
00706     uves_propertylist *master_bias_header = NULL;
00707 
00708     cpl_image        *master_flat        = NULL;
00709     uves_propertylist *master_flat_header = NULL;
00710 
00711     cpl_image        *master_dark        = NULL;
00712     uves_propertylist *master_dark_header = NULL;
00713 
00714     cpl_table        *ordertable       = NULL;
00715     uves_propertylist *ordertable_header= NULL;
00716     polynomial       *order_locations  = NULL;
00717     cpl_table        *traces           = NULL;
00718 
00719     /* Line tables for sky, object, sky (UVES specific) */
00720     const cpl_table        *linetable[3]           = {NULL, NULL, NULL};
00721     const uves_propertylist *linetable_header[3]    = {NULL, NULL, NULL};
00722     const polynomial       *dispersion_relation[3] = {NULL, NULL, NULL};
00723 
00724     cpl_image        *response_curve        = NULL;
00725     uves_propertylist *response_curve_header = NULL;
00726     cpl_table        *master_response       = NULL;
00727 
00728     cpl_table        *atm_extinction        = NULL;
00729 
00730     /* Output */
00731     /*  BKG_SCI           */
00732     cpl_image        *background            = NULL;
00733 
00734     /*  VARIANCE_SCIENCE                 */  
00735     cpl_image        *flatfielded_variance  = NULL;
00736     uves_propertylist *flatfielded_variance_header = NULL;
00737 
00738     /*  WCALIB_SCIENCE    */
00739     cpl_image        *resampled_science     = NULL;     /* extracted -> rebinned */
00740     /*  WCALIB_FLAT_OBJ   */
00741     cpl_image        *resampled_mf          = NULL;
00742     /*  WCALIB_FF_SCIENCE */
00743     cpl_image        *rebinned_science      = NULL;     /* extracted -> ff -> rebinned */
00744 
00745     uves_propertylist *rebinned_header       = NULL;
00746 
00747     /*  MERGED_SKY        */
00748     cpl_image        *merged_sky            = NULL;
00749 
00750     /*  MERGED_SCIENCE / MER2D_SCIENCE   */
00751     /*  RED_SCIENCE                      */
00752     /*  ERRORBAR_SCIENCE                 */
00753     cpl_image        *merged_science        = NULL;
00754     uves_propertylist *merged_header         = NULL;
00755     cpl_image        *reduced_science       = NULL;
00756     cpl_image        *reduced_science_error = NULL;
00757   
00758 
00759     /*  FLUXCAL_SCIENCE / FLUXCAL_ERROR */
00760     cpl_image        *fluxcal_science       = NULL;
00761     cpl_image        *fluxcal_error         = NULL;
00762     uves_propertylist *fluxcal_header       = NULL;
00763 
00764     /*  ORDER_TRACE       */
00765     cpl_table         *order_trace        = NULL;
00766     uves_propertylist *order_trace_header = NULL;
00767 
00768 
00769     /* EXT_2D_SCIENCE */
00770     cpl_image        *x2d        = NULL;
00771     uves_propertylist *x2d_header = NULL;
00772     /* FF2D_SCIENCE */
00773     cpl_image        *fx2d       = NULL;
00774 
00775     /*  CRMASK            */
00776     cpl_table        *cosmic_mask           = NULL;
00777     uves_propertylist *cosmic_mask_header    = NULL;
00778 
00779     /* QC */
00780     cpl_table* qclog[2] = {NULL, NULL};
00781     cpl_table *qclog_tflat = NULL;
00782 
00783     /* Local variables */
00784     const char *raw_filename = "";
00785     const char *atm_ext_filename = "";
00786     const char *sci_type = "";
00787     cpl_frame **raw_frames = NULL;  /* Array of cpl_frame pointers */
00788     char *product_tag = NULL;
00789     char *product_filename = NULL;
00790     char *context = NULL;
00791     double extraction_slit;
00792 
00793     bool blue  = false;
00794     enum uves_chip chip;
00795     int binx = 0;
00796     int biny = 0;
00797     
00798     cpl_table* info_tbl = NULL;
00799     const char* PROCESS_CHIP=NULL;
00800 
00801     /* Read recipe parameters */
00802     {
00803         const char *ex_method = "";
00804 
00805         /* General */
00806         check( uves_get_parameter(parameters, NULL, "uves", "debug", CPL_TYPE_BOOL, &DEBUG),
00807                "Could not read parameter");
00808 
00809 
00810 
00811         check( uves_get_parameter(parameters, NULL, "uves", "debug", CPL_TYPE_BOOL, &DEBUG),
00812                "Could not read parameter");
00813 
00814 
00815 
00816     check( uves_get_parameter(parameters, NULL, "uves", "process_chip", CPL_TYPE_STRING, &PROCESS_CHIP),
00817                "Could not read parameter");
00818     uves_string_toupper((char*)PROCESS_CHIP);
00819 
00820 
00821     check( uves_get_parameter(parameters,NULL,recipe_id, "clean_traps", CPL_TYPE_BOOL, &CLEAN_TRAPS),
00822                "Could not read parameter");
00823 
00824 
00825         
00826         /* Reduction method */
00827     context = uves_sprintf("%s.%s.%s", recipe_id, UVES_REDUCE_ID, UVES_EXTRACT_ID);
00828 
00829         check( uves_get_parameter(parameters, NULL, 
00830                                   context, "method",
00831                                   CPL_TYPE_STRING, &ex_method),
00832                "Could not read parameter");
00833 
00834         extract_is_2d = (strcmp(ex_method, "2d") == 0); 
00835     
00836     /* Load raw image and header, and identify input frame as red or blue */
00837     check( uves_load_science(frames, &raw_filename, raw_image, raw_header, rotated_header,
00838                  &blue, &sci_type),
00839            "Error loading raw frame");
00840     
00841     if ((strcmp(sci_type, "SCI_SLICER") == 0 ||
00842          strcmp(sci_type, "SCI_EXTND" ) == 0) &&
00843         strcmp(ex_method, "optimal") == 0)
00844         {
00845         uves_msg_warning("Going to optimally extract an extended object (%s). "
00846                  "This may not work because the sky cannot be "
00847                  "reliably determined",
00848                  sci_type);
00849         }
00850     }
00851     
00852     /* Load atmospheric extinction table if present */
00853     if (cpl_frameset_find(frames, UVES_EXTCOEFF_TABLE) != NULL)
00854         {
00855             check( uves_load_atmo_ext(frames, &atm_ext_filename, &atm_extinction),
00856                    "Error loading atm. extinction coefficients");
00857             
00858             uves_msg_low("Using atmospheric extinction table in '%s'", atm_ext_filename);
00859         }
00860     else
00861         {
00862             uves_msg_low("No atmospheric extinction table. Flux calibration not done");
00863         }
00864     
00865     /* Adjust parameters according to binning 
00866      * (note that x- and y-directions are swapped later by uves_crop_and_rotate()) 
00867      */
00868     check (binx = uves_pfits_get_binx(raw_header[0]), 
00869            "Could not read x binning factor from input header");
00870     check (biny = uves_pfits_get_biny(raw_header[0]), 
00871            "Could not read y binning factor from input header");
00872 
00873     /* Loop over one or two chips, over traces and
00874        over extraction windows */
00875     for (chip = uves_chip_get_first(blue);
00876          chip != UVES_CHIP_INVALID; 
00877          chip = uves_chip_get_next(chip))
00878         {
00879 
00880 
00881 
00882       if(strcmp(PROCESS_CHIP,"REDU") == 0) {
00883     chip = uves_chip_get_next(chip);
00884       }
00885 
00886             cpl_frame *mflat_frame = NULL;
00887             const char *ordertable_filename = "";
00888             const char *linetable_filename = "";
00889             const char *master_bias_filename = "";
00890             const char *master_dark_filename = "";
00891             const char *master_flat_filename = "";
00892             const char *response_curve_filename = "";
00893             const char *chip_name = "";
00894             /* const char *drs_filename        = "";    not used */
00895             /* Do this to skip REDL chip: chip = uves_chip_get_next(chip); */
00896             int raw_index = uves_chip_get_index(chip);
00897             int tracerow;                      /* Index of table row */
00898             
00899             uves_msg("Processing %s chip in '%s'",
00900                      uves_chip_tostring_upper(chip), raw_filename);
00901             
00902             check_nomsg( chip_name = uves_pfits_get_chipid(raw_header[raw_index], chip));
00903 
00904             uves_msg_debug("Binning = %dx%d", binx, biny);
00905             
00906             
00907             /* Load master bias, set pointer to NULL if not present */
00908             uves_free_image(&master_bias);
00909             uves_free_propertylist(&master_bias_header);
00910             if (cpl_frameset_find(frames, UVES_MASTER_BIAS(chip)) != NULL)
00911                 {
00912                     uves_free_image(&master_bias);
00913                     uves_free_propertylist(&master_bias_header);
00914 
00915                     check( uves_load_mbias(frames, chip_name, &master_bias_filename,
00916                                            &master_bias, &master_bias_header,
00917                                            chip),
00918                            "Error loading master bias");
00919                     
00920                     uves_msg_low("Using master bias in '%s'", master_bias_filename);
00921                 }
00922             else
00923                 {
00924                     uves_msg_low("No master bias in SOF. Bias subtraction not done");
00925                 }
00926 
00927             /* Load master dark, set pointer to NULL if not present */
00928             uves_free_image(&master_dark);
00929             uves_free_propertylist(&master_dark_header);
00930             if (cpl_frameset_find(frames, UVES_MASTER_DARK(chip))  != NULL ||
00931                 cpl_frameset_find(frames, UVES_MASTER_PDARK(chip)) != NULL)
00932 
00933                 {
00934                     check( uves_load_mdark(frames, chip_name, &master_dark_filename,
00935                                            &master_dark, &master_dark_header, chip),
00936                            "Error loading master dark");
00937                     
00938                     uves_msg_low("Using master dark in '%s'", master_dark_filename);
00939                 }
00940             else
00941                 {
00942                     uves_msg_low("No master dark in SOF. Dark subtraction not done");
00943                 }
00944             
00945             /* Load master flat */
00946             uves_free_image(&master_flat);
00947             uves_free_propertylist(&master_flat_header);
00948             check( uves_load_mflat(frames, chip_name, &master_flat_filename, &master_flat, 
00949                                    &master_flat_header, chip, &mflat_frame),
00950                    "Error loading master flat");
00951             
00952             uves_msg_low("Using master flat in '%s'", master_flat_filename);
00953             
00954             
00955             /* Load the order table for this chip */
00956             uves_free_table       (&ordertable);
00957             uves_free_propertylist(&ordertable_header);
00958             uves_polynomial_delete(&order_locations);
00959             uves_free_table       (&traces);
00960             
00961             check( uves_load_ordertable(frames, 
00962                     false,  /* FLAMES? */
00963                     chip_name, 
00964                                         &ordertable_filename, 
00965                                         &ordertable, 
00966                                         &ordertable_header,
00967                                         NULL, 
00968                                         &order_locations, 
00969                                         &traces,
00970                     NULL, NULL,
00971                                        NULL, NULL, /* fibre_pos,fibre_mask */
00972                                         chip, false),
00973                    "Could not load order table");
00974             uves_msg_low("Using order table in '%s'", ordertable_filename);
00975 
00976             /* Load response curve, if present. 
00977                Only if atm. extinction table was present. */
00978             if (atm_extinction != NULL)
00979                 {
00980                     if (cpl_frameset_find(frames, UVES_INSTR_RESPONSE(chip)) != NULL ||
00981             cpl_frameset_find(frames, UVES_MASTER_RESPONSE(chip)) != NULL)
00982                         {
00983                             uves_free_image(&response_curve);
00984                             uves_free_table(&master_response);
00985                             uves_free_propertylist(&response_curve_header);
00986                             check( uves_load_response_curve(frames, chip_name,
00987                                                             &response_curve_filename,
00988                                                             &response_curve, 
00989                                 &master_response,
00990                                                             &response_curve_header,
00991                                                             chip),
00992                                    "Error loading response curve");
00993                             
00994                 uves_msg_low("Using %sresponse curve in '%s'", 
00995                      master_response != NULL ? "master " : "",
00996                      response_curve_filename);
00997                         }
00998                     else
00999                         {
01000                             uves_msg_low("No response curve in SOF. "
01001                                          "Flux calibration not done");
01002                         }
01003                 }
01004             else
01005                 {
01006                     uves_msg_debug("There is no atmospheric extinction table. "
01007                                    "Do not look for response curve");
01008                 }
01009             
01010             /* Loop over all traces (1 trace for UVES) */
01011             for(tracerow = 0; tracerow < cpl_table_get_nrow(traces); tracerow++)
01012                 {
01013                     double trace_offset;
01014                     int trace_number;
01015                     int trace_enabled;
01016                     int badpixels_cleaned;
01017                     trace_offset  = cpl_table_get_double(traces, "Offset"    , tracerow, NULL);
01018                     trace_number  = cpl_table_get_int   (traces, "TraceID"   , tracerow, NULL);
01019                     trace_enabled = cpl_table_get_int   (traces, "Tracemask" , tracerow, NULL);
01020                     
01021                     if (trace_enabled != 0)
01022                         {
01023                             int window;          /* window number */
01024                             
01025                             if (cpl_table_get_nrow(traces) > 1) {
01026                                 uves_msg("Processing trace %d", trace_number);
01027                             }
01028                             
01029                             /* This is UVES specific. Load linetable for the 
01030                                two sky windows (number 1, 3) and for the object
01031                                window (number 2) */
01032                             
01033                             for (window = 1; window <= 3; window ++) {
01034                                 uves_free_table_const ( &(linetable[window-1]) );
01035                                 uves_free_propertylist_const( &(linetable_header[window-1]) );
01036                                 uves_polynomial_delete_const( &(dispersion_relation[window-1]) );
01037                                 check( uves_load_linetable_const(frames,
01038                                false,  /* FLAMES? */
01039                                chip_name,
01040                                                            order_locations,
01041                                                            cpl_table_get_column_min(
01042                                                                ordertable, "Order"),
01043                                                            cpl_table_get_column_max(
01044                                                                ordertable, "Order"),
01045                                                            &linetable_filename,
01046                                                            &(linetable          [window-1]),
01047                                                            &(linetable_header   [window-1]),
01048                                                            &(dispersion_relation[window-1]),
01049                                                            NULL,
01050                                                            chip,
01051                                                            trace_number,
01052                                                            window),
01053                                        "Could not load line table, window #%d", window);
01054                                 
01055                                 uves_msg_low("Using line table(s) in '%s'", linetable_filename);
01056                             }
01057                             
01058                             /* end, UVES specific */
01059                             
01060                             /* Do the science reduction + flux calibration */
01061                             uves_free_image(&x2d);
01062                             uves_free_image(&fx2d);
01063                             uves_free_propertylist(&x2d_header);
01064                             uves_free_image(&background);
01065                             uves_free_image(&flatfielded_variance);
01066                             uves_free_propertylist(&flatfielded_variance_header);
01067                             uves_free_image(&resampled_science);
01068                             uves_free_image(&resampled_mf);
01069                             uves_free_image(&rebinned_science);
01070                             uves_free_propertylist(&rebinned_header);
01071                             uves_free_image(&merged_sky);
01072                             uves_free_image(&merged_science);
01073                             uves_free_propertylist(&merged_header);
01074                             uves_free_image(&reduced_science);
01075                             uves_free_image(&reduced_science_error);
01076                             uves_free_table(&cosmic_mask);
01077                             uves_free_image(&fluxcal_science);
01078                             uves_free_image(&fluxcal_error);
01079                             uves_free_propertylist(&fluxcal_header);
01080                             uves_free_table(&info_tbl);
01081                             uves_free_table(&order_trace);                            
01082 
01083                             if(CLEAN_TRAPS) {
01084 
01085                             check( badpixels_cleaned = 
01086                                    uves_correct_badpix_all(raw_image[raw_index],
01087                                                            raw_header[raw_index], 
01088                                                            chip, binx, biny, 
01089                                                            false),
01090                                    "Error replacing bad pixels");
01091 
01092                             uves_msg("%d bad pixels replaced", 
01093                                      badpixels_cleaned);
01094                             }
01095 
01096 
01097                             check( uves_scired_process_chip(
01098                                        raw_image[raw_index], 
01099                                        raw_header[raw_index],           /* Raw         */
01100                                        rotated_header[raw_index],
01101                                        master_bias,           /* Calibration */
01102                                        master_dark, 
01103                                        master_dark_header,
01104                                        master_flat, 
01105                                        master_flat_header,
01106                                        ordertable, 
01107                                        order_locations,
01108                                        linetable, 
01109                                        linetable_header, 
01110                                        dispersion_relation,
01111                                        response_curve, 
01112                        master_response,
01113                                        response_curve_header,
01114                                        atm_extinction,
01115                                        chip,
01116                                        DEBUG, 
01117                                        parameters,
01118                        recipe_id,
01119                                        &x2d, 
01120                                        &x2d_header, 
01121                                        &fx2d,            /* Products      */
01122                                        &background,
01123                                        &flatfielded_variance,
01124                                        &flatfielded_variance_header,
01125                                        &resampled_science,
01126                                        &resampled_mf,
01127                                        &rebinned_science, 
01128                                        &rebinned_header,
01129                                        &merged_sky,
01130                                        &merged_science, 
01131                                        &merged_header,
01132                                        &reduced_science,
01133                                        &reduced_science_error,
01134                                        &cosmic_mask,
01135                                        &fluxcal_science,
01136                                        &fluxcal_error,
01137                                        &fluxcal_header,
01138                                        &info_tbl,
01139                        &extraction_slit,
01140                                        &order_trace),
01141                                    "Science reduction failed");
01142                             
01143                             if (!extract_is_2d)
01144                                 {
01145                                     uves_qclog_delete(&qclog[0]);
01146                                     qclog[0] = uves_qclog_init(raw_header[raw_index], chip);
01147                                     
01148                                     check( scired_qclog(info_tbl, 
01149                             raw_header[raw_index],
01150                             raw_image[raw_index],
01151                             extraction_slit,
01152                             qclog[0]),
01153                                            "Could not compute QC parameters");
01154                                 }
01155                             
01156                             uves_msg("Saving products...");
01157                             /* It is important to save products in the correct
01158                              * order, because users want to identify products depending on
01159                              * their number rather than the PRO-CATG (which would perhaps
01160                              * make more sense).
01161                              */
01162     
01163                             /* Save RED_SCIENCE / RED2D_SCIENCE = 
01164                                (reduced_science, merged_header) */
01165                             cpl_free(product_filename);
01166                             check( product_filename = 
01167                    (extract_is_2d) ? 
01168                                    uves_scired_red_2d_science_filename(chip) : 
01169                                    uves_scired_red_science_filename(chip),
01170                                    "Error getting filename");   
01171 
01172                             cpl_free(product_tag);
01173                             product_tag = uves_sprintf(
01174                 "RED%s_%s_%s",
01175                 (extract_is_2d) ? "_2D" : "",
01176                 sci_type, uves_chip_tostring_upper(chip));
01177                             
01178                             
01179 
01180                             check( uves_frameset_insert(frames,
01181                                                         reduced_science,
01182                                                         CPL_FRAME_GROUP_PRODUCT,
01183                                                         CPL_FRAME_TYPE_IMAGE,
01184                                                         CPL_FRAME_LEVEL_FINAL,
01185                                                         product_filename,
01186                                                         product_tag,
01187                                                         raw_header[raw_index],
01188                                                         merged_header,
01189                                                         NULL,
01190                                                         parameters,
01191                                                         recipe_id,
01192                                                         PACKAGE "/" PACKAGE_VERSION,
01193                                                         qclog,
01194                                                         starttime,
01195                             false,    /* Do not create QC log */
01196                                                         UVES_ALL_STATS),
01197                                    "Could not add reduced science spectrum '%s' (%s) to frameset",
01198                                    product_filename, product_tag);
01199                             
01200                             uves_msg("Reduced science spectrum '%s' (%s) added to frameset",
01201                                      product_filename, product_tag);
01202                             
01203                             if (extract_is_2d)
01204                                 {
01205                                     /* Save EXT_2D_SCIENCE_xxxx = (x2d, x2d_header) */
01206                                     cpl_free(product_filename);
01207                                     check( product_filename = uves_scired_ext2d_filename(chip), 
01208                                            "Error getting filename");
01209                                     
01210                                     cpl_free(product_tag);
01211                                     product_tag = 
01212                                         uves_sprintf("EXT_2D_%s_%s", sci_type,
01213                              uves_chip_tostring_upper(chip));
01214                                     
01215                                     check( uves_frameset_insert(frames,
01216                                                                 x2d,
01217                                                                 CPL_FRAME_GROUP_PRODUCT,
01218                                                                 CPL_FRAME_TYPE_IMAGE,
01219                                                                 CPL_FRAME_LEVEL_FINAL,
01220                                                                 product_filename,
01221                                                                 product_tag,
01222                                                                 raw_header[raw_index],
01223                                                                 x2d_header,
01224                                                                 NULL,
01225                                                                 parameters,
01226                                                                 recipe_id,
01227                                                                 PACKAGE "/" PACKAGE_VERSION, 
01228                                                                 qclog,
01229                                                                 starttime, false, 
01230                                                                 UVES_ALL_STATS),
01231                                            "Could not add 2d extracted "
01232                                            "spectrum '%s' (%s) to frameset",
01233                                            product_filename, product_tag);
01234                                     
01235                                     uves_msg("2d extracted spectrum '%s' (%s) added to frameset",
01236                                              product_filename, product_tag);
01237 
01238                                 }
01239                             
01240                             /* Save MERGED_SCIENCE / MER2D_SCIENCE = 
01241                                (merged_science, merged_header) */
01242                             cpl_free(product_filename);
01243                             check( product_filename = (extract_is_2d) ? 
01244                                  uves_scired_merged_2d_science_filename(chip) :
01245                                  uves_scired_merged_science_filename(chip),
01246                                    "Error getting filename");
01247                             cpl_free(product_tag);
01248                             product_tag = uves_sprintf(
01249                 "%s_%s_%s",
01250                 (extract_is_2d) ? "MER_2D" : "MERGED",
01251                                 sci_type, uves_chip_tostring_upper(chip));
01252 
01253                             check( uves_frameset_insert(frames,
01254                                                         merged_science,
01255                                                         CPL_FRAME_GROUP_PRODUCT,
01256                                                         CPL_FRAME_TYPE_IMAGE,
01257                                                         CPL_FRAME_LEVEL_FINAL,
01258                                                         product_filename,
01259                                                         product_tag,
01260                                                         raw_header[raw_index],
01261                                                         merged_header,
01262                                                         NULL,
01263                                                         parameters,
01264                                                         recipe_id,
01265                                                         PACKAGE "/" PACKAGE_VERSION,
01266                                                         qclog,
01267                                                         starttime, false, 
01268                                                         UVES_ALL_STATS),
01269                                    "Could not add merged science spectrum '%s' (%s) to frameset",
01270                                    product_filename, product_tag);
01271                             
01272                             uves_msg("Merged science spectrum '%s' (%s) added to frameset", 
01273                                      product_filename, product_tag);
01274                             
01275                             if (!extract_is_2d)
01276                                 {
01277                                     /* Save WCALIB_SCIENCE = (resampled_science, rebinned_header) 
01278                                      * If ff_method = extract, this product was not flat-fielded
01279                                      */
01280                                     cpl_free(product_filename);
01281                                     check( product_filename = (extract_is_2d) ?
01282                                            uves_scired_resampled_2d_filename(chip) :
01283                                            uves_scired_resampled_filename(chip), 
01284                                            "Error getting filename");   
01285 
01286                                     cpl_free(product_tag);
01287                                     product_tag = 
01288                                         uves_sprintf("WCALIB_%s_%s", sci_type,
01289                              uves_chip_tostring_upper(chip));
01290                             
01291                                     check( uves_frameset_insert(frames,
01292                                                                 resampled_science,
01293                                                                 CPL_FRAME_GROUP_PRODUCT,
01294                                                                 CPL_FRAME_TYPE_IMAGE,
01295                                                                 CPL_FRAME_LEVEL_FINAL,
01296                                                                 product_filename,
01297                                                                 product_tag,
01298                                                                 raw_header[raw_index],
01299                                                                 rebinned_header,
01300                                                                 NULL,
01301                                                                 parameters,
01302                                                                 recipe_id,
01303                                                                 PACKAGE "/" PACKAGE_VERSION,
01304                                                                 qclog,
01305                                                                 starttime, false, 
01306                                                                 UVES_ALL_STATS),
01307                                            "Could not add wavelength calibrated science "
01308                                            "spectrum '%s' (%s) to frameset", product_filename, 
01309                                            product_tag);
01310                                     
01311                                     uves_msg("Wavelength calibrated science spectrum '%s' "
01312                                              "(%s) added to frameset", product_filename, 
01313                                              product_tag);
01314 
01315                                 } /* if not 2d extracted */
01316                             
01317                             {
01318                                 const char *ff = "";
01319                                 
01320                                 /* Read uves_scired.reduce.ffmethd */
01321                 cpl_free(context);
01322                 context = uves_sprintf("%s.%s", recipe_id, UVES_REDUCE_ID);
01323                                 check( uves_get_parameter(parameters, NULL, 
01324                                                           context,
01325                                                           "ffmethod",
01326                                                           CPL_TYPE_STRING, &ff),
01327                                        "Could not read parameter");
01328                                 
01329                                 /* If flat-fielding was done */
01330                                 if (strcmp(ff, "no") != 0)
01331                                     {
01332                                         /* Save WCALIB_FF_SCIENCE / WCAL2D_SCIENCE =
01333                                            (rebinned_science, rebinned_header) */
01334                     cpl_table *qc_tabs[] = {NULL, NULL, NULL};
01335 
01336                     /* QC consists of usual science QC and
01337                        optionally TFLAT QC
01338                     */
01339                     
01340                     if ( strcmp(recipe_id, make_str(UVES_TFLAT_ID)) == 0 )
01341                         {
01342                         uves_qclog_delete(&qclog_tflat);
01343                         qclog_tflat = 
01344                             uves_qclog_init(raw_header[raw_index], chip);
01345                         
01346                         check( tflat_qclog(resampled_science,
01347                                    raw_header[raw_index],
01348                                    qclog_tflat),
01349                                "Could not compute QC parameters");
01350 
01351                         qc_tabs[0] = qclog_tflat;
01352                         qc_tabs[1] = qclog[0];
01353                         }
01354                     else
01355                         {
01356                         qc_tabs[0] = qclog[0];
01357                         qc_tabs[1] = NULL;
01358                         }
01359                     
01360                                         cpl_free(product_filename);
01361                                         check( product_filename = 
01362                                                (extract_is_2d) ? 
01363                                                uves_scired_rebinned_2d_filename(chip) :
01364                                                uves_scired_rebinned_filename(chip), 
01365                                                "Error getting filename");
01366 
01367                                         cpl_free(product_tag);
01368                                         product_tag = uves_sprintf(
01369                         "%s_%s_%s",
01370                                             (extract_is_2d) ? "WCAL_2D" : "WCALIB_FF",
01371                                             sci_type, uves_chip_tostring_upper(chip));
01372                                         
01373                                         check( uves_frameset_insert(frames,
01374                                                                     rebinned_science,
01375                                                                     CPL_FRAME_GROUP_PRODUCT,
01376                                                                     CPL_FRAME_TYPE_IMAGE,
01377                                                                     CPL_FRAME_LEVEL_FINAL,
01378                                                                     product_filename,
01379                                                                     product_tag,
01380                                                                     raw_header[raw_index],
01381                                                                     rebinned_header,
01382                                                                     NULL,
01383                                                                     parameters,
01384                                                                     recipe_id,
01385                                                                     PACKAGE "/" 
01386                                                                     PACKAGE_VERSION,
01387                                                                     qc_tabs,
01388                                                                     starttime, true,
01389                                                                     UVES_ALL_STATS),
01390                                                "Could not add wavelength calibrated flat-fielded "
01391                                                "science spectrum '%s' (%s) to frameset", 
01392                                                product_filename, product_tag);
01393                                     
01394                                         uves_msg("Wavelength calibrated flat-fielded science "
01395                                                  "spectrum '%s' (%s) added to frameset",
01396                                                  product_filename, product_tag);
01397                                         
01398                                         if (!extract_is_2d)
01399                                             {
01400                                                 /* Save WCALIB_FLAT_OBJ_xxxx =
01401                                                    (resampled_mf, rebinned_header) */
01402                                                 cpl_free(product_filename);
01403                                                 check( product_filename = 
01404                                                        uves_scired_resampledmf_filename(chip),
01405                                                        "Error getting filename");
01406                                                 
01407                                                 cpl_free(product_tag);
01408                                                 product_tag = 
01409                                                     uves_sprintf(
01410                                                         "WCALIB_FLAT_OBJ_%s",
01411                                                         uves_chip_tostring_upper(chip));
01412                                                 /* Independent of sci_type */
01413 
01414 
01415                                                 /* !!!Exception!!!
01416                                                  *
01417                                                  * For this reduced master flat frame we
01418                                                  * want to propagate the keywords *not*
01419                                                  * from the first raw input frame but
01420                                                  * from the master flat field itself.
01421                                                  *
01422                                                  * For that to work we temporarily set
01423                                                  * 
01424                                                  * all raw frames    := NONE
01425                                                  * master.flat frame := RAW
01426                                                  *
01427                                                  * This will make cpl_dfs_setup_product_header()
01428                                                  * find the proper "raw" frame (i.e. the mf)
01429                                                  * Also the required 'raw_header' must be
01430                                                  * that of the master flat frame, not science.
01431                                                  * After propagating keywords, we change back
01432                                                  * to normal:
01433                                                  *
01434                                                  * all raw frames    := RAW
01435                                                  * master.flat frame := CALIB
01436                                                  *
01437                                                  * (Since there could be more than 1 raw frame,
01438                                                  *  simply changing the first raw frame would
01439                                                  *  not work)
01440                                                  */                             
01441                                                 
01442                                                 cpl_free(raw_frames);
01443                                                 check_nomsg( raw_frames =
01444                                                              set_all_raw_none(frames) );
01445 
01446                                                 cpl_frame_set_group(mflat_frame, 
01447                                                                     CPL_FRAME_GROUP_RAW);
01448                                                 
01449                                                 check( uves_frameset_insert(
01450                                                            frames,
01451                                                            resampled_mf,
01452                                                            CPL_FRAME_GROUP_PRODUCT,
01453                                                            CPL_FRAME_TYPE_IMAGE,
01454                                                            CPL_FRAME_LEVEL_FINAL,
01455                                                            product_filename,
01456                                                            product_tag,
01457                                                            master_flat_header,  /* Note! */
01458                                                            rebinned_header,
01459                                                            NULL,
01460                                                            parameters,
01461                                                            recipe_id,
01462                                                            PACKAGE "/" 
01463                                                            PACKAGE_VERSION,
01464                                                            NULL, /* No QC: qclog */
01465                                                            starttime, false, 
01466                                                            CPL_STATS_MIN | CPL_STATS_MAX),
01467                                                        "Could not add wavelength calibrated "
01468                                                        "flat-field '%s' (%s) to frameset", 
01469                                                        product_filename, product_tag);
01470                                                 
01471                                                 uves_msg("Wavelength calibrated flat-field "
01472                                                          "spectrum '%s' (%s) added to frameset", 
01473                                                          product_filename, product_tag);
01474 
01475                                                 /* Change frames groups back to normal */
01476                                                 {
01477                                                     int i;
01478                                                     for (i = 0;
01479                                                          raw_frames[i] != NULL;
01480                                                          i++)
01481                                                         {
01482                                                             cpl_frame_set_group(
01483                                                                 raw_frames[i], 
01484                                                                 CPL_FRAME_GROUP_RAW);
01485                                                         }
01486                                                 }
01487                                                 cpl_frame_set_group(mflat_frame, 
01488                                                                     CPL_FRAME_GROUP_CALIB);
01489                                             }
01490 
01491                                         if (extract_is_2d)
01492                                             {
01493                                                 /* Save FF2D_SCIENCE_xxxx = (fx2d, x2d_header) */
01494                                                 cpl_free(product_filename);
01495                                                 check( product_filename = 
01496                                                        uves_scired_ff2d_filename(chip), 
01497                                                        "Error getting filename");
01498 
01499                                                 cpl_free(product_tag);
01500                                                 product_tag = 
01501                                                     uves_sprintf(
01502                             "FF_2D_%s_%s", sci_type,
01503                                                         uves_chip_tostring_upper(chip));
01504                                                 
01505                                                 check( uves_frameset_insert(
01506                                                            frames,
01507                                                            fx2d,
01508                                                            CPL_FRAME_GROUP_PRODUCT,
01509                                                            CPL_FRAME_TYPE_IMAGE,
01510                                                            CPL_FRAME_LEVEL_FINAL,
01511                                                            product_filename,
01512                                                            product_tag,
01513                                                            raw_header[raw_index],
01514                                                            x2d_header,
01515                                                            NULL,
01516                                                            parameters,
01517                                                            recipe_id,
01518                                                            PACKAGE "/" 
01519                                                            PACKAGE_VERSION,
01520                                                            qclog,
01521                                                            starttime, false, 
01522                                                            UVES_ALL_STATS),
01523                                                        "Could not add 2d extracted, flat-fielded "
01524                                                        "spectrum '%s' (%s) to frameset", 
01525                                                        product_filename, product_tag);
01526                                                 
01527                                                 uves_msg("2d extracted, flat-fielded spectrum "
01528                                                          "'%s' (%s) added to frameset", 
01529                                                          product_filename, product_tag);
01530 
01531                                             }
01532                                         
01533                                     }/* If flat-fielding != no */
01534 
01535                                     check( uves_pfits_set_bunit(merged_header, "REL. FLUX."),
01536                                            "Error writing error spectrum header");
01537                                     
01538                                     /* Save ERRORBAR_SCIENCE_xxxx =
01539                                        (reduced_science_error, merged_header) */
01540                                     cpl_free(product_filename);
01541 
01542                                     check( product_filename = (extract_is_2d) ?
01543                                  uves_scired_red_2d_error_filename(chip) :
01544                                  uves_scired_red_error_filename(chip),
01545                                    "Error getting filename");
01546 
01547                                     
01548                                     cpl_free(product_tag);
01549 
01550                                         product_tag = uves_sprintf(
01551                                    "%s_%s_%s",
01552                                             (extract_is_2d) ? "ERR_2D" : "ERRORBAR",
01553                                             sci_type, uves_chip_tostring_upper(chip));
01554 
01555                                     check( uves_frameset_insert(
01556                                                frames,
01557                                                reduced_science_error,
01558                                                CPL_FRAME_GROUP_PRODUCT,
01559                                                CPL_FRAME_TYPE_IMAGE,
01560                                                CPL_FRAME_LEVEL_FINAL,
01561                                                product_filename,
01562                                                product_tag,
01563                                                raw_header[raw_index],
01564                                                merged_header,
01565                                                NULL,
01566                                                parameters,
01567                                                recipe_id,
01568                                                PACKAGE "/" PACKAGE_VERSION,
01569                                                qclog,
01570                                                starttime, false, 
01571                                                CPL_STATS_MIN | CPL_STATS_MAX),
01572                                            "Could not add error bars '%s' (%s) to frameset", 
01573                                            product_filename, product_tag);
01574                                     
01575                                     uves_msg("Science spectrum error '%s' (%s) "
01576                                              "added to frameset", 
01577                                              product_filename, product_tag);
01578                                     
01579 
01580                             if (!extract_is_2d)
01581                                 {
01582 
01583 
01584                                     /* Save VARIANCE_SCIENCE_xxxx = 
01585                                        (flatfielded_variance, flatfielded_variance_header) */
01586                                     cpl_free(product_filename);
01587                                     check( product_filename = 
01588                                            uves_scired_ff_variance_filename(chip),
01589                                            "Error getting filename");
01590                                     
01591                                     cpl_free(product_tag);
01592                                     product_tag = 
01593                                         uves_sprintf("VARIANCE_%s_%s", sci_type,
01594                              uves_chip_tostring_upper(chip));
01595                                     
01596                                     check( uves_frameset_insert(frames,
01597                                                                 flatfielded_variance,
01598                                                                 CPL_FRAME_GROUP_PRODUCT,
01599                                                                 CPL_FRAME_TYPE_IMAGE,
01600                                                                 CPL_FRAME_LEVEL_FINAL,
01601                                                                 product_filename,
01602                                                                 product_tag,
01603                                                                 raw_header[raw_index],
01604                                                                 flatfielded_variance_header,
01605                                                                 NULL,
01606                                                                 parameters,
01607                                                                 recipe_id,
01608                                                                 PACKAGE "/" PACKAGE_VERSION,
01609                                                                 qclog,
01610                                                                 starttime, false, 
01611                                                                 CPL_STATS_MIN | CPL_STATS_MAX),
01612                                            "Could not add flat-fielded spectrum variance "
01613                                            "'%s' (%s) to frameset", 
01614                                            product_filename, product_tag);
01615                                     
01616                                     uves_msg("Flat-fielded spectrum variance '%s' (%s) "
01617                                              "added to frameset", 
01618                                              product_filename, product_tag);
01619                                     
01620                                 } /* if not 2d extraction */
01621                             }
01622 
01623                             if (!extract_is_2d)
01624                                 {
01625                                     /* Save BKG_SCI_xxxx = (background, rotated_header) */
01626                                     cpl_free(product_filename);
01627                                     check( product_filename = 
01628                                            uves_scired_background_filename(chip),
01629                                            "Error getting filename");   
01630 
01631                                     cpl_free(product_tag);
01632                                     product_tag = 
01633                                         uves_sprintf("BKG_SCI_%s",
01634                              uves_chip_tostring_upper(chip));
01635                                     
01636                                     check( uves_frameset_insert(frames,
01637                                                                 background,
01638                                                                 CPL_FRAME_GROUP_PRODUCT,
01639                                                                 CPL_FRAME_TYPE_IMAGE,
01640                                                                 CPL_FRAME_LEVEL_FINAL,
01641                                                                 product_filename,
01642                                                                 product_tag,
01643                                                                 raw_header[raw_index],
01644                                                                 rotated_header[raw_index],
01645                                                                 NULL,
01646                                                                 parameters,
01647                                                                 recipe_id,
01648                                                                 PACKAGE "/" PACKAGE_VERSION,
01649                                                                 NULL, /* QC */
01650                                                                 starttime, false, 
01651                                                                 CPL_STATS_MIN | CPL_STATS_MAX),
01652                                            "Could not add background image '%s' (%s) "
01653                                            "to frameset", product_filename, product_tag);
01654                                     
01655                                     uves_msg("Background image '%s' (%s) added to frameset", 
01656                                              product_filename, product_tag);
01657                                     
01658                                     /* If optimal extraction, also save
01659                                        cosmic_mask, order_trace */
01660                                     if (order_trace != NULL)
01661                                         {
01662                                             /* Save ORDER_TRACE_xxxx  */
01663                                             uves_free_propertylist(&order_trace_header);
01664                                             order_trace_header = uves_propertylist_new();
01665 
01666 
01667                                             /* !WARNING!: Duplicate code follows, be careful if/when
01668                                                changing. These parameters should be calculated
01669                                                the same way as in uves_qclog_add_sci().
01670 
01671                                                The MIDAS pipeline wrote these parameters only
01672                                                in this product, and for backwards compatibility
01673                                                do the same here.
01674                                             */
01675 
01676                                             uves_propertylist_update_int(
01677                                                 order_trace_header, "ESO QC OPTEX NORD",
01678                                                 uves_round_double(
01679                                                     cpl_table_get_column_max(ordertable, "Order")-
01680                                                     cpl_table_get_column_min(ordertable, "Order")+1));
01681 
01682                                             uves_propertylist_update_int(
01683                                                 order_trace_header, "ESO QC OPTEX XSIZE",
01684                                                 cpl_image_get_size_x(raw_image[raw_index]));
01685 
01686                                             uves_propertylist_update_int(
01687                                                 order_trace_header, "ESO QC OPTEX YSIZE",
01688                                                 uves_round_double(extraction_slit));
01689 
01690 
01691                                             cpl_free(product_filename);
01692                                             check( product_filename =
01693                                                    uves_scired_ordertrace_filename(chip),
01694                                                    "Error getting filename");
01695 
01696                                             cpl_free(product_tag);
01697                                             product_tag =
01698                                                 uves_sprintf("ORDER_TRACE_%s",
01699                                                              uves_chip_tostring_upper(chip));
01700                                              
01701                                             check( uves_frameset_insert(frames,
01702                                                                         order_trace,
01703                                                                         CPL_FRAME_GROUP_PRODUCT,
01704                                                                         CPL_FRAME_TYPE_TABLE,
01705                                                                         CPL_FRAME_LEVEL_FINAL,
01706                                                                         product_filename,
01707                                                                         product_tag,
01708                                                                         raw_header[raw_index],
01709                                                                         order_trace_header,
01710                                                                         NULL,
01711                                                                         parameters,
01712                                                                         recipe_id,
01713                                                                         PACKAGE "/"
01714                                                                         PACKAGE_VERSION,
01715                                                                         qclog,
01716                                                                         starttime, false,
01717                                                                         0),
01718                                                    "Could not add sky spectrum '%s' (%s) "
01719                                                    "to frameset",
01720                                                    product_filename, product_tag);
01721 
01722                                             uves_msg("Order trace table '%s' (%s) "
01723                                                      "added to frameset",
01724                                                      product_filename, product_tag);
01725                                         }
01726 
01727                                     if (cosmic_mask != NULL)
01728                                         {
01729                                             /* Save CRMASK_xxxx  */
01730                                             uves_free_propertylist(&cosmic_mask_header);
01731                                             cosmic_mask_header = uves_propertylist_new();
01732                                             
01733                                             cpl_free(product_filename);
01734                                             check( product_filename = 
01735                                                    uves_scired_crmask_filename(chip), 
01736                                                    "Error getting filename");
01737 
01738                                             cpl_free(product_tag);
01739                                             product_tag = 
01740                                                 uves_sprintf("CRMASK_%s",
01741                                  uves_chip_tostring_upper(chip));
01742                                             
01743                                             check( uves_frameset_insert(frames,
01744                                                                         cosmic_mask,
01745                                                                         CPL_FRAME_GROUP_PRODUCT,
01746                                                                         CPL_FRAME_TYPE_TABLE,
01747                                                                         CPL_FRAME_LEVEL_FINAL,
01748                                                                         product_filename,
01749                                                                         product_tag,
01750                                                                         raw_header[raw_index],
01751                                                                         cosmic_mask_header,
01752                                                                         NULL,
01753                                                                         parameters,
01754                                                                         recipe_id,
01755                                                                         PACKAGE "/" 
01756                                                                         PACKAGE_VERSION,
01757                                                                         NULL, /* qc */
01758                                                                         starttime, false,
01759                                                                         0),
01760                                                    "Could not add sky spectrum "
01761                                                    "'%s' (%s) to frameset", 
01762                                                    product_filename, product_tag);
01763                                             
01764                                             uves_msg("Cosmic ray table '%s' (%s) "
01765                                                      "added to frameset",
01766                                                      product_filename, product_tag);
01767                                         }
01768 
01769                                     if (merged_sky != NULL)     
01770                                         /* In slicer mode / 2d mode, no sky 
01771                                            spectrum is extracted */
01772                                         {
01773                                             /* Save MERGED_SKY_xxxx = 
01774                                                (merged_sky, merged_header) */
01775                                             cpl_free(product_filename);
01776                                             check( product_filename = 
01777                                                    uves_scired_merged_sky_filename(chip),
01778                                                    "Error getting filename");
01779                                             
01780                                             cpl_free(product_tag);
01781                                             product_tag = 
01782                                                 uves_sprintf("MERGED_SKY_%s",
01783                                  uves_chip_tostring_upper(chip));
01784 
01785                                             check( uves_frameset_insert(
01786                                frames,
01787                                merged_sky,
01788                                CPL_FRAME_GROUP_PRODUCT,
01789                                CPL_FRAME_TYPE_IMAGE,
01790                                CPL_FRAME_LEVEL_FINAL,
01791                                product_filename,
01792                                product_tag,
01793                                raw_header[raw_index],
01794                                merged_header,
01795                                NULL,
01796                                parameters,
01797                                recipe_id,
01798                                PACKAGE "/" 
01799                                PACKAGE_VERSION,
01800                                NULL, /* QC */
01801                                starttime, false, 
01802                                CPL_STATS_MIN | CPL_STATS_MAX),
01803                                                    "Could not add sky spectrum "
01804                                                    "'%s' (%s) to frameset", 
01805                                                    product_filename, product_tag);
01806                                             
01807                                             uves_msg("Sky spectrum '%s' (%s) added to frameset", 
01808                                                      product_filename, product_tag);
01809                                         }
01810                                     else
01811                                         {
01812                                             uves_msg_low("No sky spectrum to save");
01813                                         }
01814                                     
01815                                 }/* if extract is 2d */
01816 
01817                             if (fluxcal_science != NULL)
01818                                 {
01819                                     /* Save FLUXCAL_SCIENCE = 
01820                                        (fluxcal_science, fluxcal_header) */
01821                                     cpl_free(product_filename);
01822                                     check( product_filename = (extract_is_2d) ? 
01823                                            uves_scired_fluxcal_science_2d_filename(chip) :
01824                                            uves_scired_fluxcal_science_filename(chip), 
01825                                            "Error getting filename");
01826 
01827                                     cpl_free(product_tag);
01828 
01829                                     product_tag =  uves_sprintf(
01830                             "FLUXCAL%s_%s_%s", (extract_is_2d) ? "_2D" : "",
01831                 sci_type, uves_chip_tostring_upper(chip));
01832 
01833                                     /* Always _SCIENCE_, independent of sci_type */
01834 
01835                                     check( uves_frameset_insert(frames,
01836                                                                 fluxcal_science,
01837                                                                 CPL_FRAME_GROUP_PRODUCT,
01838                                                                 CPL_FRAME_TYPE_IMAGE,
01839                                                                 CPL_FRAME_LEVEL_FINAL,
01840                                                                 product_filename,
01841                                                                 product_tag,
01842                                                                 raw_header[raw_index],
01843                                                                 fluxcal_header,
01844                                                                 NULL,
01845                                                                 parameters,
01846                                                                 recipe_id,
01847                                                                 PACKAGE "/"
01848                                                                 PACKAGE_VERSION,
01849                                                                 qclog,
01850                                                                 starttime, false,
01851                                                                 CPL_STATS_MIN | CPL_STATS_MAX),
01852                                            "Could not add flux-calibrated science "
01853                                            "spectrum '%s' (%s) to frameset", 
01854                                            product_filename, product_tag);
01855 
01856                                     uves_msg("Flux-calibrated science spectrum "
01857                                              "'%s' (%s) added to frameset", 
01858                                              product_filename, product_tag);
01859 
01860                                     /* Save FLUXCAL_ERRORBAR = (fluxcal_error, fluxcal_header) */
01861                                     check( uves_pfits_set_bunit(fluxcal_header, 
01862                                                                 "ERROR (10^-16 erg/cm^2/A/sec)"),
01863                                            "Error writing error spectrum header");
01864 
01865                                     cpl_free(product_filename);
01866                                     check( product_filename = (extract_is_2d) ? 
01867                                            uves_scired_fluxcal_error_2d_filename(chip) :
01868                                            uves_scired_fluxcal_error_filename(chip), 
01869                                            "Error getting filename");   
01870 
01871                                     cpl_free(product_tag);
01872 
01873 
01874                                     product_tag =  uves_sprintf(
01875                             "FLUXCAL_ERRORBAR%s_%s_%s", (extract_is_2d) ? "_2D" : "",
01876                 sci_type, uves_chip_tostring_upper(chip));
01877                                     
01878                                     check( uves_frameset_insert(frames,
01879                                                                 fluxcal_error,
01880                                                                 CPL_FRAME_GROUP_PRODUCT,
01881                                                                 CPL_FRAME_TYPE_IMAGE,
01882                                                                 CPL_FRAME_LEVEL_FINAL,
01883                                                                 product_filename,
01884                                                                 product_tag,
01885                                                                 raw_header[raw_index],
01886                                                                 fluxcal_header,
01887                                                                 NULL,
01888                                                                 parameters,
01889                                                                 recipe_id,
01890                                                                 PACKAGE "/" 
01891                                                                 PACKAGE_VERSION,
01892                                                                 qclog,
01893                                                                 starttime, false,
01894                                                                 CPL_STATS_MIN | CPL_STATS_MAX),
01895                                            "Could not add flux-calibrated science "
01896                                            "spectrum error '%s' (%s) to frameset",
01897                                            product_filename, product_tag);
01898                                     
01899                                     uves_msg("Flux-calibrated science spectrum error "
01900                                              "'%s' (%s) added to frameset", 
01901                                              product_filename, product_tag);
01902                                     
01903                                 } /* If flux calibration done */
01904                             
01905                         }/* if trace is enabled */
01906                     else
01907                         {
01908                             uves_msg("Skipping trace number %d", trace_number);
01909                         }
01910                 
01911 
01912                 }/* for each trace */
01913 
01914 
01915       if(strcmp(PROCESS_CHIP,"REDL") == 0) {
01916     chip = uves_chip_get_next(chip);
01917       }
01918 
01919         
01920         }/* For each chip */
01921        
01922   cleanup:   
01923     /* Input */
01924     uves_free_table(&info_tbl);
01925     uves_free_image(&raw_image[0]);
01926     uves_free_image(&raw_image[1]);
01927     uves_free_propertylist(&raw_header[0]);
01928     uves_free_propertylist(&raw_header[1]);
01929     uves_free_propertylist(&rotated_header[0]);
01930     uves_free_propertylist(&rotated_header[1]);
01931     
01932     /* Input, calib */
01933     uves_free_image(&master_bias);
01934     uves_free_propertylist(&master_bias_header);
01935     
01936     uves_free_image(&master_dark);
01937     uves_free_propertylist(&master_dark_header);
01938 
01939     uves_free_image(&master_flat);
01940     uves_free_propertylist(&master_flat_header);
01941     
01942     uves_free_table(&ordertable);
01943     uves_free_propertylist(&ordertable_header);
01944     uves_polynomial_delete(&order_locations);
01945     uves_free_table(&traces);
01946     
01947     uves_free_table_const( &(linetable[0]) );
01948     uves_free_table_const( &(linetable[1]) );
01949     uves_free_table_const( &(linetable[2]) );
01950     uves_free_propertylist_const( &(linetable_header[0]) );
01951     uves_free_propertylist_const( &(linetable_header[1]) );
01952     uves_free_propertylist_const( &(linetable_header[2]) );
01953     uves_polynomial_delete_const( &(dispersion_relation[0]) );
01954     uves_polynomial_delete_const( &(dispersion_relation[1]) );
01955     uves_polynomial_delete_const( &(dispersion_relation[2]) );
01956 
01957     uves_free_image(&response_curve);
01958     uves_free_propertylist(&response_curve_header);
01959     uves_free_table(&master_response);
01960     
01961     uves_free_table(&atm_extinction);
01962 
01963     /* Output */
01964     uves_qclog_delete(&qclog[0]);
01965     uves_qclog_delete(&qclog_tflat);
01966     uves_free_image(&background);
01967     uves_free_image(&flatfielded_variance);
01968     uves_free_propertylist(&flatfielded_variance_header);
01969     uves_free_image(&rebinned_science);
01970     uves_free_propertylist(&rebinned_header);
01971     uves_free_image(&resampled_science);
01972     uves_free_image(&resampled_mf);
01973     uves_free_image(&merged_sky);
01974 
01975     uves_free_image(&merged_science);
01976     uves_free_propertylist(&merged_header);
01977     uves_free_image(&reduced_science);
01978     uves_free_image(&reduced_science_error);
01979     uves_free_image(&fluxcal_science);
01980     uves_free_image(&fluxcal_error);
01981     uves_free_propertylist(&fluxcal_header);
01982     uves_free_table(&cosmic_mask);
01983     uves_free_propertylist(&cosmic_mask_header);
01984 
01985     uves_free_table(&order_trace);
01986     uves_free_propertylist(&order_trace_header);
01987 
01988     uves_free_image(&x2d);
01989     uves_free_image(&fx2d);
01990     uves_free_propertylist(&x2d_header);
01991     
01992     cpl_free(raw_frames);
01993     cpl_free(product_filename);
01994     cpl_free(context);
01995     cpl_free(product_tag);
01996     
01997     return;
01998 }
01999 
02000 /*----------------------------------------------------------------------------*/
02009 /*----------------------------------------------------------------------------*/
02010 static void
02011 scired_qclog(const cpl_table* info_tbl, 
02012          const uves_propertylist *raw_header,
02013          const cpl_image *raw_image,
02014          double slit,
02015          cpl_table* qclog)
02016 {
02017   /* This test does not exist as an official QC-TEST in the MIDAS pipeline. But
02018      the QC parameters are written to the product header */
02019 
02020   check_nomsg(uves_qclog_add_string(qclog,                
02021                                     "QC TEST1 ID",
02022                                     "Science-Reduction-Test-Results",
02023                                     "Name of QC test",
02024                                     "%s"));
02025   
02026   check_nomsg( uves_qclog_add_sci(qclog,
02027                   raw_header, 
02028                   raw_image,
02029                   slit,
02030                   info_tbl) );
02031 
02032   cleanup:
02033   return;
02034 
02035 }
02036 
02037 /*----------------------------------------------------------------------------*/
02044 /*----------------------------------------------------------------------------*/
02045 static void
02046 tflat_qclog(const cpl_image* ima,
02047         const uves_propertylist *raw_header,
02048         cpl_table* qclog)
02049 {
02050   char key_name[80];
02051   cpl_image *window = NULL;
02052 
02053   double exptime;
02054   int nx;
02055   int ny;
02056   int i;
02057   
02058   check_nomsg(uves_qclog_add_string(qclog,
02059                     "QC TEST1 ID",
02060                     "TFLAT-QC",
02061                     "Name of QC test",
02062                     "%s"));
02063   
02064 
02065   check_nomsg(uves_qclog_add_string(qclog,
02066                     uves_remove_string_prefix(UVES_INSMODE, "ESO "),
02067                     uves_pfits_get_insmode(raw_header),
02068                     "Instrument mode used.",
02069                     "%s"));
02070   
02071   check_nomsg(uves_qclog_add_string(qclog,
02072                     uves_remove_string_prefix(UVES_INSPATH, "ESO "),
02073                     uves_pfits_get_inspath(raw_header),
02074                     "Optical path used.",
02075                     "%s"));
02076 
02077     check_nomsg(uves_qclog_add_string(qclog,
02078                     uves_remove_string_prefix(UVES_SLIT1NAME, "ESO "),
02079                     uves_pfits_get_slit1_name(raw_header),
02080                     "Slit common name.",
02081                     "%s"));
02082 
02083   check( exptime = uves_pfits_get_exptime(raw_header),
02084      "Error reading exposure time");
02085   
02086   nx = cpl_image_get_size_x(ima);
02087   ny = cpl_image_get_size_y(ima);
02088 
02089   for (i = 1; i <= ny; i++) 
02090       /* Always count order numbers from 1, like MIDAS */
02091       {
02092       int size = 100;
02093       int xlo = uves_max_int(1 , (nx+1)/2 - size);
02094       int xhi = uves_min_int(nx, (nx+1)/2 + size);
02095           
02096       double min, max, avg, rms, med;
02097 
02098       uves_free_image(&window);
02099       window = cpl_image_extract(ima, xlo, i, xhi, i);
02100       assure_mem( window );
02101 
02102       if (cpl_image_count_rejected(window) >= cpl_image_get_size_x(window) - 2)
02103           {
02104           min = max = avg = rms = med = 0;
02105           }
02106       else
02107           {
02108           min = cpl_image_get_min   (window) / exptime;
02109           max = cpl_image_get_max   (window) / exptime;
02110           avg = cpl_image_get_mean  (window) / exptime;
02111           rms = cpl_image_get_stdev (window) / exptime;
02112           med = cpl_image_get_median(window) / exptime;
02113           }
02114                        
02115       sprintf(key_name, "QC ORD%d DATAMIN", i);
02116       check_nomsg(uves_qclog_add_double(qclog,
02117                         key_name,
02118                         min,
02119                         "extracted order datamin",
02120                         "%f"));
02121                   
02122       sprintf(key_name, "QC ORD%d DATAMAX", i);
02123       check_nomsg(uves_qclog_add_double(qclog,
02124                         key_name,
02125                         max,
02126                         "extracted order datamax",
02127                         "%f"));
02128                   
02129       sprintf(key_name, "QC ORD%d DATAAVG", i);
02130       check_nomsg(uves_qclog_add_double(qclog,
02131                         key_name,
02132                         avg,
02133                         "extracted order datamean",
02134                         "%f"));
02135                   
02136       sprintf(key_name, "QC ORD%d DATARMS", i);
02137       check_nomsg(uves_qclog_add_double(qclog,
02138                         key_name,
02139                         rms,
02140                         "extracted order datarms",
02141                         "%f"));
02142 
02143       sprintf(key_name, "QC ORD%d DATAMED", i);
02144       check_nomsg(uves_qclog_add_double(qclog,
02145                         key_name,
02146                         med,
02147                         "extracted order datamed",
02148                         "%f"));
02149       }
02150   
02151   cleanup:
02152   uves_free_image(&window);
02153   return;
02154 
02155 }
02156 

Generated on Fri Apr 18 14:11:43 2008 for UVES Pipeline Reference Manual by  doxygen 1.5.1