[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
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);
700e6b36	174
0d82bd92	175	if (fIsInit) return;
29d3e0eb	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.
d9cae8af	179	fgLookUp = new AliT0CalibData("T0");
dd9fd8d6	180
0d72dc5b	181	fNumberOfTRMs = 1;
d9cae8af	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++)
f8bea420	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);
0d82bd92	195	fgLookUp->GetMapLookup()->Add((TObject)lookvalue,(TObject)lookkey);
663b10cd	196	if (channel<6) channel +=2;
663b10cd	197	else {channel = 0; tdc++;}
0d82bd92	198	if(ik==56) { tdc=0; channel=0; chain = 1;}
dd9fd8d6	199
f8bea420	200	}
74adb36a	201
74adb36a	202	fIsInit=kTRUE;
f8bea420	203	}
f8bea420	204	//__________________________________________________________________
dc7ca31d	205	Float_t
dc7ca31d	206	AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
82ee3b37	207	{
dc7ca31d	208	// return time delay for CFD channel
	209	//
	210	if (!fCalibentry)
	211	{
c41ceaac	212	fTimeDelayCFD = 1000+ipmt*100;
c41ceaac	213	return fTimeDelayCFD;
dc7ca31d	214	}
dc7ca31d	215
82ee3b37	216	return fgCalibData->GetTimeEq(ipmt);
dc7ca31d	217	}
58bd3a16	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	}
dc7ca31d	258	//__________________________________________________________________
dc7ca31d	259
b95e8d87	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
74adb36a	273	TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
dc7ca31d	274	{
74adb36a	275	if (!fSlewCorr) {
29d3e0eb	276	AliError("No slewing correction is available!");
29d3e0eb	277	return (TGraph*)fAmpLEDRec.At(ipmt);
dc7ca31d	278	}
74adb36a	279	return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
dc7ca31d	280	}
	281
	282	//__________________________________________________________________
	283
c41ceaac	284	TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
c41ceaac	285	{
74adb36a	286	if (!fSlewCorr) {
29d3e0eb	287	AliError("No walk correction is available!");
c41ceaac	288	return (TGraph*)fWalk.At(ipmt);
c41ceaac	289	}
74adb36a	290	return fgSlewCorr -> GetWalk(ipmt) ;
c41ceaac	291	}
	292
	293	//__________________________________________________________________
	294
c883fdf2	295	TGraph *AliT0Parameters::GetQTC(Int_t ipmt) const
c41ceaac	296	{
0d82bd92	297	if (!fSlewCorr) {
c883fdf2	298	AliError("No walk correction is available!");
	299	// return (TGraph*)fQTC.At(ipmt);
	300	return 0;
c41ceaac	301	}
c883fdf2	302	return fgSlewCorr -> GetQTC(ipmt) ;
c41ceaac	303	}
c41ceaac	304
c883fdf2	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	}
c41ceaac	315
dc7ca31d	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	}
e0bba6cc	336	//________________________________________________________________
	337
	338	Int_t
	339	AliT0Parameters::GetChannel(Int_t trm, Int_t tdc, Int_t chain, Int_t channel)
	340	{
	341
e30bc492	342	if (fgLookUp) {
e30bc492	343	AliT0LookUpValue key(trm,tdc,chain,channel);
3a06b1d2	344	AliT0LookUpKey val = (AliT0LookUpKey) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
3a06b1d2	345	// AliT0LookUpKey val = (AliT0LookUpKey) fLookUp.GetValue((TObject*)&key);
e30bc492	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!");
29d3e0eb	355	return -1;
e0bba6cc	356	}
e0bba6cc	357
e0bba6cc	358	}
5325480c	359	//__________________________________________________________________
29d3e0eb	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
5325480c	370	Int_t
	371	AliT0Parameters::GetNumberOfTRMs()
	372	{
	373	// return number of trms
	374	//
	375	if (!fgLookUp) {
29d3e0eb	376	// fNumberOfTRMs = 2;
5325480c	377	return fNumberOfTRMs;
	378	}
	379	return fgLookUp ->GetNumberOfTRMs();
	380	}
256d4943	381	/*
5325480c	382	//________________________________________________________________________________
	383	Double_t AliT0Parameters::GetZPosition(const char* symname){
	384	// Get the global z coordinate of the given T0 alignable volume
	385	//
29d3e0eb	386	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
5325480c	387
5325480c	388	return tr[2];
29d3e0eb	389	}
256d4943	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;
256d4943	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	}
29d3e0eb	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();
5325480c	426
29d3e0eb	427	return (tr[2]-otr[2]);
5325480c	428	}
5325480c	429