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

Generated on 9 Mar 2012 for UVES Pipeline Reference Manual by  doxygen 1.6.1