[u/mrichter/AliRoot.git] / T0 / AliT0CalibWalk.cxx

/**************************************************************************
 * 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>
#include <TF1.h>

ClassImp(AliT0CalibWalk)

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

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

}

//________________________________________________________________
AliT0CalibWalk::AliT0CalibWalk(const AliT0CalibWalk& calibda) :
  TNamed(calibda),		
  fWalk(0),
  fAmpLEDRec(0),
  fQTC(0),
  fAmpLED(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);

  //should be change to real
  Double_t xq[10] = { 1220, 1370, 1542, 1697, 1860, 2023,2171,2331,2495,2684};
  Double_t yq[10] = {1,2,3,4,5,6,7,8,9,10};
  TGraph* gr1 = new TGraph(10, xq, yq);
  fQTC.AddAtAndExpand(gr1,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);
  //should be change to real
  Double_t xq[10] = { 411, 412,413,415,417,419,422,428,437,452};
  Double_t yq[10] = {1,2,3,4,5,6,7,8,9,10};
  TGraph* gr1 = new TGraph(10, xq, yq);
  fAmpLED.AddAtAndExpand(gr1,ipmt);
  
}

//________________________________________________________________

void AliT0CalibWalk::MakeWalkCorrGraph(const char *laserFile)
{
  //make walk corerction for preprocessor
  Int_t nmips=14;
  gFile = TFile::Open(laserFile);
  if(!gFile) {
    AliError("No input laser data found ");
  }
  else
    {
      //      gFile->ls();

      Float_t x1[14], y1[14]; 
      Float_t x2[14], y2[14];
  
      Float_t mips[14] = {1.,2,3,4,5,6,7,8,9,10,20,30,40,50};
     
      Float_t xx1[14],yy1[14], xx[14];
      for (Int_t ii=0; ii<14; ii++)
	{      x1[ii]=0; y1[ii]=0; x2[ii]=0; y2[ii]=0; }
      
      
      TH2F*  hCFDvsQTC[24][14]; TH2F*  hCFDvsLED[24][14];
      
      for (Int_t i=0; i<24; i++)
	{
	  for (Int_t im=0; im<nmips; im++)
	    {	      
	      TString qtc = Form("CFDvsQTC%i_%i",i+1,im+1);
	      TString led = Form("CFDvsLED%i_%i",i+1,im+1);
	      hCFDvsQTC[i][im] = (TH2F*) gFile->Get(qtc.Data()) ;
	      hCFDvsLED[i][im] = (TH2F*) gFile->Get(led.Data());
	      
	      if(!hCFDvsQTC[i][im] || !hCFDvsLED[i][im]) 
	      	AliWarning(Form(" no walk correction data in LASER DA for channel %i for amplitude %f MIPs",i,mips[im]));
	      
	      Float_t qtc0 = hCFDvsQTC[i][0]->GetMean(2);	      
	      if(hCFDvsQTC[i][im])
		{	  
		  x1[im] = hCFDvsQTC[i][im]->GetMean(1);
		  y1[im] =  hCFDvsQTC[i][im]->GetMean(2) - qtc0;
		}
	      Float_t led0 = hCFDvsLED[i][0]->GetMean(2);
	      if( hCFDvsLED[i][im]){
		  x2[im] = hCFDvsLED[i][im]->GetMean(1);
		  y2[im] =  hCFDvsLED[i][im]->GetMean(2) - led0;
		}
	      xx[im]=mips[im];
	    }
	  for (Int_t imi=0; imi<nmips; imi++)
	    {
	      yy1[imi] = Float_t (mips[nmips-imi-1]);
	      xx1[imi] = x2[nmips-imi-1]; 
	    }
	  if(i==0) cout<<"Making graphs..."<<endl;
	  
	  TGraph *grwalkqtc = new TGraph (nmips,x1,y1);
	  TGraph *grwalkled = new TGraph (nmips,x2,y2);
	  fWalk.AddAtAndExpand(grwalkqtc,i);
	  fAmpLEDRec.AddAtAndExpand(grwalkled,i);
	 
	  //fit amplitude graphs to make comparison wth new one	  
	  TGraph *grampled = new TGraph (nmips,xx1,yy1);
	  TGraph *grqtc = new TGraph (nmips,x1,xx);
	  fQTC.AddAtAndExpand(grqtc,i);	 
	  fAmpLED.AddAtAndExpand(grampled,i);

	  //fit amplitude graphs
	  Double_t parled [2], parqtc[2];

	  TF1 *fuled = new TF1("fuled","expo",x1[0],x1[nmips]);
	  TF1 *fuqtc = new TF1 ("fuqtc","pol1",x1[0],x1[nmips]);
	  grqtc->Fit("fuqtc","Q"," ",x1[0],x1[nmips]);
	  grampled->Fit("fuled","Q"," ",xx1[0],xx1[nmips]);
	  fuled->GetParameters(&parled[0]);
	  fuqtc->GetParameters(&parqtc[0]);

	  for(Int_t ipar=0; ipar<2; ipar++) {
	    SetQTCpar(i,ipar,parqtc[ipar]);
	    SetAmpLEDpar(i,ipar,parled[ipar]);
	    //	    cout<<" pars :::: "<<i<<" "<<ipar<<" qtc "<<parqtc[ipar]<<" led "<<parled[ipar]<<endl;
	  }

	  if(i==23){
	    cout<<"Graphs created..."<<endl;
	  }
	}
    } //if gFile exits
}
Commit	Line	Data
a2ad8166	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
271b5bd3	15
a2ad8166	16	/* $Id$ */
	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// class T0 walk correction Alla Maevskaya alla@inr.ru 20.11.2007 //
	21	// //
	22	///////////////////////////////////////////////////////////////////////////////
	23
	24	#include "AliT0CalibWalk.h"
