/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// class T0 walk correction      Alla Maevskaya alla@inr.ru 20.11.2007        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "AliT0CalibWalk.h"
#include "AliLog.h"

#include <TObjArray.h>
#include <TGraph.h>
#include <TFile.h>
#include <TH2F.h> 
#include <TMath.h>
#include <TSystem.h>
#include <Riostream.h>
#include <TSpectrum.h>
#include <TProfile.h>


ClassImp(AliT0CalibWalk)

//________________________________________________________________
  AliT0CalibWalk::AliT0CalibWalk():   TNamed(),
				      fWalk(0),
				      fAmpLEDRec(0)
{
  //
}

//________________________________________________________________
AliT0CalibWalk::AliT0CalibWalk(const char* name):TNamed(),
				      fWalk(0),
				      fAmpLEDRec(0)				      
{
  TString namst = "Calib_";
  namst += name;
  SetName(namst.Data());
  SetTitle(namst.Data());

}

//________________________________________________________________
AliT0CalibWalk::AliT0CalibWalk(const AliT0CalibWalk& calibda) :
  TNamed(calibda),		
  fWalk(0),
  fAmpLEDRec(0)

{
// copy constructor
  SetName(calibda.GetName());
  SetTitle(calibda.GetName());


}

//________________________________________________________________
AliT0CalibWalk &AliT0CalibWalk::operator =(const AliT0CalibWalk& calibda)
{
// assignment operator
  SetName(calibda.GetName());
  SetTitle(calibda.GetName());
 
  return *this;
}

//________________________________________________________________
AliT0CalibWalk::~AliT0CalibWalk()
{
  //
}
//________________________________________________________________
void AliT0CalibWalk::SetWalk(Int_t ipmt)
{
  //read QTC walk graph from external file

  Int_t mv, ps; 
  Int_t x[70000], y[70000], index[70000];
  Float_t time[10000],amplitude[10000];
  string buffer;
  Bool_t down=false;
  
  const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/data/CFD-Amp.txt");
  ifstream inFile(filename);
  if(!inFile) AliError(Form("Cannot open file %s !",filename));
  
  Int_t i=0;
  while(getline(inFile,buffer)){
    inFile >> ps >> mv;

    x[i]=ps; y[i]=mv;
    i++;
  }
  inFile.close();
  cout<<" number of data "<<i<<endl;
 
  TMath::Sort(i, y, index,down);
  Int_t amp=0, iin=0, isum=0, sum=0;
  Int_t ind=0;
  for (Int_t ii=0; ii<i; ii++)
    {
      ind=index[ii];
      if(y[ind] == amp)
	{
	  sum +=x[ind];
	  iin++;
	}
      else
	{
	  if(iin>0)
	    time[isum] = Float_t (sum/(iin));
	  else
	    time[isum] =Float_t (x[ind]);
	  amplitude[isum] = Float_t (amp);
	  amp=y[ind];
	  iin=0;
	  isum++;
	  sum=0;
	}
    }

  inFile.close();

  TGraph* gr = new TGraph(isum, amplitude, time);
  fWalk.AddAtAndExpand(gr,ipmt);
}

//________________________________________________________________

void AliT0CalibWalk::SetAmpLEDRec(Int_t ipmt)
{
  // read LED walk from external file
  Float_t mv, ps; 
  Float_t x[100], y[100];
  string buffer;
  
  const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/data/CFD-LED.txt");
   ifstream inFile(filename);
  if(!inFile) {AliError(Form("Cannot open file %s !",filename));}
  
  inFile >> mv>>ps;
  Int_t i=0;
  
  while(getline(inFile,buffer)){
    x[i]=mv; y[i]=ps;	
    inFile >> mv >> ps;
    i++;
  }
  inFile.close();
  Float_t y1[100], x1[100];
  for (Int_t ir=0; ir<i; ir++){
    y1[ir]=y[i-ir]; x1[ir]=x[i-ir];}
  TGraph* gr = new TGraph(i,y1,x1);
  fAmpLEDRec.AddAtAndExpand(gr,ipmt);
  
}

//________________________________________________________________

