test-xsh_response_fit_bspline.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: 2013-05-14 09:55:30 $
 * $Revision: 1.3 $
 */
 
#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------
  Includes
  --------------------------------------------------------------------------*/
 
#include <tests.h>
 
#include <xsh_error.h>
#include <xsh_msg.h>
#include <xsh_efficiency_response.h>
#include <xsh_data_instrument.h>
 
/*
#include <xsh_data_pre.h>
#include <xsh_data_rec.h>
#include <xsh_data_localization.h>
#include <xsh_drl.h>
#include <xsh_pfits.h>
#include <xsh_utils.h>
 
#include <xsh_badpixelmap.h>
#include <getopt.h>
*/
#include <cpl.h>
 
 
#include <stdio.h> 
#include <stdlib.h>
#include <math.h>
#include <gsl/gsl_bspline.h>
#include <gsl/gsl_multifit.h>
#include <gsl/gsl_rng.h>
#include <gsl/gsl_randist.h>
#include <gsl/gsl_statistics.h>
 
/*--------------------------------------------------------------------------
  Defines
  --------------------------------------------------------------------------*/
 
#define MODULE_ID "XSH_RESPONSE_FIT_BSPLINE"
 
/* number of data points to fit */
#define N 200
 
/* number of fit coefficients */
#define NCOEFFS 12 // UVB 21 VIS 12 NIR 12
 
#define ORDER 6
 
/* nbreak = ncoeffs +2 -ORDER = ncoeffs -2 since ORDER = 4 */
#define NBREAK (NCOEFFS +2 -ORDER)
 
