xsh_linear.c

Go to the documentation of this file.

/*                                                                          *
 *   This file is part of the ESO X-shooter Pipeline                        *
 *   Copyright (C) 2006 European Southern Observatory                       *
 *                                                                          *
 *   This library is free software; you can redistribute it and/or modify   *
 *   it under the terms of the GNU General Public License as published by   *
 *   the Free Software Foundation; either version 2 of the License, or      *
 *   (at your option) any later version.                                    *
 *                                                                          *
 *   This program is distributed in the hope that it will be useful,        *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 *   GNU General Public License for more details.                           *
 *                                                                          *
 *   You should have received a copy of the GNU General Public License      *
 *   along with this program; if not, write to the Free Software            *
 *   Foundation, 51 Franklin St, Fifth Floor, Boston, MA  02111-1307  USA   *
 *                                                                          */
 
 
/*
 * $Author: amodigli $
 * $Date: 2012-07-26 12:22:12 $
 * $Revision: 1.58 $
 *
 
*/
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------
  Includes
  -------------------------------------------------------------------------*/
 
 
/* DRL steps */
 
/* Error handling */
#include <xsh_error.h>
/* Utility fonctions */
#include <xsh_utils.h>
#include <xsh_msg.h>
/* DFS functions */
#include <xsh_dfs.h>
/* DRL functions */
#include <xsh_drl.h>
 
#include <xsh_compute_linearity.h>
#include <xsh_detmon_lg.h>
#include <xsh_pfits.h>
#include <xsh_paf_save.h>
 
/* Library */
#include <cpl.h>
 
/*-----------------------------------------------------------------------------
  Defines
  -------------------------------------------------------------------------*/
 
#define RECIPE_ID "xsh_linear"
#define RECIPE_AUTHOR "L.Guglielmi,R.Haigron,P.Goldoni,F.Royer"
#define RECIPE_CONTACT "laurent.guglielmi@apc.univ-paris7.fr"
 
 
/*-----------------------------------------------------------------------------
  Functions prototypes
  -------------------------------------------------------------------------*/
 
/*
 *   Plugin initalization, execute and cleanup handlers
 */
 
static int create(cpl_plugin *);
static int exec(cpl_plugin *);
static int destroy(cpl_plugin *);
 
/* The actual executor function */
static void xsh_linear(cpl_parameterlist *, cpl_frameset *);
static void xsh_gain(cpl_parameterlist* parameters, 
                     cpl_frameset* frameset, 
                     xsh_instrument* instr);
static cpl_vector*
xsh_get_exptimes(cpl_frameset* set);
 
/*-----------------------------------------------------------------------------
  Static variables
  -------------------------------------------------------------------------*/
static char xsh_linear_description_short[] =
  "Create the linearity bad pixel mask";
 
static char xsh_linear_description[] =
  "This recipe creates a bad pixel mask from several (at least 3x3)\n\
 LINEARITY  frames in increasing exposure times\n\
Input Frames:\n\
  Raw Frames (Tag = LINEARITY_arm)\n\
Prepare PRE structures\n\
Group frames by exposure time\n\
Remove cosmic rays in each group and create\n\
 the median frame\n\
Finally compute the linearity bad pixel mask. Linearity is obtained by\n\
 a polynomial fit (degree 3)\n\
Product:\n\
  Bad Pixel Map, PRO.CATG = BADPIXEL_MAP_arm\n" ;
 
/*-----------------------------------------------------------------------------
  Functions code
  -------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
 
int cpl_plugin_get_info(cpl_pluginlist *list) {
  cpl_recipe *recipe = NULL;
  cpl_plugin *plugin = NULL;
 
  recipe = cpl_calloc(1, sizeof(*recipe));
  if ( recipe == NULL ){
    return -1;
  }
 
  plugin = &recipe->interface ;
 
  cpl_plugin_init(plugin,
                  CPL_PLUGIN_API,                    /* Plugin API */
                  XSH_BINARY_VERSION,             /* Plugin version */
                  CPL_PLUGIN_TYPE_RECIPE,            /* Plugin type */
                  RECIPE_ID,                         /* Plugin name */
                  xsh_linear_description_short,      /* Short help */
                  xsh_linear_description,            /* Detailed help */
                  RECIPE_AUTHOR,                     /* Author name */
                  RECIPE_CONTACT,                    /* Contact address */
                  xsh_get_license(),                 /* Copyright */
                  create,
                  exec,
                  destroy);
 
  cpl_pluginlist_append(list, plugin);
 
  return (cpl_error_get_code() != CPL_ERROR_NONE);
}
 
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
 
