xsh_util_compute_response.c

Go to the documentation of this file.

/* $Id: xsh_util_compute_response.c,v 1.19 2013-08-29 10:50:46 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
 */
 
/*
 * $Author: amodigli $
 * $Date: 2013-08-29 10:50:46 $
 * $Revision: 1.19 $
 * $Name: not supported by cvs2svn $
 */
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
/*-----------------------------------------------------------------------------
  Includes
  ----------------------------------------------------------------------------*/
#include <string.h>
 
/* cpl */
#include <cpl.h>
 
/* irplib */
#include <xsh_dfs.h>
//#include <xsh_data_pre.h>
#include <xsh_parameters.h>
#include <xsh_utils.h>
#include <xsh_utils_table.h>
#include <xsh_drl.h>
#include <xsh_msg.h>
#include <xsh_pfits.h>
#include <xsh_error.h>
 
 
/*-----------------------------------------------------------------------------
  Defines
  ----------------------------------------------------------------------------*/
 
#define RECIPE_ID "xsh_util_compute_response"
#define RECIPE_AUTHOR "A.Modigliani"
#define RECIPE_CONTACT "Andrea.Modigliani@eso.org"
#define PRO_IMA "PRO_IMA"
#define KEY_VALUE_HPRO_DID                 "PRO-1.15"
/*-----------------------------------------------------------------------------
  Functions prototypes
  ----------------------------------------------------------------------------*/
 
static int xsh_util_compute_response_create(cpl_plugin *) ;
static int xsh_util_compute_response_exec(cpl_plugin *) ;
static int xsh_util_compute_response_destroy(cpl_plugin *) ;
static int xsh_util_compute_response(cpl_parameterlist *, cpl_frameset *) ;
 
/*-----------------------------------------------------------------------------
  Static variables
  ----------------------------------------------------------------------------*/
 
static char 
xsh_util_compute_response_description_short[] = "Compute response";
static char xsh_util_compute_response_description[] =
  "This recipe compute response frame.\n"
  "Information on relevant parameters can be found with\n"
  "esorex --params xsh_util_compute_response\n"
  "esorex --help xsh_util_compute_response\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_compute_response_description_short,
          xsh_util_compute_response_description,
          RECIPE_AUTHOR,
          RECIPE_CONTACT,
          xsh_get_license(),
          xsh_util_compute_response_create,
          xsh_util_compute_response_exec,
          xsh_util_compute_response_destroy) ;
 
  cpl_pluginlist_append(list, plugin) ;
    
  return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_compute_response_create(cpl_plugin * plugin)
{
  cpl_recipe      * recipe ;
 
  /* 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);
    check( xsh_parameters_new_boolean( recipe->parameters, RECIPE_ID,
                       "correct-tellurics", TRUE,
    "TRUE if during response computation we apply telluric correction"));
 
 cleanup: 
 
  /* Return */
  return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_compute_response_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_compute_response(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_compute_response_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 int 
xsh_util_compute_response( cpl_parameterlist   *   parlist, 
                   cpl_frameset        *   framelist)
{
 
  int n=0;
  cpl_frame* high_abs_win_frame=NULL;
  cpl_frame* response_frame=NULL;
  cpl_frame* merged_frame=NULL;
  cpl_frame* atmext_frame=NULL;
  cpl_frame* flux_std_cat_frame=NULL;
 
  cpl_frameset* raws=NULL;
  cpl_frameset* calib=NULL;
  xsh_instrument* instrument=NULL;
  double exptime=0;
  cpl_propertylist* plist=NULL;
  cpl_frame* tell_mod_cat=NULL;
  cpl_frame* resp_fit_points_cat_frame=NULL;
  int corr_tell=0;
  int ndit=0;
  double dit=0;
 
 const char* recipe_tags[3] = {XSH_OBJECT_SLIT_STARE,
                                 XSH_STD_TELL_SLIT_STARE,
                 XSH_STD_FLUX_SLIT_STARE};
  int recipe_tags_size = 3;
 
  xsh_msg("Welcome to XSHOOTER Pipeline release %d.%d.%d",
      XSH_MAJOR_VERSION,XSH_MINOR_VERSION,XSH_MICRO_VERSION);
  check( xsh_begin( framelist, parlist, &instrument, &raws, &calib,
                    recipe_tags, recipe_tags_size,
                    RECIPE_ID, 
                    XSH_BINARY_VERSION,
                    xsh_util_compute_response_description_short ) ) ;
 
  n=cpl_frameset_get_size(framelist);
 
  if(n<1) {
    xsh_msg_error("Empty input frame list!");
    goto cleanup ;
  }
 
   check( corr_tell = xsh_parameters_get_boolean( parlist, RECIPE_ID,
                                                      "correct-tellurics"));
   tell_mod_cat=xsh_find_frame_with_tag(calib,XSH_TELL_MOD_CAT,instrument);
 
  check( merged_frame = xsh_find_frame_with_tag(framelist,XSH_IMA,instrument));
  plist=cpl_propertylist_load(cpl_frame_get_filename(merged_frame),0);
  if( xsh_instrument_get_arm(instrument) == XSH_ARM_NIR) {
    dit = xsh_pfits_get_dit(plist);
    ndit = xsh_pfits_get_ndit(plist);
    exptime=dit*ndit;
  } else {
    exptime=xsh_pfits_get_exptime(plist);
  }
  xsh_free_propertylist(&plist);
  atmext_frame=xsh_find_frame_with_tag(calib,XSH_ATMOS_EXT,instrument);
  
  if(atmext_frame==NULL) {
     xsh_msg_error("Provide atmospheric extinction frame");
     return CPL_ERROR_DATA_NOT_FOUND;
  }
 
  flux_std_cat_frame=xsh_find_frame_with_tag(calib,XSH_FLUX_STD_CAT,instrument);
  if(flux_std_cat_frame==NULL) {
     xsh_msg_error("Provide std star catalog frame");
     return CPL_ERROR_DATA_NOT_FOUND;
  }
 
  resp_fit_points_cat_frame=xsh_find_frame_with_tag(calib,XSH_RESP_FIT_POINTS_CAT,instrument);
  /*
  if(resp_fit_points_cat_frame==NULL) {
     xsh_msg_error("Provide response fit points catalog frame");
     return CPL_ERROR_DATA_NOT_FOUND;
  }
  */
 
  check( response_frame = xsh_compute_response2( merged_frame,
                         flux_std_cat_frame,
                         atmext_frame,
                         high_abs_win_frame,
                         resp_fit_points_cat_frame,
                         tell_mod_cat,
                         instrument,
                         exptime,corr_tell ));
  xsh_msg("response_frame=%p",response_frame);
 /*
  check(xsh_frame_table_monitor_flux_qc(response_frame,"LAMBDA","RESPONSE","RESP",
                    instrument));
*/
 
 cleanup:
  xsh_free_frameset(&raws);
  xsh_free_frameset(&calib);
  xsh_free_frame(&response_frame);
  xsh_free_propertylist(&plist);
  xsh_instrument_free(&instrument );
 
  if (cpl_error_get_code()) {
    return -1 ;
  } else {
    return 0 ;
  }
}