int main( int argc, char **argv)
{
  /* Declarations */
  int ret =0;
 
 
  size_t n = N;
  const size_t ncoeffs = NCOEFFS;
  const size_t nbreak = NBREAK;
  size_t i, j;
  gsl_bspline_workspace *bw;
  gsl_vector *B;
  double dy;
  gsl_rng *r;
  gsl_vector *c, *w;
  gsl_vector *x, *y;
  gsl_matrix *X, *cov;
  gsl_multifit_linear_workspace *mw;
  double chisq, Rsq, dof, tss;
  float* wave=NULL;
  float* response=NULL;
  double* pwav=NULL;
  double* pfit=NULL;
  int kh=0;
  double dump_factor=1.e10;
  cpl_table* tab_response=NULL;
  cpl_table* tab_resp_fit=NULL;
  HIGH_ABS_REGION * phigh;
  xsh_instrument* inst=NULL;
  const char* dir_uvb="/data3/xsh/spr/data_xsh_respon_slit_nod_uvb.sof/";
  const char* dir_vis="/data3/xsh/spr/data_xsh_respon_slit_nod_vis.sof/";
  const char* dir_nir="/data3/xsh/spr/data_xsh_respon_slit_nod_nir.sof/";
 
  char fname[256];
  const int activate=0;
  TESTS_INIT_WORKSPACE(MODULE_ID);
  TESTS_INIT(MODULE_ID);
 
  cpl_ensure(activate > 0, CPL_ERROR_ILLEGAL_INPUT,NULL);
  XSH_ASSURE_NOT_NULL_MSG(fname,"Null input response");
  /* Initialize libraries */
 
  inst = xsh_instrument_new();
  xsh_instrument_set_arm(inst, XSH_ARM_NIR);
 
  if( xsh_instrument_get_arm(inst) == XSH_ARM_UVB){
    sprintf(fname,"%sresponse_smooth.fits",dir_uvb);
  }
  else if( xsh_instrument_get_arm(inst) == XSH_ARM_VIS){
    sprintf(fname,"%sresponse_smooth.fits",dir_vis);
  }
  else if( xsh_instrument_get_arm(inst) == XSH_ARM_NIR){
    sprintf(fname,"%sresponse_smooth.fits",dir_nir);
  }
 
  XSH_MALLOC( inst->config, XSH_INSTRCONFIG, 1);
  phigh=xsh_fill_high_abs_regions(inst,NULL);
 
  tab_response=cpl_table_load(fname,1,0);
 
  n=cpl_table_get_nrow(tab_response);
  wave=cpl_table_get_data_float(tab_response,"LAMBDA");
  response=cpl_table_get_data_float(tab_response,"FLUX");
 
  /*
  for (i = 0; i < n; ++i) {
    xsh_msg("wave=%g resp=%g",wave[i],response[i]);
  }
  */
  gsl_rng_env_setup();
  r = gsl_rng_alloc(gsl_rng_default);
 
  /* allocate a cubic bspline workspace (ORDER = 4) */
  bw = gsl_bspline_alloc(ORDER, nbreak);
  B = gsl_vector_alloc(ncoeffs);
  x = gsl_vector_alloc(n);
  y = gsl_vector_alloc(n);
  X = gsl_matrix_alloc(n, ncoeffs);
  c = gsl_vector_alloc(ncoeffs);
  w = gsl_vector_alloc(n);
  cov = gsl_matrix_alloc(ncoeffs, ncoeffs);
  mw = gsl_multifit_linear_alloc(n, ncoeffs);
 
  printf("#m=0,S=0\n");
  /* this is the data to be fitted */
  for (i = 0; i < n; ++i)
    {
      double sigma;
      double xi = (double)wave[i];
      double yi = (double)response[i];
 
      sigma = 0.1 * yi;
      dy = gsl_ran_gaussian(r, sigma);
      yi += dy;
 
      gsl_vector_set(x, i, xi);
      gsl_vector_set(y, i, yi);
      gsl_vector_set(w, i, 1.0 / (sigma * sigma));
 
      //printf("%f %g\n", xi, yi);
    }
 
  if ( phigh != NULL ) {
 
      xsh_msg("Flag High Absorption Regions" ) ;
      for( kh = 0 ; phigh->lambda_min != 0. ; phigh++ ) {
    for( i = 0 ; i < n ; i++ ) {
      if( wave[i] >= phigh->lambda_min && 
              wave[i] <= phigh->lambda_max ) {
        gsl_vector_set(w, i, gsl_vector_get(w,i)/dump_factor );
      }
    }
      }
  }
 
  /* use uniform breakpoints on [0, 15] */
  gsl_bspline_knots_uniform(wave[0], wave[n-1], bw);
 
  /* construct the fit matrix X */
  for (i = 0; i < n; ++i)
    {
      double xi = gsl_vector_get(x, i);
 
      /* compute B_j(xi) for all j */
      gsl_bspline_eval(xi, B, bw);
 
      /* fill in row i of X */
      for (j = 0; j < ncoeffs; ++j)
        {
          double Bj = gsl_vector_get(B, j);
          gsl_matrix_set(X, i, j, Bj);
        }
    }
 
  /* do the fit */
  gsl_multifit_wlinear(X, w, y, c, cov, &chisq, mw);
 
  dof = n - ncoeffs;
  tss = gsl_stats_wtss(w->data, 1, y->data, 1, y->size);
  Rsq = 1.0 - chisq / tss;
 
  fprintf(stderr, "chisq/dof = %e, Rsq = %f\n", 
                   chisq / dof, Rsq);
 
  tab_resp_fit=cpl_table_new(n);
  cpl_table_new_column(tab_resp_fit, "wave", CPL_TYPE_DOUBLE); 
  cpl_table_new_column(tab_resp_fit, "fit", CPL_TYPE_DOUBLE);
  cpl_table_fill_column_window_double(tab_resp_fit,"wave",0,n,0);
  cpl_table_fill_column_window_double(tab_resp_fit,"fit",0,n,0);
  pwav=cpl_table_get_data_double(tab_resp_fit,"wave");
  pfit=cpl_table_get_data_double(tab_resp_fit,"fit");
 
  /* output the smoothed curve */
  {
    double xi, yi, yerr;
    printf("#m=1,S=0\n");
    for (i = 0; i < n; i ++)
      {
        xi=(double)wave[i];
        gsl_bspline_eval(xi, B, bw);
        gsl_multifit_linear_est(B, c, cov, &yi, &yerr);
        //printf("%f %g\n", xi, yi);
        pwav[i]=xi;
        pfit[i]=yi;
      }
  }
  cpl_table_save(tab_resp_fit,NULL,NULL,"resp_fit.fits",CPL_IO_DEFAULT);
 
  gsl_rng_free(r);
  gsl_bspline_free(bw);
  gsl_vector_free(B);
  gsl_vector_free(x);
  gsl_vector_free(y);
  gsl_matrix_free(X);
  gsl_vector_free(c);
  gsl_vector_free(w);
  gsl_matrix_free(cov);
  gsl_multifit_linear_free(mw);
  xsh_free_table(&tab_response);
  xsh_free_table(&tab_resp_fit);
  xsh_instrument_free(&inst);
 
  cleanup:
 
    if (cpl_error_get_code() != CPL_ERROR_NONE) {
      xsh_error_dump(CPL_MSG_ERROR);
      ret= 1;
    }
    TESTS_CLEAN_WORKSPACE(MODULE_ID);
    TEST_END();
    return ret ;
}