[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 "AliLog.h"		  
#include "AliT0Parameters.h"	  
#include "AliT0CalibData.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 <AliGeomManager.h>

AliT0CalibData* AliT0Parameters::fgCalibData = 0;
AliT0CalibData* AliT0Parameters::fgLookUp = 0;
AliT0CalibData* 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),
   fTimeDelayDA(0), 
   fTimeDelayCFD(0), 
   fTimeDelayTVD(0),
   fMeanT0(500),
   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  = (AliT0CalibData*)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  = (AliT0CalibData*)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.
  fNumberOfTRMs = 2;
  Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
  for (Int_t ik=0; ik<110; 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; trm=1;}
           fLookUp.Add((TObject*)lookvalue,(TObject*)lookkey);	
       }
  
  fIsInit=kTRUE;
}
//__________________________________________________________________

Float_t
AliT0Parameters::GetTimeDelayDA(Int_t ipmt) 
{
  // return time delay for LED channel
  // 
  if (!fCalibentry) {
    fTimeDelayDA = 500;
    return  fTimeDelayDA;
  } 
  return fgCalibData ->GetTimeDelayDA(ipmt);
}
//__________________________________________________________________
Float_t
AliT0Parameters::GetTimeDelayCFD(Int_t ipmt) 
{
  // return time delay for CFD channel
   // 
  if (!fCalibentry) 
    {
      fTimeDelayCFD = 1000+ipmt*100;
      return fTimeDelayCFD;
    }
   
  return fgCalibData->GetTimeDelayCFD(ipmt);
}

//__________________________________________________________________
Int_t
AliT0Parameters::GetMeanT0() 
{
  // return mean of T0 distrubution with vertex=0
   // 
  if (!fCalibentry) 
    {
      return fMeanT0;
    }
   
  return fgCalibData->GetMeanT0();
}
//__________________________________________________________________

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) ;
}

//__________________________________________________________________

Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
{
  if (!fSlewCorr) {
    return ((TGraph*)fWalk.At(ipmt))->Eval(mv); 
  } 
  return fgSlewCorr -> GetWalkVal(ipmt, mv) ;
}


