xsh_util_afc.c

Go to the documentation of this file.

/* $Id: xsh_util_afc.c,v 1.10 2012-12-18 14:12:51 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: 2012-12-18 14:12:51 $
 * $Revision: 1.10 $
 * $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>
 
 
/*-----------------------------------------------------------------------------
                               Defines
 ----------------------------------------------------------------------------*/
 
#define RECIPE_ID "xsh_util_afc"
#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_afc_create(cpl_plugin *) ;
static int xsh_util_afc_exec(cpl_plugin *) ;
static int xsh_util_afc_destroy(cpl_plugin *) ;
static int xsh_util_afc(cpl_parameterlist *, cpl_frameset *) ;
 
/*-----------------------------------------------------------------------------
                            Static variables
 ----------------------------------------------------------------------------*/
 
static char 
xsh_util_afc_description_short[] = "Measure AFC frame shift";
static char xsh_util_afc_description[] =
"This recipe compute shift of AFC frame with respect to reference pos.\n"
"The input files should be tagged as: \n"
"AFC frame: AFC_arm,\n"
"AFC pos table: AFC_POS_arm,\n"
"The output is a table with measured positions, shifts and QC\n"
"Information on relevant parameters can be found with\n"
"esorex --params xsh_util_afc\n"
"esorex --help xsh_util_afc\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_afc_description_short,
                    xsh_util_afc_description,
                    RECIPE_AUTHOR,
                    RECIPE_CONTACT,
                    xsh_get_license(),
                    xsh_util_afc_create,
                    xsh_util_afc_exec,
                    xsh_util_afc_destroy) ;
 
    cpl_pluginlist_append(list, plugin) ;
    
    return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_afc_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);
 
 cleanup: 
 
    /* Return */
    return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_afc_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_afc(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_afc_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_afc( cpl_parameterlist   *   parlist, 
        cpl_frameset        *   frames)
{
  const char* recipe_tags[1] = {XSH_AFC_SLT};
  int recipe_tags_size = 1;
 
  xsh_instrument* instrument=NULL;
 
  cpl_frame* frm_tab=NULL;
  cpl_frame* frm_afc=NULL;
 
  cpl_frameset* raws=NULL;
  cpl_frameset* calib=NULL;
 
  cpl_image* ima_afc=NULL;
  cpl_table* tbl_afc=NULL;
 
  const char* name=NULL;
  char afc_name[256];
  double xc=0;
  double yc=0;
  int size=4;
  double resx_med=0;
  double resy_med=0;
  double resx_avg=0;
  double resy_avg=0;
  cpl_propertylist* plist=NULL;
 
  float* px=NULL;
  float* py=NULL;
  float* pxm=NULL;
  float* pym=NULL;
  int i=0;
  int x=0;
  int y=0;
 
  int nrow=0;
  cpl_frame* frm_tab_afc=NULL;
  const char* tag=NULL;
 
 
    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_afc_description_short ) ) ;
   
  /* HOW TO RETRIEVE INPUT PARAMETERS */
  /* --stropt */
 
 
  check(frm_afc=xsh_find_frame_with_tag(raws,XSH_AFC_SLT, instrument));
  check(frm_tab=xsh_find_frame_with_tag(calib,XSH_AFC_POS,instrument));
 
  check(name=cpl_frame_get_filename(frm_afc));
 
  check(ima_afc=cpl_image_load(name,CPL_TYPE_DOUBLE,0,0));
  check(name=cpl_frame_get_filename(frm_tab));
  check(tbl_afc=cpl_table_load(name,1,0));
  check(nrow=cpl_table_get_nrow(tbl_afc));
 
  cpl_table_new_column(tbl_afc,"XM",CPL_TYPE_FLOAT);
  cpl_table_new_column(tbl_afc,"YM",CPL_TYPE_FLOAT);
  cpl_table_fill_column_window_float(tbl_afc,"XM",0,nrow,-1);
  cpl_table_fill_column_window_float(tbl_afc,"YM",0,nrow,-1);
 
  check(px=cpl_table_get_data_float(tbl_afc,"X"));
  check(py=cpl_table_get_data_float(tbl_afc,"Y"));
 
  check(pxm=cpl_table_get_data_float(tbl_afc,"XM"));
  check(pym=cpl_table_get_data_float(tbl_afc,"YM"));
 
 
  for(i=0;i<nrow;i++) {
   x=(int)(px[i]+0.5);
   y=(int)(py[i]+0.5);
   /*
   xsh_msg("x=%d y=%d",x,y);
   check(cpl_image_fit_gaussian(ima_afc,x,y,size,
                 &norm,&xc,&yc,&sig_x,&sig_y,&fwhm_x,&fwhm_y));
   */
   check(xc=cpl_image_get_centroid_x_window(ima_afc,
                        x-size,y-size,
                        x+size,y+size));
   check(yc=cpl_image_get_centroid_y_window(ima_afc,
                        x-size,y-size,
                        x+size,y+size));
 
    pxm[i]=xc;
    pym[i]=yc;
  }
 
  cpl_table_duplicate_column(tbl_afc,"RESX",tbl_afc,"XM");
  cpl_table_duplicate_column(tbl_afc,"RESY",tbl_afc,"YM");
 
  cpl_table_subtract_columns(tbl_afc,"RESX","X");
  cpl_table_subtract_columns(tbl_afc,"RESY","Y");
 
  resx_med=cpl_table_get_column_median(tbl_afc,"RESX");
  resy_med=cpl_table_get_column_median(tbl_afc,"RESY");
 
  resx_avg=cpl_table_get_column_mean(tbl_afc,"RESX");
  resy_avg=cpl_table_get_column_mean(tbl_afc,"RESY");
  xsh_msg("AFC med shift X: %g Y: %g",resx_med,resy_med);
  xsh_msg("AFC avg shift X: %g Y: %g",resx_avg,resy_avg);
  check(tag=XSH_GET_TAG_FROM_ARM(XSH_AFC_POS,instrument));
  sprintf(afc_name,"%s.fits",tag);
  check(plist=cpl_propertylist_new());
  check(cpl_propertylist_append_double(plist,XSH_QC_AFC_RESX_MED,resx_med));
  check(cpl_propertylist_append_double(plist,XSH_QC_AFC_RESY_MED,resy_med));
  check(cpl_propertylist_append_double(plist,XSH_QC_AFC_RESX_AVG,resx_avg));
  check(cpl_propertylist_append_double(plist,XSH_QC_AFC_RESY_AVG,resy_avg));
  check(cpl_table_save(tbl_afc,plist,NULL,afc_name,CPL_IO_DEFAULT));
  check(frm_tab_afc=xsh_frame_product(afc_name,tag,
                  CPL_FRAME_TYPE_TABLE,
                                  CPL_FRAME_GROUP_PRODUCT,
                                  CPL_FRAME_LEVEL_FINAL));
  check(xsh_add_product_table(frm_tab_afc, frames, parlist, RECIPE_ID,
                    instrument));
 cleanup:
  xsh_instrument_free(&instrument);
  xsh_free_frame(&frm_tab_afc);
  xsh_free_frameset(&raws);
  xsh_free_frameset(&calib);
 
  xsh_free_propertylist(&plist);
  xsh_free_image(&ima_afc);
  xsh_free_table(&tbl_afc);
 
  if (cpl_error_get_code()) {
    return -1 ;
  } else {
    return 0 ;
  }
 
}