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