[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 "AliT0.h"
#include "AliLog.h"		  
#include "AliT0Parameters.h"	  
#include "AliT0CalibData.h"   
#include "AliT0CalibWalk.h"   
#include "AliT0CalibTimeEq.h"   
#include "AliT0CalibLatency.h"   
#include "AliT0LookUpKey.h"
#include "AliT0LookUpValue.h"
#include <AliCDBManager.h>        
#include <AliCDBEntry.h>          
#include <AliCDBStorage.h>  
#include <TMath.h>
#include <TSystem.h>
//#include <Riostream.h>
#include <TGeoManager.h>
#include <TGeoPhysicalNode.h>
#include <TGeoMatrix.h>
#include <AliGeomManager.h>

AliT0CalibTimeEq* AliT0Parameters::fgCalibData = 0;
AliT0CalibData* AliT0Parameters::fgLookUp = 0;
AliT0CalibWalk* AliT0Parameters::fgSlewCorr =0;
AliT0CalibLatency *AliT0Parameters::fgLatency=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),
   fAmpLEDRec(0), 
   fPMTeff(),
   fWalk(0),
   fQTC(0),
   fAmpLED(0),
   fTimeDelayCFD(0), 
 //  fTimeV0(0), 
   fTimeDelayTVD(0),
   fMeanT0(512),
   fMeanVertex(0),
   fLatencyHPTDC(0),
   fLatencyL1(0),
   fLatencyL1A(0),
   fLatencyL1C(0),
   fLookUp(0),
   fNumberOfTRMs(2),
   fCalibentry(), 
   fLookUpentry(),
   fSlewCorr(),
   fLatency()
  
