xsh_util_efficiency2d.c

Go to the documentation of this file.

/* $Id: xsh_util_efficiency2d.c,v 1.19 2012-04-26 14:08:45 amodigli Exp $
 *
 * This file is part of the XSHOOTER Pipeline
 * Copyright (C) 2002,2003 European Southern Observatory
 *
 * This program 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, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
/*
<<<<<<< xsh_util_efficiency2d.c
 * $Author: amodigli $
 * $Date: 2012-04-26 14:08:45 $
 * $Revision: 1.19 $
=======
 * $Author: amodigli $
 * $Date: 2012-04-26 14:08:45 $
 * $Revision: 1.19 $
>>>>>>> 1.15.2.1
 * $Name: not supported by cvs2svn $
 */
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
/*-----------------------------------------------------------------------------
                                Includes
 ----------------------------------------------------------------------------*/
#include <string.h>
#include <math.h>
 
/* cpl */
#include <cpl.h>
 
#include <xsh_dfs.h>
#include <xsh_data_pre.h>
#include <xsh_parameters.h>
#include <xsh_drl.h>
#include <xsh_msg.h>
#include <xsh_pfits.h>
#include <xsh_pfits_qc.h>
#include <xsh_error.h>
#include <xsh_utils_image.h>
#include <xsh_data_atmos_ext.h>
 
/*-----------------------------------------------------------------------------
                               Defines
 ----------------------------------------------------------------------------*/
 
#define RECIPE_ID "xsh_util_efficiency2d"
#define RECIPE_AUTHOR "A.Modigliani"
#define RECIPE_CONTACT "Andrea.Modigliani@eso.org"
#define PRO_IMA "PRO_IMA_UVB"
#define KEY_VALUE_HPRO_DID                 "PRO-1.15"
 
#define SPEED_LIGHT 2.99792458*1.E8   /* m s-1 */
#define TEL_AREA  51.2e4             /* collecting area in cm2 */
/*-----------------------------------------------------------------------------
                            Functions prototypes
 ----------------------------------------------------------------------------*/
 
static int xsh_util_efficiency2d_create(cpl_plugin *) ;
static int xsh_util_efficiency2d_exec(cpl_plugin *) ;
static int xsh_util_efficiency2d_destroy(cpl_plugin *) ;
static int xsh_util_efficiency2d(cpl_parameterlist *, cpl_frameset *) ;
 
/*-----------------------------------------------------------------------------
                            Static variables
 ----------------------------------------------------------------------------*/
 
static char 
xsh_util_efficiency2d_description_short[] = "Compute efficiency";
static char xsh_util_efficiency2d_description[] =
"This recipe compute efficiency.\n"
"The input files should be tagged as: \n"
"input observed spectrum: RAW_IMA_SLIT_arm,\n"
"input reference spectrum: FLUX_STD_TABLE_arm,\n"
"input atmospheric  extintion table: EXTCOEFF_TABLE_arm)\n"
"The output is a table with efficiency as function of wavelength\n"
"Information on relevant parameters can be found with\n"
"esorex --params xsh_util_efficiency2d\n"
"esorex --help xsh_util_efficiency2d\n"
"\n";
 
