test-xsh_cpl_vector_correl_hdelta.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-23 13:11:02 $
 * $Revision: 1.1 $
 * $Name: not supported by cvs2svn $
 */
#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------
                                Includes
 ---------------------------------------------------------------------------*/
 
 
#include <xsh_error.h>
#include <xsh_msg.h>
#include <xsh_dfs.h>
#include <tests.h>
#include <cpl.h>
#include <math.h>
#include <getopt.h>
#include <string.h>
/*---------------------------------------------------------------------------
                            Defines
 ---------------------------------------------------------------------------*/
#define MODULE_ID "XSH_CPL_VECTOR_CORREL_HDELTA"
 
enum {
  DEBUG_OPT, HELP_OPT
};
 
static struct option LongOptions[] = {
  {"debug", required_argument, 0, DEBUG_OPT},
  {"help", 0, 0, HELP_OPT},
  {NULL, 0, 0, 0}
};
 
static void Help( void )
{
  puts ("Unitary test : Create two Gaussians one shifted to the other of a given quantity, then correlate them to check if correlation returns expected shift");
  puts( "Usage : ./tetst_xsh_correl_gaussians [options]");
 
  puts( "Options" ) ;
  puts( " --debug=<n>        : Level of debug LOW | MEDIUM | HIGH [MEDIUM]" );
  puts( " --help             : What you see" ) ;
 
  puts( "The input files argument MUST be in this order:" );
  puts( " 1. PRE frame");
  puts( " 2. SOF a) MODEL     : [XSH_MOD_CFG_TAB_UVB]");
  puts( "        b) POLYNOMIAL: [DISP_TAB, ORDER_TAB_EDGES]");
  
  TEST_END();
  exit(0);
}
 
static void HandleOptions( int argc, char ** argv)
{
  int opt ;
  int option_index = 0;
 
  while( (opt = getopt_long( argc, argv, "debug:help",
                             LongOptions, &option_index )) != EOF){
    switch( opt ) {
    case DEBUG_OPT:
      if ( strcmp( optarg, "LOW")==0){
        xsh_debug_level_set( XSH_DEBUG_LEVEL_LOW);
      }
      else if ( strcmp( optarg, "HIGH")==0){
        xsh_debug_level_set( XSH_DEBUG_LEVEL_HIGH);
      }
      break;
    case HELP_OPT:
      Help();
      break;
    default:
      break;
    }
  }
}
 
