xsh_util_efficiency.c

Go to the documentation of this file.

/* 
 * 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
 */
 
/*
 * $Author: amodigli $
 * $Date: 2012-04-26 14:08:15 $
 * $Revision: 1.11 $
 * $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_efficiency"
#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_efficiency_create(cpl_plugin *) ;
static int xsh_util_efficiency_exec(cpl_plugin *) ;
static int xsh_util_efficiency_destroy(cpl_plugin *) ;
static int xsh_util_efficiency(cpl_parameterlist *, cpl_frameset *) ;
 
/*-----------------------------------------------------------------------------
                            Static variables
 ----------------------------------------------------------------------------*/
 
static char 
xsh_util_efficiency_description_short[] = "Compute efficiency";
static char xsh_util_efficiency_description[] =
"This recipe compute efficiency.\n"
"The input files should be tagged as: \n"
"input observed spectrum: IMA_arm,\n"
"input reference spectrum: FLUX_STD_TABLE,\n"
"input atmospheric  extintion table: EXTCOEFF_TABLE)\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_efficiency\n"
"esorex --help xsh_util_efficiency\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_efficiency_description_short,
                    xsh_util_efficiency_description,
                    RECIPE_AUTHOR,
                    RECIPE_CONTACT,
                    xsh_get_license(),
                    xsh_util_efficiency_create,
                    xsh_util_efficiency_exec,
                    xsh_util_efficiency_destroy) ;
 
    cpl_pluginlist_append(list, plugin) ;
    
    return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_efficiency_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_efficiency.airmass", 
                                CPL_TYPE_DOUBLE, 
                                "Airmass value", 
                                "xsh.xsh_util_efficiency",1.2);
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "airmass") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 
    /* Fill the parameters list */
    p = cpl_parameter_new_value("xsh.xsh_util_efficiency.gain", 
                                CPL_TYPE_DOUBLE, 
                                "Detector gain value", 
                                "xsh.xsh_util_efficiency",1.5);
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "gain") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 
 cleanup: 
 
    /* Return */
    return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_efficiency_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_efficiency(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_efficiency_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 y1=0;
 double 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);
 y1=cpl_table_get_column_min(tbl,coly);
 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];
     y1=pe[i];
     y2=pe[i+1];
   }
 }
 
 y=y1+(y2-y1)/(w2-w1)*(wav-w1);
 
 
