X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TOF%2FAliTOFcalib.cxx;h=b977a648d8b6e306d111a035dbab320f90fff04f;hb=4682c56e32cf939ad0815430785dec9507f31d50;hp=d9eeb7511a0253853db2f60ccaee5ca3ed6cda74;hpb=24d1e16e8a239110e0689dd58b4a0abca62384e6;p=u%2Fmrichter%2FAliRoot.git diff --git a/TOF/AliTOFcalib.cxx b/TOF/AliTOFcalib.cxx index d9eeb7511a0..b977a648d8b 100644 --- a/TOF/AliTOFcalib.cxx +++ b/TOF/AliTOFcalib.cxx @@ -113,6 +113,13 @@ author: Chiara Zampolli, zampolli@bo.infn.it #include "AliTOFChannelOffline.h" #include "AliTOFGeometry.h" #include "AliTOFRecoParam.h" +#include "AliTOFDeltaBCOffset.h" +#include "AliTOFCTPLatency.h" +#include "AliTOFT0Fill.h" +#include "AliTOFRunParams.h" +#include "AliTOFResponseParams.h" +#include "AliESDEvent.h" +#include "AliESDtrack.h" class TROOT; class TStyle; @@ -140,7 +147,16 @@ AliTOFcalib::AliTOFcalib(): fNruns(0), fFirstRun(0), fLastRun(AliCDBRunRange::Infinity()), - fConfigMap(new TMap) + fConfigMap(new TMap), + fDeltaBCOffset(NULL), + fCTPLatency(NULL), + fT0Fill(NULL), + fRunParams(NULL), + fResponseParams(NULL), + fInitFlag(kFALSE), + fRemoveMeanT0(kTRUE), + fCalibrateTOFsignal(kTRUE), + fCorrectTExp(kFALSE) { //TOF Calibration Class ctor fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX(); @@ -148,7 +164,7 @@ AliTOFcalib::AliTOFcalib(): //____________________________________________________________________________ AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib): - TTask("AliTOFcalib",""), + TTask(calib), fNChannels(calib.fNChannels), fTOFCalOnline(0x0), fTOFCalOnlinePulser(0x0), @@ -164,7 +180,16 @@ AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib): fNruns(calib.fNruns), fFirstRun(calib.fFirstRun), fLastRun(calib.fLastRun), - fConfigMap(calib.fConfigMap) + fConfigMap(calib.fConfigMap), + fDeltaBCOffset(NULL), + fCTPLatency(NULL), + fT0Fill(NULL), + fRunParams(NULL), + fResponseParams(NULL), + fInitFlag(calib.fInitFlag), + fRemoveMeanT0(calib.fRemoveMeanT0), + fCalibrateTOFsignal(calib.fCalibrateTOFsignal), + fCorrectTExp(calib.fCorrectTExp) { //TOF Calibration Class copy ctor for (Int_t iarray = 0; iarrayAddAt(calChOnlineStHW,iarray); fTOFCalOffline->AddAt(calChOffline,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); } //____________________________________________________________________________ @@ -186,28 +217,61 @@ AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib): AliTOFcalib& AliTOFcalib::operator=(const AliTOFcalib &calib) { //TOF Calibration Class assignment operator - this->fNChannels = calib.fNChannels; - this->fCal = calib.fCal; - this->fStatus = calib.fStatus; - this->fTOFSimToT = calib.fTOFSimToT; - this->fkValidity = calib.fkValidity; - this->fTree = calib.fTree; - this->fChain = calib.fChain; - 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); AliTOFChannelOnlineStatus * calChOnlineStPulser = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlinePulser->At(iarray); AliTOFChannelOnlineStatus * calChOnlineStNoise = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineNoise->At(iarray); AliTOFChannelOnlineStatus * calChOnlineStHW = (AliTOFChannelOnlineStatus*)calib.fTOFCalOnlineHW->At(iarray); - this->fTOFCalOnline->AddAt(calChOnline,iarray); - this->fTOFCalOnlinePulser->AddAt(calChOnlineStPulser,iarray); - this->fTOFCalOnlineNoise->AddAt(calChOnlineStNoise,iarray); - this->fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray); - this->fTOFCalOffline->AddAt(calChOffline,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); + } + fInitFlag = calib.fInitFlag; + fRemoveMeanT0 = calib.fRemoveMeanT0; + fCalibrateTOFsignal = calib.fCalibrateTOFsignal; + fCorrectTExp = calib.fCorrectTExp; + return *this; } @@ -241,9 +305,14 @@ AliTOFcalib::~AliTOFcalib() if (fConfigMap){ delete fConfigMap; } + if (fDeltaBCOffset) delete fDeltaBCOffset; + if (fCTPLatency) delete fCTPLatency; + if (fT0Fill) delete fT0Fill; + if (fRunParams) delete fRunParams; } if (fTree!=0x0) delete fTree; if (fChain!=0x0) delete fChain; + } //_____________________________________________________________________________ void AliTOFcalib::CreateCalArrays(){ @@ -290,13 +359,13 @@ void AliTOFcalib::CreateCalObjects(){ fStatus = new AliTOFChannelOnlineStatusArray(fNChannels); } //_____________________________________________________________________________ -void AliTOFcalib::WriteConfigMapOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun) +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(); - Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliDebug(2,Form("Writing TOF configuration map for online calib on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); @@ -311,11 +380,11 @@ void AliTOFcalib::WriteConfigMapOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun) } //_____________________________________________________________________________ -void AliTOFcalib::WriteConfigMapOnCDB(Char_t *sel) +void AliTOFcalib::WriteConfigMapOnCDB(const Char_t *sel) { //Write calibration parameters to the CDB with infinite validity AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBRunRange runrange(fFirstRun,fLastRun); @@ -330,13 +399,13 @@ void AliTOFcalib::WriteConfigMapOnCDB(Char_t *sel) delete md; } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlineDelayOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun) +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(); - Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); @@ -350,13 +419,13 @@ void AliTOFcalib::WriteParOnlineDelayOnCDB(Char_t *sel, Int_t minrun, Int_t maxr delete md; } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlineStatusOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun) +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(); - Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliDebug(2,Form("Writing TOF online status calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); @@ -371,11 +440,11 @@ void AliTOFcalib::WriteParOnlineStatusOnCDB(Char_t *sel, Int_t minrun, Int_t max } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlineDelayOnCDB(Char_t *sel) +void AliTOFcalib::WriteParOnlineDelayOnCDB(const Char_t *sel) { //Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!! AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBRunRange runrange(fFirstRun,fLastRun); @@ -391,11 +460,11 @@ void AliTOFcalib::WriteParOnlineDelayOnCDB(Char_t *sel) } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlineStatusOnCDB(Char_t *sel) +void AliTOFcalib::WriteParOnlineStatusOnCDB(const Char_t *sel) { //Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!! AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBRunRange runrange(fFirstRun,fLastRun); @@ -410,13 +479,13 @@ void AliTOFcalib::WriteParOnlineStatusOnCDB(Char_t *sel) 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 + const Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); @@ -430,13 +499,13 @@ void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun) delete md; } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlinePulserOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun) +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(); - Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliDebug(2,Form("Writing TOF online calib obj from pulser on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); @@ -450,13 +519,13 @@ void AliTOFcalib::WriteParOnlinePulserOnCDB(Char_t *sel, Int_t minrun, Int_t max delete md; } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlineNoiseOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun) +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(); - Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliDebug(2,Form("Writing TOF online calib obj from noise on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); @@ -470,13 +539,13 @@ void AliTOFcalib::WriteParOnlineNoiseOnCDB(Char_t *sel, Int_t minrun, Int_t maxr delete md; } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlineHWOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun) +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(); - Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliDebug(2,Form("Writing TOF online calib obj from hardware on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); @@ -491,11 +560,11 @@ void AliTOFcalib::WriteParOnlineHWOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun) } //_____________________________________________________________________________ -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 + const Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBRunRange runrange(fFirstRun,fLastRun); @@ -511,11 +580,11 @@ void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel) } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlinePulserOnCDB(Char_t *sel) +void AliTOFcalib::WriteParOnlinePulserOnCDB(const Char_t *sel) { //Write calibration parameters from pulser to the CDB with infinite validity AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBRunRange runrange(fFirstRun,fLastRun); @@ -531,11 +600,11 @@ void AliTOFcalib::WriteParOnlinePulserOnCDB(Char_t *sel) } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlineNoiseOnCDB(Char_t *sel) +void AliTOFcalib::WriteParOnlineNoiseOnCDB(const Char_t *sel) { //Write calibration parameters from noise to the CDB with infinite validity AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBRunRange runrange(fFirstRun,fLastRun); @@ -551,11 +620,11 @@ void AliTOFcalib::WriteParOnlineNoiseOnCDB(Char_t *sel) } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOnlineHWOnCDB(Char_t *sel) +void AliTOFcalib::WriteParOnlineHWOnCDB(const Char_t *sel) { //Write calibration parameters from hardware to the CDB with infinite validity AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor + const Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBRunRange runrange(fFirstRun,fLastRun); @@ -571,13 +640,13 @@ void AliTOFcalib::WriteParOnlineHWOnCDB(Char_t *sel) } //_____________________________________________________________________________ -void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun) +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" ; + const Char_t *sel1 = "ParOffline" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliDebug(2,Form("Writing TOF offline calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun)); @@ -590,11 +659,11 @@ 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" ; + const Char_t *sel1 = "ParOffline" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBRunRange runrange(fFirstRun,fLastRun); @@ -608,11 +677,11 @@ void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity) } //_____________________________________________________________________________ -Bool_t AliTOFcalib::ReadConfigMapFromCDB(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 = "Config" ; + const Char_t *sel1 = "Config" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBEntry *entry = man->Get(out,nrun); @@ -632,11 +701,11 @@ Bool_t AliTOFcalib::ReadConfigMapFromCDB(Char_t *sel, Int_t nrun) } //_____________________________________________________________________________ -Bool_t AliTOFcalib::ReadParOnlineDelayFromCDB(Char_t *sel, Int_t nrun) +Bool_t AliTOFcalib::ReadParOnlineDelayFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from the CDB -------> new calib objs!!!!! AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "ParOnlineDelay" ; + const Char_t *sel1 = "ParOnlineDelay" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBEntry *entry = man->Get(out,nrun); @@ -656,11 +725,11 @@ Bool_t AliTOFcalib::ReadParOnlineDelayFromCDB(Char_t *sel, Int_t nrun) } //_____________________________________________________________________________ -Bool_t AliTOFcalib::ReadParOnlineStatusFromCDB(Char_t *sel, Int_t nrun) +Bool_t AliTOFcalib::ReadParOnlineStatusFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from the CDB -------> new calib objs!!!!! AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "Status" ; + const Char_t *sel1 = "Status" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBEntry *entry = man->Get(out,nrun); @@ -680,11 +749,11 @@ Bool_t AliTOFcalib::ReadParOnlineStatusFromCDB(Char_t *sel, Int_t nrun) } //_____________________________________________________________________________ -Bool_t AliTOFcalib::ReadParOnlineFromCDB(Char_t *sel, Int_t nrun) +Bool_t AliTOFcalib::ReadParOnlineFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from the CDB AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "ParOnline" ; + const Char_t *sel1 = "ParOnline" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBEntry *entry = man->Get(out,nrun); @@ -704,11 +773,11 @@ Bool_t AliTOFcalib::ReadParOnlineFromCDB(Char_t *sel, Int_t nrun) } //_____________________________________________________________________________ -Bool_t AliTOFcalib::ReadParOnlinePulserFromCDB(Char_t *sel, Int_t nrun) +Bool_t AliTOFcalib::ReadParOnlinePulserFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from pulser from the CDB AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "Pulser" ; + const Char_t *sel1 = "Pulser" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBEntry *entry = man->Get(out,nrun); @@ -728,11 +797,11 @@ Bool_t AliTOFcalib::ReadParOnlinePulserFromCDB(Char_t *sel, Int_t nrun) } //_____________________________________________________________________________ -Bool_t AliTOFcalib::ReadParOnlineNoiseFromCDB(Char_t *sel, Int_t nrun) +Bool_t AliTOFcalib::ReadParOnlineNoiseFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from noise from the CDB AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "Noise" ; + const Char_t *sel1 = "Noise" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBEntry *entry = man->Get(out,nrun); @@ -752,11 +821,11 @@ Bool_t AliTOFcalib::ReadParOnlineNoiseFromCDB(Char_t *sel, Int_t nrun) } //_____________________________________________________________________________ -Bool_t AliTOFcalib::ReadParOnlineHWFromCDB(Char_t *sel, Int_t nrun) +Bool_t AliTOFcalib::ReadParOnlineHWFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from hardware from the CDB AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "HW" ; + const Char_t *sel1 = "HW" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBEntry *entry = man->Get(out,nrun); @@ -776,11 +845,11 @@ Bool_t AliTOFcalib::ReadParOnlineHWFromCDB(Char_t *sel, Int_t nrun) } //_____________________________________________________________________________ -Bool_t AliTOFcalib::ReadParOfflineFromCDB(Char_t *sel, Int_t nrun) +Bool_t AliTOFcalib::ReadParOfflineFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from the CDB AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "ParOffline" ; + const Char_t *sel1 = "ParOffline" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBEntry *entry = man->Get(out,nrun); @@ -800,12 +869,12 @@ Bool_t AliTOFcalib::ReadParOfflineFromCDB(Char_t *sel, Int_t nrun) } //_____________________________________________________________________________ -void AliTOFcalib::WriteSimHistoOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, TH1F *histo){ +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(); - Char_t *sel1 = "SimHisto" ; + const Char_t *sel1 = "SimHisto" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBMetaData *mdhisto = new AliCDBMetaData(); @@ -815,14 +884,14 @@ void AliTOFcalib::WriteSimHistoOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, TH delete mdhisto; } //_____________________________________________________________________________ -Bool_t AliTOFcalib::ReadSimHistoFromCDB(Char_t *sel, Int_t nrun) +Bool_t AliTOFcalib::ReadSimHistoFromCDB(const Char_t *sel, Int_t nrun) { //Read miscalibration parameters from the CDB AliCDBManager *man = AliCDBManager::Instance(); // The Tot Histo - Char_t *sel1 = "SimHisto" ; + const Char_t *sel1 = "SimHisto" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBEntry *entry = man->Get(out,nrun); @@ -839,13 +908,13 @@ Bool_t AliTOFcalib::ReadSimHistoFromCDB(Char_t *sel, Int_t nrun) return kTRUE; } //_____________________________________________________________________________ -void AliTOFcalib::WriteRecParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param){ +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"); - Char_t *sel1 = "RecPar" ; + const Char_t *sel1 = "RecoParam" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBId id(out,minrun,maxrun); @@ -853,20 +922,20 @@ void AliTOFcalib::WriteRecParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, AliT delete md; } //_____________________________________________________________________________ -AliTOFRecoParam * AliTOFcalib::ReadRecParFromCDB(Char_t *sel, Int_t nrun) +AliTOFRecoParam * AliTOFcalib::ReadRecParFromCDB(const Char_t *sel, Int_t nrun) { //Read reconstruction parameters from the CDB AliCDBManager *man = AliCDBManager::Instance(); - Char_t *sel1 = "RecPar" ; + const Char_t *sel1 = "RecoParam" ; Char_t out[100]; sprintf(out,"%s/%s",sel,sel1); AliCDBEntry *entry = man->Get(out,nrun); if (!entry) { - AliFatal("Exiting, no CDB object (RecPar) found!!!"); + AliFatal("Exiting, no CDB object (RecoParam) found!!!"); exit(0); } if(!entry->GetObject()){ - AliFatal("Exiting, no CDB object (RecPar) found!!!"); + AliFatal("Exiting, no CDB object (RecoParam) found!!!"); exit(0); } @@ -888,7 +957,7 @@ 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){ @@ -1337,7 +1406,7 @@ Int_t AliTOFcalib::Calibrate(Int_t nch, Int_t *ch, Option_t *optionSave, Option_ 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; } @@ -1453,7 +1522,7 @@ Int_t AliTOFcalib::CalibrateFromProfile(Int_t ich, Option_t *optionSave, Option_ } 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; } @@ -1552,7 +1621,7 @@ Int_t AliTOFcalib::Calibrate(Option_t *optionSave, Option_t *optionFit){ 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; @@ -1788,3 +1857,425 @@ Int_t AliTOFcalib::FindBins(TH1F* h, Double_t *binsProfile) const{ } return nusefulbins; } + + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::CreateDeltaBCOffset() +{ + /* + * create deltaBC offset + */ + + if (fDeltaBCOffset) { + AliWarning("DeltaBCOffset object already defined, cannot create a new one"); + return; + } + fDeltaBCOffset = new AliTOFDeltaBCOffset(); +} + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::CreateCTPLatency() +{ + /* + * create CTP latency + */ + + if (fCTPLatency) { + AliWarning("CTPLatency object already defined, cannot create a new one"); + return; + } + fCTPLatency = new AliTOFCTPLatency(); +} + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::CreateT0Fill() +{ + /* + * create event-time + */ + + if (fT0Fill) { + AliWarning("T0Fill object already defined, cannot create a new one"); + return; + } + fT0Fill = new AliTOFT0Fill(); +} + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::CreateRunParams() +{ + /* + * create run params + */ + + if (fRunParams) { + AliWarning("RunParams object already defined, cannot create a new one"); + return; + } + fRunParams = new AliTOFRunParams(); +} + +//---------------------------------------------------------------------------- + +void +AliTOFcalib::WriteDeltaBCOffsetOnCDB(const Char_t *sel , Int_t minrun, Int_t maxrun) +{ + /* + * deltaBC offset on CDB + */ + + if (!fDeltaBCOffset) return; + AliCDBId id(Form("%s/DeltaBCOffset", sel), minrun, maxrun); + AliCDBMetaData *md = new AliCDBMetaData(); + md->SetResponsible("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; +} + +//---------------------------------------------------------------------------- + +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); + 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::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 response params */ + if (fCorrectTExp) { + 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(); + } + + /* 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.; + } + + /* 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); + /* check whether to remove mean T0. + * useful when one wants to compute mean T0 */ + if (!fRemoveMeanT0) timezero = 0.; + + /* 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; + } + + /* loop over tracks */ + AliESDtrack *track = NULL; + Int_t index, l0l1, deltaBC; + Double_t time, tot, corr, texp[AliPID::kSPECIES]; + UInt_t timestamp = event->GetTimeStamp(); + 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); + } + + /* correct expected time */ + if (fCorrectTExp) { + /* get integrated times */ + track->GetIntegratedTimes(texp); + /* 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); + } + + } + +} + +//---------------------------------------------------------------------------- + +Bool_t +AliTOFcalib::IsChannelEnabled(Int_t index) +{ + /* + * 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; + + /* good status */ + return kTRUE; + +}