// 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 <Riostream.h>
#include <TGeoManager.h>
#include <TGeoPhysicalNode.h>
+#include <TGeoMatrix.h>
+#include <AliGeomManager.h>
-AliT0CalibData* AliT0Parameters::fgCalibData = 0;
+AliT0CalibTimeEq* AliT0Parameters::fgCalibData = 0;
AliT0CalibData* AliT0Parameters::fgLookUp = 0;
-AliT0CalibData* AliT0Parameters::fgSlewCorr =0;
+AliT0CalibWalk* AliT0Parameters::fgSlewCorr =0;
+AliT0CalibLatency *AliT0Parameters::fgLatency=0;
//====================================================================
ClassImp(AliT0Parameters)
#if 0
// Get static instance
if (!fgInstance) {
fgInstance = new AliT0Parameters;
- // fgInstance->Init();
}
return fgInstance;
}
fPh2Mip(0),fmV2Mip(0),
fChannelWidth(0),fmV2Channel(0),
fQTmin(0),fQTmax(0),
+ fAmpLEDRec(0),
fPMTeff(),
- fCalibentry(), fLookUpentry(),fSlewCorr(),
- fLookUp(0), fNumberOfTRMs(2)
+ 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
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;
- }
+ 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 = (AliT0CalibData*)fSlewCorr->GetObject();
+ fgSlewCorr = (AliT0CalibWalk*)fSlewCorr->GetObject();
}
else {
- AliFatal(" ALARM !!!! No slewing correction in CDB ");
+ AliFatal(" ALARM !!!! No slewing correction in CDB ");
fIsInit = kFALSE;
return;
}
fgLookUp = (AliT0CalibData*)fLookUpentry->GetObject();
}
else {
- AliFatal(" ALARM !!!! No Lookup table in CDB ");
+ AliFatal(" ALARM !!!! No Lookup table in CDB ");
fIsInit = kFALSE;
return;
}
- fIsInit = kTRUE;
+ //latency
+
+ fLatency = stor->Get("T0/Calib/Latency");
+ if (fLatency){
+ fgLatency = (AliT0CalibLatency*)fLatency->GetObject();
+ }
+ else {
+ AliWarning(" !!! no latency in CDB ");
+ return;
+ }
+
+fIsInit = kTRUE;
}
// for switching to this one should write
// AliT0RawReader myrawreader(rawReader);
// myrawreader.SetOnlineMode(kTRUE);
-
-
+
if (fIsInit) return;
-
- 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(ik==55) { trm=1; tdc=0; channel=0;}
- if (channel<6) channel +=2;
- else {channel = 0; tdc++;}
- fLookUp.Add((TObject*)lookvalue,(TObject*)lookkey);
- }
+ //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::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)
return fTimeDelayCFD;
}
- return fgCalibData->GetTimeDelayCFD(ipmt);
+ return fgCalibData->GetTimeEq(ipmt);
+}
+//__________________________________________________________________
+Float_t
+AliT0Parameters::GetCFD(Int_t ipmt)
+ {
+ // return CFD channel
+
+ return fgCalibData->GetCFDvalue(ipmt,0);
}
//__________________________________________________________________
-Int_t
-AliT0Parameters::GetMeanT0()
-{
- // return mean of T0 distrubution with vertex=0
- //
- if (!fCalibentry)
+Float_t
+AliT0Parameters::GetLatencyHPTDC()
+ {
+ // return LatencyHPTDC for CFD channel
+ if (!fLatency)
{
- return fMeanT0;
+ fLatencyHPTDC=9000.;
+ return fLatencyHPTDC;
}
- return fgCalibData->GetMeanT0();
+ return fgLatency->GetLatencyHPTDC();
}
//__________________________________________________________________
+Float_t
+AliT0Parameters::GetLatencyL1()
+ {
+ // return time delay for CFD channel
+
+ return fgLatency->GetLatencyL1();
+}
-TGraph *AliT0Parameters::GetAmpLED(Int_t ipmt) const
-{
- if (!fSlewCorr) {
- return (TGraph*)fAmpLED.At(ipmt);
- }
- return fgSlewCorr -> GetAmpLED(ipmt) ;
+//__________________________________________________________________
+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) {
- cout<<"AliT0Parameters::GetSlewingRec !fSlewCorr"<<endl;
- return (TGraph*)fAmpLEDRec.At(ipmt);
+ AliError("No slewing correction is available!");
+ return (TGraph*)fAmpLEDRec.At(ipmt);
}
return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
}
TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
{
if (!fSlewCorr) {
- cout<<" AliT0Parameters::GetWalk "<<fSlewCorr<<endl;
+ 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
+TGraph *AliT0Parameters::GetQTC(Int_t ipmt) const
{
if (!fSlewCorr) {
- return ((TGraph*)fWalk.At(ipmt))->Eval(mv);
+ AliError("No walk correction is available!");
+ // return (TGraph*)fQTC.At(ipmt);
+ return 0;
}
- return fgSlewCorr -> GetWalkVal(ipmt, mv) ;
+ 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::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 ) {
- cout<<" no such address "<<endl; return -1;
+ 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;
}
-
-
- //cout<<"AliT0Parameters:: key "<<lookkey->GetKey()<<endl;
- 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;
+ // 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;
-
- cout<<symname<<endl;
TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
if (!pne) return 0;
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]);
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff