[u/mrichter/AliRoot.git] / T0 / AliT0Parameters.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:  */

//____________________________________________________________________
//                                                                          
// T0 - T0. 
//
// This class is a singleton that handles various parameters of
// the T0 detectors.  
// Eventually, this class will use the Conditions DB to get the
// various parameters, which code can then request from here.
//                                                       
#include "AliLog.h"		  
#include "AliT0Parameters.h"	  
#include "AliT0CalibData.h"   
#include "AliT0LookUpValue.h"
#include <AliCDBManager.h>        
#include <AliCDBEntry.h>          
#include <AliCDBStorage.h>  
#include <TMath.h>        
#include <Riostream.h>

AliT0CalibData* AliT0Parameters::fgCalibData = 0;
AliT0CalibData* AliT0Parameters::fgLookUp = 0;
AliT0CalibData* AliT0Parameters::fgSlewCorr =0;
//====================================================================
ClassImp(AliT0Parameters)
#if 0
  ; // This is here to keep Emacs for indenting the next line
#endif

//____________________________________________________________________
AliT0Parameters* AliT0Parameters::fgInstance = 0;
//____________________________________________________________________
AliT0Parameters* 
AliT0Parameters::Instance() 
{
  // Get static instance 
  if (!fgInstance) fgInstance = new AliT0Parameters;
  return fgInstance;
}

//____________________________________________________________________
AliT0Parameters::AliT0Parameters()
  :fIsInit(kFALSE),fPh2Mip(0),fmV2Mip(0),fChannelWidth(0),fmV2Channel(0),fQTmin(0),fQTmax(0),fSlewingLED(),fSlewingRec(),fPMTeff(),fTimeDelayLED(0),fTimeDelayCFD(0),fTimeDelayTVD(0),fCalibentry(), fLookUpentry(),fSlewCorr()
{
  // Default constructor 

  for (Int_t ipmt=0; ipmt<24; ipmt++)
    {
      SetSlewingLED(ipmt);
      SetSlewingRec(ipmt);
      SetWalk(ipmt);
      SetPh2Mip();      
      SetmV2Mip();      
      SetChannelWidth();
      SetmV2channel();
      SetQTmin();
      SetQTmax();
      SetPMTeff(ipmt);

   }
  SetTimeDelayTVD();
  SetZposition();
  
}

//__________________________________________________________________
void
AliT0Parameters::Init()
{
  // Initialize the parameters manager.  We need to get stuff from the
  // CDB here. 
  //   if (fIsInit) return;
  
  // AliCDBManager* cdb      = AliCDBManager::Instance();
  // fCalibentry  = cdb->Get("T0/Calib/Gain_TimeDelay_Slewing_Walk");
 

  AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
  //time equalizing
  AliCDBEntry* fCalibentry  = stor->Get("T0/Calib/TimeDelay",0);
 if (fCalibentry){
   fgCalibData  = (AliT0CalibData*)fCalibentry->GetObject();
  }
 else 
   { AliError(" ALARM !!!! No time delays in CDB "); }
 //slewing correction
  AliCDBEntry* fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk",0);
 if (fSlewCorr){
   fgSlewCorr  = (AliT0CalibData*)fSlewCorr->GetObject();
  }
 // fLookUpentry  = cdb->Get("T0/Calib/LookUp_Table");
  fLookUpentry  = stor->Get("T0/Calib/LookUp_Table",0);
  if (fLookUpentry){
    fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
    //   fgLookUp->Dump();
  }
  else {
    fgLookUp->ReadAsciiLookup("$ALICE_ROOT/T0/lookUpTable.txt");
  }

  fIsInit = kTRUE;
}


//__________________________________________________________________
Float_t
AliT0Parameters::GetTimeDelayLED(Int_t ipmt) 
{
  // return time delay for LED channel
  // 
  if (!fCalibentry) {
    fTimeDelayLED = 0;
    return  fTimeDelayLED;
  } 
  return fgCalibData ->GetTimeDelayLED(ipmt);
}
//__________________________________________________________________
Float_t
AliT0Parameters::GetTimeDelayCFD(Int_t ipmt) 
{
  // return time delay for CFD channel
   // 
  if (!fCalibentry) 
    {
      fTimeDelayCFD = 1000+ipmt*100;
      return fTimeDelayCFD;
    }
   
  return fgCalibData->GetTimeDelayCFD(ipmt);
}

//__________________________________________________________________