return y;
 
}
 
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int 
xsh_util_efficiency( cpl_parameterlist   *   parlist, 
        cpl_frameset        *   frames)
{
  const char* recipe_tags[1] = {XSH_EFFICIENCY};
  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 aimprim=1.446;
    //double gain=1.75;            /* e-/adu 400k,low gain, UVB */
    double gain=1.5;            /* e-/adu 400k,low gain, VIS */
    double ref_wmin=0;
    double ref_wmax=0;
    double src_wmin=0;
    double src_wmax=0;
    double ext_wmin=0;
    double ext_wmax=0;
    double ext_wdel=0;
 
    double wmin=0;
    double wmax=0;
 
    cpl_propertylist* plist=NULL;
    double crpix1=0;
    double crval1=0;
    double cdelt1=0;
    int naxis1=0;
    int nrow=0;
    float* psrc=NULL;
    float* pext=NULL;
    float* pwav=NULL;
    float* pcor=NULL;
    float* pref=NULL;
    float* peph=NULL;
   
 
    double exptime=0;
    double confidence=0;
    cpl_vector* rec_profile=NULL;
    double x=0;
    int i=0;
    double airmass=0;
    double binsize=0.1; /* AA/pxl */
 
    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_efficiency_description_short ) ) ;
    */
 
    check(param=cpl_parameterlist_find(parlist,"xsh.xsh_util_efficiency.airmass"));
    check(airmass=cpl_parameter_get_double(param));
 
 
    check(param=cpl_parameterlist_find(parlist,"xsh.xsh_util_efficiency.gain"));
    check(gain=cpl_parameter_get_double(param));
 
    /* HOW TO RETRIEVE INPUT PARAMETERS */
    /* --stropt */
    check(frm_sci=cpl_frameset_get_frame(frames,0));
    check(frm_ref=cpl_frameset_get_frame(frames,1));
    check(frm_atmext=cpl_frameset_get_frame(frames,2));
 
    check(name=cpl_frame_get_filename(frm_sci));
    check(ima_sci=cpl_image_load(name,CPL_TYPE_FLOAT,0,0));
    check(plist=cpl_propertylist_load(name,0));
    check(crpix1=xsh_pfits_get_crpix1(plist));
    check(crval1=xsh_pfits_get_crval1(plist));
    check(cdelt1=xsh_pfits_get_cdelt1(plist));
    check(naxis1=xsh_pfits_get_naxis1(plist));
    check(exptime=xsh_pfits_get_exptime(plist));
    xsh_free_propertylist(&plist);
 
    src_wmin=crval1;
    src_wmax=src_wmin+naxis1*cdelt1;
 
    check(name=cpl_frame_get_filename(frm_ref));
    check(tbl_ref=cpl_table_load(name,1,0));
 
    check(name=cpl_frame_get_filename(frm_atmext));
    check(tbl_atmext=cpl_table_load(name,1,0));
 
    cpl_table_divide_scalar(tbl_ref,"WAVELENGTH",10.);
    check(ref_wmin=cpl_table_get_column_min(tbl_ref,"WAVELENGTH"));
    check(ref_wmax=cpl_table_get_column_max(tbl_ref,"WAVELENGTH"));
 
 
    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"));
    nrow=cpl_table_get_nrow(tbl_atmext);
    ext_wdel=(ext_wmax-ext_wmin)/(nrow-1);
    xsh_msg("wdel=%g",ext_wdel);
    wmin=(src_wmin>ref_wmin) ? src_wmin : ref_wmin;
    wmax=(src_wmax<ref_wmax) ? src_wmax : ref_wmax;
    xsh_msg("eff wave min: %g max: %g",wmin,wmax);
 
    wmin=(ext_wmin>wmin) ? ext_wmin : wmin;
    wmax=(ext_wmax<wmax) ? ext_wmax : wmax;
    
    xsh_msg("ref wave min: %g max: %g",ref_wmin,ref_wmax);
    xsh_msg("src wave min: %g max: %g",src_wmin,src_wmax);
    xsh_msg("ext wave min: %g max: %g",ext_wmin,ext_wmax);
    xsh_msg("eff wave min: %g max: %g",wmin,wmax);
 
    check(cpl_table_and_selected_float(tbl_ref,"WAVELENGTH",CPL_NOT_LESS_THAN,wmin));
    check(cpl_table_and_selected_float(tbl_ref,"WAVELENGTH",CPL_NOT_GREATER_THAN,wmax));
    check(tbl_ext=cpl_table_extract_selected(tbl_ref));
    check(ref_wmin=cpl_table_get_column_min(tbl_ext,"WAVELENGTH"));
    check(ref_wmax=cpl_table_get_column_max(tbl_ext,"WAVELENGTH"));
    xsh_msg("sel wave min: %g max: %g",ref_wmin,ref_wmax);
 
    check(nrow=cpl_table_get_nrow(tbl_ext));
 
    check(cpl_table_new_column(tbl_ext,"SRC",CPL_TYPE_FLOAT));
    check(cpl_table_fill_column_window_float(tbl_ext,"SRC",0,nrow,-1));
 
    check(cpl_table_new_column(tbl_ext,"REF",CPL_TYPE_FLOAT));
    check(cpl_table_fill_column_window_float(tbl_ext,"REF",0,nrow,-1));
 
    check(cpl_table_new_column(tbl_ext,"EXT",CPL_TYPE_FLOAT));
    check(cpl_table_fill_column_window_float(tbl_ext,"EXT",0,nrow,-1));
 
    check(cpl_table_new_column(tbl_ext,"COR",CPL_TYPE_FLOAT));
    check(cpl_table_fill_column_window_float(tbl_ext,"COR",0,nrow,-1));
 
    check(cpl_table_new_column(tbl_ext,"EPHOT",CPL_TYPE_FLOAT));
    check(cpl_table_fill_column_window_float(tbl_ext,"EPHOT",0,nrow,-1));
 
 
    check(psrc=cpl_table_get_data_float(tbl_ext,"SRC"));
    check(pref=cpl_table_get_data_float(tbl_ext,"REF"));
    check(pext=cpl_table_get_data_float(tbl_ext,"EXT"));
    check(pcor=cpl_table_get_data_float(tbl_ext,"COR"));
    check(peph=cpl_table_get_data_float(tbl_ext,"EPHOT"));
    check(peph=cpl_table_get_data_float(tbl_ext,"EPHOT"));
 
    check(pwav=cpl_table_get_data_float(tbl_ext,"WAVELENGTH"));
    check( rec_profile = cpl_vector_new( CPL_KERNEL_DEF_SAMPLES ) ) ;
    check( cpl_vector_fill_kernel_profile( rec_profile,
                       CPL_KERNEL_DEFAULT,
                       1 ) ) ;
    for(i=0;i<nrow;i++) {
      x=(pwav[i]-src_wmin)/cdelt1;
      /* xsh_msg("x=%g",x); */
      check(psrc[i]=cpl_image_get_interpolated( ima_sci,x, 1,
                        rec_profile,
                        1,
                        rec_profile,
                        1,
                        &confidence ) ) ;
 
 
 
 
      check(pext[i]=xsh_table_get_interpolated(tbl_atmext,pwav[i],"LAMBDA",
                                               XSH_ATMOS_EXT_LIST_COLNAME_K));
 
      check(pref[i]=xsh_table_get_interpolated(tbl_ref,pwav[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.986e-16/(pwav[i]*1e-8);
 
    }
 
    check(cpl_table_duplicate_column(tbl_ext,"SRC_COR",tbl_ext,"SRC"));
    check(cpl_table_multiply_columns(tbl_ext,"SRC_COR","COR"));
    check(cpl_table_duplicate_column(tbl_ext,"EFF",tbl_ext,"SRC_COR"));
    //check(cpl_table_divide_scalar(tbl_ext,"EFF",binsize));
    check(cpl_table_multiply_scalar(tbl_ext,"EFF",gain));
    check(cpl_table_multiply_columns(tbl_ext,"EFF","EPHOT"));
    check(cpl_table_divide_scalar(tbl_ext,"EFF",exptime));
    check(cpl_table_divide_scalar(tbl_ext,"EFF",TEL_AREA));
    check(cpl_table_divide_columns(tbl_ext,"EFF","REF"));
 
    check(cpl_table_save(tbl_ext,NULL,NULL,"tab.fits",CPL_IO_DEFAULT));
 cleanup:
    xsh_free_propertylist(&plist);
    xsh_free_image(&ima_sci);
    xsh_free_table(&tbl_ref);
    xsh_free_table(&tbl_ext);
    xsh_free_table(&tbl_atmext);
    xsh_free_vector(&rec_profile); 
    if (cpl_error_get_code()) {
       return -1 ;
    } else {
       return 0 ;
    }
 
}