/*-----------------------------------------------------------------------------
                                Functions code
 ----------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int cpl_plugin_get_info(cpl_pluginlist * list)
{
    cpl_recipe  *   recipe = cpl_calloc(1, sizeof *recipe ) ;
    cpl_plugin  *   plugin = &recipe->interface ;
 
    cpl_plugin_init(plugin,
                    CPL_PLUGIN_API,
                    XSH_BINARY_VERSION,
                    CPL_PLUGIN_TYPE_RECIPE,
                    RECIPE_ID,
                    xsh_util_efficiency2d_description_short,
                    xsh_util_efficiency2d_description,
                    RECIPE_AUTHOR,
                    RECIPE_CONTACT,
                    xsh_get_license(),
                    xsh_util_efficiency2d_create,
                    xsh_util_efficiency2d_exec,
                    xsh_util_efficiency2d_destroy) ;
 
    cpl_pluginlist_append(list, plugin) ;
    
    return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_efficiency2d_create(cpl_plugin * plugin)
{
    cpl_recipe      * recipe ;
    cpl_parameter   * p ;
 
  /* Reset library state */
  xsh_init();
 
    /* Get the recipe out of the plugin */
    if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE) 
        recipe = (cpl_recipe *)plugin ;
    else return -1 ;
    cpl_error_reset();
 
 
    /* Create the parameters list in the cpl_recipe object */
    recipe->parameters = cpl_parameterlist_new() ; 
 
 
    /* Set generic parameters (common to all recipes) */
    check( xsh_parameters_generic(RECIPE_ID, 
                  recipe->parameters ) ) ;
    xsh_parameters_decode_bp(RECIPE_ID,recipe->parameters,-1);
    /* Fill the parameters list */
    p = cpl_parameter_new_value("xsh.xsh_util_efficiency2d.sky1_lly", 
                                CPL_TYPE_INT, 
                                "Sky1 lly", 
                                "xsh.xsh_util_efficiency2d",2);
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sky1_lly") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 
 
 
    /* Fill the parameters list */
    p = cpl_parameter_new_value("xsh.xsh_util_efficiency2d.sky1_ury", 
                                CPL_TYPE_INT, 
                                "Sky1 ury", 
                                "xsh.xsh_util_efficiency2d",20);
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sky1_ury") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 
 
 
 
    /* Fill the parameters list */
    p = cpl_parameter_new_value("xsh.xsh_util_efficiency2d.sky2_lly", 
                                CPL_TYPE_INT, 
                                "Sky2 lly", 
                                "xsh.xsh_util_efficiency2d",75);
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sky2_lly") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 
 
 
    /* Fill the parameters list */
    p = cpl_parameter_new_value("xsh.xsh_util_efficiency2d.sky2_ury", 
                                CPL_TYPE_INT, 
                                "Sky ury", 
                                "xsh.xsh_util_efficiency2d",100);
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sky2_ury") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 
 
 
 
 
    /* Fill the parameters list */
    p = cpl_parameter_new_value("xsh.xsh_util_efficiency2d.obj_lly", 
                                CPL_TYPE_INT, 
                                "Sky2 lly", 
                                "xsh.xsh_util_efficiency2d",22);
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "obj_lly") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 
 
 
    /* Fill the parameters list */
    p = cpl_parameter_new_value("xsh.xsh_util_efficiency2d.obj_ury", 
                                CPL_TYPE_INT, 
                                "Sky ury", 
                                "xsh.xsh_util_efficiency2d",70);
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "obj_ury") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 
 
 
 
 cleanup: 
 
    /* Return */
    return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_efficiency2d_exec(cpl_plugin * plugin)
{
    cpl_recipe  *   recipe ;
     int code=0;
     cpl_errorstate initial_errorstate = cpl_errorstate_get();
 
    /* Get the recipe out of the plugin */
    if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE) 
        recipe = (cpl_recipe *)plugin ;
    else return -1 ;
    cpl_error_reset();
 
    code = xsh_util_efficiency2d(recipe->parameters, recipe->frames) ;
 
 
    if (!cpl_errorstate_is_equal(initial_errorstate)) {                      
        /* Dump the error history since recipe execution start.                
           At this point the recipe cannot recover from the error */           
        cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);              
    } 
 
    return code ;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_efficiency2d_destroy(cpl_plugin * plugin)
{
    cpl_recipe  *   recipe ;
    
    /* Get the recipe out of the plugin */
    if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE) 
        recipe = (cpl_recipe *)plugin ;
    else return -1 ;
 
    cpl_parameterlist_delete(recipe->parameters) ; 
    return 0 ;
}
 
