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