void 
AliT0Parameters::SetSlewingLED(Int_t ipmt)
{
  //  Set Slweing Correction for LED channel 
     Float_t mv[23] = {25, 30,40,60, 80,100,150,200,250,300,
		       400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
		       6000, 7000,8000};
      Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
		       1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
		       156, 78, 0};
      
      TGraph* gr = new TGraph(23,mv,y);
      fSlewingLED.AddAtAndExpand(gr,ipmt);
  }
//__________________________________________________________________

Float_t AliT0Parameters::GetSlewingLED(Int_t ipmt, Float_t mv) const
{
  if (!fCalibentry) {
    return ((TGraph*)fSlewingLED.At(ipmt))->Eval(mv); 
  } 
  return fgCalibData->GetSlewingLED(ipmt, mv) ;
}


//__________________________________________________________________

TGraph *AliT0Parameters::GetSlew(Int_t ipmt) const
{
  if (!fCalibentry) {
    return  (TGraph*)fSlewingLED.At(ipmt); 
  } 
  return fgCalibData -> GetSlew(ipmt) ;
}

//__________________________________________________________________


void 
AliT0Parameters::SetSlewingRec(Int_t ipmt)
{
  //  Set Slweing Correction for LED channel 
      Float_t mv[23] = {25, 30, 40,60, 80,100,150,200,250,300,
			400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
			6000, 7000,8000};
      Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781, 
		       1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234, 
		       156, 78, 0};
      Float_t y1[23], mv1[23];
      for (Int_t i=0; i<23; i++){
	y1[i] = y[22-i]; mv1[i] = mv[22-i];}

      TGraph* gr = new TGraph(23,y1,mv1);
      fSlewingRec.AddAtAndExpand(gr,ipmt);

}
//__________________________________________________________________

Float_t AliT0Parameters::GetSlewingRec(Int_t ipmt, Float_t mv) const
{
  if (!fCalibentry) {
    return ((TGraph*)fSlewingRec.At(ipmt))->Eval(mv); 
  } 
  return fgCalibData -> GetSlewingRec(ipmt, mv) ;
}

//__________________________________________________________________

TGraph *AliT0Parameters::GetSlewRec(Int_t ipmt) const
{
  if (!fCalibentry) {
    return  (TGraph*)fSlewingRec.At(ipmt); 
  } 
  return fgCalibData -> GetSlewRec(ipmt) ;
}


//________________________________________________________________
void AliT0Parameters::SetWalk(Int_t ipmt)
{

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

    x[i]=ps; y[i]=mv;
    i++;
  }
  inFile.close();
 
  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<70000; 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];
	  //	  cout<<ii<<" "<<ind<<" "<<y[ind]<<" "<<x[ind]<<" iin "<<iin<<" mean "<<time[isum]<<" amp "<< amplitude[isum]<<" "<<isum<<endl;
	  iin=0;
	  isum++;
	  sum=0;
	}


    }

  inFile.close();

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

TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
{
  if (!fCalibentry) {
    return  (TGraph*)fWalk.At(ipmt); 
  } 
  return fgCalibData -> GetWalk(ipmt) ;
}

//__________________________________________________________________

Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
{
  if (!fCalibentry) {
    return ((TGraph*)fWalk.At(ipmt))->Eval(mv); 
  } 
  return fgCalibData -> GetWalkVal(ipmt, mv) ;
}

//__________________________________________________________________

//__________________________________________________________________
void 
AliT0Parameters::SetPMTeff(Int_t ipmt)
{
  Float_t lambda[50];
  Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913, 
		    0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
		    0.252276, 0.256267,0.26,     0.27125,  0.281818,
		    0.288118, 0.294057,0.296222, 0.301622, 0.290421, 
		    0.276615, 0.2666,  0.248,    0.23619,  0.227814, 
		    0.219818, 0.206667,0.194087, 0.184681, 0.167917, 
		    0.154367, 0.1364,  0.109412, 0.0834615,0.0725283, 
		    0.0642963,0.05861, 0.0465,   0.0413333,0.032069, 
		    0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
		    0.003875, 0.00190, 0,        0,        0          } ;
  for (Int_t i=0; i<50; i++) lambda[i]=200+10*i; 

  TGraph* gr = new TGraph(50,lambda,eff);
  fPMTeff.AddAtAndExpand(gr,ipmt);
}
//________________________________________________________________

