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

Generated on Thu Nov 15 14:32:30 2007 for UVES Pipeline Reference Manual by  doxygen 1.5.1