[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;}
    }
  //2 recent open channels
  trm=7; tdc=14; channel=2; chain=0; 
  for (Int_t ik=105; ik<107; 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++;}
    }
  
  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	lookvalue->SetTRM(trm);
	189	lookvalue->SetTDC(tdc);
	190	lookvalue->SetChain(chain);
	191	lookvalue->SetChannel(channel);
	192	lookkey->SetKey(ik);
	193	fgLookUp->GetMapLookup()->Add((TObject)lookvalue,(TObject)lookkey);
	194	if (channel<6) channel +=2;
	195	else {channel = 0; tdc++;}
	196	if(ik==56) { tdc=0; channel=0; chain = 1;}
	197	}
	198	//2 recent open channels
	199	trm=7; tdc=14; channel=2; chain=0;
	200	for (Int_t ik=105; ik<107; ik++)
	201	{
	202	AliT0LookUpKey * lookkey= new AliT0LookUpKey();
	203	AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
	204
	205	lookvalue->SetTRM(trm);
	206	lookvalue->SetTDC(tdc);
	207	lookvalue->SetChain(chain);
	208	lookvalue->SetChannel(channel);
	209	lookkey->SetKey(ik);
	210	fgLookUp->GetMapLookup()->Add((TObject)lookvalue,(TObject)lookkey);
	211	if (channel<6) channel +=2;
	212	else {channel = 0; tdc++;}
	213	}
	214
	215	fIsInit=kTRUE;
	216	}
	217	//__________________________________________________________________
	218	Float_t
	219	AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
	220	{
	221	// return time delay for CFD channel
	222	//
	223	if (!fCalibentry)
	224	{
	225	fTimeDelayCFD = 1000+ipmt*100;
	226	return fTimeDelayCFD;
	227	}
	228
	229	return fgCalibData->GetTimeEq(ipmt);
	230	}
	231
	232	//__________________________________________________________________
	233	Float_t
	234	AliT0Parameters::GetLatencyHPTDC()
	235	{
	236	// return LatencyHPTDC for CFD channel
	237	if (!fLatency)
	238	{
	239	fLatencyHPTDC=9000.;
	240	return fLatencyHPTDC;
	241	}
	242
	243	return fgLatency->GetLatencyHPTDC();
	244	}
	245	//__________________________________________________________________
	246	Float_t
	247	AliT0Parameters::GetLatencyL1()
	248	{
	249	// return time delay for CFD channel
	250
	251	return fgLatency->GetLatencyL1();
	252	}
	253
	254	//__________________________________________________________________
	255	Float_t
	256	AliT0Parameters::GetLatencyL1A()
	257	{
	258	// return time delay for CFD channel
	259
	260	return fgLatency->GetLatencyL1A();
	261	}
	262
	263	//__________________________________________________________________
	264	Float_t
	265	AliT0Parameters::GetLatencyL1C()
	266	{
	267	// return time delay for CFD channel
	268
	269	return fgLatency->GetLatencyL1C();
	270	}
	271	//__________________________________________________________________
	272
	273	Float_t
	274	AliT0Parameters:: GetMeanVertex()
	275	{
	276	if (!fCalibentry)
	277	{
	278	fMeanVertex=0;
	279	return fMeanVertex;
	280	}
	281
	282	return fgCalibData->GetMeanVertex();
	283	}
	284	//__________________________________________________________________
	285
	286	TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
	287	{
	288	if (!fSlewCorr) {
	289	AliError("No slewing correction is available!");
	290	return (TGraph*)fAmpLEDRec.At(ipmt);
	291	}
	292	return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
	293	}
	294
	295	//__________________________________________________________________
	296
	297	TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
	298	{
	299	if (!fSlewCorr) {
	300	AliError("No walk correction is available!");
	301	return (TGraph*)fWalk.At(ipmt);
	302	}
	303	return fgSlewCorr -> GetWalk(ipmt) ;
	304	}
	305
	306	//__________________________________________________________________
	307
	308	TGraph *AliT0Parameters::GetQTC(Int_t ipmt) const
	309	{
	310	if (!fSlewCorr) {
	311	AliError("No walk correction is available!");
	312	// return (TGraph*)fQTC.At(ipmt);
	313	return 0;
	314	}
	315	return fgSlewCorr -> GetQTC(ipmt) ;
	316	}
	317
	318	//__________________________________________________________________
	319	TGraph *AliT0Parameters::GetAmpLED(Int_t ipmt) const
	320	{
	321	if (!fSlewCorr) {
	322	AliError("No walk correction is available!");
	323	// return (TGraph*)fQTC.At(ipmt);
	324	return 0;
	325	}
	326	return fgSlewCorr -> GetAmpLED(ipmt) ;
	327	}
	328
	329	//__________________________________________________________________
	330	void
	331	AliT0Parameters::SetPMTeff(Int_t ipmt)
	332	{
	333	Float_t lambda[50];
	334	Float_t eff[50 ] = {0, 0, 0.23619, 0.202909, 0.177913,
	335	0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
	336	0.252276, 0.256267,0.26, 0.27125, 0.281818,
	337	0.288118, 0.294057,0.296222, 0.301622, 0.290421,
	338	0.276615, 0.2666, 0.248, 0.23619, 0.227814,
	339	0.219818, 0.206667,0.194087, 0.184681, 0.167917,
	340	0.154367, 0.1364, 0.109412, 0.0834615,0.0725283,
	341	0.0642963,0.05861, 0.0465, 0.0413333,0.032069,
	342	0.0252203,0.02066, 0.016262, 0.012, 0.00590476,
	343	0.003875, 0.00190, 0, 0, 0 } ;
	344	for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
	345
	346	TGraph* gr = new TGraph(50,lambda,eff);
	347	fPMTeff.AddAtAndExpand(gr,ipmt);
	348	}
	349	//________________________________________________________________
	350
	351	Int_t
	352	AliT0Parameters::GetChannel(Int_t trm, Int_t tdc, Int_t chain, Int_t channel)
	353	{
	354
	355	if (fgLookUp) {
	356	AliT0LookUpValue key(trm,tdc,chain,channel);
	357	AliT0LookUpKey val = (AliT0LookUpKey) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
	358	// AliT0LookUpKey val = (AliT0LookUpKey) fLookUp.GetValue((TObject*)&key);
	359	if (val )
	360	return val->GetKey();
	361	else {
	362	AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
	363	return -1;
	364	}
	365	}
	366	else {
	367	AliError("No look up table has been loader!");
	368	return -1;
	369	}
	370
	371	}
	372	//__________________________________________________________________
	373	TMap *AliT0Parameters::GetMapLookup()
	374	{
	375	if (!fgLookUp){
	376	cout<<" No look up table in OCDB";
	377	return 0;
	378	}
	379	return fgLookUp->GetMapLookup();
	380	}
	381	//__________________________________________________________________
	382
	383	Int_t
	384	AliT0Parameters::GetNumberOfTRMs()
	385	{
	386	// return number of trms
	387	//
	388	if (!fgLookUp) {
	389	// fNumberOfTRMs = 2;
	390	return fNumberOfTRMs;
	391	}
	392	return fgLookUp ->GetNumberOfTRMs();
	393	}
	394	/*
	395	//________________________________________________________________________________
	396	Double_t AliT0Parameters::GetZPosition(const char* symname){
	397	// Get the global z coordinate of the given T0 alignable volume
	398	//
	399	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
	400
	401	return tr[2];
	402	}
	403	*/
	404	//________________________________________________________________________________
	405	Double_t AliT0Parameters::GetZPosition(const char* symname){
	406	// Get the global z coordinate of the given T0 alignable volume
	407	//
	408	Double_t *tr;
	409	TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
	410	if (!pne) return 0;
	411
	412
	413	TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
	414	if(pnode){
	415	TGeoHMatrix* hm = pnode->GetMatrix();
	416	tr = hm->GetTranslation();
	417	}else{
	418	const char* path = pne->GetTitle();
	419	if(!gGeoManager->cd(path)){
	420	AliErrorClass(Form("Volume path %s not valid!",path));
	421	return 0;
	422	}
	423	tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
	424	}
	425	return tr[2];
	426
	427	}
	428	//________________________________________________________________________________
	429
	430	Double_t AliT0Parameters::GetZPositionShift(const char* symname)
	431	{
	432	// Get the global z coordinate of the given T0 alignable volume
	433	//
	434	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
	435
	436	TGeoHMatrix origmat;
	437	AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
	438	Double_t *otr = origmat.GetTranslation();
	439
	440	return (tr[2]-otr[2]);
	441	}
	442