static double
xsh_table_get_interpolated(cpl_table* tbl,
                           double wav, 
                           const char* colx, 
                           const char* coly)
{
 
 double y=0;
 double w1=0;
 double w2=0;
 double pos_y1=0;
 double pos_y2=0;
 float* pe=NULL;
 float* pw=NULL;
 int nrow=0;
 int i=0;
  
 
 w1=cpl_table_get_column_min(tbl,colx);
 w2=cpl_table_get_column_max(tbl,colx);
 pos_y1=cpl_table_get_column_min(tbl,coly);
 pos_y2=cpl_table_get_column_max(tbl,coly);
 
 
 pw=cpl_table_get_data_float(tbl,colx);
 pe=cpl_table_get_data_float(tbl,coly);
 nrow=cpl_table_get_nrow(tbl);
 
 
 for(i=0;i<nrow-1;i++) {
   if(pw[i]<wav) {
     w1=pw[i];
     w2=pw[i+1];
     pos_y1=pe[i];
     pos_y2=pe[i+1];
   }
 }
 
 y=pos_y1+(pos_y2-pos_y1)/(w2-w1)*(wav-w1);
 
 
return y;
 
}
 
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int 
xsh_util_efficiency2d( cpl_parameterlist   *   parlist, 
        cpl_frameset        *   frames)
{
  const char* recipe_tags[1] = {XSH_RAW_IMA_SLIT};
  int recipe_tags_size = 1;
 
  xsh_instrument* instrument=NULL;
    cpl_parameter       *   param= NULL ;
    cpl_frame* frm_sci=NULL;
    cpl_frame* frm_ref=NULL;
    cpl_frame* frm_atmext=NULL;
 
    cpl_frameset* raws=NULL;
    cpl_frameset* calib=NULL;
 
    cpl_image* ima_sci=NULL;
    cpl_table* tbl_ref=NULL;
    cpl_table* tbl_ext=NULL;
    cpl_table* tbl_atmext=NULL;
 
    const char* name=NULL;
    double ref_wmin=0;
    double ref_wmax=0;
    double ext_wmin=0;
    double ext_wmax=0;
 
    cpl_propertylist* plist=NULL;
    double crval1=0;
    double cdelt1=0;
    int naxis1=0;
    int nrow=0;
    double* pext=NULL;
    double* pcor=NULL;
    double* pref=NULL;
    double* peph=NULL;
    double aimprim=1.446;
 
 
    double exptime=600;
    cpl_vector* rec_profile=NULL;
    int i=0;
    double airmass=0;
    double airmass_start=0;
    double airmass_end=0;
 
    double nm2AA=10.; /* nm/AA */
    int next=0;
    int nord=0;
    cpl_image* ima_ord=0;
    cpl_image* ima_obj=0;
    cpl_image* ima_sky1=0;
    cpl_image* ima_sky2=0;
    cpl_image* ima_sky=0;
    int sx=0;
    int obj_lly=37;//22; //18;
    int obj_ury=85;//70; //80;
 
    int sky1_lly=20;//2;//3;
    int sky1_ury=35;//20;//15;
 
 
    int sky2_lly=90;//75;//81;
    int sky2_ury=105;//100;//100;
    cpl_table* obj_tab=NULL;
   
    double * pobj=NULL;
    double * pw=NULL;
    double * pf=NULL;
    int * po=NULL;
    int k=0;
    int j=0;
    double wav=0;
    double gain=0;
    cpl_table* tbl_sel=NULL;
    int biny=1;
   
    xsh_msg("Welcome to XSHOOTER Pipeline release %d.%d.%d",
            XSH_MAJOR_VERSION,XSH_MINOR_VERSION,XSH_MICRO_VERSION);
 
   
    check( xsh_begin( frames, parlist, &instrument, &raws, &calib,
            recipe_tags, recipe_tags_size,
            RECIPE_ID, XSH_BINARY_VERSION,
            xsh_util_efficiency2d_description_short ) ) ;
   
 
 
    check(param=cpl_parameterlist_find(parlist,"xsh.xsh_util_efficiency2d.sky1_lly"));
    check(sky1_lly=cpl_parameter_get_int(param));
 
    check(param=cpl_parameterlist_find(parlist,"xsh.xsh_util_efficiency2d.sky1_ury"));
    check(sky1_ury=cpl_parameter_get_int(param));
 
 
    check(param=cpl_parameterlist_find(parlist,"xsh.xsh_util_efficiency2d.sky2_lly"));
    check(sky2_lly=cpl_parameter_get_int(param));
 
    check(param=cpl_parameterlist_find(parlist,"xsh.xsh_util_efficiency2d.sky2_ury"));
    check(sky2_ury=cpl_parameter_get_int(param));
 
 
 
 
    check(param=cpl_parameterlist_find(parlist,"xsh.xsh_util_efficiency2d.obj_lly"));
    check(obj_lly=cpl_parameter_get_int(param));
 
    check(param=cpl_parameterlist_find(parlist,"xsh.xsh_util_efficiency2d.obj_ury"));
    check(obj_ury=cpl_parameter_get_int(param));
    xsh_msg("Obj extraction window: %d %d",obj_lly,obj_ury);
    xsh_msg("Sky1 extraction window: %d %d",sky1_lly,sky1_ury);
    xsh_msg("Sky2 extraction window: %d %d",sky2_lly,sky2_ury);
 
 
    /* HOW TO RETRIEVE INPUT PARAMETERS */
    /* --stropt */
    check(frm_sci=xsh_find_frame_with_tag(raws,XSH_RAW_IMA_SLIT, instrument));
    check(frm_ref=xsh_find_frame_with_tag(calib,XSH_FLUX_STD_TAB,instrument));
    check(frm_atmext=xsh_find_frame_with_tag(calib,XSH_EXTCOEFF_TAB,instrument));
    check(next = cpl_frame_get_nextensions(frm_sci));
    
    xsh_msg("next=%d",next);
    nord=(next+1)/3;
    name=cpl_frame_get_filename(frm_sci);
 
    check(plist=cpl_propertylist_load(name,0));
    check(naxis1=xsh_pfits_get_naxis1(plist));
    check(airmass_start=xsh_pfits_get_airm_start(plist));
    check(airmass_end=xsh_pfits_get_airm_end(plist));
    if( xsh_instrument_get_arm(instrument) == XSH_ARM_NIR){
        gain=2.12;
        biny=1;
        check(exptime=xsh_pfits_get_dit(plist));
    } else {
      check(gain=xsh_pfits_get_conad(plist));
      check(biny=xsh_pfits_get_biny(plist)); 
      check(exptime=xsh_pfits_get_win1_dit1(plist));
    }
 
    xsh_free_propertylist(&plist);
    airmass=0.5*(airmass_start+airmass_end);
 
    xsh_msg("gain=%g airm=%g exptime=%g",gain,airmass,exptime);
 
    xsh_msg("name=%s",name);
    nrow=naxis1*nord;
    obj_tab=cpl_table_new(nrow);
    cpl_table_new_column(obj_tab,"ORD",CPL_TYPE_INT);
    cpl_table_new_column(obj_tab,"WAVELENGTH",CPL_TYPE_DOUBLE);
    cpl_table_new_column(obj_tab,"FLUX",CPL_TYPE_DOUBLE);
 
    check(po=cpl_table_get_data_int(obj_tab,"ORD"));
    check(pw=cpl_table_get_data_double(obj_tab,"WAVELENGTH"));
    check(pf=cpl_table_get_data_double(obj_tab,"FLUX"));
 
    check(cpl_table_fill_column_window_int(obj_tab,"ORD",0,nrow,-1));
    check(cpl_table_fill_column_window_double(obj_tab,"WAVELENGTH",0,nrow,-1));
    check(cpl_table_fill_column_window_double(obj_tab,"FLUX",0,nrow,-1));
 
    /* extract the object signal on a given slit
       extract the sky signal on 2 given slits
       computes the extracted sky per pixel on each sky window
       average the two extracted sky
       rescale the averaged sky to the object windows and 
       subtract it from the object
    */
    xsh_msg("extract object");
    k=0;
    for(i=0;i<next;i+=3) {
      xsh_msg("processing extension %d",i);
      check(ima_ord=cpl_image_load(name,CPL_TYPE_DOUBLE,0,i));
      check(plist=cpl_propertylist_load(name,i));
      check(sx=cpl_image_get_size_x(ima_ord));
      check(ima_obj=cpl_image_collapse_window_create(ima_ord,1,obj_lly,
                             sx,obj_ury,0));
      check(ima_sky1=cpl_image_collapse_window_create(ima_ord,1,sky1_lly,
                              sx,sky1_ury,0));
      check(ima_sky2=cpl_image_collapse_window_create(ima_ord,1,sky2_lly,
                              sx,sky2_ury,0));
      check(cpl_image_divide_scalar(ima_sky1,sky1_ury-sky1_lly+1));
      check(cpl_image_divide_scalar(ima_sky2,sky2_ury-sky2_lly+1));
 
 
      check(ima_sky=cpl_image_duplicate(ima_sky1));
      check(cpl_image_add(ima_sky,ima_sky2));
      check(cpl_image_divide_scalar(ima_sky,2));
      check(cpl_image_multiply_scalar(ima_sky,obj_ury-obj_lly+1));
      check(cpl_image_subtract(ima_obj,ima_sky));
 
      check(pobj=cpl_image_get_data_double(ima_obj));
      check(crval1=xsh_pfits_get_crval1(plist));
      check(cdelt1=xsh_pfits_get_cdelt1(plist));
      //pcor[i]=poh_pfits_get_cdelt1(plist));
      
    
      for(j=0;j<naxis1;j++) {
 
    wav=crval1+cdelt1*j;
    pw[k+j]=wav;
        po[k+j]=i/3;
        if( ( xsh_instrument_get_arm(instrument) == XSH_ARM_NIR) && 
            ( (po[k+j]==3) ||(po[k+j]==8) ) ) {
      pf[k+j]=0;
    } else {
      pf[k+j]=pobj[j];
    }
      }
 
      k+=naxis1;
      xsh_free_image(&ima_ord);
      xsh_free_image(&ima_obj);
      xsh_free_image(&ima_sky);
      xsh_free_image(&ima_sky);
      xsh_free_image(&ima_sky1);
      xsh_free_image(&ima_sky2);
      xsh_free_propertylist(&plist);
 
 
      //pcor[i]=po
    }
    xsh_msg("Extracted spectrum sampling bin=%g [nm]",cdelt1); 
    check(name=cpl_frame_get_filename(frm_ref));
    check(tbl_ref=cpl_table_load(name,1,0));
    /* ref std spectrum wavelengh scale is in A units */
    /* atm ext spectrum wavelengh scale in A units */
    /* => we need to bring XSH spectrum to A */
    /* In reference source the flux is in: erg/s/cm2/A */
    /* In XSH the spectrum in in : erg/s/cm2/bin
       we need to scale it to erg/s/cm2/A==> divide by bin/A */
 
    /* express the extracted spectrum in AA units, same as reference */
    cpl_table_multiply_scalar(obj_tab,"WAVELENGTH",nm2AA);
 
 
    check(ref_wmin=cpl_table_get_column_min(tbl_ref,"WAVELENGTH"));
    check(ref_wmax=cpl_table_get_column_max(tbl_ref,"WAVELENGTH"));
    xsh_msg("Ref spectrum wmin=%g [A] wmax=%g [A]",ref_wmin,ref_wmax);
 
    check(name=cpl_frame_get_filename(frm_atmext));
    check(tbl_atmext=cpl_table_load(name,1,0));
 
    //cpl_table_divide_scalar(tbl_atmext,"LAMBDA",10.);
    check(ext_wmin=cpl_table_get_column_min(tbl_atmext,"LAMBDA"));
    check(ext_wmax=cpl_table_get_column_max(tbl_atmext,"LAMBDA"));
    xsh_msg("extinction wmin=%g [A] wmax=%g [A]",ext_wmin,ext_wmax);
 
 
    check(cpl_table_new_column(obj_tab,"REF",CPL_TYPE_DOUBLE));
    check(cpl_table_fill_column_window_double(obj_tab,"REF",0,nrow,-1));
 
    check(cpl_table_new_column(obj_tab,"EXT",CPL_TYPE_DOUBLE));
    check(cpl_table_fill_column_window_double(obj_tab,"EXT",0,nrow,-1));
 
    check(cpl_table_new_column(obj_tab,"COR",CPL_TYPE_DOUBLE));
    check(cpl_table_fill_column_window_double(obj_tab,"COR",0,nrow,-1));
 
    check(cpl_table_new_column(obj_tab,"EPHOT",CPL_TYPE_DOUBLE));
    check(cpl_table_fill_column_window_double(obj_tab,"EPHOT",0,nrow,-1));
 
 
    check(pref=cpl_table_get_data_double(obj_tab,"REF"));
    check(pext=cpl_table_get_data_double(obj_tab,"EXT"));
    check(pcor=cpl_table_get_data_double(obj_tab,"COR"));
    check(peph=cpl_table_get_data_double(obj_tab,"EPHOT"));
 
    check(pw=cpl_table_get_data_double(obj_tab,"WAVELENGTH"));
    check(pf=cpl_table_get_data_double(obj_tab,"FLUX"));
    xsh_msg("Resample atmosphere and std star");
    for(i=0;i<nrow;i++) {
 
 
      check(pext[i]=xsh_table_get_interpolated(tbl_atmext,pw[i],"LAMBDA",
                                               XSH_ATMOS_EXT_LIST_COLNAME_K));
 
      check(pref[i]=xsh_table_get_interpolated(tbl_ref,pw[i],
                           "WAVELENGTH","FLUX"));
 
      pcor[i]=pow(10,(0.4*pext[i]*aimprim));
      if(airmass != 0) pcor[i]/=pow(10,(0.4*pext[i]*airmass));
      peph[i]=1.e7*1.986e-19/(pw[i]*1e-4); 
      /* ph energy: 1.986*10^-19(J.ph^-1)/lam(um) */
 
    }
    xsh_msg("apply corrections");
    check(cpl_table_duplicate_column(obj_tab,"SRC_COR",obj_tab,"FLUX"));
    check(cpl_table_multiply_columns(obj_tab,"SRC_COR","COR"));
 
    /* correct flux by binning: divides by binsize in AA: cdelt1[nm]*nm2AA */
    cpl_table_divide_scalar(obj_tab,"SRC_COR",nm2AA);
    cpl_table_divide_scalar(obj_tab,"SRC_COR",cdelt1);
    cpl_table_divide_scalar(obj_tab,"SRC_COR",biny);
 
    check(cpl_table_duplicate_column(obj_tab,"EFF",obj_tab,"SRC_COR"));
    //check(cpl_table_divide_scalar(obj_tab,"EFF",binsize));
    check(cpl_table_multiply_scalar(obj_tab,"EFF",gain));
    check(cpl_table_multiply_columns(obj_tab,"EFF","EPHOT"));
    check(cpl_table_divide_scalar(obj_tab,"EFF",exptime));
    check(cpl_table_divide_scalar(obj_tab,"EFF",TEL_AREA));
    check(cpl_table_divide_columns(obj_tab,"EFF","REF"));
 
 
    cpl_table_and_selected_double(obj_tab,"EFF",CPL_GREATER_THAN,1.e-5);
    cpl_table_and_selected_double(obj_tab,"EFF",CPL_LESS_THAN,1.);
    tbl_sel=cpl_table_extract_selected(obj_tab);
   
 
    check( cpl_table_save(tbl_sel, NULL, NULL,"eff.fits", CPL_IO_DEFAULT));
 
 
    xsh_free_table(&obj_tab);
 
 cleanup:
    xsh_free_table(&tbl_sel);
    xsh_free_image(&ima_sci);
    xsh_free_table(&obj_tab);
    xsh_free_table(&tbl_ref);
    xsh_free_table(&tbl_ext);
    xsh_free_table(&tbl_atmext);
    xsh_free_vector(&rec_profile); 
 
    xsh_free_image(&ima_ord);
    xsh_free_image(&ima_obj);
    xsh_free_image(&ima_sky);
    xsh_free_image(&ima_sky);
    xsh_free_image(&ima_sky1);
    xsh_free_image(&ima_sky2);
    xsh_free_propertylist(&plist);
    xsh_free_frameset(&raws);
    xsh_free_frameset(&calib);
    xsh_instrument_free( &instrument);
 
    if (cpl_error_get_code()) {
      return -1 ;
    } else {
      return 0 ;
    }
 
}