cpl_vector*
xsh_vector_supersample(cpl_vector* v, const int factor)
{
  cpl_vector* result=NULL;
  int size=cpl_vector_get_size(v);
  double* dv=NULL;
  double* dr=NULL;
  int size_new=size*factor;
  double dfactor=factor;
  int i=0,j=0;
  double m=0;
 
  xsh_msg("rk1 size_new=%d",size_new);
  result=cpl_vector_new(size_new);
  xsh_msg("rk2");
  dv=cpl_vector_get_data(v);
  xsh_msg("rk3");
  dr=cpl_vector_get_data(result);
  xsh_msg("rk4");
  xsh_msg("0-val=%g",dv[0]);
  xsh_msg("1-val=%g",dv[1]);
 
  for(i=0;i<size-1;i++) {
    m=(dv[i+1]-dv[i])/dfactor;
    //xsh_msg("ok1=%d dv[%d]=%g dv[%d]=%g",i,i+1,dv[i+1],i,dv[i]);
    for(j=0;j<factor;j++) {
      dr[i*factor+j]=dv[i]+m*j;
      //xsh_msg("ok2=%d dr=%g",j,dr[i*size+j]);
    }
  }
 
  return result;
}
/*---------------------------------------------------------------------------
                         Functions prototypes
 ---------------------------------------------------------------------------*/
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
int main( int argc, char** argv)
{
  /* Initialize libraries */
  TESTS_INIT( MODULE_ID);
  cpl_msg_set_level( CPL_MSG_DEBUG);
  xsh_debug_level_set( XSH_DEBUG_LEVEL_MEDIUM) ;
 
  HandleOptions( argc, argv);
 
  /* Analyse parameters */
  if ( (argc-optind) >= 2) {
    Help();
  }
 
  int ret=0;
  int size=100;
  int size_obs=0;
  int size_ref=0;
 
  double shift_i=5.15;
  double shift_o=0;
  double gauss_c=0.5*size;
  double gauss_s=10.;
  double* dobs=NULL;
  double* dref=NULL;
  const int file_size=256;
  char dir[file_size]; 
  char file_obs[file_size];
  char file_ref[file_size];
 
  sprintf(dir,"%s","/media/SCRATCH_BACKUP/data7/xsh/spr/RESPONSE_SLIT_NOD_UVB_GD71/");
  sprintf(file_obs,"%svof.fits",dir);
  sprintf(file_ref,"%svrf.fits",dir);
  xsh_msg("file_obs=%s",file_obs);
  xsh_msg("file_ref=%s",file_ref);
 
  cpl_vector* vobs=NULL;
  cpl_vector* vref=NULL;
  cpl_vector* vobs_res=NULL;
  cpl_vector* vref_res=NULL;
  check(vobs=cpl_vector_load(file_obs,0));
  check(vref=cpl_vector_load(file_ref,0));
  size_obs=cpl_vector_get_size(vobs);
  size_ref=cpl_vector_get_size(vref);
  int factor=1000;
  xsh_msg("ok1");
  dobs=cpl_vector_get_data(vobs);
  dref=cpl_vector_get_data(vref);
 
  xsh_msg("vk1");
  check(vobs_res=xsh_vector_supersample(vobs,factor));
  xsh_msg("vk2");
  check(vref_res=xsh_vector_supersample(vref,factor));
  xsh_msg("vk3");
 
 
 
 
  xsh_msg("ok1 size_obs=%d size_ref=%d",size_obs,size_ref);
 
  int len_corr=factor*(size_obs+size_ref)-5;
  xsh_msg("len_corr=%d",len_corr);
  /* CPL VECTOR */
  cpl_vector* correl=cpl_vector_new(len_corr);
 
 
  cpl_vector* filter=NULL;
  double radius=2;
  cpl_vector_save(vobs,"vobs.fits",CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_DEFAULT);
  cpl_vector_save(vref,"vref.fits",CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_DEFAULT);
 
  cpl_vector_save(vobs_res,"vobs_res.fits",CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_DEFAULT);
  cpl_vector_save(vref_res,"vref_res.fits",CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_DEFAULT);
 
  double shift=cpl_vector_correlate(correl,vobs_res,vref_res);
 
 
  filter=cpl_vector_new(size_obs);
  /*
  check(cpl_vector_fill_kernel_profile(filter,CPL_KERNEL_HAMMING,radius));
  cpl_vector_multiply(vobs,filter);
  cpl_vector_multiply(vref,filter);
  xsh_msg("ok3");
  cpl_vector_save(filter,"filter.fits",CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_DEFAULT);
  */
  xsh_msg("ok4");
  cpl_vector_save(vobs,"vobs_filt.fits",CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_DEFAULT);
  xsh_msg("ok5");
  cpl_vector_save(vref,"vref_filt.fits",CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_DEFAULT);
  xsh_msg("ok6");
 
  cpl_vector_save(correl,"correl.fits",CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_DEFAULT);
  xsh_msg("ok1");
  xsh_msg("shift=%g",shift);
  //cpl_vector_dump(correl,stdout);
  double max=0;
  int maxpos=0;
  double* pvec=NULL;
  /* get maxpos */
  pvec=cpl_vector_get_data(correl);
  max=-100;
  int i=0;
  for(i=0;i<len_corr;i++) {
    if(max<pvec[i] ) {
      max=pvec[i];
      maxpos=i;
    }
  }
  xsh_msg("maxpos my determination: %d",maxpos);
  xsh_msg("ok1");
 
  double a=0;
  double b=0;
  double c=0;
  double fraction=0;
  //maxpos +=1;
  a=cpl_vector_get(correl,maxpos-1);
  b=cpl_vector_get(correl,maxpos+1);
  c=cpl_vector_get(correl,maxpos);
  fraction=(a-b)/(2.*a+2.*b-4.*c);
  xsh_msg("len_corr=%d",len_corr);
  xsh_msg("a=%g b=%g c=%g fraction=%g",a,b,c,fraction);
  xsh_msg("shift - (size-1)=%g",shift -(size-1));
  xsh_msg("fraction shift - (size-1)=%g",
      (shift -(size*factor-1)+fraction)/factor);
  xsh_msg("ok1");
 
  
 cleanup: 
  xsh_free_vector(&vobs);
  xsh_free_vector(&vref);
  xsh_free_vector(&vobs_res);
  xsh_free_vector(&vref_res);
  xsh_free_vector(&correl);
  xsh_free_vector(&filter);
 
 
    if (cpl_error_get_code() != CPL_ERROR_NONE) {
      xsh_error_dump( CPL_MSG_ERROR);
      ret=1;
    } 
    TEST_END();
    return ret;
}