{
  // Default constructor 
  for (Int_t ipmt=0; ipmt<24; 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 *stor =AliCDBManager::Instance();
   //time equalizing
   fCalibentry  = stor->Get("T0/Calib/TimeDelay");
   if (fCalibentry)
     fgCalibData  = (AliT0CalibTimeEq*)fCalibentry->GetObject();
   else {
         AliFatal(" ALARM !!!! No time delays in CDB "); 
     fIsInit = kFALSE;
     return;
   }
 //slewing correction
  fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk");
  if (fSlewCorr){
    fgSlewCorr  = (AliT0CalibWalk*)fSlewCorr->GetObject();
  }
  else {
      AliFatal(" ALARM !!!! No slewing correction in CDB "); 
    fIsInit = kFALSE;
    return;
  }
  //lookup table
  fLookUpentry  = stor->Get("T0/Calib/LookUp_Table");
  if (fLookUpentry){
    fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
  }
  else {
     AliFatal(" ALARM !!!! No Lookup table  in CDB "); 
    fIsInit = kFALSE;
    return;
  }
  //latency
  
 fLatency  = stor->Get("T0/Calib/Latency");
  if (fLatency){
    fgLatency  = (AliT0CalibLatency*)fLatency->GetObject();
  }
  else {
     AliWarning(" !!! no latency  in CDB "); 
    return;
  }
  
fIsInit = kTRUE;
}


//__________________________________________________________________

void AliT0Parameters::InitIfOnline()
{
// should be used in online
// for switching to this one should write
  // AliT0RawReader myrawreader(rawReader);
//	myrawreader.SetOnlineMode(kTRUE);

  if (fIsInit) return;
   //standart configuration (used for simulation)
   //Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
  // configuration for test Jun07.
   fgLookUp = new AliT0CalibData("T0");

  fNumberOfTRMs = 1;
 fgLookUp-> SetNumberOfTRMs(fNumberOfTRMs);
  Int_t trm=7; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
  for (Int_t ik=0; ik<105; ik++)
        {
         AliT0LookUpKey * lookkey= new AliT0LookUpKey();
         AliT0LookUpValue * lookvalue= new AliT0LookUpValue();


          lookvalue->SetTRM(trm);
          lookvalue->SetTDC(tdc);
          lookvalue->SetChain(chain);
          lookvalue->SetChannel(channel);
          lookkey->SetKey(ik);
	  fgLookUp->GetMapLookup()->Add((TObject*)lookvalue,(TObject*)lookkey);	
	  if (channel<6) channel +=2;
	  else {channel = 0; tdc++;}
	  if(ik==56) { tdc=0; channel=0; chain = 1;}

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

//__________________________________________________________________
Float_t
AliT0Parameters::GetLatencyHPTDC() 
  {
  // return LatencyHPTDC for CFD channel
  if (!fLatency) 
    {
      fLatencyHPTDC=9000.;
      return fLatencyHPTDC;
    }
   
  return fgLatency->GetLatencyHPTDC();
}
//__________________________________________________________________
Float_t
AliT0Parameters::GetLatencyL1() 
  {
  // return time delay for CFD channel
   
  return fgLatency->GetLatencyL1();
}

//__________________________________________________________________
Float_t
AliT0Parameters::GetLatencyL1A() 
  {
  // return time delay for CFD channel
   
  return fgLatency->GetLatencyL1A();
}

//__________________________________________________________________
Float_t
AliT0Parameters::GetLatencyL1C() 
  {
  // return time delay for CFD channel
   
  return fgLatency->GetLatencyL1C();
}
//__________________________________________________________________

Float_t
AliT0Parameters:: GetMeanVertex()
{ 
  if (!fCalibentry) 
    {
      fMeanVertex=0;
      return fMeanVertex;
    }
   
  return fgCalibData->GetMeanVertex();
}
//__________________________________________________________________

TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
{
   if (!fSlewCorr) {
     AliError("No slewing correction is available!");
     return  (TGraph*)fAmpLEDRec.At(ipmt); 
  } 
  return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
}

//__________________________________________________________________

TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
{
  if (!fSlewCorr) {
    AliError("No walk correction is available!");
    return  (TGraph*)fWalk.At(ipmt); 
  } 
  return fgSlewCorr -> GetWalk(ipmt) ;
}

//__________________________________________________________________

TGraph *AliT0Parameters::GetQTC(Int_t ipmt) const
{
  if (!fSlewCorr) {
    AliError("No walk correction is available!");
    //    return  (TGraph*)fQTC.At(ipmt); 
   return  0; 
  } 
  return fgSlewCorr -> GetQTC(ipmt) ;
}

//__________________________________________________________________
TGraph *AliT0Parameters::GetAmpLED(Int_t ipmt) const
{
  if (!fSlewCorr) {
    AliError("No walk correction is available!");
    //    return  (TGraph*)fQTC.At(ipmt); 
   return  0; 
  } 
  return fgSlewCorr -> GetAmpLED(ipmt) ;
}

//__________________________________________________________________
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)
{

  if (fgLookUp) {
    AliT0LookUpValue key(trm,tdc,chain,channel);
      AliT0LookUpKey *val = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
      // AliT0LookUpKey *val = (AliT0LookUpKey*) fLookUp.GetValue((TObject*)&key);
    if (val )
      return val->GetKey();
    else {
      AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
      return -1;
    }
  }
  else {
    AliError("No look up table has been loader!");
    return -1;
  }

}
//__________________________________________________________________
TMap *AliT0Parameters::GetMapLookup()
{
  if (!fgLookUp){
    cout<<" No look up table in OCDB";
    return 0;
  }
  return   fgLookUp->GetMapLookup();
}
//__________________________________________________________________

Int_t
AliT0Parameters::GetNumberOfTRMs() 
{
  // return number of trms
  // 
  if (!fgLookUp) {
    //  fNumberOfTRMs = 2;
    return  fNumberOfTRMs;
  } 
  return  fgLookUp ->GetNumberOfTRMs();
}
/*
//________________________________________________________________________________
Double_t AliT0Parameters::GetZPosition(const char* symname){
// Get the global z coordinate of the given T0 alignable volume
//
  Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();

  return tr[2];
}
*/
//________________________________________________________________________________
Double_t AliT0Parameters::GetZPosition(const char* symname){
// Get the global z coordinate of the given T0 alignable volume
//
  Double_t *tr;
  TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
  if (!pne) return 0;
  

  TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
  if(pnode){
          TGeoHMatrix* hm = pnode->GetMatrix();
           tr = hm->GetTranslation();
  }else{
          const char* path = pne->GetTitle();
          if(!gGeoManager->cd(path)){
                  AliErrorClass(Form("Volume path %s not valid!",path));
                  return 0;
          }
         tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
  }
  return tr[2];

}
//________________________________________________________________________________

Double_t AliT0Parameters::GetZPositionShift(const char* symname)
{
// Get the global z coordinate of the given T0 alignable volume
//
  Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();

  TGeoHMatrix origmat;
  AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
  Double_t *otr = origmat.GetTranslation();

  return (tr[2]-otr[2]);
}
Commit	Line	Data
	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 "AliT0.h"
	28	#include "AliLog.h"
	29	#include "AliT0Parameters.h"
	30	#include "AliT0CalibData.h"
	31	#include "AliT0CalibWalk.h"
	32	#include "AliT0CalibTimeEq.h"
	33	#include "AliT0CalibLatency.h"
	34	#include "AliT0LookUpKey.h"
	35	#include "AliT0LookUpValue.h"
	36	#include <AliCDBManager.h>
	37	#include <AliCDBEntry.h>
	38	#include <AliCDBStorage.h>
	39	#include <TMath.h>
	40	#include <TSystem.h>
	41	//#include <Riostream.h>
	42	#include <TGeoManager.h>
	43	#include <TGeoPhysicalNode.h>
	44	#include <TGeoMatrix.h>
	45	#include <AliGeomManager.h>
	46
	47	AliT0CalibTimeEq* AliT0Parameters::fgCalibData = 0;
	48	AliT0CalibData* AliT0Parameters::fgLookUp = 0;
	49	AliT0CalibWalk* AliT0Parameters::fgSlewCorr =0;
	50	AliT0CalibLatency *AliT0Parameters::fgLatency=0;
	51	//====================================================================
	52	ClassImp(AliT0Parameters)
	53	#if 0
	54	; // This is here to keep Emacs for indenting the next line
	55	#endif
	56
	57	//____________________________________________________________________
	58	AliT0Parameters* AliT0Parameters::fgInstance = 0;
	59	//____________________________________________________________________
	60	AliT0Parameters* AliT0Parameters::Instance()
	61	{
	62	// Get static instance
	63	if (!fgInstance) {
	64	fgInstance = new AliT0Parameters;
	65	}
	66	return fgInstance;
	67	}
	68
	69	//____________________________________________________________________
	70	AliT0Parameters::AliT0Parameters()
	71	:fIsInit(kFALSE),
	72	fPh2Mip(0),fmV2Mip(0),
	73	fChannelWidth(0),fmV2Channel(0),
	74	fQTmin(0),fQTmax(0),
	75	fAmpLEDRec(0),
	76	fPMTeff(),
	77	fWalk(0),
	78	fQTC(0),
	79	fAmpLED(0),
	80	fTimeDelayCFD(0),
	81	// fTimeV0(0),
	82	fTimeDelayTVD(0),
	83	fMeanT0(512),
	84	fMeanVertex(0),
	85	fLatencyHPTDC(0),
	86	fLatencyL1(0),
	87	fLatencyL1A(0),
	88	fLatencyL1C(0),
	89	fLookUp(0),
	90	fNumberOfTRMs(2),
	91	fCalibentry(),
	92	fLookUpentry(),
	93	fSlewCorr(),
	94	fLatency()
	95
	96	{
	97	// Default constructor
	98	for (Int_t ipmt=0; ipmt<24; ipmt++)
	99	{
	100	SetPh2Mip();
	101	SetmV2Mip();
	102	SetChannelWidth();
	103	SetmV2channel();
	104	SetQTmin();
	105	SetQTmax();
	106	SetPMTeff(ipmt);
	107	}
	108	SetTimeDelayTVD();
	109	SetZposition();
	110
	111	}
	112
	113	//__________________________________________________________________
	114	void
	115	AliT0Parameters::Init()
	116	{
	117	// Initialize the parameters manager. We need to get stuff from the
	118	// CDB here.
	119	if (fIsInit) return;
	120
	121	AliCDBManager *stor =AliCDBManager::Instance();
	122	//time equalizing
	123	fCalibentry = stor->Get("T0/Calib/TimeDelay");
	124	if (fCalibentry)
	125	fgCalibData = (AliT0CalibTimeEq*)fCalibentry->GetObject();
	126	else {
	127	AliFatal(" ALARM !!!! No time delays in CDB ");
	128	fIsInit = kFALSE;
	129	return;
	130	}
	131	//slewing correction
	132	fSlewCorr = stor->Get("T0/Calib/Slewing_Walk");
	133	if (fSlewCorr){
	134	fgSlewCorr = (AliT0CalibWalk*)fSlewCorr->GetObject();
	135	}
	136	else {
	137	AliFatal(" ALARM !!!! No slewing correction in CDB ");
	138	fIsInit = kFALSE;
	139	return;
	140	}
	141	//lookup table
	142	fLookUpentry = stor->Get("T0/Calib/LookUp_Table");
	143	if (fLookUpentry){
	144	fgLookUp = (AliT0CalibData*)fLookUpentry->GetObject();
	145	}
	146	else {
	147	AliFatal(" ALARM !!!! No Lookup table in CDB ");
	148	fIsInit = kFALSE;
	149	return;
	150	}
	151	//latency
	152
	153	fLatency = stor->Get("T0/Calib/Latency");
	154	if (fLatency){
	155	fgLatency = (AliT0CalibLatency*)fLatency->GetObject();
	156	}
	157	else {
	158	AliWarning(" !!! no latency in CDB ");
	159	return;
	160	}
	161
	162	fIsInit = kTRUE;
	163	}
	164
	165
	166	//__________________________________________________________________
	167
	168	void AliT0Parameters::InitIfOnline()
	169	{
	170	// should be used in online
	171	// for switching to this one should write
	172	// AliT0RawReader myrawreader(rawReader);
	173	// myrawreader.SetOnlineMode(kTRUE);
	174
	175	if (fIsInit) return;
	176	//standart configuration (used for simulation)
	177	//Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
	178	// configuration for test Jun07.
	179	fgLookUp = new AliT0CalibData("T0");
	180
	181	fNumberOfTRMs = 1;
	182	fgLookUp-> SetNumberOfTRMs(fNumberOfTRMs);
	183	Int_t trm=7; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
	184	for (Int_t ik=0; ik<105; ik++)
	185	{
	186	AliT0LookUpKey * lookkey= new AliT0LookUpKey();
	187	AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
	188
	189
	190	lookvalue->SetTRM(trm);
	191	lookvalue->SetTDC(tdc);
	192	lookvalue->SetChain(chain);
	193	lookvalue->SetChannel(channel);
	194	lookkey->SetKey(ik);
	195	fgLookUp->GetMapLookup()->Add((TObject)lookvalue,(TObject)lookkey);
	196	if (channel<6) channel +=2;
	197	else {channel = 0; tdc++;}
	198	if(ik==56) { tdc=0; channel=0; chain = 1;}
	199
	200	}
	201
	202	fIsInit=kTRUE;
	203	}
	204	//__________________________________________________________________
	205	Float_t
	206	AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
	207	{
	208	// return time delay for CFD channel
	209	//
	210	if (!fCalibentry)
	211	{
	212	fTimeDelayCFD = 1000+ipmt*100;
	213	return fTimeDelayCFD;
	214	}
	215
	216	return fgCalibData->GetTimeEq(ipmt);
	217	}
	218
	219	//__________________________________________________________________
	220	Float_t
	221	AliT0Parameters::GetLatencyHPTDC()
	222	{
	223	// return LatencyHPTDC for CFD channel
	224	if (!fLatency)
	225	{
	226	fLatencyHPTDC=9000.;
	227	return fLatencyHPTDC;
	228	}
	229
	230	return fgLatency->GetLatencyHPTDC();
	231	}
	232	//__________________________________________________________________
	233	Float_t
	234	AliT0Parameters::GetLatencyL1()
	235	{
	236	// return time delay for CFD channel
	237
	238	return fgLatency->GetLatencyL1();
	239	}
	240
	241	//__________________________________________________________________
	242	Float_t
	243	AliT0Parameters::GetLatencyL1A()
	244	{
	245	// return time delay for CFD channel
	246
	247	return fgLatency->GetLatencyL1A();
	248	}
	249
	250	//__________________________________________________________________
	251	Float_t
	252	AliT0Parameters::GetLatencyL1C()
	253	{
	254	// return time delay for CFD channel
	255
	256	return fgLatency->GetLatencyL1C();
	257	}
	258	//__________________________________________________________________
	259
	260	Float_t
	261	AliT0Parameters:: GetMeanVertex()
	262	{
	263	if (!fCalibentry)
	264	{
	265	fMeanVertex=0;
	266	return fMeanVertex;
	267	}
	268
	269	return fgCalibData->GetMeanVertex();
	270	}
	271	//__________________________________________________________________
	272
	273	TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
	274	{
	275	if (!fSlewCorr) {
	276	AliError("No slewing correction is available!");
	277	return (TGraph*)fAmpLEDRec.At(ipmt);
	278	}
	279	return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
	280	}
	281
	282	//__________________________________________________________________
	283
	284	TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
	285	{
	286	if (!fSlewCorr) {
	287	AliError("No walk correction is available!");
	288	return (TGraph*)fWalk.At(ipmt);
	289	}
	290	return fgSlewCorr -> GetWalk(ipmt) ;
	291	}
	292
	293	//__________________________________________________________________
	294
	295	TGraph *AliT0Parameters::GetQTC(Int_t ipmt) const
	296	{
	297	if (!fSlewCorr) {
	298	AliError("No walk correction is available!");
	299	// return (TGraph*)fQTC.At(ipmt);
	300	return 0;
	301	}
	302	return fgSlewCorr -> GetQTC(ipmt) ;
	303	}
	304
	305	//__________________________________________________________________
	306	TGraph *AliT0Parameters::GetAmpLED(Int_t ipmt) const
	307	{
	308	if (!fSlewCorr) {
	309	AliError("No walk correction is available!");
	310	// return (TGraph*)fQTC.At(ipmt);
	311	return 0;
	312	}
	313	return fgSlewCorr -> GetAmpLED(ipmt) ;
	314	}
	315
	316	//__________________________________________________________________
	317	void
	318	AliT0Parameters::SetPMTeff(Int_t ipmt)
	319	{
	320	Float_t lambda[50];
	321	Float_t eff[50 ] = {0, 0, 0.23619, 0.202909, 0.177913,
	322	0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
	323	0.252276, 0.256267,0.26, 0.27125, 0.281818,
	324	0.288118, 0.294057,0.296222, 0.301622, 0.290421,
	325	0.276615, 0.2666, 0.248, 0.23619, 0.227814,
	326	0.219818, 0.206667,0.194087, 0.184681, 0.167917,
	327	0.154367, 0.1364, 0.109412, 0.0834615,0.0725283,
	328	0.0642963,0.05861, 0.0465, 0.0413333,0.032069,
	329	0.0252203,0.02066, 0.016262, 0.012, 0.00590476,
	330	0.003875, 0.00190, 0, 0, 0 } ;
	331	for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
	332
	333	TGraph* gr = new TGraph(50,lambda,eff);
	334	fPMTeff.AddAtAndExpand(gr,ipmt);
	335	}
	336	//________________________________________________________________
	337
	338	Int_t
	339	AliT0Parameters::GetChannel(Int_t trm, Int_t tdc, Int_t chain, Int_t channel)
	340	{
	341
	342	if (fgLookUp) {
	343	AliT0LookUpValue key(trm,tdc,chain,channel);
	344	AliT0LookUpKey val = (AliT0LookUpKey) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
	345	// AliT0LookUpKey val = (AliT0LookUpKey) fLookUp.GetValue((TObject*)&key);
	346	if (val )
	347	return val->GetKey();
	348	else {
	349	AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
	350	return -1;
	351	}
	352	}
	353	else {
	354	AliError("No look up table has been loader!");
	355	return -1;
	356	}
	357
	358	}
	359	//__________________________________________________________________
	360	TMap *AliT0Parameters::GetMapLookup()
	361	{
	362	if (!fgLookUp){
	363	cout<<" No look up table in OCDB";
	364	return 0;
	365	}
	366	return fgLookUp->GetMapLookup();
	367	}
	368	//__________________________________________________________________
	369
	370	Int_t
	371	AliT0Parameters::GetNumberOfTRMs()
	372	{
	373	// return number of trms
	374	//
	375	if (!fgLookUp) {
	376	// fNumberOfTRMs = 2;
	377	return fNumberOfTRMs;
	378	}
	379	return fgLookUp ->GetNumberOfTRMs();
	380	}
	381	/*
	382	//________________________________________________________________________________
	383	Double_t AliT0Parameters::GetZPosition(const char* symname){
	384	// Get the global z coordinate of the given T0 alignable volume
	385	//
	386	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
	387
	388	return tr[2];
	389	}
	390	*/
	391	//________________________________________________________________________________
	392	Double_t AliT0Parameters::GetZPosition(const char* symname){
	393	// Get the global z coordinate of the given T0 alignable volume
	394	//
	395	Double_t *tr;
	396	TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
	397	if (!pne) return 0;
	398
	399
	400	TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
	401	if(pnode){
	402	TGeoHMatrix* hm = pnode->GetMatrix();
	403	tr = hm->GetTranslation();
	404	}else{
	405	const char* path = pne->GetTitle();
	406	if(!gGeoManager->cd(path)){
	407	AliErrorClass(Form("Volume path %s not valid!",path));
	408	return 0;
	409	}
	410	tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
	411	}
	412	return tr[2];
	413
	414	}
	415	//________________________________________________________________________________
	416
	417	Double_t AliT0Parameters::GetZPositionShift(const char* symname)
	418	{
	419	// Get the global z coordinate of the given T0 alignable volume
	420	//
	421	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
	422
	423	TGeoHMatrix origmat;
	424	AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
	425	Double_t *otr = origmat.GetTranslation();
	426
	427	return (tr[2]-otr[2]);
	428	}
	429