//__________________________________________________________________
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)
{

  
  AliT0LookUpKey * lookkey;  //= new AliT0LookUpKey();
  AliT0LookUpValue * lookvalue= new AliT0LookUpValue(trm,tdc,chain,channel);
  if (fgLookUp)
       lookkey = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)lookvalue);
   else
   lookkey = (AliT0LookUpKey*) fLookUp.GetValue((TObject*)lookvalue);

  if (!lookkey ) {
    AliInfo(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
    return -1;
  }
  
  return lookkey->GetKey();
  

}
//__________________________________________________________________
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::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 "AliLog.h"
	28	#include "AliT0Parameters.h"
	29	#include "AliT0CalibData.h"
	30	#include "AliT0LookUpValue.h"
	31	#include <AliCDBManager.h>
	32	#include <AliCDBEntry.h>
	33	#include <AliCDBStorage.h>
	34	#include <TMath.h>
	35	#include <TSystem.h>
	36	#include <Riostream.h>
	37	#include <TGeoManager.h>
	38	#include <TGeoPhysicalNode.h>
	39	#include <AliGeomManager.h>
	40
	41	AliT0CalibData* AliT0Parameters::fgCalibData = 0;
	42	AliT0CalibData* AliT0Parameters::fgLookUp = 0;
	43	AliT0CalibData* AliT0Parameters::fgSlewCorr =0;
	44	//====================================================================
	45	ClassImp(AliT0Parameters)
	46	#if 0
	47	; // This is here to keep Emacs for indenting the next line
	48	#endif
	49
	50	//____________________________________________________________________
	51	AliT0Parameters* AliT0Parameters::fgInstance = 0;
	52	//____________________________________________________________________
	53	AliT0Parameters* AliT0Parameters::Instance()
	54	{
	55	// Get static instance
	56	if (!fgInstance) {
	57	fgInstance = new AliT0Parameters;
	58	}
	59	return fgInstance;
	60	}
	61
	62	//____________________________________________________________________
	63	AliT0Parameters::AliT0Parameters()
	64	:fIsInit(kFALSE),
	65	fPh2Mip(0),fmV2Mip(0),
	66	fChannelWidth(0),fmV2Channel(0),
	67	fQTmin(0),fQTmax(0),
	68	fAmpLEDRec(0),
	69	fPMTeff(),
	70	fWalk(0),
	71	fTimeDelayDA(0),
	72	fTimeDelayCFD(0),
	73	fTimeDelayTVD(0),
	74	fMeanT0(500),
	75	fLookUp(0),
	76	fNumberOfTRMs(2),
	77	fCalibentry(), fLookUpentry(),fSlewCorr()
	78
	79
	80	{
	81	// Default constructor
	82	for (Int_t ipmt=0; ipmt<24; ipmt++)
	83	{
	84	SetPh2Mip();
	85	SetmV2Mip();
	86	SetChannelWidth();
	87	SetmV2channel();
	88	SetQTmin();
	89	SetQTmax();
	90	SetPMTeff(ipmt);
	91	}
	92	SetTimeDelayTVD();
	93	SetZposition();
	94
	95	}
	96
	97	//__________________________________________________________________
	98	void
	99	AliT0Parameters::Init()
	100	{
	101	// Initialize the parameters manager. We need to get stuff from the
	102	// CDB here.
	103	if (fIsInit) return;
	104
	105	AliCDBManager *stor =AliCDBManager::Instance();
	106
	107	//time equalizing
	108	fCalibentry = stor->Get("T0/Calib/TimeDelay");
	109	if (fCalibentry)
	110	fgCalibData = (AliT0CalibData*)fCalibentry->GetObject();
	111	else {
	112	AliFatal(" ALARM !!!! No time delays in CDB ");
	113	fIsInit = kFALSE;
	114	return;
	115	}
	116	//slewing correction
	117	fSlewCorr = stor->Get("T0/Calib/Slewing_Walk");
	118	if (fSlewCorr){
	119	fgSlewCorr = (AliT0CalibData*)fSlewCorr->GetObject();
	120	}
	121	else {
	122	AliFatal(" ALARM !!!! No slewing correction in CDB ");
	123	fIsInit = kFALSE;
	124	return;
	125	}
	126	//lookup table
	127	fLookUpentry = stor->Get("T0/Calib/LookUp_Table");
	128	if (fLookUpentry){
	129	fgLookUp = (AliT0CalibData*)fLookUpentry->GetObject();
	130	}
	131	else {
	132	AliFatal(" ALARM !!!! No Lookup table in CDB ");
	133	fIsInit = kFALSE;
	134	return;
	135	}
	136	fIsInit = kTRUE;
	137	}
	138
	139
	140	//__________________________________________________________________
	141
	142	void AliT0Parameters::InitIfOnline()
	143	{
	144	// should be used in online
	145	// for switching to this one should write
	146	// AliT0RawReader myrawreader(rawReader);
	147	// myrawreader.SetOnlineMode(kTRUE);
	148
	149	if (fIsInit) return;
	150	//standart configuration (used for simulation)
	151	//Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
	152	// configuration for test Jun07.
	153	fNumberOfTRMs = 2;
	154	Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
	155	for (Int_t ik=0; ik<110; ik++)
	156	{
	157	AliT0LookUpKey * lookkey= new AliT0LookUpKey();
	158	AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
	159
	160
	161	lookvalue->SetTRM(trm);
	162	lookvalue->SetTDC(tdc);
	163	lookvalue->SetChain(chain);
	164	lookvalue->SetChannel(channel);
	165	lookkey->SetKey(ik);
	166	if (channel<6) channel +=2;
	167	else {channel = 0; tdc++;}
	168	if(ik==57) { tdc=0; channel=0; trm=1;}
	169	fLookUp.Add((TObject)lookvalue,(TObject)lookkey);
	170	}
	171
	172	fIsInit=kTRUE;
	173	}
	174	//__________________________________________________________________
	175
	176	Float_t
	177	AliT0Parameters::GetTimeDelayDA(Int_t ipmt)
	178	{
	179	// return time delay for LED channel
	180	//
	181	if (!fCalibentry) {
	182	fTimeDelayDA = 500;
	183	return fTimeDelayDA;
	184	}
	185	return fgCalibData ->GetTimeDelayDA(ipmt);
	186	}
	187	//__________________________________________________________________
	188	Float_t
	189	AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
	190	{
	191	// return time delay for CFD channel
	192	//
	193	if (!fCalibentry)
	194	{
	195	fTimeDelayCFD = 1000+ipmt*100;
	196	return fTimeDelayCFD;
	197	}
	198
	199	return fgCalibData->GetTimeDelayCFD(ipmt);
	200	}
	201
	202	//__________________________________________________________________
	203	Int_t
	204	AliT0Parameters::GetMeanT0()
	205	{
	206	// return mean of T0 distrubution with vertex=0
	207	//
	208	if (!fCalibentry)
	209	{
	210	return fMeanT0;
	211	}
	212
	213	return fgCalibData->GetMeanT0();
	214	}
	215	//__________________________________________________________________
	216
	217	TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
	218	{
	219	if (!fSlewCorr) {
	220	AliError("No slewing correction is available!");
	221	return (TGraph*)fAmpLEDRec.At(ipmt);
	222	}
	223	return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
	224	}
	225
	226	//__________________________________________________________________
	227
	228	TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
	229	{
	230	if (!fSlewCorr) {
	231	AliError("No walk correction is available!");
	232	return (TGraph*)fWalk.At(ipmt);
	233	}
	234	return fgSlewCorr -> GetWalk(ipmt) ;
	235	}
	236
	237	//__________________________________________________________________
	238
	239	Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
	240	{
	241	if (!fSlewCorr) {
	242	return ((TGraph*)fWalk.At(ipmt))->Eval(mv);
	243	}
	244	return fgSlewCorr -> GetWalkVal(ipmt, mv) ;
	245	}
	246
	247
	248	//__________________________________________________________________
	249	void
	250	AliT0Parameters::SetPMTeff(Int_t ipmt)
	251	{
	252	Float_t lambda[50];
	253	Float_t eff[50 ] = {0, 0, 0.23619, 0.202909, 0.177913,
	254	0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
	255	0.252276, 0.256267,0.26, 0.27125, 0.281818,
	256	0.288118, 0.294057,0.296222, 0.301622, 0.290421,
	257	0.276615, 0.2666, 0.248, 0.23619, 0.227814,
	258	0.219818, 0.206667,0.194087, 0.184681, 0.167917,
	259	0.154367, 0.1364, 0.109412, 0.0834615,0.0725283,
	260	0.0642963,0.05861, 0.0465, 0.0413333,0.032069,
	261	0.0252203,0.02066, 0.016262, 0.012, 0.00590476,
	262	0.003875, 0.00190, 0, 0, 0 } ;
	263	for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
	264
	265	TGraph* gr = new TGraph(50,lambda,eff);
	266	fPMTeff.AddAtAndExpand(gr,ipmt);
	267	}
	268	//________________________________________________________________
	269
	270	Int_t
	271	AliT0Parameters::GetChannel(Int_t trm, Int_t tdc, Int_t chain, Int_t channel)
	272	{
	273
	274
	275	AliT0LookUpKey * lookkey; //= new AliT0LookUpKey();
	276	AliT0LookUpValue * lookvalue= new AliT0LookUpValue(trm,tdc,chain,channel);
	277	if (fgLookUp)
	278	lookkey = (AliT0LookUpKey) fgLookUp->GetMapLookup()->GetValue((TObject)lookvalue);
	279	else
	280	lookkey = (AliT0LookUpKey) fLookUp.GetValue((TObject)lookvalue);
	281
	282	if (!lookkey ) {
	283	AliInfo(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
	284	return -1;
	285	}
	286
	287	return lookkey->GetKey();
	288
	289
	290	}
	291	//__________________________________________________________________
	292	TMap *AliT0Parameters::GetMapLookup()
	293	{
	294	if (!fgLookUp){
	295	cout<<" No look up table in OCDB";
	296	return 0;
	297	}
	298	return fgLookUp->GetMapLookup();
	299	}
	300	//__________________________________________________________________
	301
	302	Int_t
	303	AliT0Parameters::GetNumberOfTRMs()
	304	{
	305	// return number of trms
	306	//
	307	if (!fgLookUp) {
	308	// fNumberOfTRMs = 2;
	309	return fNumberOfTRMs;
	310	}
	311	return fgLookUp ->GetNumberOfTRMs();
	312	}
	313	//________________________________________________________________________________
	314	Double_t AliT0Parameters::GetZPosition(const char* symname){
	315	// Get the global z coordinate of the given T0 alignable volume
	316	//
	317	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
	318
	319	return tr[2];
	320	}
	321	//________________________________________________________________________________
	322
	323	Double_t AliT0Parameters::GetZPositionShift(const char* symname)
	324	{
	325	// Get the global z coordinate of the given T0 alignable volume
	326	//
	327	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
	328
	329	TGeoHMatrix origmat;
	330	AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
	331	Double_t *otr = origmat.GetTranslation();
	332
	333	return (tr[2]-otr[2]);
	334	}
	335