[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
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	//
6b7d32f7	27	#include "AliT0.h"
dc7ca31d	28	#include "AliLog.h"
	29	#include "AliT0Parameters.h"
	30	#include "AliT0CalibData.h"
82ee3b37	31	#include "AliT0CalibWalk.h"
82ee3b37	32	#include "AliT0CalibTimeEq.h"
58bd3a16	33	#include "AliT0CalibLatency.h"
2d3bfdf7	34	#include "AliT0LookUpKey.h"
e0bba6cc	35	#include "AliT0LookUpValue.h"
dc7ca31d	36	#include <AliCDBManager.h>
dc7ca31d	37	#include <AliCDBEntry.h>
0d82bd92	38	#include <AliCDBStorage.h>
aae44346	39	#include <TMath.h>
0d82bd92	40	#include <TSystem.h>
700e6b36	41	//#include <Riostream.h>
5325480c	42	#include <TGeoManager.h>
5325480c	43	#include <TGeoPhysicalNode.h>
212239a1	44	#include <TGeoMatrix.h>
0d82bd92	45	#include <AliGeomManager.h>
dc7ca31d	46
82ee3b37	47	AliT0CalibTimeEq* AliT0Parameters::fgCalibData = 0;
e0bba6cc	48	AliT0CalibData* AliT0Parameters::fgLookUp = 0;
82ee3b37	49	AliT0CalibWalk* AliT0Parameters::fgSlewCorr =0;
58bd3a16	50	AliT0CalibLatency *AliT0Parameters::fgLatency=0;
dc7ca31d	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	//____________________________________________________________________
3b7f37fd	60	AliT0Parameters* AliT0Parameters::Instance()
dc7ca31d	61	{
dc7ca31d	62	// Get static instance
76f3b07a	63	if (!fgInstance) {
76f3b07a	64	fgInstance = new AliT0Parameters;
76f3b07a	65	}
dc7ca31d	66	return fgInstance;
	67	}
	68
	69	//____________________________________________________________________
	70	AliT0Parameters::AliT0Parameters()
5325480c	71	:fIsInit(kFALSE),
	72	fPh2Mip(0),fmV2Mip(0),
	73	fChannelWidth(0),fmV2Channel(0),
	74	fQTmin(0),fQTmax(0),
29d3e0eb	75	fAmpLEDRec(0),
5325480c	76	fPMTeff(),
29d3e0eb	77	fWalk(0),
c2337900	78	fQTC(0),
c2337900	79	fAmpLED(0),
29d3e0eb	80	fTimeDelayCFD(0),
82ee3b37	81	// fTimeV0(0),
29d3e0eb	82	fTimeDelayTVD(0),
494f5042	83	fMeanT0(512),
4c809cd8	84	fMeanVertex(0),
c05dcae4	85	fLatencyHPTDC(0),
	86	fLatencyL1(0),
	87	fLatencyL1A(0),
	88	fLatencyL1C(0),
29d3e0eb	89	fLookUp(0),
29d3e0eb	90	fNumberOfTRMs(2),
92a84efb	91	fCalibentry(),
	92	fLookUpentry(),
	93	fSlewCorr(),
	94	fLatency()
74adb36a	95
dc7ca31d	96	{
dc7ca31d	97	// Default constructor
dc7ca31d	98	for (Int_t ipmt=0; ipmt<24; ipmt++)
dc7ca31d	99	{
dc7ca31d	100	SetPh2Mip();
	101	SetmV2Mip();
	102	SetChannelWidth();
	103	SetmV2channel();
dc7ca31d	104	SetQTmin();
	105	SetQTmax();
	106	SetPMTeff(ipmt);
74adb36a	107	}
dc7ca31d	108	SetTimeDelayTVD();
dc7ca31d	109	SetZposition();
74adb36a	110
dc7ca31d	111	}
	112
	113	//__________________________________________________________________
	114	void
	115	AliT0Parameters::Init()
	116	{
	117	// Initialize the parameters manager. We need to get stuff from the
	118	// CDB here.
94c27e4f	119	if (fIsInit) return;
6ba20b30	120
74adb36a	121	AliCDBManager *stor =AliCDBManager::Instance();
74adb36a	122	//time equalizing
256d4943	123	fCalibentry = stor->Get("T0/Calib/TimeDelay");
256d4943	124	if (fCalibentry)
82ee3b37	125	fgCalibData = (AliT0CalibTimeEq*)fCalibentry->GetObject();
256d4943	126	else {
	127	AliFatal(" ALARM !!!! No time delays in CDB ");
	128	fIsInit = kFALSE;
	129	return;
	130	}
c41ceaac	131	//slewing correction
74adb36a	132	fSlewCorr = stor->Get("T0/Calib/Slewing_Walk");
5325480c	133	if (fSlewCorr){
82ee3b37	134	fgSlewCorr = (AliT0CalibWalk*)fSlewCorr->GetObject();
c41ceaac	135	}
3b7f37fd	136	else {
256d4943	137	AliFatal(" ALARM !!!! No slewing correction in CDB ");
3b7f37fd	138	fIsInit = kFALSE;
	139	return;
	140	}
74adb36a	141	//lookup table
6eac39a1	142	fLookUpentry = stor->Get("T0/Calib/LookUp_Table");
e0bba6cc	143	if (fLookUpentry){
e0bba6cc	144	fgLookUp = (AliT0CalibData*)fLookUpentry->GetObject();
e0bba6cc	145	}
3b7f37fd	146	else {
256d4943	147	AliFatal(" ALARM !!!! No Lookup table in CDB ");
3b7f37fd	148	fIsInit = kFALSE;
	149	return;
	150	}
58bd3a16	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;
dc7ca31d	163	}
	164
	165
dc7ca31d	166	//__________________________________________________________________
f8bea420	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);
0277ddeb	174
0d82bd92	175	if (fIsInit) return;
0277ddeb	176	//standart configuration (used for simulation)
0277ddeb	177	//Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
29d3e0eb	178	// configuration for test Jun07.
0277ddeb	179	fgLookUp = new AliT0CalibData("T0");
0277ddeb	180
0d72dc5b	181	fNumberOfTRMs = 1;
0277ddeb	182	fgLookUp-> SetNumberOfTRMs(fNumberOfTRMs);
0d72dc5b	183	Int_t trm=7; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
79e04c5f	184	for (Int_t ik=0; ik<105; ik++)
0277ddeb	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	}
74adb36a	214
74adb36a	215	fIsInit=kTRUE;
f8bea420	216	}
f8bea420	217	//__________________________________________________________________
dc7ca31d	218	Float_t
dc7ca31d	219	AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
82ee3b37	220	{
dc7ca31d	221	// return time delay for CFD channel
	222	//
	223	if (!fCalibentry)
	224	{
c41ceaac	225	fTimeDelayCFD = 1000+ipmt*100;
c41ceaac	226	return fTimeDelayCFD;
dc7ca31d	227	}
dc7ca31d	228
82ee3b37	229	return fgCalibData->GetTimeEq(ipmt);
dc7ca31d	230	}
58bd3a16	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	}
dc7ca31d	271	//__________________________________________________________________
dc7ca31d	272
b95e8d87	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
74adb36a	286	TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
dc7ca31d	287	{
74adb36a	288	if (!fSlewCorr) {
29d3e0eb	289	AliError("No slewing correction is available!");
29d3e0eb	290	return (TGraph*)fAmpLEDRec.At(ipmt);
dc7ca31d	291	}
74adb36a	292	return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
dc7ca31d	293	}
	294
	295	//__________________________________________________________________
	296