a2ad8166	25	#include "AliLog.h"
a2ad8166	26
	27	#include <TObjArray.h>
	28	#include <TGraph.h>
	29	#include <TFile.h>
a2ad8166	30	#include <TH2F.h>
	31	#include <TMath.h>
	32	#include <TSystem.h>
	33	#include <Riostream.h>
	34	#include <TSpectrum.h>
a2ad8166	35	#include <TProfile.h>
8f1790c4	36	#include <TF1.h>
a2ad8166	37
	38	ClassImp(AliT0CalibWalk)
	39
	40	//________________________________________________________________
	41	AliT0CalibWalk::AliT0CalibWalk(): TNamed(),
	42	fWalk(0),
c883fdf2	43	fAmpLEDRec(0),
	44	fQTC(0),
	45	fAmpLED(0)
a2ad8166	46	{
	47	//
	48	}
	49
	50	//________________________________________________________________
	51	AliT0CalibWalk::AliT0CalibWalk(const char* name):TNamed(),
	52	fWalk(0),
c883fdf2	53	fAmpLEDRec(0), fQTC(0),
	54	fAmpLED(0)
	55
a2ad8166	56	{
	57	TString namst = "Calib_";
	58	namst += name;
	59	SetName(namst.Data());
	60	SetTitle(namst.Data());
	61
	62	}
	63
	64	//________________________________________________________________
	65	AliT0CalibWalk::AliT0CalibWalk(const AliT0CalibWalk& calibda) :
	66	TNamed(calibda),
	67	fWalk(0),
c883fdf2	68	fAmpLEDRec(0),
	69	fQTC(0),
	70	fAmpLED(0)
	71
