[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 "AliT0LookUpValue.h"
#include "AliT0LookUpKey.h"
#include <AliCDBManager.h>        
#include <AliCDBEntry.h>          
#include <TMath.h>
#include <TGeoManager.h>
#include <TGeoPhysicalNode.h>
#include <AliGeomManager.h>
#include <TGeoMatrix.h>

AliT0CalibTimeEq* AliT0Parameters::fgCalibData = 0;
AliT0CalibData* AliT0Parameters::fgLookUp = 0;
AliT0CalibWalk* AliT0Parameters::fgSlewCorr =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),
   fTimeDelayCFD(0), 
 //  fTimeV0(0), 
   fTimeDelayTVD(0),
   fMeanT0(512),
   fLookUp(0),
   fNumberOfTRMs(2),
   fCalibentry(), fLookUpentry(),fSlewCorr()

  
{
  // 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;
  }
  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);
	  if (channel<6) channel +=2;
	  else {channel = 0; tdc++;}
	  if(ik==57) { tdc=0; channel=0; chain = 1;}

	  fgLookUp->GetMapLookup()->Add((TObject*)lookvalue,(TObject*)lookkey);	
       }
  
  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);
}
//__________________________________________________________________

TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
{
 // get walk correction by LED-CFD vs CFD graph
   if (!fSlewCorr) {
     AliError("No slewing correction is available!");
     return  (TGraph*)fAmpLEDRec.At(ipmt); 
  } 
  return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
}

//__________________________________________________________________

TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
{
  // get walk correction by QTC vs CFD
  if (!fSlewCorr) {
    AliError("No walk correction is available!");
    return  (TGraph*)fWalk.At(ipmt); 
  } 
  return fgSlewCorr -> GetWalk(ipmt) ;
}

//__________________________________________________________________

Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
{
 // get walk correction by QTC vs CFD
   if (!fSlewCorr) {
    return ((TGraph*)fWalk.At(ipmt))->Eval(mv); 
  } 
  return fgSlewCorr -> GetWalkVal(ipmt, mv) ;
}


