[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::GetCFD(Int_t ipmt) 
  {
  // return  CFD channel
   
    return fgCalibData->GetCFDvalue(ipmt,0);
}

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