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

Generated on 3 Mar 2013 for UVES Pipeline Reference Manual by  doxygen 1.6.1