static int create(cpl_plugin *plugin){
  cpl_recipe *recipe = NULL;
  cpl_parameter* p =NULL;
 
  /* Reset library state */
  xsh_init();
 
  /* Check input */
  assure( plugin != NULL, CPL_ERROR_NULL_INPUT, "Null plugin");
 
  /* Get the recipe out of the plugin */
  assure( cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE,
          CPL_ERROR_TYPE_MISMATCH,
          "Plugin is not a recipe");
 
  recipe = (cpl_recipe *)plugin;
 
  /* Create the parameter list in the cpl_recipe object */
  recipe->parameters = cpl_parameterlist_new();
  assure( recipe->parameters != NULL,
          CPL_ERROR_ILLEGAL_OUTPUT,
          "Memory allocation failed!");
 
  /* Fill the parameter list */
  /* Set generic parameters (common to all recipes) */
  check( xsh_parameters_generic( RECIPE_ID, recipe->parameters ) ) ;
  xsh_parameters_decode_bp(RECIPE_ID,recipe->parameters,-1);
  /* Define parameters for all substeps called by this recipe */
  /* --crh-clip-kappa */
  p = cpl_parameter_new_value("xsh.xsh_linear.crh_clip_kappa",
                              CPL_TYPE_DOUBLE,
                              "multiple of sigma in sigma clipping",
                              "xsh.xsh_linear",5.0);
 
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"crh_clip_kappa");
  cpl_parameterlist_append(recipe->parameters,p);
 
  /* --crh-clip-niter */
  p = cpl_parameter_new_value("xsh.xsh_linear.crh_clip_niter",
    CPL_TYPE_INT,"number of iterations in sigma clipping","xsh.xsh_linear",2);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"crh_clip_niter");
  cpl_parameterlist_append(recipe->parameters,p);  
 
  /* --crh-clip-frac */
  p = cpl_parameter_new_value("xsh.xsh_linear.crh_clip_frac",
            CPL_TYPE_DOUBLE,"minimal fractions of points accepted \
    / total in sigma clipping",
            "xsh.xsh_linear",0.7);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"crh_clip_frac");
  cpl_parameterlist_append(recipe->parameters,p);
 
  /* --lin-clip-kappa */
  p = cpl_parameter_new_value("xsh.xsh_linear.lin_clip_kappa",
                              CPL_TYPE_DOUBLE,
                              "multiple of sigma in sigma clipping",
                              "xsh.xsh_linear",10.0);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"lin_clip_kappa");
  cpl_parameterlist_append(recipe->parameters,p);
  /* --lin-clip-niter */
  p = cpl_parameter_new_value("xsh.xsh_linear.lin_clip_niter",
    CPL_TYPE_INT,"number of iterations in sigma clipping","xsh.xsh_linear",2);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"lin_clip_niter");
  cpl_parameterlist_append(recipe->parameters,p);  
  /* --lin-clip-frac */
  p = cpl_parameter_new_value("xsh.xsh_linear.lin_clip_frac",
            CPL_TYPE_DOUBLE,"Minimum fraction of bad pixels allowed",
            "xsh.xsh_linear",0.7);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"lin_clip_frac");
  cpl_parameterlist_append(recipe->parameters,p);
  /* --lin-clip-diff */
  p = cpl_parameter_new_value("xsh.xsh_linear.lin_clip_diff",
    CPL_TYPE_DOUBLE,"Minimum relative change in sigma for sigma clipping",
            "xsh.xsh_linear",0.7);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"lin_clip_diff");
  cpl_parameterlist_append(recipe->parameters,p);
 
  /* --exp-toler */
  p = cpl_parameter_new_value("xsh.xsh_linear.exp_toler",
            CPL_TYPE_DOUBLE,"Tolerance for equal exposures times in seconds",
            "xsh.xsh_linear", 0.001);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"exp_toler");
  cpl_parameterlist_append(recipe->parameters,p);
 
 
 
  /* --compute_gain */
  p = cpl_parameter_new_value("xsh.xsh_linear.compute_gain",
                              CPL_TYPE_BOOL,
                              "Compute gain",
                              "xsh.xsh_linear",CPL_FALSE);
 
 
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"compute_gain");
  cpl_parameterlist_append(recipe->parameters,p);
 
  /* --llx */
  p = cpl_parameter_new_value("xsh.xsh_linear.llx",
            CPL_TYPE_INT,"Detector lower left x pix",
            "xsh.xsh_linear", 1);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"llx");
  cpl_parameterlist_append(recipe->parameters,p);
 
  /* --lly */
  p = cpl_parameter_new_value("xsh.xsh_linear.lly",
            CPL_TYPE_INT,"Detector lower left y pix",
            "xsh.xsh_linear", 1);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"lly");
  cpl_parameterlist_append(recipe->parameters,p);
 
 
  /* --urx */
  p = cpl_parameter_new_value("xsh.xsh_linear.urx",
            CPL_TYPE_INT,"Detector upper right x pix",
            "xsh.xsh_linear", 2148);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"urx");
  cpl_parameterlist_append(recipe->parameters,p);
 
 
  /* --ury */
  p = cpl_parameter_new_value("xsh.xsh_linear.ury",
            CPL_TYPE_INT,"Detector upper right y pix",
            "xsh.xsh_linear", 3000);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"ury");
  cpl_parameterlist_append(recipe->parameters,p);
 
 
  /* --kappa */
  p = cpl_parameter_new_value("xsh.xsh_linear.kappa",
            CPL_TYPE_DOUBLE,"Value in kappa-sigma clip",
            "xsh.xsh_linear", 3.);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"kappa");
  cpl_parameterlist_append(recipe->parameters,p);
 
 
 
  /* --nclip */
  p = cpl_parameter_new_value("xsh.xsh_linear.nclip",
            CPL_TYPE_INT,"Number of kappa-sigma clip iterations",
            "xsh.xsh_linear", 5);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"nclip");
  cpl_parameterlist_append(recipe->parameters,p);
 
 
  /* --shiftx */
  p = cpl_parameter_new_value("xsh.xsh_linear.shiftx",
            CPL_TYPE_INT,"Pixel X shift applied in autocorrelation. "
                         "Must be > 0.",
            "xsh.xsh_linear", 26);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"shiftx");
  cpl_parameterlist_append(recipe->parameters,p);
 
 
  /* --shifty */
  p = cpl_parameter_new_value("xsh.xsh_linear.shifty",
            CPL_TYPE_INT,"Pixel Y shift applied in autocorrelation. "
                         "Must be > 0.",
            "xsh.xsh_linear", 26);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"shifty");
  cpl_parameterlist_append(recipe->parameters,p);
 
 
 
  /* --shifty */
  p = cpl_parameter_new_value("xsh.xsh_linear.autocorr",
            CPL_TYPE_BOOL,"Compute autocor?",
            "xsh.xsh_linear",CPL_FALSE);
  cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"autocorr");
  cpl_parameterlist_append(recipe->parameters,p);
 
 
 
  /* Get any global parameters */
 
  /* Define parameters specific to this recipe */
 
 cleanup:
  if ( cpl_error_get_code() != CPL_ERROR_NONE ){
    xsh_error_dump(CPL_MSG_ERROR);
    return 1;
  }
  else {
    return 0;
  }
}
 
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
 