//__________________________________________________________________
void 
AliT0Parameters::SetPMTeff(Int_t ipmt)
{
  // PMT quantum efficiency
  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)
{
    // get logical number of channel according physical address

  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()
{
  // get LookUp Table

  if (!fgLookUp){
    cout<<" No look up table in OCDB";
    return 0;
  }
  return   fgLookUp->GetMapLookup();
}
//__________________________________________________________________

Int_t
AliT0Parameters::GetNumberOfTRMs() 
{
  // return number of trms
  // 
  if (!fgLookUp) {
    //  fNumberOfTRMs = 2;
    return  fNumberOfTRMs;
  } 
  return  fgLookUp ->GetNumberOfTRMs();
}
/*
//________________________________________________________________________________
Double_t AliT0Parameters::GetZPosition(const char* symname){
// Get the global z coordinate of the given T0 alignable volume
//
  Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();

  return tr[2];
}
*/
//________________________________________________________________________________
Double_t AliT0Parameters::GetZPosition(const char* symname){
// Get the global z coordinate of the given T0 alignable volume
//
  Double_t *tr;
  TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
  if (!pne) return 0;
  

  TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
  if(pnode){
          TGeoHMatrix* hm = pnode->GetMatrix();
           tr = hm->GetTranslation();
  }else{
          const char* path = pne->GetTitle();
          if(!gGeoManager->cd(path)){
                  AliErrorClass(Form("Volume path %s not valid!",path));
                  return 0;
          }
         tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
  }
  return tr[2];

}
//________________________________________________________________________________

Double_t AliT0Parameters::GetZPositionShift(const char* symname)
{
// Get the global z coordinate of the given T0 alignable volume
//
  Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();

  TGeoHMatrix origmat;
  AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
  Double_t *otr = origmat.GetTranslation();

  return (tr[2]-otr[2]);
}
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id: */
	17
	18	//____________________________________________________________________
	19	//
	20	// T0 - T0.
	21	//
	22	// This class is a singleton that handles various parameters of
	23	// the T0 detectors.
	24	// Eventually, this class will use the Conditions DB to get the
	25	// various parameters, which code can then request from here.
	26	//
	27	#include "AliT0.h"
	28	#include "AliLog.h"
	29	#include "AliT0Parameters.h"
	30	#include "AliT0CalibData.h"
	31	#include "AliT0CalibWalk.h"
	32	#include "AliT0CalibTimeEq.h"
	33	#include "AliT0LookUpValue.h"
	34	#include "AliT0LookUpKey.h"
	35	#include <AliCDBManager.h>
	36	#include <AliCDBEntry.h>
	37	#include <TMath.h>
	38	#include <TGeoManager.h>
	39	#include <TGeoPhysicalNode.h>
	40	#include <AliGeomManager.h>
	41	#include <TGeoMatrix.h>
	42
	43	AliT0CalibTimeEq* AliT0Parameters::fgCalibData = 0;
	44	AliT0CalibData* AliT0Parameters::fgLookUp = 0;
	45	AliT0CalibWalk* AliT0Parameters::fgSlewCorr =0;
	46	//====================================================================
	47	ClassImp(AliT0Parameters)
	48	#if 0
	49	; // This is here to keep Emacs for indenting the next line
	50	#endif
	51
	52	//____________________________________________________________________
	53	AliT0Parameters* AliT0Parameters::fgInstance = 0;
	54	//____________________________________________________________________
	55	AliT0Parameters* AliT0Parameters::Instance()
	56	{
	57	// Get static instance
	58	if (!fgInstance) {
	59	fgInstance = new AliT0Parameters;
	60	}
	61	return fgInstance;
	62	}
	63
	64	//____________________________________________________________________
	65	AliT0Parameters::AliT0Parameters()
	66	:fIsInit(kFALSE),
	67	fPh2Mip(0),fmV2Mip(0),
	68	fChannelWidth(0),fmV2Channel(0),
	69	fQTmin(0),fQTmax(0),
	70	fAmpLEDRec(0),
	71	fPMTeff(),
	72	fWalk(0),
	73	fTimeDelayCFD(0),
	74	// fTimeV0(0),
	75	fTimeDelayTVD(0),
	76	fMeanT0(512),
	77	fLookUp(0),
	78	fNumberOfTRMs(2),
	79	fCalibentry(), fLookUpentry(),fSlewCorr()
	80
	81
	82	{
	83	// Default constructor
	84	for (Int_t ipmt=0; ipmt<24; ipmt++)
	85	{
	86	SetPh2Mip();
	87	SetmV2Mip();
	88	SetChannelWidth();
	89	SetmV2channel();
	90	SetQTmin();
	91	SetQTmax();
	92	SetPMTeff(ipmt);
	93	}
	94	SetTimeDelayTVD();
	95	SetZposition();
	96
	97	}
	98
	99	//__________________________________________________________________
	100	void
	101	AliT0Parameters::Init()
	102	{
	103	// Initialize the parameters manager. We need to get stuff from the
	104	// CDB here.
	105	if (fIsInit) return;
	106
	107	AliCDBManager *stor =AliCDBManager::Instance();
	108	//time equalizing
	109	fCalibentry = stor->Get("T0/Calib/TimeDelay");
	110	if (fCalibentry)
	111	fgCalibData = (AliT0CalibTimeEq*)fCalibentry->GetObject();
	112	else {
	113	AliFatal(" ALARM !!!! No time delays in CDB ");
	114	fIsInit = kFALSE;
	115	return;
	116	}
	117	//slewing correction
	118	fSlewCorr = stor->Get("T0/Calib/Slewing_Walk");
	119	if (fSlewCorr){
	120	fgSlewCorr = (AliT0CalibWalk*)fSlewCorr->GetObject();
	121	}
	122	else {
	123	AliFatal(" ALARM !!!! No slewing correction in CDB ");
	124	fIsInit = kFALSE;
	125	return;
	126	}
	127	//lookup table
	128	fLookUpentry = stor->Get("T0/Calib/LookUp_Table");
	129	if (fLookUpentry){
	130	fgLookUp = (AliT0CalibData*)fLookUpentry->GetObject();
	131	}
	132	else {
	133	AliFatal(" ALARM !!!! No Lookup table in CDB ");
	134	fIsInit = kFALSE;
	135	return;
	136	}
	137	fIsInit = kTRUE;
	138	}
	139
	140
	141	//__________________________________________________________________
	142
	143	void AliT0Parameters::InitIfOnline()
	144	{
	145	// should be used in online
	146	// for switching to this one should write
	147	// AliT0RawReader myrawreader(rawReader);
	148	// myrawreader.SetOnlineMode(kTRUE);
	149
	150	if (fIsInit) return;
	151	//standart configuration (used for simulation)
	152	//Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
	153	// configuration for test Jun07.
	154	fgLookUp = new AliT0CalibData("T0");
	155
	156	fNumberOfTRMs = 1;
	157	fgLookUp-> SetNumberOfTRMs(fNumberOfTRMs);
	158	Int_t trm=7; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
	159	for (Int_t ik=0; ik<105; ik++)
	160	{
	161	AliT0LookUpKey * lookkey= new AliT0LookUpKey();
	162	AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
	163
	164
	165	lookvalue->SetTRM(trm);
	166	lookvalue->SetTDC(tdc);
	167	lookvalue->SetChain(chain);
	168	lookvalue->SetChannel(channel);
	169	lookkey->SetKey(ik);
	170	if (channel<6) channel +=2;
	171	else {channel = 0; tdc++;}
	172	if(ik==57) { tdc=0; channel=0; chain = 1;}
	173
	174	fgLookUp->GetMapLookup()->Add((TObject)lookvalue,(TObject)lookkey);
	175	}
	176
	177	fIsInit=kTRUE;
	178	}
	179	//__________________________________________________________________
	180	Float_t
	181	AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
	182	{
	183	// return time delay for CFD channel
	184	//
	185	if (!fCalibentry)
	186	{
	187	fTimeDelayCFD = 1000+ipmt*100;
	188	return fTimeDelayCFD;
	189	}
	190
	191	return fgCalibData->GetTimeEq(ipmt);
	192	}
	193	//__________________________________________________________________
	194
	195	TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
	196	{
	197	// get walk correction by LED-CFD vs CFD graph
	198	if (!fSlewCorr) {
	199	AliError("No slewing correction is available!");
	200	return (TGraph*)fAmpLEDRec.At(ipmt);
	201	}
	202	return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
	203	}
	204
	205	//__________________________________________________________________
	206
	207	TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
	208	{
	209	// get walk correction by QTC vs CFD
	210	if (!fSlewCorr) {
	211	AliError("No walk correction is available!");
	212	return (TGraph*)fWalk.At(ipmt);
	213	}
	214	return fgSlewCorr -> GetWalk(ipmt) ;
	215	}
	216
	217	//__________________________________________________________________
	218
	219	Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
	220	{
	221	// get walk correction by QTC vs CFD
	222	if (!fSlewCorr) {
	223	return ((TGraph*)fWalk.At(ipmt))->Eval(mv);
	224	}
	225	return fgSlewCorr -> GetWalkVal(ipmt, mv) ;
	226	}
	227
	228
	229	//__________________________________________________________________
	230	void
	231	AliT0Parameters::SetPMTeff(Int_t ipmt)
	232	{
	233	// PMT quantum efficiency
	234	Float_t lambda[50];
	235	Float_t eff[50 ] = {0, 0, 0.23619, 0.202909, 0.177913,
	236	0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
	237	0.252276, 0.256267,0.26, 0.27125, 0.281818,
	238	0.288118, 0.294057,0.296222, 0.301622, 0.290421,
	239	0.276615, 0.2666, 0.248, 0.23619, 0.227814,
	240	0.219818, 0.206667,0.194087, 0.184681, 0.167917,
	241	0.154367, 0.1364, 0.109412, 0.0834615,0.0725283,
	242	0.0642963,0.05861, 0.0465, 0.0413333,0.032069,
	243	0.0252203,0.02066, 0.016262, 0.012, 0.00590476,
	244	0.003875, 0.00190, 0, 0, 0 } ;
	245	for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
	246
	247	TGraph* gr = new TGraph(50,lambda,eff);
	248	fPMTeff.AddAtAndExpand(gr,ipmt);
	249	}
	250	//________________________________________________________________
	251
	252	Int_t
	253	AliT0Parameters::GetChannel(Int_t trm, Int_t tdc, Int_t chain, Int_t channel)
	254	{
	255	// get logical number of channel according physical address
	256
	257	if (fgLookUp) {
	258	AliT0LookUpValue key(trm,tdc,chain,channel);
	259	AliT0LookUpKey val = (AliT0LookUpKey) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
	260	// AliT0LookUpKey val = (AliT0LookUpKey) fLookUp.GetValue((TObject*)&key);
	261	if (val )
	262	return val->GetKey();
	263	else {
	264	AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
	265	return -1;
	266	}
	267	}
	268	else {
	269	AliError("No look up table has been loader!");
	270	return -1;
	271	}
	272
	273	}
	274	//__________________________________________________________________
	275	TMap *AliT0Parameters::GetMapLookup()
	276	{
	277	// get LookUp Table
	278
	279	if (!fgLookUp){
	280	cout<<" No look up table in OCDB";
	281	return 0;
	282	}
	283	return fgLookUp->GetMapLookup();
	284	}
	285	//__________________________________________________________________
	286
	287	Int_t
	288	AliT0Parameters::GetNumberOfTRMs()
	289	{
	290	// return number of trms
	291	//
	292	if (!fgLookUp) {
	293	// fNumberOfTRMs = 2;
	294	return fNumberOfTRMs;
	295	}
	296	return fgLookUp ->GetNumberOfTRMs();
	297	}
	298	/*
	299	//________________________________________________________________________________
	300	Double_t AliT0Parameters::GetZPosition(const char* symname){
	301	// Get the global z coordinate of the given T0 alignable volume
	302	//
	303	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
	304
	305	return tr[2];
	306	}
	307	*/
	308	//________________________________________________________________________________
	309	Double_t AliT0Parameters::GetZPosition(const char* symname){
	310	// Get the global z coordinate of the given T0 alignable volume
	311	//
	312	Double_t *tr;
	313	TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
	314	if (!pne) return 0;
	315
	316
	317	TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
	318	if(pnode){
	319	TGeoHMatrix* hm = pnode->GetMatrix();
	320	tr = hm->GetTranslation();
	321	}else{
	322	const char* path = pne->GetTitle();
	323	if(!gGeoManager->cd(path)){
	324	AliErrorClass(Form("Volume path %s not valid!",path));
	325	return 0;
	326	}
	327	tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
	328	}
	329	return tr[2];
	330
	331	}
	332	//________________________________________________________________________________
	333
	334	Double_t AliT0Parameters::GetZPositionShift(const char* symname)
	335	{
	336	// Get the global z coordinate of the given T0 alignable volume
	337	//
	338	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
	339
	340	TGeoHMatrix origmat;
	341	AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
	342	Double_t *otr = origmat.GetTranslation();
	343
	344	return (tr[2]-otr[2]);
	345	}
	346