Int_t 
AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
{

  
  AliT0LookUpKey * lookkey;  //= new AliT0LookUpKey();
  AliT0LookUpValue * lookvalue= new AliT0LookUpValue(trm,tdc,chain,channel);
    
   lookkey = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)lookvalue);
  if (!lookkey ) {
    cout<<" no such address "<<endl; return -1;
  }
  

  //cout<<"AliT0Parameters:: key "<<lookkey->GetKey()<<endl;
  return lookkey->GetKey();
  

}
Commit	Line	Data
dc7ca31d	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	**************************************************************************/
	15
	16	/* $Id: */
	17
	18	//____________________________________________________________________
	19	//
	20	// T0 - T0.
	21	//
	22	// This class is a singleton that handles various parameters of
	23	// the T0 detectors.
	24	// Eventually, this class will use the Conditions DB to get the
	25	// various parameters, which code can then request from here.
	26	//
	27	#include "AliLog.h"
	28	#include "AliT0Parameters.h"
	29	#include "AliT0CalibData.h"
e0bba6cc	30	#include "AliT0LookUpValue.h"
dc7ca31d	31	#include <AliCDBManager.h>
dc7ca31d	32	#include <AliCDBEntry.h>
7d95281b	33	#include <AliCDBStorage.h>
7d95281b	34	#include <TMath.h>
dc7ca31d	35	#include <Riostream.h>
	36
	37	AliT0CalibData* AliT0Parameters::fgCalibData = 0;
e0bba6cc	38	AliT0CalibData* AliT0Parameters::fgLookUp = 0;
c41ceaac	39	AliT0CalibData* AliT0Parameters::fgSlewCorr =0;
dc7ca31d	40	//====================================================================
	41	ClassImp(AliT0Parameters)
	42	#if 0
	43	; // This is here to keep Emacs for indenting the next line
	44	#endif
	45
	46	//____________________________________________________________________
	47	AliT0Parameters* AliT0Parameters::fgInstance = 0;
	48	//____________________________________________________________________
	49	AliT0Parameters*
	50	AliT0Parameters::Instance()
	51	{
	52	// Get static instance
	53	if (!fgInstance) fgInstance = new AliT0Parameters;
	54	return fgInstance;
	55	}
	56
	57	//____________________________________________________________________
	58	AliT0Parameters::AliT0Parameters()
c41ceaac	59	:fIsInit(kFALSE),fPh2Mip(0),fmV2Mip(0),fChannelWidth(0),fmV2Channel(0),fQTmin(0),fQTmax(0),fSlewingLED(),fSlewingRec(),fPMTeff(),fTimeDelayLED(0),fTimeDelayCFD(0),fTimeDelayTVD(0),fCalibentry(), fLookUpentry(),fSlewCorr()
dc7ca31d	60	{
	61	// Default constructor
	62
	63	for (Int_t ipmt=0; ipmt<24; ipmt++)
	64	{
dc7ca31d	65	SetSlewingLED(ipmt);
dc7ca31d	66	SetSlewingRec(ipmt);
c41ceaac	67	SetWalk(ipmt);
dc7ca31d	68	SetPh2Mip();
	69	SetmV2Mip();
	70	SetChannelWidth();
	71	SetmV2channel();
dc7ca31d	72	SetQTmin();
	73	SetQTmax();
	74	SetPMTeff(ipmt);
c41ceaac	75
dc7ca31d	76	}
	77	SetTimeDelayTVD();
	78	SetZposition();
	79
	80	}
	81
	82	//__________________________________________________________________
	83	void
	84	AliT0Parameters::Init()
	85	{
	86	// Initialize the parameters manager. We need to get stuff from the
	87	// CDB here.
	88	// if (fIsInit) return;
	89
6ba20b30	90	// AliCDBManager* cdb = AliCDBManager::Instance();
	91	// fCalibentry = cdb->Get("T0/Calib/Gain_TimeDelay_Slewing_Walk");
	92
	93
	94	AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
c41ceaac	95	//time equalizing
c41ceaac	96	AliCDBEntry* fCalibentry = stor->Get("T0/Calib/TimeDelay",0);
6ba20b30	97	if (fCalibentry){
dc7ca31d	98	fgCalibData = (AliT0CalibData*)fCalibentry->GetObject();
dc7ca31d	99	}
c41ceaac	100	else
	101	{ AliError(" ALARM !!!! No time delays in CDB "); }
	102	//slewing correction
	103	AliCDBEntry* fSlewCorr = stor->Get("T0/Calib/Slewing_Walk",0);
	104	if (fSlewCorr){
	105	fgSlewCorr = (AliT0CalibData*)fSlewCorr->GetObject();
	106	}
6ba20b30	107	// fLookUpentry = cdb->Get("T0/Calib/LookUp_Table");
6ba20b30	108	fLookUpentry = stor->Get("T0/Calib/LookUp_Table",0);
e0bba6cc	109	if (fLookUpentry){
	110	fgLookUp = (AliT0CalibData*)fLookUpentry->GetObject();
	111	// fgLookUp->Dump();
	112	}
	113	else {
	114	fgLookUp->ReadAsciiLookup("$ALICE_ROOT/T0/lookUpTable.txt");
	115	}
dc7ca31d	116
	117	fIsInit = kTRUE;
	118	}
	119
	120