static int exec(cpl_plugin *plugin) {
  cpl_recipe *recipe = NULL;
 
  /* Check parameter */
  assure( plugin != NULL, CPL_ERROR_NULL_INPUT, "Null plugin" );
 
  /* Get the recipe out of the plugin */
  assure( cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE,
          CPL_ERROR_TYPE_MISMATCH, "Plugin is not a recipe");
 
  recipe = (cpl_recipe *)plugin;
 
  /* Check recipe */
  xsh_linear(recipe->parameters, recipe->frames);
 
 cleanup:
  if ( cpl_error_get_code() != CPL_ERROR_NONE ) {
    xsh_error_dump(CPL_MSG_ERROR);
    return 1;
  }
  else {
    return 0;
  }
}
 
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
static int
destroy(cpl_plugin *plugin)
{
  cpl_recipe *recipe = NULL;
 
  /* Check parameter */
  assure( plugin != NULL, CPL_ERROR_NULL_INPUT, "Null plugin" );
 
  /* Get the recipe out of the plugin */
  assure( cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE,
    CPL_ERROR_TYPE_MISMATCH, "Plugin is not a recipe");
 
  recipe = (cpl_recipe *)plugin;
 
  xsh_free_parameterlist(&recipe->parameters);
 
 cleanup:
  if (cpl_error_get_code() != CPL_ERROR_NONE)
    {
      return 1;
    }
  else
    {
      return 0;
    }
}
 
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
static void xsh_linear(cpl_parameterlist* parameters, cpl_frameset* frameset){
 
  const char* recipe_tags[1] = {XSH_LINEARITY};
  int recipe_tags_size = 1;
 
  cpl_parameter* param = NULL;
  cpl_frameset* raws = NULL;
  cpl_frameset* calib = NULL;
  cpl_frame* bpmap = NULL;
  xsh_instrument* instrument = NULL;
 
  /* CRH sigma clipping parameters */
  xsh_clipping_param crh_clipping = {
     0.0, 0, 0.0, 0.0, 0.3
  } ;
 
  /* NOISE sigma clipping parameters */
  xsh_clipping_param lin_clipping = {
     0.0, 0, 0.0, 0.0, 0.3
  } ;
  
  /* Exposure time Tolerance */
  double exp_toler ;
  
  int nbLinGroups ;
  int nRawFrames ;
  cpl_frameset ** rawGrp = NULL;
  cpl_frameset ** pgrp = NULL;
  cpl_frameset * medSet = NULL;
  cpl_frameset * nirSet = NULL ;
  cpl_imagelist * crh_list=NULL;
 
  char *final_prefix = NULL ;
  int gain_switch=false;
  cpl_image* crh_ima=NULL;
  //cpl_frame* crh_frm=NULL;
 
  int i = 0, minfr = 999999 ;
  char * crh_name;
 
 
  cpl_frame *medFrame =NULL;
  char *ftag =NULL;
  char str[16] ;
  int pre_overscan_corr=0;
 
  /* Retrieve Recipe parameters */
  /* --crh-clip-kappa */
  param = cpl_parameterlist_find(parameters,"xsh.xsh_linear.crh_clip_kappa");
  crh_clipping.sigma = cpl_parameter_get_double(param);
  /* --crh-clip-niter */
  param = cpl_parameterlist_find(parameters,"xsh.xsh_linear.crh_clip_niter");
  crh_clipping.niter = cpl_parameter_get_int(param);
  /* --crh-clip-frac */
  param = cpl_parameterlist_find(parameters,"xsh.xsh_linear.crh_clip_frac");
  crh_clipping.frac = cpl_parameter_get_double(param);
 
  /* --lin-clip-kappa */
  param = cpl_parameterlist_find(parameters,"xsh.xsh_linear.lin_clip_kappa");
  lin_clipping.sigma = cpl_parameter_get_double(param);
  /* --lin-clip-niter */
  param = cpl_parameterlist_find(parameters,"xsh.xsh_linear.lin_clip_niter");
  lin_clipping.niter = cpl_parameter_get_int(param);
  /* --lin-clip-frac */
  param = cpl_parameterlist_find(parameters,"xsh.xsh_linear.lin_clip_frac");
  lin_clipping.frac = cpl_parameter_get_double(param);
  /* --lin-clip-diff */
  param = cpl_parameterlist_find(parameters,"xsh.xsh_linear.lin_clip_diff");
  lin_clipping.diff = cpl_parameter_get_double(param);
 
  /* --exp_toler */
  param = cpl_parameterlist_find(parameters,"xsh.xsh_linear.exp_toler");
  exp_toler = cpl_parameter_get_double(param);
 
 
 
 
  /**************************************************************************/
  /* DFS management */
  /**************************************************************************/
  check( xsh_begin( frameset, parameters, &instrument, &raws, &calib,
                    recipe_tags, recipe_tags_size,
                    RECIPE_ID, XSH_BINARY_VERSION,
                    xsh_linear_description_short ) ) ;
 
   check(param=cpl_parameterlist_find(parameters,
                      "xsh.xsh_linear.compute_gain"));
   check(gain_switch = cpl_parameter_get_bool(param));
 
   if(gain_switch) {
     check(xsh_gain(parameters,frameset,instrument));
   }
 
 
 
  /* search the bad pixel map */
  bpmap = xsh_find_bpmap(calib) ;
 
  /* Call xsh_prepare function */
 
  xsh_msg("Calling the xsh_prepare function");
 
  check_msg(xsh_prepare(raws,bpmap, NULL, XSH_LINEARITY, instrument,
            pre_overscan_corr,CPL_TRUE),
                        "Error with linear");
 
  xsh_msg( "Working on Arm %s", xsh_instrument_arm_tostring( instrument) ) ;
  final_prefix = xsh_stringcat_any( "LINEAR_BPMAP_",
                    xsh_instrument_arm_tostring( instrument),
                    "" ) ;
  assure( final_prefix != NULL, cpl_error_get_code(),
      "Cant allocate memory for final prefix" ) ;
 
  nRawFrames = cpl_frameset_get_size( raws ) ;
  xsh_msg( "Found %d LINEARITY Raw files", nRawFrames ) ;
 
  if ( bpmap == NULL )
    xsh_msg( "No Bad Pixel Map" ) ;
  else
    xsh_msg( "Found BadPixel Map Frame: %s",
       cpl_frame_get_filename( bpmap ) ) ;
 
  /* Group frames by exposure times */
  xsh_msg( "Calling xsh_linear_group_by_exptime" ) ;
  xsh_msg( "exp_toler: %lf", exp_toler ) ;
 
  /* 
     The fonction group_by_exptime returns the nb of groups AND 
     an array of frameset (1 frameset per group)
  */
  rawGrp = cpl_malloc( nRawFrames*sizeof( cpl_frameset *) ) ;
  //The following generates leaks (and is very complex!)
  nbLinGroups = xsh_linear_group_by_exptime( raws, instrument, exp_toler,
               rawGrp ) ;
 
  xsh_msg( "Nb of groups: %d", nbLinGroups ) ;
 
  // verification
  assure( nbLinGroups >= 3, CPL_ERROR_ILLEGAL_INPUT,
    "Not enough EXPTIME Groups, %d < 3", nbLinGroups ) ;
  pgrp = rawGrp ;
 
  for( i = 0 ; i<nbLinGroups ; i++, pgrp++ ) {
    int nfr = cpl_frameset_get_size( *pgrp ) ;
    if ( nfr < minfr ) minfr = nfr ;
    xsh_msg( "Frameset #%d - %d frames", i, nfr ) ;
  }
 
 
  /*
    Remove CRH and create median frame per group (same DIT)
    and per ON/OFF (if NIR)
  */
  xsh_msg( "Calling xsh_remove_crh_multiple" ) ;
  xsh_msg( "  CRH parameters: Sigma %lf, Niteration %d, Fraction %lf",
     crh_clipping.sigma, crh_clipping.niter, crh_clipping.frac ) ;
  
  medSet = cpl_frameset_new() ;
  crh_list=cpl_imagelist_new();
 
  for( i=0, pgrp = rawGrp ; i<nbLinGroups ; i++, pgrp++ ) {
 
    sprintf( str, "%02d", i ) ;
    ftag = xsh_stringcat_any( "remove_crh_",
                   xsh_instrument_arm_tostring( instrument),
                   str, "", (void*)NULL ) ;
    crh_name= xsh_stringcat_any( "crh_map_",
                   xsh_instrument_arm_tostring( instrument),
                   str, ".fits", (void*)NULL ) ;
    xsh_free_frame(&medFrame);
    check_msg( medFrame = xsh_remove_crh_multiple( *pgrp,
                           ftag,
                           &crh_clipping,
                           instrument, 
                           &crh_list,&crh_ima ),
           "Error in xsh_remove_crh" ) ;
    // Insert medFrame into a frameset
    cpl_frameset_insert( medSet, cpl_frame_duplicate(medFrame) ) ;
    cpl_free( ftag ) ;
    xsh_msg("saving file %d",i);
    cpl_imagelist_save(crh_list,"crh_list.fits",CPL_BPP_IEEE_FLOAT,
               NULL,CPL_IO_DEFAULT);
    xsh_add_temporary_file("crh_list.fits");
    cpl_image_save (crh_ima,crh_name, CPL_BPP_32_SIGNED,
            NULL, CPL_IO_DEFAULT);
    xsh_add_temporary_file(crh_name);
    cpl_free(crh_name ) ;
    xsh_free_imagelist(&crh_list);
    xsh_free_image(&crh_ima);
  }
  xsh_free_imagelist(&crh_list);
 
  /*
    Special for NIR: subtract ON-OFF before computing linearity
    At this point we have in medSet, a succession of ON/OFF frames
    We now subtract frames 2 by 2 and finally have the right nb of frames
  */
  //xsh_show_time( "======= Before xsh_compute_linearity") ;
  if ( instrument->arm == XSH_ARM_NIR ) {
    // create a new set of frame
    nirSet = xsh_subtract_on_off( medSet, instrument ) ;
    assure( nirSet != NULL, cpl_error_get_code(),
      "Error in subtract" ) ;
    /* NIR: Compute linearity (and create bad pixel map) */
    check( bpmap = xsh_compute_linearity( nirSet, instrument,
            &lin_clipping ) ) ;
  }
  else {
    /* UVB/VIS: Compute linearity (and create bad pixel map) */
    bpmap = xsh_compute_linearity( medSet, instrument,
                   &lin_clipping ) ;
    assure( bpmap != NULL, cpl_error_get_code(),
        "Error in compute_linearity" ) ;
  }
  //xsh_show_time( "======= Before Final Product" ) ;
 
  xsh_msg( "Bad Pixel Map created" ) ;
  xsh_msg( "Saving final product" ) ;
 
  // create final product
 
  check( xsh_add_product_bpmap( bpmap, frameset,  parameters, RECIPE_ID,
                instrument, NULL ) ) ;
 
 
 
 cleanup:
  xsh_end( RECIPE_ID, frameset, parameters ) ;
  // freeing memory
  xsh_instrument_free( &instrument ) ;
  xsh_free_frame( &bpmap ) ;
  xsh_free_frameset( &raws ) ;
  xsh_free_frameset( &calib ) ;
  cpl_free( rawGrp ) ;
  xsh_free_frame(&medFrame);
  xsh_free_frameset( &medSet ) ;
  xsh_free_frameset( &nirSet ) ;
  cpl_free( final_prefix ) ;
  xsh_free_imagelist(&crh_list);
 
  return;
}
 
 
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
static void
xsh_gain(cpl_parameterlist* parameters, 
         cpl_frameset* frameset,
         xsh_instrument* instr){
 
 
   cpl_frameset* set_flats=NULL; 
   cpl_frameset* set_biases=NULL;
   cpl_table* gain_tbl=NULL;
   cpl_parameter* p=NULL;
   cpl_imagelist* diff_imlist=NULL;
   cpl_imagelist* autocorr_imlist=NULL;
   cpl_propertylist* qclist=NULL;
   cpl_imagelist* iml_flats=NULL;
   cpl_imagelist* iml_biases=NULL;
   cpl_image* img=NULL;
   cpl_frame* frm=NULL;
   cpl_frame* result=NULL;
 
   unsigned mode_collapse_noautocorr=IRPLIB_GAIN_PTC | 
                 IRPLIB_GAIN_WITH_RESCALE |
      IRPLIB_GAIN_COLLAPSE;
 
 
 
   unsigned mode_collapse_autocorr=IRPLIB_GAIN_PTC | 
                 IRPLIB_GAIN_WITH_RESCALE | 
                 IRPLIB_GAIN_COLLAPSE |
      IRPLIB_GAIN_WITH_AUTOCORR;
 
 
 
   unsigned mode_nocollapse_noautocorr=IRPLIB_GAIN_PTC | 
                 IRPLIB_GAIN_WITH_RESCALE | 
      IRPLIB_GAIN_NO_COLLAPSE;
 
 
   unsigned mode_nocollapse_autocorr=IRPLIB_GAIN_PTC | 
                 IRPLIB_GAIN_WITH_RESCALE | 
                 IRPLIB_GAIN_NO_COLLAPSE |
     IRPLIB_GAIN_WITH_AUTOCORR;
  
 
   unsigned mode=0;
   const char* tag_on=NULL;
   const char* tag_off=NULL;
   cpl_vector* exptimes=NULL;
   int llx=0;
   int lly=0;
   int urx=0;
   int ury=0;
   double kappa=0;
   int nclip=3;
   int shiftx=0;
   int shifty=0;
   int auto_corr=0;
   const char* name=NULL;
   double mjd_obs=0;
 
   int i=0;
   const char* name_o="gain_table.fits";
   const char* name_diff_o="diff.fits";
   const char* name_autocorr_o="autocorr.fits";
   const char* pro_catg=XSH_GET_TAG_FROM_ARM(XSH_GAIN,instr);
   const char* file=NULL;
   int ext=0;
   int nbiases=0;
   int nflats=0;
   int sx=0;
   int sy=0;
 
   cpl_propertylist* plist=NULL;
   int      ext_min=0;
   int      ext_max=1;
   double tolerance=0;
 
 
 
 
   // Get input parameters
   check(p = cpl_parameterlist_find(parameters,"xsh.xsh_linear.llx"));
   check(llx = cpl_parameter_get_int(p));
 
   check(p = cpl_parameterlist_find(parameters,"xsh.xsh_linear.lly"));
   check(lly = cpl_parameter_get_int(p));
 
   check(p = cpl_parameterlist_find(parameters,"xsh.xsh_linear.urx"));
   check(urx = cpl_parameter_get_int(p));
 
   check(p = cpl_parameterlist_find(parameters,"xsh.xsh_linear.ury"));
   check(ury = cpl_parameter_get_int(p));
 
   check(p = cpl_parameterlist_find(parameters,"xsh.xsh_linear.kappa"));
   check(kappa = cpl_parameter_get_double(p));
 
   check(p = cpl_parameterlist_find(parameters,"xsh.xsh_linear.nclip"));
   check(nclip = cpl_parameter_get_int(p));
 
   check(p = cpl_parameterlist_find(parameters,"xsh.xsh_linear.shiftx"));
   check(shiftx = cpl_parameter_get_int(p));
 
   check(p = cpl_parameterlist_find(parameters,"xsh.xsh_linear.shifty"));
   check(shifty = cpl_parameter_get_int(p));
 
   check(p = cpl_parameterlist_find(parameters,"xsh.xsh_linear.autocorr"));
   check(auto_corr = cpl_parameter_get_bool(p));
 
   check(p = cpl_parameterlist_find(parameters,"xsh.xsh_linear.exp_toler"));
   check(tolerance = cpl_parameter_get_double(p));
 
   if(shiftx < 1) {
     shiftx=1;
     xsh_msg_warning("Autocorrelation X shift must be >1. Set it to 1.");
   }
 
   if(shifty < 1) {
     shifty=1;
     xsh_msg_warning("Autocorrelation Y shift must be >1. Set it to 1.");
   }
 
   if(xsh_instrument_get_arm(instr) == XSH_ARM_UVB) {
     tag_on ="LINEARITY_UVB";
     tag_off="BIAS_UVB";
 
     if(auto_corr==0) {
       mode=mode_collapse_noautocorr|IRPLIB_GAIN_OPT;
     } else {
       mode=mode_collapse_autocorr|IRPLIB_GAIN_OPT;
     }
 
   } else if (xsh_instrument_get_arm(instr) == XSH_ARM_VIS) {
     tag_on ="LINEARITY_VIS";
     tag_off="BIAS_VIS";
 
     if(auto_corr==0) {
       mode=mode_collapse_noautocorr|IRPLIB_GAIN_OPT;
     } else {
       mode=mode_collapse_autocorr|IRPLIB_GAIN_OPT;
     }
 
   } else if (xsh_instrument_get_arm(instr) == XSH_ARM_NIR) {
     tag_on ="LINEARITY_NIR_ON";
     tag_off="LINEARITY_NIR_OFF";
 
     if(auto_corr==0) {
       mode=mode_nocollapse_noautocorr|IRPLIB_GAIN_NIR;
     } else {
       mode=mode_nocollapse_autocorr|IRPLIB_GAIN_NIR;
     }
 
   } else {
     xsh_msg_error("instr %d not supported. Exit.",
           xsh_instrument_get_arm(instr));
   }
   xsh_msg("tag_on=%s tag_off=%s",tag_on,tag_off);
 
 
   // extract flats
   check(set_flats= xsh_frameset_extract((cpl_frameset*) frameset,tag_on));
   nflats=cpl_frameset_get_size(set_flats);
 
 
 
   // extract biases
   check(set_biases= xsh_frameset_extract((cpl_frameset*) frameset,tag_off));
   check(exptimes=xsh_get_exptimes(set_flats));
   check(nbiases=cpl_frameset_get_size(set_biases));
   check(name=cpl_frame_get_filename(cpl_frameset_get_first(set_flats)));
   check(plist=cpl_propertylist_load(name,0));
   check(mjd_obs=xsh_pfits_get_mjdobs(plist));
   xsh_free_propertylist(&plist);
 
   if(xsh_instrument_get_arm(instr) == XSH_ARM_VIS) {
     //1st april 2004
     if(mjd_obs> 53095.4) {
       ext_min=1;
       ext_max=3;
     }
   }
 
   // Loop over extentions
   for(ext=ext_min;ext<ext_max;ext++) {
     xsh_msg("Processing extention %d",ext);
     //Fill flats imagelist
     xsh_free_imagelist(&iml_flats); //make sure pointer is deallocated
     iml_flats=cpl_imagelist_new();
     for(i=0;i<nflats;i++) {
       check(frm=cpl_frameset_get_frame(set_flats,i));
       check(file=cpl_frame_get_filename(frm));
       check(img=cpl_image_load(file,CPL_TYPE_FLOAT,0,ext));
       check(cpl_imagelist_set(iml_flats,cpl_image_duplicate(img),i));
       xsh_free_image(&img);
     }
 
     //Fill biases imagelist
     xsh_free_imagelist(&iml_biases);//make sure pointer is deallocated
     iml_biases=cpl_imagelist_new();
     for(i=0;i<nbiases;i++) {
       check(frm=cpl_frameset_get_frame(set_biases,i));
       check(file=cpl_frame_get_filename(frm));
       check(img=cpl_image_load(file,CPL_TYPE_FLOAT,0,ext));
       check(cpl_imagelist_set(iml_biases,cpl_image_duplicate(img),i));
       xsh_free_image(&img);
     }
 
     xsh_free_propertylist(&qclist);
     check(qclist=cpl_propertylist_new());
     //Compute gain
     xsh_free_table(&gain_tbl);
 
     sx=cpl_image_get_size_x(cpl_imagelist_get(iml_flats,0));
     sy=cpl_image_get_size_y(cpl_imagelist_get(iml_flats,0));
 
     urx=(urx<sx) ? urx : sx;
     ury=(ury<sy) ? ury : sy;
 
     llx=(llx>1) ? llx : 1;
     lly=(lly>1) ? lly : 1;
     check(gain_tbl=xsh_detmon_gain(iml_flats,iml_biases,exptimes,tolerance,
                    llx,lly,urx,ury,
                    kappa,nclip,
                    shiftx,shifty,qclist,mode,
                    &diff_imlist,&autocorr_imlist));
 
 
     if(ext==ext_min) {
 
       check(cpl_table_save(gain_tbl,qclist,NULL,name_o,CPL_IO_DEFAULT));
       if(auto_corr==1) {
     cpl_imagelist_save(diff_imlist,name_diff_o,CPL_BPP_IEEE_FLOAT,
                NULL,CPL_IO_DEFAULT);
 
     cpl_imagelist_save(autocorr_imlist,name_autocorr_o,
                CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_DEFAULT);
 
       }
     } else {
       check(cpl_table_save(gain_tbl,qclist,NULL,name_o,CPL_IO_EXTEND));
 
       if(auto_corr==1) {
     cpl_imagelist_save(diff_imlist,name_diff_o,CPL_BPP_IEEE_FLOAT,
                NULL,CPL_IO_EXTEND);
 
     cpl_imagelist_save(autocorr_imlist,name_autocorr_o,
                CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_EXTEND);
 
       }
 
 
     }
 
   }
 
 
 
 
   xsh_free_frame(&result);
   check(result=cpl_frame_new());
 
   //Prepare resulting frameset
   cpl_frame_set_filename(result,name_o);
   cpl_frame_set_tag(result,pro_catg);
   cpl_frame_set_type(result,CPL_FRAME_TYPE_TABLE);
   cpl_frame_set_group(result, CPL_FRAME_GROUP_PRODUCT);
   cpl_frame_set_level(result, CPL_FRAME_LEVEL_FINAL);
 
 
   check(xsh_add_product_table(cpl_frame_duplicate(result),
                               frameset,parameters,RECIPE_ID,instr));
   //Amo: comment following line to prevent error
   //if(qclist != NULL) {
   //  check(xsh_paf_save(instr,RECIPE_ID,qclist,name_o,pro_catg));
   //}
 
 cleanup:
   xsh_free_propertylist(&plist);
   cpl_free(exptimes); exptimes=NULL;
   xsh_free_frame(&result);
   xsh_free_frameset(&set_flats);
   xsh_free_frameset(&set_biases);
   xsh_free_propertylist(&qclist);
   xsh_free_imagelist(&iml_biases);
   xsh_free_imagelist(&iml_flats);
 
   return;
}
 
 
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
static cpl_vector*
xsh_get_exptimes(cpl_frameset* set) 
{
 
  cpl_vector* times=NULL;
  int n=0;
  int i=0;
  cpl_propertylist* plist=NULL;
  cpl_frame* frm=NULL;
 
 
  n=cpl_frameset_get_size(set);
  times=cpl_vector_new(n);
 
  for(i=0;i<n;i++) {
    check(frm=cpl_frameset_get_frame(set,i));
    check(plist=cpl_propertylist_load(cpl_frame_get_filename(frm),0));
    cpl_vector_set(times,i,xsh_pfits_get_exptime(plist));
    //xsh_msg("times[%d]=%f",i,xsh_pfits_get_exptime(plist));
    xsh_free_propertylist(&plist);
  }
 
 cleanup:
 
 
  return times;
 
}