void AliT0CalibWalk::MakeWalkCorrGraph(const char *laserFile)
{
  //make walk corerction for preprocessor

  TFile *gFile = TFile::Open(laserFile);
 
  Int_t npeaks = 20;
  Double_t sigma=3.;
  Bool_t down = false;
 
  Int_t index[20];
  Char_t buf1[20], buf2[20],buf3[20];
  
  
  for (Int_t i=0; i<24; i++)
    {
      if(i>11)	{  sprintf(buf1,"T0_A_%i_CFD",i+1-12); }

      if(i<12)	{ sprintf(buf1,"T0_C_%i_CFD",i+1); }

      sprintf(buf2,"CFDvsQTC%i",i+1);
      sprintf(buf3,"CFDvsLED%i",i+1);
      // cout<<buf1<<" "<<buf2<<" "<<buf3<<endl;
      TH2F *qtcVScfd = (TH2F*) gFile->Get(buf2);
      //	qtcVScfd->Print();
      TH2F *ledVScfd = (TH2F*) gFile->Get(buf3);
      TH1F *cfd = (TH1F*) gFile->Get(buf1);
         
      TSpectrum *s = new TSpectrum(2*npeaks,1);
      Int_t nfound = s->Search(cfd,sigma,"goff",0.1);
      //      cout<<"Found "<<nfound<<" peaks sigma "<<sigma<<endl;;
       if(nfound!=0){
	Float_t *xpeak = s->GetPositionX();
  	TMath::Sort(nfound, xpeak, index,down);
  	Float_t xp = xpeak[index[0]];
	Int_t xbin = cfd->GetXaxis()->FindBin(xp);
	Float_t yp = cfd->GetBinContent(xbin);
	//	cout<<"xbin = "<<xbin<<"\txpeak = "<<xpeak[1]<<"\typeak = "<<yp<<endl;
	Float_t hmax = xp+20*sigma;
	Float_t hmin = xp-20*sigma;
      }
	//QTC
	Int_t nbins= qtcVScfd->GetXaxis()->GetNbins();
	TProfile *prY = qtcVScfd->ProfileX();
	Float_t	hmin = qtcVScfd->GetYaxis()->GetXmin();
	Float_t	hmax = qtcVScfd->GetYaxis()->GetXmax();
	prY->SetMaximum(hmax);
	prY->SetMinimum(hmin);
	Int_t np=0; //=nbins/5;
	Double_t *xx = new Double_t[nbins];
	Double_t *yy = new Double_t[nbins];
	Int_t ng=0;
	Double_t yg=0;
	for (Int_t ip=1; ip<nbins; ip++)
	  {
	    
	    if(ip%5 != 0 )
	      {
	      //	      if (prY->GetBinContent(ip) !=0)
		if (prY->GetBinContent(ip) >hmin && prY->GetBinContent(ip)<hmax){
		yg +=prY->GetBinContent(ip);
		ng++;
		//	cout<<" ip "<<ip<<" Y "<<yg<<endl;
			  }
	    }
	    else {
	      if (/*prY->GetBinContent(ip) >hmin && prY->GetBinContent(ip)<hmax &&*/ ng>0){
		//		xx[ip/5] = Float_t (prY->GetBinCenter(ip));
		//	yy[ip/5] = yg/ng;
		xx[np] = Float_t (prY->GetBinCenter(ip));
		yy[np] = yg/ng;
		yg=0;
		ng=0;
		//	cout<<" ip "<<ip<<" np "<<np<<" XX "<<xx[np]<<" YY "<<yy[np]<<endl;
		np++;
	      }
	    }
	  }
	  
	TGraph *gr = new TGraph(np,xx,yy);
	gr->SetMinimum(hmin);
	gr->SetMaximum(hmax);
	fWalk.AddAtAndExpand(gr,i);	  

	//LED
	Int_t nbinsled= ledVScfd->GetXaxis()->GetNbins();
	cout<<" nbins led "<<nbinsled<<endl;
	TProfile *prledY = ledVScfd->ProfileX();
	
	Int_t npled = 0; //nbinsled/5;
	Double_t *xxled = new Double_t[nbinsled];
	Double_t *yyled = new Double_t[nbinsled];
	Int_t ngled=0;
	Double_t ygled=0;
	for (Int_t ip=1; ip<nbinsled; ip++)
	  {
	    if(ip%5 != 0 ) {
	      if (prledY->GetBinContent(ip) !=0)
		ygled +=prledY->GetBinContent(ip);
	      ngled++;}
	    else {
	      xxled[npled] = Float_t (prledY->GetBinCenter(ip));
	      yyled[npled] = ygled/ngled;
	      ygled=0;
	      ngled=0;
	      npled++;
	    }
	  }
        
 	TGraph *grled = new TGraph(npled,xxled,yyled);
	grled->SetMinimum(hmin);
	grled->SetMaximum(hmax);
	fAmpLEDRec.AddAtAndExpand(grled,i);	  

 	delete [] xx;
	delete [] yy;
	delete [] xxled;
	delete [] yyled;
	delete prY;
	delete prledY;
	
	// }
      delete cfd;
      delete qtcVScfd;
      delete ledVScfd;
    }
  
}