dc7ca31d	121	//__________________________________________________________________
	122	Float_t
	123	AliT0Parameters::GetTimeDelayLED(Int_t ipmt)
	124	{
	125	// return time delay for LED channel
	126	//
	127	if (!fCalibentry) {
c41ceaac	128	fTimeDelayLED = 0;
dc7ca31d	129	return fTimeDelayLED;
	130	}
	131	return fgCalibData ->GetTimeDelayLED(ipmt);
	132	}
	133	//__________________________________________________________________
	134	Float_t
	135	AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
	136	{
	137	// return time delay for CFD channel
	138	//
	139	if (!fCalibentry)
	140	{
c41ceaac	141	fTimeDelayCFD = 1000+ipmt*100;
c41ceaac	142	return fTimeDelayCFD;
dc7ca31d	143	}
	144
	145	return fgCalibData->GetTimeDelayCFD(ipmt);
	146	}
	147
	148	//__________________________________________________________________
	149
	150	void
	151	AliT0Parameters::SetSlewingLED(Int_t ipmt)
	152	{
	153	// Set Slweing Correction for LED channel
	154	Float_t mv[23] = {25, 30,40,60, 80,100,150,200,250,300,
	155	400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
	156	6000, 7000,8000};
	157	Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
	158	1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
	159	156, 78, 0};
	160
	161	TGraph* gr = new TGraph(23,mv,y);
	162	fSlewingLED.AddAtAndExpand(gr,ipmt);
	163	}
	164	//__________________________________________________________________
	165
	166	Float_t AliT0Parameters::GetSlewingLED(Int_t ipmt, Float_t mv) const
	167	{
	168	if (!fCalibentry) {
	169	return ((TGraph*)fSlewingLED.At(ipmt))->Eval(mv);
	170	}
	171	return fgCalibData->GetSlewingLED(ipmt, mv) ;
	172	}
	173
	174
	175	//__________________________________________________________________
	176
	177	TGraph *AliT0Parameters::GetSlew(Int_t ipmt) const
	178	{
	179	if (!fCalibentry) {
	180	return (TGraph*)fSlewingLED.At(ipmt);
	181	}
	182	return fgCalibData -> GetSlew(ipmt) ;
	183	}
	184
	185	//__________________________________________________________________
	186
	187
	188	void
	189	AliT0Parameters::SetSlewingRec(Int_t ipmt)
	190	{
	191	// Set Slweing Correction for LED channel
	192	Float_t mv[23] = {25, 30, 40,60, 80,100,150,200,250,300,
	193	400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
	194	6000, 7000,8000};
	195	Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
	196	1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
	197	156, 78, 0};
	198	Float_t y1[23], mv1[23];
	199	for (Int_t i=0; i<23; i++){
	200	y1[i] = y[22-i]; mv1[i] = mv[22-i];}
	201
	202	TGraph* gr = new TGraph(23,y1,mv1);
	203	fSlewingRec.AddAtAndExpand(gr,ipmt);
	204
	205	}
	206	//__________________________________________________________________