a2ad8166	72	{
	73	// copy constructor
	74	SetName(calibda.GetName());
	75	SetTitle(calibda.GetName());
	76
	77
	78	}
	79
	80	//________________________________________________________________
	81	AliT0CalibWalk &AliT0CalibWalk::operator =(const AliT0CalibWalk& calibda)
	82	{
	83	// assignment operator
	84	SetName(calibda.GetName());
	85	SetTitle(calibda.GetName());
	86
	87	return *this;
	88	}
	89
	90	//________________________________________________________________
	91	AliT0CalibWalk::~AliT0CalibWalk()
	92	{
	93	//
	94	}
	95	//________________________________________________________________
	96	void AliT0CalibWalk::SetWalk(Int_t ipmt)
	97	{
7576945f	98	//read QTC walk graph from external file
a2ad8166	99
	100	Int_t mv, ps;
	101	Int_t x[70000], y[70000], index[70000];
	102	Float_t time[10000],amplitude[10000];
	103	string buffer;
	104	Bool_t down=false;
	105
	106	const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/data/CFD-Amp.txt");
	107	ifstream inFile(filename);
	108	if(!inFile) AliError(Form("Cannot open file %s !",filename));
	109
	110	Int_t i=0;
	111	while(getline(inFile,buffer)){
	112	inFile >> ps >> mv;
	113
	114	x[i]=ps; y[i]=mv;
	115	i++;
	116	}
	117	inFile.close();
8f1790c4	118	// cout<<" number of data "<<i<<endl;
a2ad8166	119
	120	TMath::Sort(i, y, index,down);
	121	Int_t amp=0, iin=0, isum=0, sum=0;
	122	Int_t ind=0;
	123	for (Int_t ii=0; ii<i; ii++)
	124	{
	125	ind=index[ii];
	126	if(y[ind] == amp)
	127	{
	128	sum +=x[ind];
	129	iin++;
	130	}
	131	else
	132	{
	133	if(iin>0)
	134	time[isum] = Float_t (sum/(iin));
	135	else
	136	time[isum] =Float_t (x[ind]);
	137	amplitude[isum] = Float_t (amp);
	138	amp=y[ind];
	139	iin=0;
	140	isum++;
	141	sum=0;
	142	}
	143	}
	144
	145	inFile.close();
	146
	147	TGraph* gr = new TGraph(isum, amplitude, time);
	148	fWalk.AddAtAndExpand(gr,ipmt);
c883fdf2	149
	150	//should be change to real
	151	Double_t xq[10] = { 1220, 1370, 1542, 1697, 1860, 2023,2171,2331,2495,2684};
	152	Double_t yq[10] = {1,2,3,4,5,6,7,8,9,10};
	153	TGraph* gr1 = new TGraph(10, xq, yq);
	154	fQTC.AddAtAndExpand(gr1,ipmt);
a2ad8166	155	}
	156
	157	//________________________________________________________________
	158
	159	void AliT0CalibWalk::SetAmpLEDRec(Int_t ipmt)
	160	{
7576945f	161	// read LED walk from external file
a2ad8166	162	Float_t mv, ps;
	163	Float_t x[100], y[100];
	164	string buffer;
	165
	166	const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/data/CFD-LED.txt");
	167	ifstream inFile(filename);
	168	if(!inFile) {AliError(Form("Cannot open file %s !",filename));}
	169
	170	inFile >> mv>>ps;
	171	Int_t i=0;
	172
	173	while(getline(inFile,buffer)){
	174	x[i]=mv; y[i]=ps;
	175	inFile >> mv >> ps;
	176	i++;
	177	}
	178	inFile.close();
	179	Float_t y1[100], x1[100];
	180	for (Int_t ir=0; ir<i; ir++){
	181	y1[ir]=y[i-ir]; x1[ir]=x[i-ir];}
	182	TGraph* gr = new TGraph(i,y1,x1);
	183	fAmpLEDRec.AddAtAndExpand(gr,ipmt);
c883fdf2	184	//should be change to real
	185	Double_t xq[10] = { 411, 412,413,415,417,419,422,428,437,452};
	186	Double_t yq[10] = {1,2,3,4,5,6,7,8,9,10};
	187	TGraph* gr1 = new TGraph(10, xq, yq);
	188	fAmpLED.AddAtAndExpand(gr1,ipmt);
a2ad8166	189
	190	}
	191
	192	//________________________________________________________________
	193
	194	void AliT0CalibWalk::MakeWalkCorrGraph(const char *laserFile)
	195	{
7576945f	196	//make walk corerction for preprocessor
8f1790c4	197	Int_t nmips=14;
c2337900	198	gFile = TFile::Open(laserFile);
6318dd46	199	if(!gFile) {
	200	AliError("No input laser data found ");
	201	}
	202	else
	203	{
8f1790c4	204	// gFile->ls();
	205
	206	Float_t x1[14], y1[14];
	207	Float_t x2[14], y2[14];
	208
	209	Float_t mips[14] = {1.,2,3,4,5,6,7,8,9,10,20,30,40,50};
	210
	211	Float_t xx1[14],yy1[14], xx[14];
	212	for (Int_t ii=0; ii<14; ii++)
95f63b36	213	{ x1[ii]=0; y1[ii]=0; x2[ii]=0; y2[ii]=0; }
	214
	215
8f1790c4	216	TH2F* hCFDvsQTC[24][14]; TH2F* hCFDvsLED[24][14];
95f63b36	217
95f63b36	218	for (Int_t i=0; i<24; i++)
c883fdf2	219	{
8f1790c4	220	for (Int_t im=0; im<nmips; im++)
8f1790c4	221	{
95f63b36	222	TString qtc = Form("CFDvsQTC%i_%i",i+1,im+1);
95f63b36	223	TString led = Form("CFDvsLED%i_%i",i+1,im+1);
95f63b36	224	hCFDvsQTC[i][im] = (TH2F*) gFile->Get(qtc.Data()) ;
	225	hCFDvsLED[i][im] = (TH2F*) gFile->Get(led.Data());
	226
8f1790c4	227	if(!hCFDvsQTC[i][im] \|\| !hCFDvsLED[i][im])
8f1790c4	228	AliWarning(Form(" no walk correction data in LASER DA for channel %i for amplitude %f MIPs",i,mips[im]));
95f63b36	229
0c2f5b5a	230	Float_t qtc0 = hCFDvsQTC[i][0]->GetMean(2);
8f1790c4	231	if(hCFDvsQTC[i][im])
95f63b36	232	{
95f63b36	233	x1[im] = hCFDvsQTC[i][im]->GetMean(1);
0c2f5b5a	234	y1[im] = hCFDvsQTC[i][im]->GetMean(2) - qtc0;
8f1790c4	235	}
0c2f5b5a	236	Float_t led0 = hCFDvsLED[i][0]->GetMean(2);
8f1790c4	237	if( hCFDvsLED[i][im]){
95f63b36	238	x2[im] = hCFDvsLED[i][im]->GetMean(1);
0c2f5b5a	239	y2[im] = hCFDvsLED[i][im]->GetMean(2) - led0;
95f63b36	240	}
8f1790c4	241	xx[im]=mips[im];
e47b556f	242	}
8f1790c4	243	for (Int_t imi=0; imi<nmips; imi++)
95f63b36	244	{
8f1790c4	245	yy1[imi] = Float_t (mips[nmips-imi-1]);
8f1790c4	246	xx1[imi] = x2[nmips-imi-1];
95f63b36	247	}
8f1790c4	248	if(i==0) cout<<"Making graphs..."<<endl;
95f63b36	249
8f1790c4	250	TGraph *grwalkqtc = new TGraph (nmips,x1,y1);
	251	TGraph *grwalkled = new TGraph (nmips,x2,y2);
	252	fWalk.AddAtAndExpand(grwalkqtc,i);
	253	fAmpLEDRec.AddAtAndExpand(grwalkled,i);
	254
	255	//fit amplitude graphs to make comparison wth new one
	256	TGraph *grampled = new TGraph (nmips,xx1,yy1);
	257	TGraph *grqtc = new TGraph (nmips,x1,xx);
	258	fQTC.AddAtAndExpand(grqtc,i);
	259	fAmpLED.AddAtAndExpand(grampled,i);
	260
	261	//fit amplitude graphs
	262	Double_t parled [2], parqtc[2];
	263
	264	TF1 *fuled = new TF1("fuled","expo",x1[0],x1[nmips]);
	265	TF1 *fuqtc = new TF1 ("fuqtc","pol1",x1[0],x1[nmips]);
	266	grqtc->Fit("fuqtc","Q"," ",x1[0],x1[nmips]);
	267	grampled->Fit("fuled","Q"," ",xx1[0],xx1[nmips]);
	268	fuled->GetParameters(&parled[0]);
	269	fuqtc->GetParameters(&parqtc[0]);
	270
	271	for(Int_t ipar=0; ipar<2; ipar++) {
	272	SetQTCpar(i,ipar,parqtc[ipar]);
	273	SetAmpLEDpar(i,ipar,parled[ipar]);
	274	// cout<<" pars :::: "<<i<<" "<<ipar<<" qtc "<<parqtc[ipar]<<" led "<<parled[ipar]<<endl;
	275	}
	276
95f63b36	277	if(i==23){
	278	cout<<"Graphs created..."<<endl;
	279	}
271b5bd3	280	}
6318dd46	281	} //if gFile exits
a2ad8166	282	}
a2ad8166	283
c883fdf2	284
	285
	286