X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TOF%2FAliTOFcalib.cxx;h=e24882ed110b0c9a10b41f7028112f654ca68434;hb=52284ebd6794b13619ef2b316ef86e85ff3fd0f2;hp=bbaaa28a2b0f467a62aace1222c2d08f0b3065b9;hpb=785674040b18a252747cb25249321acceb7cf7ea;p=u%2Fmrichter%2FAliRoot.git diff --git a/TOF/AliTOFcalib.cxx b/TOF/AliTOFcalib.cxx index bbaaa28a2b0..e24882ed110 100644 --- a/TOF/AliTOFcalib.cxx +++ b/TOF/AliTOFcalib.cxx @@ -14,9 +14,15 @@ **************************************************************************/ /* -$Log$ -Revision 1.17 2007/10/18 09:12:22 zampolli -New naming of online calibration directory +$Log: AliTOFcalib.cxx,v $ +Revision 1.21 2007/11/02 15:41:49 hristov +Provide return value if the function is not void + +Revision 1.20 2007/10/26 15:13:50 zampolli +Using a TChain instead of a TTree + +Revision 1.19 2007/10/23 15:27:38 zampolli +Rearrangement of Calibration objects for simulation Revision 1.16 2007/10/08 10:13:26 zampolli First Run and Last Run members added, infinite validity of calib obj implemented. @@ -78,13 +84,17 @@ author: Chiara Zampolli, zampolli@bo.infn.it #include "TF1.h" #include "TFile.h" #include "TH1F.h" +#include "TH1C.h" #include "TH2F.h" -#include "TList.h" -#include "TROOT.h" -#include "TStyle.h" +//#include "TList.h" +//#include "TROOT.h" +//#include "TStyle.h" #include "TTree.h" +#include "TChain.h" #include "TProfile.h" #include "TGrid.h" +#include "TMath.h" +#include "TMap.h" #include "AliCDBEntry.h" #include "AliCDBRunRange.h" @@ -92,17 +102,32 @@ author: Chiara Zampolli, zampolli@bo.infn.it #include "AliCDBManager.h" #include "AliCDBStorage.h" #include "AliCDBMetaData.h" -#include "AliESDtrack.h" -#include "AliESD.h" +//#include "AliESDtrack.h" +//#include "AliESD.h" #include "AliLog.h" #include "AliTOFcalib.h" +#include "AliTOFChannelOnlineArray.h" #include "AliTOFChannelOnline.h" +#include "AliTOFChannelOnlineStatus.h" +#include "AliTOFChannelOnlineStatusArray.h" #include "AliTOFChannelOffline.h" #include "AliTOFGeometry.h" #include "AliTOFRecoParam.h" +#include "AliTOFDeltaBCOffset.h" +#include "AliTOFCTPLatency.h" +#include "AliTOFT0Fill.h" +#include "AliTOFRunParams.h" +#include "AliLHCClockPhase.h" +#include "AliTOFResponseParams.h" +#include "AliESDEvent.h" +#include "AliESDtrack.h" +#include "TRandom.h" -extern TROOT *gROOT; +class TROOT; +class TStyle; + +//extern TROOT *gROOT; extern TStyle *gStyle; ClassImp(AliTOFcalib) @@ -112,47 +137,110 @@ AliTOFcalib::AliTOFcalib(): TTask("AliTOFcalib",""), fNChannels(-1), fTOFCalOnline(0x0), + fTOFCalOnlinePulser(0x0), + fTOFCalOnlineNoise(0x0), + fTOFCalOnlineHW(0x0), fTOFCalOffline(0x0), - fTOFSimCalOnline(0x0), - fTOFSimCalOffline(0x0), + fCal(0x0), + fStatus(0x0), fTOFSimToT(0x0), fkValidity(0x0), fTree(0x0), + fChain(0x0), fNruns(0), fFirstRun(0), - fLastRun(AliCDBRunRange::Infinity()) + fLastRun(AliCDBRunRange::Infinity()), + fConfigMap(new TMap), + fDeltaBCOffset(NULL), + fCTPLatency(NULL), + fT0Fill(NULL), + fRunParams(NULL), + fLHCClockPhase(NULL), + fResponseParams(NULL), + fReadoutEfficiency(NULL), + fProblematic(NULL), + fInitFlag(kFALSE), + fRemoveMeanT0(kTRUE), + fUseLHCClockPhase(kFALSE), + fCalibrateTOFsignal(kTRUE), + fCorrectTExp(kFALSE), + fRunParamsSpecificVersion(-1) { //TOF Calibration Class ctor fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX(); + + gRandom->SetSeed(123456789); } //____________________________________________________________________________ AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib): - TTask("AliTOFcalib",""), + TTask(calib), fNChannels(calib.fNChannels), fTOFCalOnline(0x0), + fTOFCalOnlinePulser(0x0), + fTOFCalOnlineNoise(0x0), + fTOFCalOnlineHW(0x0), fTOFCalOffline(0x0), - fTOFSimCalOnline(0x0), - fTOFSimCalOffline(0x0), + fCal(calib.fCal), + fStatus(calib.fStatus), fTOFSimToT(calib.fTOFSimToT), fkValidity(calib.fkValidity), fTree(calib.fTree), + fChain(calib.fChain), fNruns(calib.fNruns), fFirstRun(calib.fFirstRun), - fLastRun(calib.fLastRun) + fLastRun(calib.fLastRun), + fConfigMap(calib.fConfigMap), + fDeltaBCOffset(NULL), + fCTPLatency(NULL), + fT0Fill(NULL), + fRunParams(NULL), + fLHCClockPhase(NULL), + fResponseParams(NULL), + fReadoutEfficiency(NULL), + fProblematic(NULL), + fInitFlag(calib.fInitFlag), + fRemoveMeanT0(calib.fRemoveMeanT0), + fUseLHCClockPhase(calib.fUseLHCClockPhase), + fCalibrateTOFsignal(calib.fCalibrateTOFsignal), + fCorrectTExp(calib.fCorrectTExp), + fRunParamsSpecificVersion(calib.fRunParamsSpecificVersion) { + + fTOFCalOnline = new TObjArray(fNChannels); + fTOFCalOnlinePulser = new TObjArray(fNChannels); + fTOFCalOnlineNoise = new TObjArray(fNChannels); + fTOFCalOnlineHW = new TObjArray(fNChannels); + fTOFCalOffline = new TObjArray(fNChannels); + fTOFCalOnline->SetOwner(); + fTOFCalOnlinePulser->SetOwner(); + fTOFCalOnlineNoise->SetOwner(); + fTOFCalOnlineHW->SetOwner(); + fTOFCalOffline->SetOwner(); + //TOF Calibration Class copy ctor for (Int_t iarray = 0; iarrayAt(iarray); + AliTOFChannelOnlineStatus * calChOnlineStPulser = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlinePulser->At(iarray); + AliTOFChannelOnlineStatus * calChOnlineStNoise = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineNoise->At(iarray); + AliTOFChannelOnlineStatus * calChOnlineStHW = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineHW->At(iarray); AliTOFChannelOffline * calChOffline = (AliTOFChannelOffline*)calib.fTOFCalOffline->At(iarray); fTOFCalOnline->AddAt(calChOnline,iarray); + fTOFCalOnlinePulser->AddAt(calChOnlineStPulser,iarray); + fTOFCalOnlineNoise->AddAt(calChOnlineStNoise,iarray); + fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray); fTOFCalOffline->AddAt(calChOffline,iarray); - - AliTOFChannelOnline * simCalChOnline = (AliTOFChannelOnline*)calib.fTOFSimCalOnline->At(iarray); - AliTOFChannelOffline * simCalChOffline = (AliTOFChannelOffline*)calib.fTOFSimCalOffline->At(iarray); - fTOFSimCalOnline->AddAt(simCalChOnline,iarray); - fTOFSimCalOffline->AddAt(simCalChOffline,iarray); } + + if (calib.fDeltaBCOffset) fDeltaBCOffset = new AliTOFDeltaBCOffset(*calib.fDeltaBCOffset); + if (calib.fCTPLatency) fCTPLatency = new AliTOFCTPLatency(*calib.fCTPLatency); + if (calib.fT0Fill) fT0Fill = new AliTOFT0Fill(*calib.fT0Fill); + if (calib.fRunParams) fRunParams = new AliTOFRunParams(*calib.fRunParams); + if (calib.fResponseParams) fResponseParams = new AliTOFResponseParams(*calib.fResponseParams); + if (calib.fReadoutEfficiency) fReadoutEfficiency = new TH1F(*calib.fReadoutEfficiency); + if (calib.fProblematic) fProblematic = new TH1C(*calib.fProblematic); + + gRandom->SetSeed(123456789); } //____________________________________________________________________________ @@ -160,23 +248,71 @@ AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib): AliTOFcalib& AliTOFcalib::operator=(const AliTOFcalib &calib) { //TOF Calibration Class assignment operator - this->fNChannels = calib.fNChannels; - this->fTOFSimToT = calib.fTOFSimToT; - this->fkValidity = calib.fkValidity; - this->fTree = calib.fTree; - this->fNruns = calib.fNruns; - this->fFirstRun = calib.fFirstRun; - this->fLastRun = calib.fLastRun; + + if (this == &calib) + return *this; + + TTask::operator=(calib); + fNChannels = calib.fNChannels; + fCal = calib.fCal; + fStatus = calib.fStatus; + fTOFSimToT = calib.fTOFSimToT; + fkValidity = calib.fkValidity; + fTree = calib.fTree; + fChain = calib.fChain; + fNruns = calib.fNruns; + fFirstRun = calib.fFirstRun; + fLastRun = calib.fLastRun; for (Int_t iarray = 0; iarrayAt(iarray); AliTOFChannelOffline * calChOffline = (AliTOFChannelOffline*)calib.fTOFCalOffline->At(iarray); - this->fTOFCalOnline->AddAt(calChOnline,iarray); - this->fTOFCalOffline->AddAt(calChOffline,iarray); - AliTOFChannelOnline * simCalChOnline = (AliTOFChannelOnline*)calib.fTOFSimCalOnline->At(iarray); - AliTOFChannelOffline * simCalChOffline = (AliTOFChannelOffline*)calib.fTOFSimCalOffline->At(iarray); - this->fTOFSimCalOnline->AddAt(simCalChOnline,iarray); - this->fTOFSimCalOffline->AddAt(simCalChOffline,iarray); + AliTOFChannelOnlineStatus * calChOnlineStPulser = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlinePulser->At(iarray); + AliTOFChannelOnlineStatus * calChOnlineStNoise = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineNoise->At(iarray); + AliTOFChannelOnlineStatus * calChOnlineStHW = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineHW->At(iarray); + fTOFCalOnline->AddAt(calChOnline,iarray); + fTOFCalOnlinePulser->AddAt(calChOnlineStPulser,iarray); + fTOFCalOnlineNoise->AddAt(calChOnlineStNoise,iarray); + fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray); + fTOFCalOffline->AddAt(calChOffline,iarray); + } + + if (calib.fDeltaBCOffset) { + if (fDeltaBCOffset) *fDeltaBCOffset = *calib.fDeltaBCOffset; + else fDeltaBCOffset = new AliTOFDeltaBCOffset(*calib.fDeltaBCOffset); + } + + if (calib.fCTPLatency) { + if (fCTPLatency) *fCTPLatency = *calib.fCTPLatency; + else fCTPLatency = new AliTOFCTPLatency(*calib.fCTPLatency); } + + if (calib.fT0Fill) { + if (fT0Fill) *fT0Fill = *calib.fT0Fill; + else fT0Fill = new AliTOFT0Fill(*calib.fT0Fill); + } + if (calib.fRunParams) { + if (fRunParams) *fRunParams = *calib.fRunParams; + else fRunParams = new AliTOFRunParams(*calib.fRunParams); + } + if (calib.fResponseParams) { + if (fResponseParams) *fResponseParams = *calib.fResponseParams; + else fResponseParams = new AliTOFResponseParams(*calib.fResponseParams); + } + if (calib.fReadoutEfficiency) { + if (fReadoutEfficiency) *fReadoutEfficiency = *calib.fReadoutEfficiency; + else fReadoutEfficiency = new TH1F(*calib.fReadoutEfficiency); + } + if (calib.fProblematic) { + if (fProblematic) *fProblematic = *calib.fProblematic; + else fProblematic = new TH1C(*calib.fProblematic); + } + fInitFlag = calib.fInitFlag; + fRemoveMeanT0 = calib.fRemoveMeanT0; + fUseLHCClockPhase = calib.fUseLHCClockPhase; + fCalibrateTOFsignal = calib.fCalibrateTOFsignal; + fCorrectTExp = calib.fCorrectTExp; + fRunParamsSpecificVersion = calib.fRunParamsSpecificVersion; + return *this; } @@ -187,23 +323,40 @@ AliTOFcalib::~AliTOFcalib() //TOF Calibration Class dtor if(!(AliCDBManager::Instance()->GetCacheFlag())){ // CDB objects must NOT be deleted if cache is active! if (fTOFCalOnline){ - // fTOFCalOnline->Clear(); delete fTOFCalOnline; } + if (fTOFCalOnlinePulser){ + delete fTOFCalOnlinePulser; + } + if (fTOFCalOnlineNoise){ + delete fTOFCalOnlineNoise; + } + if (fTOFCalOnlineHW){ + delete fTOFCalOnlineHW; + } if (fTOFCalOffline){ - //fTOFCalOffline->Clear(); delete fTOFCalOffline; } - if (fTOFSimCalOnline){ - //fTOFSimCalOnline->Clear(); - delete fTOFSimCalOnline; + if (fCal){ + delete fCal; } - if (fTOFSimCalOffline){ - //fTOFSimCalOffline->Clear(); - delete fTOFSimCalOffline; + if (fStatus){ + delete fStatus; } + if (fConfigMap){ + delete fConfigMap; + } + if (fDeltaBCOffset) delete fDeltaBCOffset; + if (fCTPLatency) delete fCTPLatency; + if (fT0Fill) delete fT0Fill; + if (fRunParams) delete fRunParams; + if (fResponseParams) delete fResponseParams; + if (fReadoutEfficiency) delete fReadoutEfficiency; + if (fProblematic) delete fProblematic; } if (fTree!=0x0) delete fTree; + if (fChain!=0x0) delete fChain; + } //_____________________________________________________________________________ void AliTOFcalib::CreateCalArrays(){ @@ -211,42 +364,167 @@ void AliTOFcalib::CreateCalArrays(){ // creating arrays for online/offline calibration objs fTOFCalOnline = new TObjArray(fNChannels); + fTOFCalOnlinePulser = new TObjArray(fNChannels); + fTOFCalOnlineNoise = new TObjArray(fNChannels); + fTOFCalOnlineHW = new TObjArray(fNChannels); fTOFCalOffline = new TObjArray(fNChannels); fTOFCalOnline->SetOwner(); + fTOFCalOnlinePulser->SetOwner(); + fTOFCalOnlineNoise->SetOwner(); + fTOFCalOnlineHW->SetOwner(); fTOFCalOffline->SetOwner(); for (Int_t iarray = 0; iarrayAddAt(calChOnline,iarray); + fTOFCalOnlinePulser->AddAt(calChOnlineStPulser,iarray); + fTOFCalOnlineNoise->AddAt(calChOnlineStNoise,iarray); + fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray); fTOFCalOffline->AddAt(calChOffline,iarray); } + fCal = new AliTOFChannelOnlineArray(fNChannels); + fStatus = new AliTOFChannelOnlineStatusArray(fNChannels); } //_____________________________________________________________________________ -void AliTOFcalib::CreateSimCalArrays(){ +void AliTOFcalib::CreateCalObjects(){ - // creating arrays for simulation online/offline calibration objs + // creating arrays for online/offline calibration objs - fTOFSimCalOnline = new TObjArray(fNChannels); - fTOFSimCalOffline = new TObjArray(fNChannels); - fTOFSimCalOnline->SetOwner(); - fTOFSimCalOffline->SetOwner(); + fTOFCalOffline = new TObjArray(fNChannels); + fTOFCalOffline->SetOwner(); for (Int_t iarray = 0; iarrayAddAt(simCalChOnline,iarray); - fTOFSimCalOffline->AddAt(simCalChOffline,iarray); + AliTOFChannelOffline * calChOffline = new AliTOFChannelOffline(); + fTOFCalOffline->AddAt(calChOffline,iarray); + } + fCal = new AliTOFChannelOnlineArray(fNChannels); + fStatus = new AliTOFChannelOnlineStatusArray(fNChannels); +} +//_____________________________________________________________________________ +void AliTOFcalib::WriteConfigMapOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun) +{ + //Write calibration parameters to the CDB + SetFirstRun(minrun); + SetLastRun(maxrun); + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliDebug(2,Form("Writing TOF configuration map for online calib on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); + AliCDBId id(out,fFirstRun,fLastRun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fConfigMap) { + // deve uscire!! + } + man->Put(fConfigMap,id,md); + delete md; +} +//_____________________________________________________________________________ + +void AliTOFcalib::WriteConfigMapOnCDB(const Char_t *sel) +{ + //Write calibration parameters to the CDB with infinite validity + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliCDBRunRange runrange(fFirstRun,fLastRun); + AliDebug(2,Form("Writing TOF config map for online calib on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun())); + AliCDBId id(out,runrange); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fConfigMap) { + // deve uscire!! + } + man->Put(fConfigMap,id,md); + delete md; +} +//_____________________________________________________________________________ +void AliTOFcalib::WriteParOnlineDelayOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun) +{ + //Write calibration parameters to the CDB -------> new calib objs!!!!! + SetFirstRun(minrun); + SetLastRun(maxrun); + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); + AliCDBId id(out,fFirstRun,fLastRun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fCal) { + // deve uscire!! + } + man->Put(fCal,id,md); + delete md; +} +//_____________________________________________________________________________ +void AliTOFcalib::WriteParOnlineStatusOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun) +{ + //Write calibration parameters to the CDB -------> new calib objs!!!!! + SetFirstRun(minrun); + SetLastRun(maxrun); + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliDebug(2,Form("Writing TOF online status calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); + AliCDBId id(out,fFirstRun,fLastRun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fStatus) { + // deve uscire!! + } + man->Put(fStatus,id,md); + delete md; +} +//_____________________________________________________________________________ + +void AliTOFcalib::WriteParOnlineDelayOnCDB(const Char_t *sel) +{ + //Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!! + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliCDBRunRange runrange(fFirstRun,fLastRun); + AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun())); + AliCDBId id(out,runrange); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fCal) { + // deve uscire!! + } + man->Put(fCal,id,md); + delete md; +} +//_____________________________________________________________________________ + +void AliTOFcalib::WriteParOnlineStatusOnCDB(const Char_t *sel) +{ + //Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!! + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliCDBRunRange runrange(fFirstRun,fLastRun); + AliDebug(2,Form("Writing TOF online status calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun())); + AliCDBId id(out,runrange); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fStatus) { + // deve uscire!! } + man->Put(fStatus,id,md); + delete md; } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun) +void AliTOFcalib::WriteParOnlineOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun) { //Write calibration parameters to the CDB SetFirstRun(minrun); SetLastRun(maxrun); AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); + const Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); AliCDBId id(out,fFirstRun,fLastRun); AliCDBMetaData *md = new AliCDBMetaData(); @@ -258,14 +536,70 @@ void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun) delete md; } //_____________________________________________________________________________ +void AliTOFcalib::WriteParOnlinePulserOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun) +{ + //Write calibration parameters from pulser to the CDB + SetFirstRun(minrun); + SetLastRun(maxrun); + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliDebug(2,Form("Writing TOF online calib obj from pulser on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); + AliCDBId id(out,fFirstRun,fLastRun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fTOFCalOnlinePulser) { + // deve uscire!! + } + man->Put(fTOFCalOnlinePulser,id,md); + delete md; +} +//_____________________________________________________________________________ +void AliTOFcalib::WriteParOnlineNoiseOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun) +{ + //Write calibration parameters from noise to the CDB + SetFirstRun(minrun); + SetLastRun(maxrun); + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliDebug(2,Form("Writing TOF online calib obj from noise on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); + AliCDBId id(out,fFirstRun,fLastRun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fTOFCalOnlineNoise) { + // deve uscire!! + } + man->Put(fTOFCalOnlineNoise,id,md); + delete md; +} +//_____________________________________________________________________________ +void AliTOFcalib::WriteParOnlineHWOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun) +{ + //Write calibration parameters from hardware to the CDB + SetFirstRun(minrun); + SetLastRun(maxrun); + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliDebug(2,Form("Writing TOF online calib obj from hardware on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); + AliCDBId id(out,fFirstRun,fLastRun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fTOFCalOnlineHW) { + // deve uscire!! + } + man->Put(fTOFCalOnlineHW,id,md); + delete md; +} +//_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel) +void AliTOFcalib::WriteParOnlineOnCDB(const Char_t *sel) { //Write calibration parameters to the CDB with infinite validity AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); + const Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); AliCDBRunRange runrange(fFirstRun,fLastRun); AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun())); AliCDBId id(out,runrange); @@ -279,15 +613,71 @@ void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel) } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun) +void AliTOFcalib::WriteParOnlinePulserOnCDB(const Char_t *sel) +{ + //Write calibration parameters from pulser to the CDB with infinite validity + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliCDBRunRange runrange(fFirstRun,fLastRun); + AliDebug(2,Form("Writing TOF online calib obj from pulser on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun())); + AliCDBId id(out,runrange); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fTOFCalOnlinePulser) { + // deve uscire!! + } + man->Put(fTOFCalOnlinePulser,id,md); + delete md; +} +//_____________________________________________________________________________ + +void AliTOFcalib::WriteParOnlineNoiseOnCDB(const Char_t *sel) +{ + //Write calibration parameters from noise to the CDB with infinite validity + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliCDBRunRange runrange(fFirstRun,fLastRun); + AliDebug(2,Form("Writing TOF online calib obj from noise on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun())); + AliCDBId id(out,runrange); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fTOFCalOnlineNoise) { + // deve uscire!! + } + man->Put(fTOFCalOnlineNoise,id,md); + delete md; +} +//_____________________________________________________________________________ + +void AliTOFcalib::WriteParOnlineHWOnCDB(const Char_t *sel) +{ + //Write calibration parameters from hardware to the CDB with infinite validity + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor + TString out(Form("%s/%s",sel,sel1)); + AliCDBRunRange runrange(fFirstRun,fLastRun); + AliDebug(2,Form("Writing TOF online calib obj from harware on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun())); + AliCDBId id(out,runrange); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Chiara Zampolli"); + if (!fTOFCalOnlineHW) { + // deve uscire!! + } + man->Put(fTOFCalOnlineHW,id,md); + delete md; +} +//_____________________________________________________________________________ + +void AliTOFcalib::WriteParOfflineOnCDB(const Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun) { //Write calibration parameters to the CDB SetFirstRun(minrun); SetLastRun(maxrun); AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "ParOffline" ; - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); + const Char_t *sel1 = "ParOffline" ; + TString out(Form("%s/%s",sel,sel1)); AliDebug(2,Form("Writing TOF offline calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); AliCDBId id(out,fFirstRun,fLastRun); AliCDBMetaData *md = new AliCDBMetaData(); @@ -298,13 +688,12 @@ void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity, Int_ } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity) +void AliTOFcalib::WriteParOfflineOnCDB(const Char_t *sel, const Char_t *validity) { //Write calibration parameters to the CDB with infinite validity AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "ParOffline" ; - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); + const Char_t *sel1 = "ParOffline" ; + TString out(Form("%s/%s",sel,sel1)); AliCDBRunRange runrange(fFirstRun,fLastRun); AliDebug(2,Form("Writing TOF offline calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun())); AliCDBId id(out,runrange); @@ -316,187 +705,279 @@ void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity) } //_____________________________________________________________________________ -Bool_t AliTOFcalib::ReadParOnlineFromCDB(Char_t *sel, Int_t nrun) +Bool_t AliTOFcalib::ReadConfigMapFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from the CDB AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "ParOnline" ; - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); - if (!man->Get(out,nrun)) { - return kFALSE; - } + const Char_t *sel1 = "Config" ; + TString out(Form("%s/%s",sel,sel1)); AliCDBEntry *entry = man->Get(out,nrun); + if (!entry) { + AliFatal("Exiting, no CDB object (ConfigMap) found!!!"); + exit(0); + } if(!entry->GetObject()){ - return kFALSE; + AliFatal("Exiting, no CDB object (ConfigMap) found!!!"); + exit(0); } - fTOFCalOnline =(TObjArray*)entry->GetObject(); + fConfigMap =(TMap*)entry->GetObject(); return kTRUE; } //_____________________________________________________________________________ -Bool_t AliTOFcalib::ReadParOfflineFromCDB(Char_t *sel, Int_t nrun) +Bool_t AliTOFcalib::ReadParOnlineDelayFromCDB(const Char_t *sel, Int_t nrun) { - //Read calibration parameters from the CDB + //Read calibration parameters from the CDB -------> new calib objs!!!!! AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "ParOffline" ; - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); - if (!man->Get(out,nrun)) { - return kFALSE; - } + const Char_t *sel1 = "ParOnlineDelay" ; + TString out(Form("%s/%s",sel,sel1)); AliCDBEntry *entry = man->Get(out,nrun); + if (!entry) { + AliFatal("Exiting, no CDB object (ParOnlineDelay) found!!!"); + exit(0); + } if(!entry->GetObject()){ - return kFALSE; + AliFatal("Exiting, no CDB object (ParOnlineDelay) found!!!"); + exit(0); } - AliCDBMetaData * md = entry->GetMetaData(); - fkValidity = md->GetComment(); - fTOFCalOffline =(TObjArray*)entry->GetObject(); + + fCal =(AliTOFChannelOnlineArray*)entry->GetObject(); return kTRUE; } //_____________________________________________________________________________ -void AliTOFcalib::WriteSimParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, TObjArray *calOnline){ - //Write Sim miscalibration parameters to the CDB - - fTOFSimCalOnline=calOnline; - AliCDBManager *man = AliCDBManager::Instance(); - AliCDBMetaData *md = new AliCDBMetaData(); - md->SetResponsible("Chiara Zampolli"); - Char_t *sel1 = "SimParOnline" ; - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); - AliCDBId id1(out,minrun,maxrun); - man->Put(fTOFSimCalOnline,id1,md); - delete md; -} -//_____________________________________________________________________________ -void AliTOFcalib::WriteSimParOfflineOnCDB(Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun, TObjArray *calOffline, TH1F *histo){ - //Write Sim miscalibration parameters to the CDB - fTOFSimToT=histo; - fTOFSimCalOffline=calOffline; - AliCDBManager *man = AliCDBManager::Instance(); - AliCDBMetaData *md = new AliCDBMetaData(); - md->SetResponsible("Chiara Zampolli"); - md->SetComment(validity); - Char_t *sel1 = "SimParOffline" ; - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); - AliCDBId id1(out,minrun,maxrun); - man->Put(fTOFSimCalOffline,id1,md); - Char_t *sel2 = "SimHisto" ; - sprintf(out,"%s/%s",sel,sel2); - AliCDBMetaData *mdhisto = new AliCDBMetaData(); - mdhisto->SetResponsible("Chiara Zampolli"); - AliCDBId id2(out,minrun,maxrun); - man->Put(fTOFSimToT,id2,mdhisto); - delete md; - delete mdhisto; -} -//_____________________________________________________________________________ -void AliTOFcalib::ReadSimParOnlineFromCDB(Char_t *sel, Int_t nrun) +Bool_t AliTOFcalib::ReadParOnlineStatusFromCDB(const Char_t *sel, Int_t nrun) { - //Read miscalibration parameters from the CDB + //Read calibration parameters from the CDB -------> new calib objs!!!!! AliCDBManager *man = AliCDBManager::Instance(); - - // The Slewing Pars - - Char_t *sel1 = "SimParOnline" ; - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); - if (!man->Get(out,nrun)) { - AliFatal("Exiting, no CDB object (SimParOnline) found!!!"); + const Char_t *sel1 = "Status" ; + TString out(Form("%s/%s",sel,sel1)); + AliCDBEntry *entry = man->Get(out,nrun); + if (!entry) { + AliFatal("Exiting, no CDB object (Status) found!!!"); exit(0); } - AliCDBEntry *entry1 = man->Get(out,nrun); - if(!entry1->GetObject()){ - AliFatal("Exiting, no CDB object (SimParOnline) found!!!"); + if(!entry->GetObject()){ + AliFatal("Exiting, no CDB object (Status) found!!!"); exit(0); } - TObjArray *cal =(TObjArray*)entry1->GetObject(); - fTOFSimCalOnline=cal; + + fStatus =(AliTOFChannelOnlineStatusArray*)entry->GetObject(); + return kTRUE; + } //_____________________________________________________________________________ -void AliTOFcalib::ReadSimParOfflineFromCDB(Char_t *sel, Int_t nrun) + +Bool_t AliTOFcalib::ReadParOnlineFromCDB(const Char_t *sel, Int_t nrun) { - //Read miscalibration parameters from the CDB + //Read calibration parameters from the CDB AliCDBManager *man = AliCDBManager::Instance(); - - // The Slewing Pars - - Char_t *sel1 = "SimParOffline" ; - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); - if (!man->Get(out,nrun)) { - AliFatal("Exiting, no CDB object (SimParOffline) found!!!"); + const Char_t *sel1 = "ParOnline" ; + TString out(Form("%s/%s",sel,sel1)); + AliCDBEntry *entry = man->Get(out,nrun); + if (!entry) { + AliFatal("Exiting, no CDB object (ParOnline) found!!!"); exit(0); } - AliCDBEntry *entry1 = man->Get(out,nrun); - if(!entry1->GetObject()){ - AliFatal("Exiting, no CDB object (SimParOffline) found!!!"); + if(!entry->GetObject()){ + AliFatal("Exiting, no CDB object (ParOnline) found!!!"); exit(0); } - TObjArray *cal =(TObjArray*)entry1->GetObject(); - AliCDBMetaData *md = (AliCDBMetaData*)entry1->GetMetaData(); - fkValidity = md->GetComment(); - fTOFSimCalOffline=cal; + + fTOFCalOnline =(TObjArray*)entry->GetObject(); - // The Tot Histo + return kTRUE; + +} +//_____________________________________________________________________________ - Char_t *sel2 = "SimHisto" ; - sprintf(out,"%s/%s",sel,sel2); - if (!man->Get(out,nrun)) { - AliFatal("Exiting, no CDB object (SimHisto) found!!!"); +Bool_t AliTOFcalib::ReadParOnlinePulserFromCDB(const Char_t *sel, Int_t nrun) +{ + //Read calibration parameters from pulser from the CDB + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "Pulser" ; + TString out(Form("%s/%s",sel,sel1)); + AliCDBEntry *entry = man->Get(out,nrun); + if (!entry) { + AliFatal("Exiting, no CDB object (Pulser) found!!!"); exit(0); } - AliCDBEntry *entry2 = man->Get(out,nrun); - if(!entry2->GetObject()){ - AliFatal("Exiting, no CDB object (SimHisto) found!!!"); + if(!entry->GetObject()){ + AliFatal("Exiting, no CDB object (Pulser) found!!!"); exit(0); } - TH1F *histo =(TH1F*)entry2->GetObject(); - fTOFSimToT=histo; + + fTOFCalOnlinePulser =(TObjArray*)entry->GetObject(); + + return kTRUE; + } //_____________________________________________________________________________ -void AliTOFcalib::WriteRecParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param){ + +Bool_t AliTOFcalib::ReadParOnlineNoiseFromCDB(const Char_t *sel, Int_t nrun) +{ + //Read calibration parameters from noise from the CDB + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "Noise" ; + TString out(Form("%s/%s",sel,sel1)); + AliCDBEntry *entry = man->Get(out,nrun); + if (!entry) { + AliFatal("Exiting, no CDB object (Noise) found!!!"); + exit(0); + } + if(!entry->GetObject()){ + AliFatal("Exiting, no CDB object (Noise) found!!!"); + exit(0); + } + + fTOFCalOnlineNoise =(TObjArray*)entry->GetObject(); + + return kTRUE; + +} +//_____________________________________________________________________________ + +Bool_t AliTOFcalib::ReadParOnlineHWFromCDB(const Char_t *sel, Int_t nrun) +{ + //Read calibration parameters from hardware from the CDB + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "HW" ; + TString out(Form("%s/%s",sel,sel1)); + AliCDBEntry *entry = man->Get(out,nrun); + if (!entry) { + AliFatal("Exiting, no CDB object (HW map) found!!!"); + exit(0); + } + if(!entry->GetObject()){ + AliFatal("Exiting, no CDB object (HW map) found!!!"); + exit(0); + } + + fTOFCalOnlineHW =(TObjArray*)entry->GetObject(); + + return kTRUE; + +} +//_____________________________________________________________________________ + +Bool_t AliTOFcalib::ReadParOfflineFromCDB(const Char_t *sel, Int_t nrun) +{ + //Read calibration parameters from the CDB + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "ParOffline" ; + TString out(Form("%s/%s",sel,sel1)); + AliCDBEntry *entry = man->Get(out,nrun); + if (!entry) { + AliFatal("Exiting, no CDB object (ParOffline) found!!!"); + exit(0); + } + if(!entry->GetObject()){ + AliFatal("Exiting, no CDB object (ParOffline) found!!!"); + exit(0); + } + AliCDBMetaData * md = entry->GetMetaData(); + fkValidity = md->GetComment(); + fTOFCalOffline =(TObjArray*)entry->GetObject(); + + return kTRUE; + +} +//_____________________________________________________________________________ +void AliTOFcalib::WriteSimHistoOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun, TH1F *histo){ + //Write Sim miscalibration parameters to the CDB + + fTOFSimToT=histo; + AliCDBManager *man = AliCDBManager::Instance(); + const Char_t *sel1 = "SimHisto" ; + TString out(Form("%s/%s",sel,sel1)); + AliCDBMetaData *mdhisto = new AliCDBMetaData(); + mdhisto->SetResponsible("Chiara Zampolli"); + AliCDBId id(out,minrun,maxrun); + man->Put(fTOFSimToT,id,mdhisto); + delete mdhisto; +} +//_____________________________________________________________________________ +Bool_t AliTOFcalib::ReadSimHistoFromCDB(const Char_t *sel, Int_t nrun) +{ + //Read miscalibration parameters from the CDB + AliCDBManager *man = AliCDBManager::Instance(); + + // The Tot Histo + + const Char_t *sel1 = "SimHisto" ; + TString out(Form("%s/%s",sel,sel1)); + AliCDBEntry *entry = man->Get(out,nrun); + if (!entry) { + AliFatal("Exiting, no CDB object (SimHisto) found!!!"); + exit(0); + } + if(!entry->GetObject()){ + AliFatal("Exiting, no CDB object (SimHisto) found!!!"); + exit(0); + } + TH1F *histo =(TH1F*)entry->GetObject(); + fTOFSimToT=histo; + return kTRUE; +} +//_____________________________________________________________________________ +void AliTOFcalib::WriteRecParOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param){ + //Write reconstruction parameters to the CDB + + AliCDBManager *man = AliCDBManager::Instance(); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Silvia Arcelli"); + const Char_t *sel1 = "RecoParam" ; + TString out(Form("%s/%s",sel,sel1)); + AliCDBId id(out,minrun,maxrun); + + TObjArray *arr=new TObjArray(1); + arr->AddLast(param); + man->Put(arr,id,md); + //man->Put(param,id,md); + delete md; +} +//_____________________________________________________________________________ +void AliTOFcalib::WriteRecParOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun, TObjArray *arr){ //Write reconstruction parameters to the CDB AliCDBManager *man = AliCDBManager::Instance(); AliCDBMetaData *md = new AliCDBMetaData(); md->SetResponsible("Silvia Arcelli"); - Char_t *sel1 = "RecPar" ; - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); + const Char_t *sel1 = "RecoParam" ; + TString out(Form("%s/%s",sel,sel1)); AliCDBId id(out,minrun,maxrun); - man->Put(param,id,md); + man->Put(arr,id,md); delete md; } //_____________________________________________________________________________ -AliTOFRecoParam * AliTOFcalib::ReadRecParFromCDB(Char_t *sel, Int_t nrun) +AliTOFRecoParam * AliTOFcalib::ReadRecParFromCDB(const Char_t *sel, Int_t nrun, Int_t eventType) { //Read reconstruction parameters from the CDB AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "RecPar" ; - Char_t out[100]; - sprintf(out,"%s/%s",sel,sel1); - if (!man->Get(out,nrun)) { - AliFatal("Exiting, no CDB object (RecPar) found!!!"); + const Char_t *sel1 = "RecoParam" ; + TString out(Form("%s/%s",sel,sel1)); + AliCDBEntry *entry = man->Get(out,nrun); + if (!entry) { + AliFatal("Exiting, no CDB object (RecoParam) found!!!"); exit(0); } - AliCDBEntry *entry = man->Get(out,nrun); if(!entry->GetObject()){ - AliFatal("Exiting, no CDB object (RecPar) found!!!"); + AliFatal("Exiting, no CDB object (RecoParam) found!!!"); exit(0); } - AliTOFRecoParam *param=(AliTOFRecoParam*)entry->GetObject(); + TObjArray *array = (TObjArray*)entry->GetObject(); + AliTOFRecoParam *param=0x0; + if (eventType>=0 || eventTypeGetEntries()) + param=(AliTOFRecoParam*)array->At(eventType); return param; + } //----------------------------------------------------------------------------- // Calibration methods @@ -513,19 +994,17 @@ void AliTOFcalib::CreateTreeFromCDB(Int_t minrun, Int_t maxrun){ fTree->Branch("nentries",&nentries,"nentries/I"); fTree->Branch("TOFentries",p,"TOFentries[nentries]/F"); AliCDBManager *man = AliCDBManager::Instance(); - AliCDBStorage *aStorage = man->GetStorage("local://$ALICE_ROOT"); + AliCDBStorage *aStorage = man->GetStorage("local://$ALICE_ROOT/OCDB"); for (Int_t irun = minrun;irun<=maxrun;irun++){ AliCDBEntry *entry = aStorage->Get("TOF/RefData/TreeForCalib",irun); if (!entry){ AliInfo(Form("No entry found for run %i",irun)); } else{ - TTree *tree = new TTree(); - tree = (TTree*)entry->GetObject(); + TTree *tree = (TTree*)entry->GetObject(); tree->SetBranchAddress("nentries",&nentries); tree->SetBranchAddress("TOFentries",p); fTree->CopyEntries(tree); - delete tree; fNruns++; } } @@ -547,10 +1026,10 @@ void AliTOFcalib::CreateTreeFromGrid(Int_t minrun, Int_t maxrun){ AliInfo("connected to alien"); TGrid::Connect("alien://"); - Char_t filename[100]; + TString filename; for (Int_t irun = minrun;irun<=maxrun;irun++){ - sprintf(filename,"alien:///alice/cern.ch/user/c/czampolli/TOFCalibReference_%i.root",irun); - TFile *filegrid = TFile::Open(filename,"READ"); + filename = Form("alien:///alice/cern.ch/user/c/czampolli/TOFCalibReference_%i.root",irun); + TFile *filegrid = TFile::Open(filename.Data(),"READ"); TTree *tree = (TTree*)filegrid->Get("T"); tree->SetBranchAddress("nentries",&nentries); tree->SetBranchAddress("TOFentries",p); @@ -574,10 +1053,10 @@ void AliTOFcalib::CreateTreeFromFile(Int_t minrun, Int_t maxrun){ fTree->SetDirectory(0); fTree->Branch("nentries",&nentries,"nentries/I"); fTree->Branch("TOFentries",p,"TOFentries[nentries]/F"); - Char_t filename[100]; + TString filename; for (Int_t irun = minrun;irun<=maxrun;irun++){ - sprintf(filename,"$ALICE_ROOT/TOF/RefData/TreeForCalib/fileout_%i.root",irun); - TFile *file = new TFile(filename,"READ"); + filename = Form("$ALICE_ROOT/TOF/RefData/TreeForCalib/fileout_%i.root",irun); + TFile *file = new TFile(filename.Data(),"READ"); TTree *tree = (TTree*)file->Get("T"); tree->SetBranchAddress("nentries",&nentries); tree->SetBranchAddress("TOFentries",p); @@ -591,6 +1070,26 @@ void AliTOFcalib::CreateTreeFromFile(Int_t minrun, Int_t maxrun){ AliInfo(Form("Number of runs being analyzed %i",fNruns)); } //----------------------------------------------------------------------------- +void AliTOFcalib::CreateChainFromGrid(Int_t minrun, Int_t maxrun){ + + // creating the chain with the trees for calibration + // collecting them from the Grid + // from minrun to maxrun + + fChain = new TChain("T"); + AliInfo("connected to alien"); + TGrid::Connect("alien://"); + + TString filename; + for (Int_t irun = minrun;irun<=maxrun;irun++){ + filename = Form("alien:///alice/cern.ch/user/c/czampolli/TOFCalibReference_%i.root",irun); + fChain->Add(filename.Data()); + fNruns++; + } + + AliInfo(Form("Number of runs being analyzed %i",fNruns)); +} +//----------------------------------------------------------------------------- Int_t AliTOFcalib::Calibrate(Int_t ichmin, Int_t ichmax, Option_t *optionSave, Option_t *optionFit){ // calibrating summing more than one channels @@ -609,15 +1108,18 @@ Int_t AliTOFcalib::Calibrate(Int_t ichmin, Int_t ichmax, Option_t *optionSave, O Float_t p[CHENTRIESSMALL]; Int_t nentries; - fTree->SetBranchAddress("nentries",&nentries); - fTree->SetBranchAddress("TOFentries",p); + //fTree->SetBranchAddress("nentries",&nentries); + //fTree->SetBranchAddress("TOFentries",p); + fChain->SetBranchAddress("nentries",&nentries); + fChain->SetBranchAddress("TOFentries",p); Float_t ntracksTotalmean =0; for (Int_t i=ichmin; iGetEntry(ientry); + //fTree->GetEntry(ientry); + fChain->GetEntry(ientry); Int_t ntracksRun=nentries/3; ntracksTotalmean+=ntracksRun; } @@ -646,7 +1148,8 @@ Int_t AliTOFcalib::Calibrate(Int_t ichmin, Int_t ichmax, Option_t *optionSave, O Int_t ientry = -1; for (Int_t irun=0;irunGetEntry(ientry); + //fTree->GetEntry(ientry); + fChain->GetEntry(ientry); ntracksTotal+=nentries/3; ntracksRun=nentries/3; AliDebug(2,Form("run %i, channel %i, nentries = %i, ntracks = %i",irun,i,nentries, ntracksRun)); @@ -662,7 +1165,9 @@ Int_t AliTOFcalib::Calibrate(Int_t ichmin, Int_t ichmax, Option_t *optionSave, O } } nusefulbins = FindBins(hToT,&binsProfile[0]); - meantime/=ntracksTotal; + if (ntracksTotal != 0){ + meantime/=ntracksTotal; + } AliDebug(2, Form("meantime = %f",meantime)); for (Int_t j=1;j<=nusefulbins;j++) { @@ -676,7 +1181,8 @@ Int_t AliTOFcalib::Calibrate(Int_t ichmin, Int_t ichmax, Option_t *optionSave, O Int_t ientry = -1; for (Int_t i=ichmin; iGetEntry(ientry); + //fTree->GetEntry(ientry); + fChain->GetEntry(ientry); ntracksRun=nentries/3; for (Int_t j=0;jSetBranchAddress("nentries",&nentries); - fTree->SetBranchAddress("TOFentries",p); + //fTree->SetBranchAddress("nentries",&nentries); + //fTree->SetBranchAddress("TOFentries",p); + fChain->SetBranchAddress("nentries",&nentries); + fChain->SetBranchAddress("TOFentries",p); Float_t ntracksTotal =0; for (Int_t irun=0;irunGetEntry(ientry); + //fTree->GetEntry(ientry); + fChain->GetEntry(ientry); ntracksTotal+=nentries/3; } @@ -779,7 +1288,8 @@ Int_t AliTOFcalib::Calibrate(Int_t i, Option_t *optionSave, Option_t *optionFit) for (Int_t irun=0;irunGetEntry(ientry); + //fTree->GetEntry(ientry); + fChain->GetEntry(ientry); ntracksRun=nentries/3; AliDebug(2,Form("run %i, channel %i, nentries = %i, ntracksRun = %i",irun, i ,nentries, ntracksRun)); for (Int_t j=0;jGetEntry(ientry); + //fTree->GetEntry(ientry); + fChain->GetEntry(ientry); ntracksRun=nentries/3; for (Int_t j=0;jSetBranchAddress("nentries",&nentries); - fTree->SetBranchAddress("TOFentries",p); + //fTree->SetBranchAddress("nentries",&nentries); + //fTree->SetBranchAddress("TOFentries",p); + fChain->SetBranchAddress("nentries",&nentries); + fChain->SetBranchAddress("TOFentries",p); Float_t ntracksTotalmean =0; for (Int_t ich=0; ichGetEntry(ientry); + //fTree->GetEntry(ientry); + fChain->GetEntry(ientry); ntracksTotalmean+=nentries/3; } } @@ -924,17 +1438,19 @@ Int_t AliTOFcalib::Calibrate(Int_t nch, Int_t *ch, Option_t *optionSave, Option_ for (Int_t irun=0;irunGetEntry(i); + //fTree->GetEntry(i); + fChain->GetEntry(i); ntracksTotal+=nentries/3; } if (ntracksTotal < MEANENTRIES) { - AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %f), not calibrating channel and continuing.....",i,ntracksTotal)); + AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %d), not calibrating channel and continuing.....",i,ntracksTotal)); continue; } for (Int_t irun=0;irunGetEntry(i); + i = ch[ich]+irun*fNChannels; + //fTree->GetEntry(i); + fChain->GetEntry(i); ntracksRun=nentries/3; for (Int_t j=0;jGetEntry(i); + i = ch[ich]+irun*fNChannels; + //fTree->GetEntry(i); + fChain->GetEntry(i); ntracksRun=nentries/3; for (Int_t j=0;jSetBranchAddress("nentries",&nentries); - fTree->SetBranchAddress("TOFentries",p); + //fTree->SetBranchAddress("nentries",&nentries); + //fTree->SetBranchAddress("TOFentries",p); + fChain->SetBranchAddress("nentries",&nentries); + fChain->SetBranchAddress("TOFentries",p); for (Int_t irun=0;irunGetEntry(i); + //fTree->GetEntry(i); + fChain->GetEntry(i); ntracksTotal+=nentries/3; } if (ntracksTotal < MEANENTRIES) { - AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotal)); + AliInfo(Form(" Too small mean number of entires per channel (mean number = %d) not calibrating and exiting.....",ntracksTotal)); return 2; } - TH1F * hProf = new TH1F(); - hProf = Profile(ich); + TH1F * hProf = Profile(ich); hProf->Fit("pol5",optionFit,"",0,4); TF1 * calibfunc = (TF1*)hProf->GetFunction("pol5"); Float_t par[6]; @@ -1094,14 +1613,17 @@ Int_t AliTOFcalib::Calibrate(Option_t *optionSave, Option_t *optionFit){ Float_t p[MAXCHENTRIESSMALL]; Int_t nentries; - fTree->SetBranchAddress("nentries",&nentries); - fTree->SetBranchAddress("TOFentries",p); + //fTree->SetBranchAddress("nentries",&nentries); + //fTree->SetBranchAddress("TOFentries",p); + fChain->SetBranchAddress("nentries",&nentries); + fChain->SetBranchAddress("TOFentries",p); Float_t ntracksTotalmean =0; for (Int_t ii=0; iiGetEntry(i); + //fTree->GetEntry(i); + fChain->GetEntry(i); ntracksTotalmean+=nentries/3; } } @@ -1130,17 +1652,19 @@ Int_t AliTOFcalib::Calibrate(Option_t *optionSave, Option_t *optionFit){ Int_t ntracksTotal = 0; for (Int_t irun=0;irunGetEntry(i); + //fTree->GetEntry(i); + fChain->GetEntry(i); ntracksTotal+=nentries/3; } if (ntracksTotal < MEANENTRIES) { - AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %f), not calibrating channel and continuing.....",ii,ntracksTotal)); + AliInfo(Form(" Too small mean number of entires in channel %i (number of tracks = %d), not calibrating channel and continuing.....",ii,ntracksTotal)); continue; } Float_t meantime=0; for (Int_t irun=0;irunGetEntry(i); + //fTree->GetEntry(i); + fChain->GetEntry(i); ntracksRun=nentries/3; for (Int_t j=0;jGetEntry(i); + //fTree->GetEntry(i); + fChain->GetEntry(i); ntracksRun=nentries/3; for (Int_t j=0;jSetBranchAddress("nentries",&nentries); - fTree->SetBranchAddress("TOFentries",p); + //fTree->SetBranchAddress("nentries",&nentries); + //fTree->SetBranchAddress("TOFentries",p); + fChain->SetBranchAddress("nentries",&nentries); + fChain->SetBranchAddress("TOFentries",p); //Prepare histograms for Slewing Correction const Int_t knbinToT = 100; @@ -1232,9 +1759,9 @@ TH1F* AliTOFcalib::Profile(Int_t ich) Float_t minToT = 0; //ns Float_t maxToT = 5.; //ns Float_t deltaToT = (maxToT-minToT)/knbinToT; - Double_t mTime[knbinToT+1],mToT[knbinToT+1],meanTime[knbinToT+1], meanTime2[knbinToT+1],vToT[knbinToT+1], vToT2[knbinToT+1],meanToT[knbinToT+1],meanToT2[knbinToT+1],vTime[knbinToT+1],vTime2[knbinToT+1],xlow[knbinToT+1],sigmaTime[knbinToT+1]; + Double_t mTime[knbinToT+1],mToT[knbinToT+1],meanTime[knbinToT+1], meanTime2[knbinToT+1],vToT[knbinToT+1], vToT2[knbinToT+1],meanToT[knbinToT+1],meanToT2[knbinToT+1],vTime[knbinToT+1],vTime2[knbinToT+1],sigmaTime[knbinToT+1]; Int_t n[knbinToT+1], nentrx[knbinToT+1]; - Double_t sigmaToT[knbinToT+1]; + //Double_t xlow[knbinToT+1],sigmaToT[knbinToT+1]; // not used for the time being for (Int_t i = 0; i < knbinToT+1 ; i++){ mTime[i]=0; mToT[i]=0; @@ -1247,9 +1774,9 @@ TH1F* AliTOFcalib::Profile(Int_t ich) meanToT2[i]=0; vTime[i]=0; vTime2[i]=0; - xlow[i]=0; + //xlow[i]=0; sigmaTime[i]=0; - sigmaToT[i]=0; + //sigmaToT[i]=0; n[i]=0; nentrx[i]=0; } @@ -1258,7 +1785,8 @@ TH1F* AliTOFcalib::Profile(Int_t ich) TH1F *histo = new TH1F("histo", "1D Time vs ToT", knbinToT, minToT, maxToT); for (Int_t irun=0;irunGetEntry(i); + //fTree->GetEntry(i); + fChain->GetEntry(i); ntracksRun=nentries/3; for (Int_t j=0;jSetResponsible("Roberto Preghenella"); + AliCDBManager *man = AliCDBManager::Instance(); + man->Put(fDeltaBCOffset, id, md); + AliDebug(2,Form("DeltaBCOffset written on CDB with run range [%i, %i] ",minrun ,maxrun)); + delete md; +} + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::WriteCTPLatencyOnCDB(const Char_t *sel , Int_t minrun, Int_t maxrun) +{ + /* + * write CTP latency on CDB + */ + + if (!fCTPLatency) return; + AliCDBId id(Form("%s/CTPLatency", sel), minrun, maxrun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Roberto Preghenella"); + AliCDBManager *man = AliCDBManager::Instance(); + man->Put(fCTPLatency, id, md); + AliDebug(2,Form("CTPLatency written on CDB with run range [%i, %i] ",minrun ,maxrun)); + delete md; +} + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::WriteT0FillOnCDB(const Char_t *sel , Int_t minrun, Int_t maxrun) +{ + /* + * write event-time on CDB + */ + + if (!fT0Fill) return; + AliCDBId id(Form("%s/T0Fill", sel), minrun, maxrun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Roberto Preghenella"); + AliCDBManager *man = AliCDBManager::Instance(); + man->Put(fT0Fill, id, md); + AliDebug(2,Form("T0Fill written on CDB with run range [%i, %i] ",minrun ,maxrun)); + delete md; +} + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::WriteRunParamsOnCDB(const Char_t *sel , Int_t minrun, Int_t maxrun) +{ + /* + * write run params on CDB + */ + + if (!fRunParams) return; + AliCDBId id(Form("%s/RunParams", sel), minrun, maxrun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Roberto Preghenella"); + AliCDBManager *man = AliCDBManager::Instance(); + man->Put(fRunParams, id, md); + AliDebug(2,Form("RunParams written on CDB with run range [%i, %i] ",minrun ,maxrun)); + delete md; +} + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::WriteReadoutEfficiencyOnCDB(const Char_t *sel , Int_t minrun, Int_t maxrun) +{ + /* + * write readout efficiency on CDB + */ + + if (!fReadoutEfficiency) return; + AliCDBId id(Form("%s/ReadoutEfficiency", sel), minrun, maxrun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Roberto Preghenella"); + AliCDBManager *man = AliCDBManager::Instance(); + man->Put(fReadoutEfficiency, id, md); + AliDebug(2,Form("ReadoutEfficiency written on CDB with run range [%i, %i] ",minrun ,maxrun)); + delete md; +} + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::WriteProblematicOnCDB(const Char_t *sel , Int_t minrun, Int_t maxrun) +{ + /* + * write problematic on CDB + */ + + if (!fProblematic) return; + AliCDBId id(Form("%s/Problematic", sel), minrun, maxrun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("Roberto Preghenella"); + AliCDBManager *man = AliCDBManager::Instance(); + man->Put(fProblematic, id, md); + AliDebug(2,Form("Problematic written on CDB with run range [%i, %i] ",minrun ,maxrun)); + delete md; +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::ReadDeltaBCOffsetFromCDB(const Char_t *sel , Int_t nrun) +{ + /* + * read deltaBC offset from CDB + */ + + AliCDBManager *man = AliCDBManager::Instance(); + AliCDBEntry *entry = man->Get(Form("%s/DeltaBCOffset", sel),nrun); + if (!entry) { + AliFatal("No DeltaBCOffset entry found in CDB"); + exit(0); + } + fDeltaBCOffset =(AliTOFDeltaBCOffset *)entry->GetObject(); + if(!fDeltaBCOffset){ + AliFatal("No DeltaBCOffset object found in CDB entry"); + exit(0); + } + return kTRUE; +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::ReadCTPLatencyFromCDB(const Char_t *sel , Int_t nrun) +{ + /* + * read CTP latency from CDB + */ + + AliCDBManager *man = AliCDBManager::Instance(); + AliCDBEntry *entry = man->Get(Form("%s/CTPLatency", sel),nrun); + if (!entry) { + AliFatal("No CTPLatency entry found in CDB"); + exit(0); + } + fCTPLatency =(AliTOFCTPLatency *)entry->GetObject(); + if(!fCTPLatency){ + AliFatal("No CTPLatency object found in CDB entry"); + exit(0); + } + return kTRUE; +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::ReadT0FillFromCDB(const Char_t *sel , Int_t nrun) +{ + /* + * read event-time from CDB + */ + + AliCDBManager *man = AliCDBManager::Instance(); + AliCDBEntry *entry = man->Get(Form("%s/T0Fill", sel),nrun); + if (!entry) { + AliFatal("No T0Fill entry found in CDB"); + exit(0); + } + fT0Fill =(AliTOFT0Fill *)entry->GetObject(); + if(!fT0Fill){ + AliFatal("No T0Fill object found in CDB entry"); + exit(0); + } + return kTRUE; +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::ReadRunParamsFromCDB(const Char_t *sel , Int_t nrun) +{ + /* + * read run params from CDB + */ + + AliCDBManager *man = AliCDBManager::Instance(); + AliCDBEntry *entry = man->Get(Form("%s/RunParams", sel),nrun, fRunParamsSpecificVersion); + if (!entry) { + AliFatal("No RunParams entry found in CDB"); + exit(0); + } + fRunParams =(AliTOFRunParams *)entry->GetObject(); + if(!fRunParams){ + AliFatal("No RunParams object found in CDB entry"); + exit(0); + } + return kTRUE; +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::ReadLHCClockPhaseFromCDB(const Char_t *sel , Int_t nrun) +{ + /* + * read LHC clock-phase from CDB + */ + + AliCDBManager *man = AliCDBManager::Instance(); + AliCDBEntry *entry = man->Get(Form("%s/LHCClockPhase", sel),nrun); + if (!entry) { + AliFatal("No LHCClockPhase entry found in CDB"); + exit(0); + } + fLHCClockPhase =(AliLHCClockPhase *)entry->GetObject(); + if(!fRunParams){ + AliFatal("No LHCClockPhase object found in CDB entry"); + exit(0); + } + return kTRUE; +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::ReadReadoutEfficiencyFromCDB(const Char_t *sel , Int_t nrun) +{ + /* + * read readout efficiency from CDB + */ + + AliCDBManager *man = AliCDBManager::Instance(); + AliCDBEntry *entry = man->Get(Form("%s/ReadoutEfficiency", sel),nrun); + if (!entry) { + AliFatal("No ReadoutEfficiency entry found in CDB"); + exit(0); + } + fReadoutEfficiency = (TH1F *)entry->GetObject(); + if(!fReadoutEfficiency){ + AliFatal("No ReadoutEfficiency object found in CDB entry"); + exit(0); + } + return kTRUE; +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::ReadProblematicFromCDB(const Char_t *sel , Int_t nrun) +{ + /* + * read problematic from CDB + */ + + AliCDBManager *man = AliCDBManager::Instance(); + AliCDBEntry *entry = man->Get(Form("%s/Problematic", sel),nrun); + if (!entry) { + AliFatal("No Problematic entry found in CDB"); + exit(0); + } + fProblematic = (TH1C *)entry->GetObject(); + if(!fProblematic){ + AliFatal("No Problematic object found in CDB entry"); + exit(0); + } + return kTRUE; +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::Init(Int_t run) +{ + /* + * init + */ + + if (fInitFlag) { + AliWarning("the class was already initialized, re-initialize it"); + fInitFlag = kFALSE; + } + + /* read channel status array */ + if (!ReadParOnlineStatusFromCDB("TOF/Calib", run)) { + AliError("cannot get \"Status\" object from OCDB"); + return kFALSE; + } + /* get par offline array */ + if (!ReadParOfflineFromCDB("TOF/Calib", run)) { + AliError("cannot get \"ParOffline\" object from OCDB"); + return kFALSE; + } + /* get deltaBC offset obj */ + if (!ReadDeltaBCOffsetFromCDB("TOF/Calib", run)) { + AliError("cannot get \"DeltaBCOffset\" object from OCDB"); + return kFALSE; + } + /* get CTP latency obj */ + if (!ReadCTPLatencyFromCDB("TOF/Calib", run)) { + AliError("cannot get \"CTPLatency\" object from OCDB"); + return kFALSE; + } + /* get run params obj */ + if (!ReadRunParamsFromCDB("TOF/Calib", run)) { + AliError("cannot get \"RunParams\" object from OCDB"); + return kFALSE; + } + /* get LHC clock-phase obj */ + if (!ReadLHCClockPhaseFromCDB("GRP/Calib", run)) { + AliError("cannot get \"LHCClockPhase\" object from OCDB"); + return kFALSE; + } + /* get readout efficiency obj */ + if (!ReadReadoutEfficiencyFromCDB("TOF/Calib", run)) { + AliError("cannot get \"ReadoutEfficiency\" object from OCDB"); + return kFALSE; + } + /* get readout efficiency obj */ + if (!ReadProblematicFromCDB("TOF/Calib", run)) { + AliError("cannot get \"Problematic\" object from OCDB"); + return kFALSE; + } + /* get response params */ + TFile *responseFile = TFile::Open("$ALICE_ROOT/TOF/data/AliTOFresponsePar.root"); + if (!responseFile || !responseFile->IsOpen()) { + AliError("cannot open \"ResponseParams\" local file"); + return kFALSE; + } + fResponseParams = (AliTOFResponseParams *)responseFile->Get("ResponseParams"); + if (!fResponseParams) { + AliError("cannot get \"ResponseParams\" object from local file"); + return kFALSE; + } + responseFile->Close(); + + /* check whether to use the clock phase */ + if (fRunParams->GetUseLHCClockPhase()) + fUseLHCClockPhase = kTRUE; + + if (fUseLHCClockPhase) + AliInfo("calibration using BPTX LHC clock-phase"); + + /* all done */ + fInitFlag = kTRUE; + return kTRUE; + +} + +//---------------------------------------------------------------------------- + +Double_t +AliTOFcalib::GetTimeCorrection(Int_t index, Double_t tot, Int_t deltaBC, Int_t l0l1, UInt_t timestamp) +{ + /* + * get time correction + */ + + if (!fInitFlag) { + AliError("class not yet initialized. Initialize it before."); + return 0.; + } + + /* deal with L0-L1 orbit crossing (negative values) */ + if (l0l1 < 0) l0l1 += 3564; + + /* get calibration params */ + AliTOFChannelOffline *parOffline = (AliTOFChannelOffline *)fTOFCalOffline->At(index); + Int_t deltaBCOffset = fDeltaBCOffset->GetDeltaBCOffset(); + Float_t ctpLatency = fCTPLatency->GetCTPLatency(); + Float_t tdcLatencyWindow = fStatus->GetLatencyWindow(index) * 1.e3; + Float_t timezero = fRunParams->EvalT0(timestamp); + Float_t clockphase = fLHCClockPhase->GetPhase(timestamp); + /* check whether to remove mean T0. + * useful when one wants to compute mean T0 */ + if (!fRemoveMeanT0) timezero = 0.; + /* check whether to use the clock phase */ + if (fUseLHCClockPhase) timezero -= 1.e3 * clockphase; + + /* compute correction */ + Double_t corr = 0.; + /* deltaBC correction */ + deltaBC = deltaBCOffset; /* inhibit deltaBC correction for the time being */ + corr += (deltaBC - deltaBCOffset) * AliTOFGeometry::BunchCrossingBinWidth(); + /* L0-L1 latency correction */ + corr -= l0l1 * AliTOFGeometry::BunchCrossingBinWidth(); + /* CTP latency correction */ + corr -= ctpLatency; + /* TDC latency window correction */ + corr += tdcLatencyWindow; + /* time-zero correction */ + corr += timezero; + /* time calibration correction */ + if (tot < AliTOFGeometry::SlewTOTMin()) + tot = AliTOFGeometry::SlewTOTMin(); + if (tot > AliTOFGeometry::SlewTOTMax()) + tot = AliTOFGeometry::SlewTOTMax(); + for (Int_t islew = 0; islew < 6; islew++) + corr += parOffline->GetSlewPar(islew) * TMath::Power(tot, islew) * 1.e3; + + /* return correction */ + return corr; +} + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::CalibrateESD(AliESDEvent *event) +{ + /* + * calibrate ESD + */ + + if (!fInitFlag) { + AliError("class not yet initialized. Initialize it before."); + return; + } + + Int_t index, l0l1, deltaBC; + Double_t time, tot, corr; + UInt_t timestamp = event->GetTimeStamp(); + + // calibrating TOF hits + + AliESDTOFHit* hit = NULL; + AliESDtrack* track = NULL; + TClonesArray* esdTOFhits = event->GetESDTOFHits(); + if (esdTOFhits) { // new TOF data structure + for (Int_t ihit = 0; ihit < esdTOFhits->GetEntriesFast(); ihit++) { + + /* get track */ + hit = (AliESDTOFHit*)esdTOFhits->At(ihit); + //if (!track || !(track->GetStatus() & AliESDtrack::kTOFout)) continue; + if (!hit) continue; + + /* calibrate TOF signal */ + if (fCalibrateTOFsignal) { + /* get info */ + index = hit->GetTOFchannel(); + time = hit->GetTimeRaw(); + tot = hit->GetTOT(); + l0l1 = hit->GetL0L1Latency(); + deltaBC = hit->GetDeltaBC(); + /* get correction */ + corr = GetTimeCorrection(index, tot, deltaBC, l0l1, timestamp); + /* apply correction */ + time -= corr; + /* set new TOF signal */ + hit->SetTime(time); + } + + } + } + else { // old TOF data structure + + for (Int_t itrk = 0; itrk < event->GetNumberOfTracks(); itrk++) { + + /* get track */ + track = event->GetTrack(itrk); + if (!track || !(track->GetStatus() & AliESDtrack::kTOFout)) continue; + + /* calibrate TOF signal */ + if (fCalibrateTOFsignal) { + /* get info */ + index = track->GetTOFCalChannel(); + time = track->GetTOFsignalRaw(); + tot = track->GetTOFsignalToT(); + l0l1 = track->GetTOFL0L1(); + deltaBC = track->GetTOFDeltaBC(); + /* get correction */ + corr = GetTimeCorrection(index, tot, deltaBC, l0l1, timestamp); + /* apply correction */ + time -= corr; + /* set new TOF signal */ + track->SetTOFsignal(time); + } + } + + if (fCorrectTExp) + CalibrateTExp(event); + } + +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::IsChannelEnabled(Int_t index, Bool_t checkEfficiency, Bool_t checkProblematic) +{ + /* + * is channel enabled + */ + + if (!fInitFlag) { + AliError("class not yet initialized. Initialize it before."); + return kTRUE; + } + + /* check bad status */ + if (fStatus->GetPulserStatus(index) == AliTOFChannelOnlineStatusArray::kTOFPulserBad) return kFALSE; + if (fStatus->GetNoiseStatus(index) == AliTOFChannelOnlineStatusArray::kTOFNoiseBad) return kFALSE; + if (fStatus->GetHWStatus(index) == AliTOFChannelOnlineStatusArray::kTOFHWBad) return kFALSE; + if (checkEfficiency && !IsChannelEfficient(index)) return kFALSE; + if (checkProblematic && IsChannelProblematic(index)) return kFALSE; + + /* good status */ + return kTRUE; + +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::IsChannelEfficient(Int_t index) +{ + /* + * is channel efficient + */ + + if (!fInitFlag) { + AliError("class not yet initialized. Initialize it before."); + return kTRUE; + } + + /* check efficiency */ + if (fReadoutEfficiency->GetBinContent(index + 1) < 0.95) return kFALSE; + return kTRUE; + +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::IsChannelProblematic(Int_t index) +{ + /* + * is channel problematic + */ + + if (!fInitFlag) { + AliError("class not yet initialized. Initialize it before."); + return kTRUE; + } + + /* check problematic */ + if (fProblematic->GetBinContent(index + 1) != 0) return kTRUE; + return kFALSE; + +} + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::CalibrateTExp(AliESDEvent *event) const +{ + /* + * calibrate TExp + */ + + /* check if new TOF data structure, crash in case */ + TClonesArray* esdTOFhits = event->GetESDTOFHits(); + if (esdTOFhits) { + AliFatal("This method is DEPRECATED, doing NOTHING"); + return ; + } + + if (!fInitFlag) { + AliError("class not yet initialized. Initialize it before."); + return; + } + + /* loop over tracks */ + AliESDtrack *track = NULL; + Double_t texp[AliPID::kSPECIESC]; + for (Int_t itrk = 0; itrk < event->GetNumberOfTracks(); itrk++) { + + /* get track */ + track = event->GetTrack(itrk); + if (!track || !(track->GetStatus() & AliESDtrack::kTOFout)) continue; + + /* get integrated times */ + track->GetIntegratedTimes(texp,AliPID::kSPECIESC); + /* loop over particle types and correct expected time */ + for (Int_t ipart = 0; ipart < AliPID::kSPECIES; ipart++) + texp[ipart] += fResponseParams->EvalTExpCorr(ipart, track->P()); + /* set integrated times */ + track->SetIntegratedTimes(texp); + + } + +} + +//---------------------------------------------------------------------------- + +Double_t +AliTOFcalib::TuneForMC(AliESDEvent *event, Double_t resolution) +{ + /* + * tune for MC + */ + + /* check if new TOF data structure, crash in case */ + TClonesArray* esdTOFhits = event->GetESDTOFHits(); + if (esdTOFhits) { + AliFatal("This method is DEPRECATED, doing NOTHING"); + return 0.; + } + + /* get vertex spread and define T0-spread */ + Double_t diamond2 = TMath::Abs(event->GetSigma2DiamondZ()); + Double_t t0spread = TMath::Sqrt(diamond2) / 2.99792457999999984e-02; + /* generate random startTime */ + Double_t startTime = gRandom->Gaus(0., t0spread); + /* define extra smearing for resolution */ + Double_t defaultResolution = 80.; + Double_t extraSmearing = 0.; + if (resolution > defaultResolution) + extraSmearing = TMath::Sqrt(resolution * resolution - defaultResolution * defaultResolution); + + /* loop over tracks */ + AliESDtrack *track = NULL; + Double_t time; + for (Int_t itrk = 0; itrk < event->GetNumberOfTracks(); itrk++) { + /* get track */ + track = event->GetTrack(itrk); + if (!track) continue; + /* check TOF match */ + if (!track->IsOn(AliESDtrack::kTOFout)) continue; + /* check if channel is enabled */ + if (!IsChannelEnabled(track->GetTOFCalChannel())) { + /* reset TOF status */ + track->ResetStatus(AliESDtrack::kTOFin); + track->ResetStatus(AliESDtrack::kTOFout); + track->ResetStatus(AliESDtrack::kTOFmismatch); + track->ResetStatus(AliESDtrack::kTOFpid); + } + /* get original time and manipulate it */ + time = track->GetTOFsignal(); + time += startTime; /* add start time */ + time += gRandom->Gaus(0., extraSmearing); /* extra smearing */ + time -= 25.; /* remove 25 ps to center the signal */ + track->SetTOFsignal(time); + } + + return startTime; +}