c41ceaac	297	TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
c41ceaac	298	{
74adb36a	299	if (!fSlewCorr) {
29d3e0eb	300	AliError("No walk correction is available!");
c41ceaac	301	return (TGraph*)fWalk.At(ipmt);
c41ceaac	302	}
74adb36a	303	return fgSlewCorr -> GetWalk(ipmt) ;
c41ceaac	304	}
	305
	306	//__________________________________________________________________
	307
c883fdf2	308	TGraph *AliT0Parameters::GetQTC(Int_t ipmt) const
c41ceaac	309	{
0d82bd92	310	if (!fSlewCorr) {
c883fdf2	311	AliError("No walk correction is available!");
	312	// return (TGraph*)fQTC.At(ipmt);
	313	return 0;
c41ceaac	314	}
c883fdf2	315	return fgSlewCorr -> GetQTC(ipmt) ;
c41ceaac	316	}
c41ceaac	317
c883fdf2	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	}
c41ceaac	328
dc7ca31d	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	}
e0bba6cc	349	//________________________________________________________________
	350
	351	Int_t
	352	AliT0Parameters::GetChannel(Int_t trm, Int_t tdc, Int_t chain, Int_t channel)
	353	{
	354
e30bc492	355	if (fgLookUp) {
e30bc492	356	AliT0LookUpValue key(trm,tdc,chain,channel);
3a06b1d2	357	AliT0LookUpKey val = (AliT0LookUpKey) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
3a06b1d2	358	// AliT0LookUpKey val = (AliT0LookUpKey) fLookUp.GetValue((TObject*)&key);
e30bc492	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!");
29d3e0eb	368	return -1;
e0bba6cc	369	}
e0bba6cc	370
e0bba6cc	371	}
5325480c	372	//__________________________________________________________________
29d3e0eb	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
5325480c	383	Int_t
	384	AliT0Parameters::GetNumberOfTRMs()
	385	{
	386	// return number of trms
	387	//
	388	if (!fgLookUp) {
29d3e0eb	389	// fNumberOfTRMs = 2;
5325480c	390	return fNumberOfTRMs;
	391	}
	392	return fgLookUp ->GetNumberOfTRMs();
	393	}
256d4943	394	/*
5325480c	395	//________________________________________________________________________________
	396	Double_t AliT0Parameters::GetZPosition(const char* symname){
	397	// Get the global z coordinate of the given T0 alignable volume
	398	//
29d3e0eb	399	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
5325480c	400
5325480c	401	return tr[2];
29d3e0eb	402	}
256d4943	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;
256d4943	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	}
29d3e0eb	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();
5325480c	439
29d3e0eb	440	return (tr[2]-otr[2]);
5325480c	441	}
5325480c	442