207
208	Float_t AliT0Parameters::GetSlewingRec(Int_t ipmt, Float_t mv) const
209	{
210	if (!fCalibentry) {
211	return ((TGraph*)fSlewingRec.At(ipmt))->Eval(mv);
212	}
213	return fgCalibData -> GetSlewingRec(ipmt, mv) ;
214	}
215
216	//__________________________________________________________________
217
218	TGraph *AliT0Parameters::GetSlewRec(Int_t ipmt) const
219	{
220	if (!fCalibentry) {
221	return (TGraph*)fSlewingRec.At(ipmt);
222	}
223	return fgCalibData -> GetSlewRec(ipmt) ;
224	}
225
c41ceaac	226
	227	//________________________________________________________________
	228	void AliT0Parameters::SetWalk(Int_t ipmt)
	229	{
	230
	231	Int_t mv, ps;
	232	Int_t x[70000], y[70000], index[70000];
	233	Float_t time[10000],amplitude[10000];
	234	string buffer;
	235	Bool_t down=false;
	236
	237	ifstream inFile("data/CFD-Amp.txt");
	238	// if(!inFile) AliError(Form("Cannot open file %s !",filename));
	239
	240	Int_t i=0, i1=0, i2=0;
	241	while(getline(inFile,buffer)){
	242	inFile >> ps >> mv;
	243
	244	x[i]=ps; y[i]=mv;
	245	i++;
	246	}
	247	inFile.close();
	248
	249	TMath::Sort(i, y, index,down);
	250	Int_t amp=0, iin=0, isum=0, sum=0;
	251	Int_t ind=0;
	252	for (Int_t ii=0; ii<70000; ii++)
	253	{
	254	ind=index[ii];
	255	if(y[ind] == amp)
	256	{
	257	sum +=x[ind];
	258	iin++;
	259	}
	260	else
	261	{
	262	if(iin>0)
	263	time[isum] = Float_t (sum/(iin));
	264	else
	265	time[isum] =Float_t (x[ind]);
	266	amplitude[isum] = Float_t (amp);
	267	amp=y[ind];
	268	// cout<<ii<<" "<<ind<<" "<<y[ind]<<" "<<x[ind]<<" iin "<<iin<<" mean "<<time[isum]<<" amp "<< amplitude[isum]<<" "<<isum<<endl;
	269	iin=0;
	270	isum++;
	271	sum=0;
	272	}
	273
	274
	275	}
	276
	277	inFile.close();
	278
	279	TGraph* gr = new TGraph(isum, amplitude, time);
	280	fWalk.AddAtAndExpand(gr,ipmt);
	281
	282
	283	}
	284	//__________________________________________________________________
	285
	286	TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
	287	{
	288	if (!fCalibentry) {
	289	return (TGraph*)fWalk.At(ipmt);
290	}
291	return fgCalibData -> GetWalk(ipmt) ;
292	}
293
294	//__________________________________________________________________
295
296	Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
297	{
298	if (!fCalibentry) {
299	return ((TGraph*)fWalk.At(ipmt))->Eval(mv);
300	}
301	return fgCalibData -> GetWalkVal(ipmt, mv) ;
302	}
303
304	//__________________________________________________________________
305
dc7ca31d	306	//__________________________________________________________________
	307	void
	308	AliT0Parameters::SetPMTeff(Int_t ipmt)
	309	{
	310	Float_t lambda[50];
	311	Float_t eff[50 ] = {0, 0, 0.23619, 0.202909, 0.177913,
	312	0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
	313	0.252276, 0.256267,0.26, 0.27125, 0.281818,
	314	0.288118, 0.294057,0.296222, 0.301622, 0.290421,
	315	0.276615, 0.2666, 0.248, 0.23619, 0.227814,
	316	0.219818, 0.206667,0.194087, 0.184681, 0.167917,
	317	0.154367, 0.1364, 0.109412, 0.0834615,0.0725283,
	318	0.0642963,0.05861, 0.0465, 0.0413333,0.032069,
	319	0.0252203,0.02066, 0.016262, 0.012, 0.00590476,
	320	0.003875, 0.00190, 0, 0, 0 } ;
	321	for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
	322
	323	TGraph* gr = new TGraph(50,lambda,eff);
	324	fPMTeff.AddAtAndExpand(gr,ipmt);
	325	}
e0bba6cc	326	//________________________________________________________________
	327
	328	Int_t
	329	AliT0Parameters::GetChannel(Int_t trm, Int_t tdc, Int_t chain, Int_t channel)
	330	{
	331
	332
	333	AliT0LookUpKey * lookkey; //= new AliT0LookUpKey();
	334	AliT0LookUpValue * lookvalue= new AliT0LookUpValue(trm,tdc,chain,channel);
	335
	336	lookkey = (AliT0LookUpKey) fgLookUp->GetMapLookup()->GetValue((TObject)lookvalue);
	337	if (!lookkey ) {
	338	cout<<" no such address "<<endl; return -1;
	339	}
	340
	341
	342	//cout<<"AliT0Parameters:: key "<<lookkey->GetKey()<<endl;
	343	return lookkey->GetKey();
	344
	345
	346	}