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

Generated on Tue Jun 19 14:39:17 2007 for UVES Pipeline Reference Manual by  doxygen 1.4.6