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