/************************************************************************** * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * * * * Author: The ALICE Off-line Project. * * Contributors are mentioned in the code where appropriate. * * * * Permission to use, copy, modify and distribute this software and its * * documentation strictly for non-commercial purposes is hereby granted * * without fee, provided that the above copyright notice appears in all * * copies and that both the copyright notice and this permission notice * * appear in the supporting documentation. The authors make no claims * * about the suitability of this software for any purpose. It is * * provided "as is" without express or implied warranty. * **************************************************************************/ /* $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. Revision 1.15 2007/10/04 13:23:28 zampolli Updates to handle functionalities in TOF online/offline calibration according to the latest schema Revision 1.14 2007/06/06 16:26:30 arcelli remove fall-back call to local CDB storage Revision 1.13 2007/04/20 13:59:40 arcelli make protections agains failed retrieval of the CDB object in a proper way Revision 1.12 2007/03/23 11:31:16 arcelli CDB Entry for TOF Reconstruction Parameters Revision 1.11 2007/02/28 18:08:26 arcelli Add protection against failed retrieval of the CDB cal object Revision 1.10 2006/08/22 13:30:49 arcelli removal of effective c++ warnings (C.Zampolli) Revision 1.9 2006/04/20 22:30:50 hristov Coding conventions (Annalisa) Revision 1.8 2006/04/16 22:29:05 hristov Coding conventions (Annalisa) Revision 1.7 2006/04/16 20:12:46 hristov Removing memory leak in case of cached CDB entries Revision 1.6 2006/04/11 15:28:32 hristov Checks on cache status before deleting calibration objects (A.Colla) Revision 1.5 2006/04/05 08:35:38 hristov Coding conventions (S.Arcelli, C.Zampolli) Revision 1.4 2006/03/31 11:26:46 arcelli changing CDB Ids according to standard convention Revision 1.3 2006/03/28 14:57:02 arcelli updates to handle new V5 geometry & some re-arrangements Revision 1.2 2006/02/13 17:22:26 arcelli just Fixing Log info Revision 1.1 2006/02/13 16:10:48 arcelli Add classes for TOF Calibration (C.Zampolli) author: Chiara Zampolli, zampolli@bo.infn.it */ /////////////////////////////////////////////////////////////////////////////// // // // class for TOF calibration // // // /////////////////////////////////////////////////////////////////////////////// #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 "TTree.h" #include "TChain.h" #include "TProfile.h" #include "TGrid.h" #include "TMath.h" #include "TMap.h" #include "AliCDBEntry.h" #include "AliCDBRunRange.h" #include "AliCDBId.h" #include "AliCDBManager.h" #include "AliCDBStorage.h" #include "AliCDBMetaData.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" class TROOT; class TStyle; //extern TROOT *gROOT; extern TStyle *gStyle; ClassImp(AliTOFcalib) //_______________________________________________________________________ AliTOFcalib::AliTOFcalib(): TTask("AliTOFcalib",""), fNChannels(-1), fTOFCalOnline(0x0), fTOFCalOnlinePulser(0x0), fTOFCalOnlineNoise(0x0), fTOFCalOnlineHW(0x0), fTOFCalOffline(0x0), fCal(0x0), fStatus(0x0), fTOFSimToT(0x0), fkValidity(0x0), fTree(0x0), fChain(0x0), fNruns(0), fFirstRun(0), 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(calib), fNChannels(calib.fNChannels), fTOFCalOnline(0x0), fTOFCalOnlinePulser(0x0), fTOFCalOnlineNoise(0x0), fTOFCalOnlineHW(0x0), fTOFCalOffline(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), 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); } 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); } //____________________________________________________________________________ AliTOFcalib& AliTOFcalib::operator=(const AliTOFcalib &calib) { //TOF Calibration Class assignment operator 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); 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; } //____________________________________________________________________________ AliTOFcalib::~AliTOFcalib() { //TOF Calibration Class dtor if(!(AliCDBManager::Instance()->GetCacheFlag())){ // CDB objects must NOT be deleted if cache is active! if (fTOFCalOnline){ delete fTOFCalOnline; } if (fTOFCalOnlinePulser){ delete fTOFCalOnlinePulser; } if (fTOFCalOnlineNoise){ delete fTOFCalOnlineNoise; } if (fTOFCalOnlineHW){ delete fTOFCalOnlineHW; } if (fTOFCalOffline){ delete fTOFCalOffline; } if (fCal){ delete fCal; } 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(){ // 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::CreateCalObjects(){ // creating arrays for online/offline calibration objs fTOFCalOffline = new TObjArray(fNChannels); fTOFCalOffline->SetOwner(); for (Int_t iarray = 0; iarrayAddAt(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(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 = "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(); md->SetResponsible("Chiara Zampolli"); if (!fTOFCalOnline) { // deve uscire!! } man->Put(fTOFCalOnline,id,md); 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(const Char_t *sel) { //Write calibration parameters to the CDB with infinite validity AliCDBManager *man = AliCDBManager::Instance(); 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); AliCDBMetaData *md = new AliCDBMetaData(); md->SetResponsible("Chiara Zampolli"); if (!fTOFCalOnline) { // deve uscire!! } man->Put(fTOFCalOnline,id,md); delete md; } //_____________________________________________________________________________ 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(); 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(); md->SetResponsible("Chiara Zampolli"); md->SetComment(validity); man->Put(fTOFCalOffline,id,md); delete md; } //_____________________________________________________________________________ void AliTOFcalib::WriteParOfflineOnCDB(const Char_t *sel, const Char_t *validity) { //Write calibration parameters to the CDB with infinite validity AliCDBManager *man = AliCDBManager::Instance(); 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); AliCDBMetaData *md = new AliCDBMetaData(); md->SetResponsible("Chiara Zampolli"); md->SetComment(validity); man->Put(fTOFCalOffline,id,md); delete md; } //_____________________________________________________________________________ Bool_t AliTOFcalib::ReadConfigMapFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from the CDB AliCDBManager *man = AliCDBManager::Instance(); 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()){ AliFatal("Exiting, no CDB object (ConfigMap) found!!!"); exit(0); } fConfigMap =(TMap*)entry->GetObject(); return kTRUE; } //_____________________________________________________________________________ Bool_t AliTOFcalib::ReadParOnlineDelayFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from the CDB -------> new calib objs!!!!! AliCDBManager *man = AliCDBManager::Instance(); 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()){ AliFatal("Exiting, no CDB object (ParOnlineDelay) found!!!"); exit(0); } fCal =(AliTOFChannelOnlineArray*)entry->GetObject(); return kTRUE; } //_____________________________________________________________________________ Bool_t AliTOFcalib::ReadParOnlineStatusFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from the CDB -------> new calib objs!!!!! AliCDBManager *man = AliCDBManager::Instance(); 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); } if(!entry->GetObject()){ AliFatal("Exiting, no CDB object (Status) found!!!"); exit(0); } fStatus =(AliTOFChannelOnlineStatusArray*)entry->GetObject(); return kTRUE; } //_____________________________________________________________________________ Bool_t AliTOFcalib::ReadParOnlineFromCDB(const Char_t *sel, Int_t nrun) { //Read calibration parameters from the CDB AliCDBManager *man = AliCDBManager::Instance(); 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); } if(!entry->GetObject()){ AliFatal("Exiting, no CDB object (ParOnline) found!!!"); exit(0); } fTOFCalOnline =(TObjArray*)entry->GetObject(); return kTRUE; } //_____________________________________________________________________________ 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); } if(!entry->GetObject()){ AliFatal("Exiting, no CDB object (Pulser) found!!!"); exit(0); } fTOFCalOnlinePulser =(TObjArray*)entry->GetObject(); return kTRUE; } //_____________________________________________________________________________ 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"); const Char_t *sel1 = "RecoParam" ; TString out(Form("%s/%s",sel,sel1)); AliCDBId id(out,minrun,maxrun); man->Put(arr,id,md); delete md; } //_____________________________________________________________________________ AliTOFRecoParam * AliTOFcalib::ReadRecParFromCDB(const Char_t *sel, Int_t nrun, Int_t eventType) { //Read reconstruction parameters from the CDB AliCDBManager *man = AliCDBManager::Instance(); 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); } if(!entry->GetObject()){ AliFatal("Exiting, no CDB object (RecoParam) found!!!"); exit(0); } TObjArray *array = (TObjArray*)entry->GetObject(); AliTOFRecoParam *param=0x0; if (eventType>=0 || eventTypeGetEntries()) param=(AliTOFRecoParam*)array->At(eventType); return param; } //----------------------------------------------------------------------------- // Calibration methods //----------------------------------------------------------------------------- void AliTOFcalib::CreateTreeFromCDB(Int_t minrun, Int_t maxrun){ // creating the chain with the trees for calibration // collecting them from reference data // from minrun to maxrun Float_t p[CHENTRIESSMALL]; Int_t nentries; fTree = new TTree("TOFCalib","Tree for TOF Calibration"); fTree->Branch("nentries",&nentries,"nentries/I"); fTree->Branch("TOFentries",p,"TOFentries[nentries]/F"); AliCDBManager *man = AliCDBManager::Instance(); 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 = (TTree*)entry->GetObject(); tree->SetBranchAddress("nentries",&nentries); tree->SetBranchAddress("TOFentries",p); fTree->CopyEntries(tree); fNruns++; } } AliInfo(Form("Number of runs being analyzed %i",fNruns)); } //----------------------------------------------------------------------------- void AliTOFcalib::CreateTreeFromGrid(Int_t minrun, Int_t maxrun){ // creating the chain with the trees for calibration // collecting them from the Grid // from minrun to maxrun Float_t p[CHENTRIESSMALL]; Int_t nentries; fTree = new TTree("TOFCalib","Tree for TOF Calibration"); fTree->SetDirectory(0); fTree->Branch("nentries",&nentries,"nentries/I"); fTree->Branch("TOFentries",p,"TOFentries[nentries]/F"); 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); TFile *filegrid = TFile::Open(filename.Data(),"READ"); TTree *tree = (TTree*)filegrid->Get("T"); tree->SetBranchAddress("nentries",&nentries); tree->SetBranchAddress("TOFentries",p); fTree->CopyEntries(tree); delete tree; fNruns++; } AliInfo(Form("Number of runs being analyzed %i",fNruns)); } //----------------------------------------------------------------------------- void AliTOFcalib::CreateTreeFromFile(Int_t minrun, Int_t maxrun){ // creating the tree with the trees for calibration // collecting them from reference data (from file) // from minrun to maxrun Float_t p[CHENTRIESSMALL]; Int_t nentries; fTree = new TTree("TOFCalib","Tree for TOF Calibration"); fTree->SetDirectory(0); fTree->Branch("nentries",&nentries,"nentries/I"); fTree->Branch("TOFentries",p,"TOFentries[nentries]/F"); TString filename; for (Int_t irun = minrun;irun<=maxrun;irun++){ 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); fTree->CopyEntries(tree); delete tree; delete file; file = 0x0; fNruns++; } 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 // computing calibration parameters // Returning codes: // 0 -> everything was ok // 1 -> no tree for calibration found // 2 -> not enough statistics to perform calibration // 3 -> problems with arrays TH1::AddDirectory(0); AliInfo(Form("*** Calibrating Histograms %s, summing more channels, from channel %i, to channel %i, storing Calib Pars in channel %i", GetName(),ichmin,ichmax,ichmin)) ; AliInfo(Form("Option for Saving histos = %s",optionSave )) ; AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ; Float_t p[CHENTRIESSMALL]; Int_t nentries; //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); fChain->GetEntry(ientry); Int_t ntracksRun=nentries/3; ntracksTotalmean+=ntracksRun; } } if (ntracksTotalmean < MEANENTRIES) { AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean)); return 2; } //filling ToT and Time arrays Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps Float_t minToT = 0; // ns Float_t maxToT = 4.88; // ns TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT); TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4); Int_t ntracksTotal = 0; Int_t ntracksRun = 0; Double_t binsProfile[101]; // sized larger than necessary, the correct // dim being set in the booking of the profile Int_t nusefulbins=0; Float_t meantime=0; for (Int_t i = ichmin;iGetEntry(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)); for (Int_t j=0;jFill(p[idxexTime]-p[idxexExTime]); meantime+=p[idxexTime]-p[idxexExTime]; hToT->Fill(tot); } } } nusefulbins = FindBins(hToT,&binsProfile[0]); if (ntracksTotal != 0){ meantime/=ntracksTotal; } AliDebug(2, Form("meantime = %f",meantime)); for (Int_t j=1;j<=nusefulbins;j++) { AliDebug(2,Form(" summing channels from %i to %i, nusefulbins = %i, bin %i = %f",ichmin,ichmax,nusefulbins,j,binsProfile[j])); } TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!! TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10); for (Int_t irun=0;irunGetEntry(ientry); fChain->GetEntry(ientry); ntracksRun=nentries/3; for (Int_t j=0;jFill(tot,time); // if meantime is not used, the fill may be moved in the loop above htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above } } } hSlewingProf->Fit("pol5",optionFit,"",0,4); TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5"); Float_t par[6]; for(Int_t kk=0;kk<6;kk++){ par[kk]=calibfunc->GetParameter(kk); AliDebug(2,Form("parameter %i = %f",kk,par[kk])); } if(strstr(optionSave,"save")){ TFile * fileProf = new TFile("TOFCalibSave.root","recreate"); fileProf->cd(); TString profName=Form("Profile%06i_%06i",ichmin,ichmax); TString timeTotName=Form("TimeTot%06i_%06i",ichmin,ichmax); TString totName=Form("Tot%06i_%06i",ichmin,ichmax); TString deltaName=Form("Delta%06i_%06i",ichmin,ichmax); hSlewingProf->Write(profName); htimetot->Write(timeTotName); hToT->Write(totName); hdeltaTime->Write(deltaName); fileProf->Close(); delete fileProf; fileProf=0x0; } delete hToT; hToT=0x0; delete hSlewingProf; hSlewingProf=0x0; delete htimetot; htimetot=0x0; delete hdeltaTime; hdeltaTime=0x0; AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ichmin); calChannel->SetSlewPar(par); WriteParOfflineOnCDB("TOF/Calib","valid"); return 0; } //---------------------------------------------------------------------------- Int_t AliTOFcalib::Calibrate(Int_t i, Option_t *optionSave, Option_t *optionFit){ // computing calibration parameters for channel i // Returning codes: // 0 -> everything was ok // 1 -> no tree for calibration found // 2 -> not enough statistics to perform calibration // 3 -> problems with arrays TH1::AddDirectory(0); AliInfo(Form("*** Calibrating Histograms (one channel) %s", GetName())) ; AliInfo(Form("Option for Saving histos = %s",optionSave )) ; AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ; Float_t p[MAXCHENTRIESSMALL]; Int_t nentries; //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); fChain->GetEntry(ientry); ntracksTotal+=nentries/3; } if (ntracksTotal < MEANENTRIES) { AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotal)); return 2; } //filling ToT and Time arrays Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps Float_t minToT = 0; // ns Float_t maxToT = 4.88; // ns TH1F *hToT = new TH1F("htot","htot",nbinToT, minToT, maxToT); TH1F *hdeltaTime = new TH1F("hdeltaTime","hdeltaTime",200,2,4); Int_t ntracksRun = 0; Double_t binsProfile[101]; // sized larger than necessary, the correct // dim being set in the booking of the profile Int_t nusefulbins=0; Float_t meantime=0; for (Int_t irun=0;irunGetEntry(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;jFill(p[idxexTime]-p[idxexExTime]); hToT->Fill(tot); } } nusefulbins = FindBins(hToT,&binsProfile[0]); meantime/=ntracksTotal; AliDebug(2,Form("meantime = %f",meantime)); for (Int_t j=1;j<=nusefulbins;j++) { AliDebug(2,Form(" channel %i, nusefulbins = %i, bin %i = %f",i,nusefulbins,j,binsProfile[j])); } TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!! TH2F * htimetot = new TH2F("htimetot","htimetot",nbinToT, minToT, maxToT,600,-5,10); for (Int_t irun=0;irunGetEntry(ientry); fChain->GetEntry(ientry); ntracksRun=nentries/3; for (Int_t j=0;jFill(tot,time); // if meantime is not used, the fill may be moved in the loop above htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above } } hSlewingProf->Fit("pol5",optionFit,"",0,4); TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5"); Float_t par[6]; for(Int_t kk=0;kk<6;kk++){ par[kk]=calibfunc->GetParameter(kk); AliDebug(2,Form("parameter %i = %f",kk,par[kk])); } if(strstr(optionSave,"save")){ TFile * fileProf = new TFile("TOFCalibSave.root","recreate"); fileProf->cd(); TString profName=Form("Profile%06i",i); TString timeTotName=Form("TimeTot%06i",i); TString totName=Form("Tot%06i",i); TString deltaName=Form("Delta%06i",i); hSlewingProf->Write(profName); htimetot->Write(timeTotName); hToT->Write(totName); hdeltaTime->Write(deltaName); fileProf->Close(); delete fileProf; fileProf=0x0; } delete hToT; hToT=0x0; delete hSlewingProf; hSlewingProf=0x0; delete htimetot; htimetot=0x0; delete hdeltaTime; hdeltaTime=0x0; AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(i); calChannel->SetSlewPar(par); WriteParOfflineOnCDB("TOF/Calib","valid"); return 0; } //---------------------------------------------------------------------------- Int_t AliTOFcalib::Calibrate(Int_t nch, Int_t *ch, Option_t *optionSave, Option_t *optionFit){ // calibrating an array of channels // computing calibration parameters // Returning codes: // 0 -> everything was ok // 1 -> no tree for calibration found // 2 -> not enough statistics to perform calibration // 3 -> problems with arrays TH1::AddDirectory(0); AliInfo(Form("*** Calibrating Histograms %s, number of channels = %i", GetName(),nch)) ; AliInfo(Form("Option for Saving histos = %s",optionSave )) ; AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ; for (Int_t ich=0; ichSetBranchAddress("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); fChain->GetEntry(ientry); ntracksTotalmean+=nentries/3; } } ntracksTotalmean/=nch; if (ntracksTotalmean < MEANENTRIES) { AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean)); return 2; } //filling ToT and Time arrays Int_t nbinToT = 100; // ToT bin width in Profile = 48.8 ps Float_t minToT = 0; // ns Float_t maxToT = 4.88; // ns TFile * fileProf=0x0; if(strstr(optionSave,"save")){ fileProf = new TFile("TOFCalibSave.root","recreate"); } for (Int_t ich=0; ichGetEntry(i); fChain->GetEntry(i); ntracksTotal+=nentries/3; } if (ntracksTotal < MEANENTRIES) { 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); fChain->GetEntry(i); ntracksRun=nentries/3; for (Int_t j=0;jFill(p[idxexTime]-p[idxexExTime]); meantime+=p[idxexTime]-p[idxexExTime]; hToT->Fill(tot); } } nusefulbins = FindBins(hToT,&binsProfile[0]); meantime/=ntracksTotal; for (Int_t j=1;j<=nusefulbins;j++) { AliDebug(2,Form(" channel %i, nusefulbins = %i, bin %i = %f",i,nusefulbins,j,binsProfile[j])); } TProfile* hSlewingProf = new TProfile("hSlewingProf", "hSlewingProf",nusefulbins, binsProfile, "G"); // CHECK THE BUILD OPTION, PLEASE!!!!!! for (Int_t irun=0;irunGetEntry(i); fChain->GetEntry(i); ntracksRun=nentries/3; for (Int_t j=0;jFill(tot,time); // if meantime is not used, the fill may be moved in the loop above htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above } } hSlewingProf->Fit("pol5",optionFit,"",1,4); TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5"); Float_t par[6]; for(Int_t kk=0;kk<6;kk++){ par[kk]=calibfunc->GetParameter(kk); AliDebug(2,Form("parameter %i = %f",kk,par[kk])); } if(strstr(optionSave,"save") && fileProf){ TString profName=Form("Profile%06i",i); TString timeTotName=Form("TimeTot%06i",i); TString totName=Form("Tot%06i",i); TString deltaName=Form("Delta%06i",i); fileProf->cd(); hSlewingProf->Write(profName); htimetot->Write(timeTotName); hToT->Write(totName); hdeltaTime->Write(deltaName); } AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(i); calChannel->SetSlewPar(par); delete hToT; hToT=0x0; delete hSlewingProf; hSlewingProf=0x0; delete htimetot; htimetot=0x0; delete hdeltaTime; hdeltaTime=0x0; } if(strstr(optionSave,"save") && fileProf){ fileProf->Close(); delete fileProf; fileProf=0x0; } WriteParOfflineOnCDB("TOF/Calib","valid"); return 0; } //---------------------------------------------------------------------------- Int_t AliTOFcalib::CalibrateFromProfile(Int_t ich, Option_t *optionSave, Option_t *optionFit){ // computing calibration parameters using the old profiling algo // Returning codes: // 0 -> everything was ok // 1 -> no tree for calibration found // 2 -> not enough statistics to perform calibration // 3 -> problems with arrays TH1::AddDirectory(0); AliInfo(Form("*** Calibrating Histograms From Profile %s", GetName())) ; AliInfo(Form("Option for Saving histos = %s",optionSave )) ; AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ; Float_t p[MAXCHENTRIESSMALL]; Int_t nentries; Int_t ntracksTotal=0; //fTree->SetBranchAddress("nentries",&nentries); //fTree->SetBranchAddress("TOFentries",p); fChain->SetBranchAddress("nentries",&nentries); fChain->SetBranchAddress("TOFentries",p); for (Int_t irun=0;irunGetEntry(i); fChain->GetEntry(i); ntracksTotal+=nentries/3; } if (ntracksTotal < MEANENTRIES) { AliInfo(Form(" Too small mean number of entires per channel (mean number = %d) not calibrating and exiting.....",ntracksTotal)); return 2; } TH1F * hProf = Profile(ich); hProf->Fit("pol5",optionFit,"",0,4); TF1 * calibfunc = (TF1*)hProf->GetFunction("pol5"); Float_t par[6]; for(Int_t kk=0;kk<6;kk++){ par[kk]=calibfunc->GetParameter(kk); AliDebug(2,Form("parameter %i = %f",kk,par[kk])); } if(strstr(optionSave,"save")){ TFile * fileProf = new TFile("TOFCalibSave.root","recreate"); fileProf->cd(); TString profName=Form("Profile%06i",ich); hProf->Write(profName); fileProf->Close(); delete fileProf; fileProf=0x0; } delete hProf; hProf=0x0; AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ich); calChannel->SetSlewPar(par); WriteParOfflineOnCDB("TOF/Calib","valid"); return 0; } //---------------------------------------------------------------------------- Int_t AliTOFcalib::Calibrate(Option_t *optionSave, Option_t *optionFit){ // calibrating the whole TOF // computing calibration parameters // Returning codes: // 0 -> everything was ok // 1 -> no tree for calibration found // 2 -> not enough statistics to perform calibration // 3 -> problems with arrays TH1::AddDirectory(0); AliInfo(Form("*** Calibrating Histograms %s, all channels", GetName())) ; AliInfo(Form("Option for Saving histos = %s",optionSave )) ; AliInfo(Form("Option for Fitting Profile histos = %s",optionFit )) ; TFile * fileProf=0x0; if(strstr(optionSave,"save")){ fileProf = new TFile("TOFCalibSave.root","recreate"); } Float_t p[MAXCHENTRIESSMALL]; Int_t nentries; //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); fChain->GetEntry(i); ntracksTotalmean+=nentries/3; } } ntracksTotalmean/=fNChannels; if (ntracksTotalmean < MEANENTRIES) { AliInfo(Form(" Too small mean number of entires per channel (mean number = %f) not calibrating and exiting.....",ntracksTotalmean)); return 2; } //filling ToT and Time arrays Int_t nbinToT = 100; // ToT bin width in Profile = 50.0 ps Float_t minToT = 0; // ns Float_t maxToT = 4.88;// ns for (Int_t ii=0; iiGetEntry(i); fChain->GetEntry(i); ntracksTotal+=nentries/3; } if (ntracksTotal < MEANENTRIES) { 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); fChain->GetEntry(i); ntracksRun=nentries/3; for (Int_t j=0;jFill(p[idxexTime]-p[idxexExTime]); meantime+=p[idxexTime]-p[idxexExTime]; hToT->Fill(tot); } } nusefulbins = FindBins(hToT,&binsProfile[0]); meantime/=ntracksTotal; for (Int_t j=0;jGetEntry(i); fChain->GetEntry(i); ntracksRun=nentries/3; for (Int_t j=0;jFill(tot,time); // if meantime is not used, the fill may be moved in the loop above htimetot->Fill(tot,time-meantime); // if meantime is not used, the fill may be moved in the loop above } } hSlewingProf->Fit("pol5",optionFit,"",1,4); TF1 * calibfunc = (TF1*)hSlewingProf->GetFunction("pol5"); Float_t par[6]; for(Int_t kk=0;kk<6;kk++){ par[kk]=calibfunc->GetParameter(kk); AliDebug(2,Form("parameter %i = %f",kk,par[kk])); } if(strstr(optionSave,"save") && fileProf){ TString profName=Form("Profile%06i",ii); TString timeTotName=Form("TimeTot%06i",ii); TString totName=Form("Tot%06i",ii); TString deltaName=Form("Delta%06i",ii); fileProf->cd(); hSlewingProf->Write(profName); htimetot->Write(timeTotName); hToT->Write(totName); hdeltaTime->Write(deltaName); } AliTOFChannelOffline * calChannel = (AliTOFChannelOffline*)fTOFCalOffline->At(ii); calChannel->SetSlewPar(par); delete hToT; hToT=0x0; delete hSlewingProf; hSlewingProf=0x0; delete htimetot; htimetot=0x0; delete hdeltaTime; hdeltaTime=0x0; } if(strstr(optionSave,"save")){ fileProf->Close(); delete fileProf; fileProf=0x0; } WriteParOfflineOnCDB("TOF/Calib","valid"); return 0; } //----------------------------------------------------------------------- TH1F* AliTOFcalib::Profile(Int_t ich) { // profiling algo Float_t p[MAXCHENTRIESSMALL]; Int_t nentries; //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; Int_t nbinTime = 200; Float_t minTime = -5.5; //ns Float_t maxTime = 5.5; //ns 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],sigmaTime[knbinToT+1]; Int_t n[knbinToT+1], nentrx[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; n[i]=0; meanTime[i]=0; meanTime2[i]=0; vToT[i]=0; vToT2[i]=0; meanToT[i]=0; meanToT2[i]=0; vTime[i]=0; vTime2[i]=0; //xlow[i]=0; sigmaTime[i]=0; //sigmaToT[i]=0; n[i]=0; nentrx[i]=0; } TH2F* hSlewing = new TH2F("hSlewing", "hSlewing", knbinToT, minToT, maxToT, nbinTime, minTime, maxTime); Int_t ntracksRun = 0; TH1F *histo = new TH1F("histo", "1D Time vs ToT", knbinToT, minToT, maxToT); for (Int_t irun=0;irunGetEntry(i); fChain->GetEntry(i); ntracksRun=nentries/3; for (Int_t j=0;jFill(tot,time); } } } Int_t nbinsToT=hSlewing->GetNbinsX(); if (nbinsToT != knbinToT) { AliError("Profile :: incompatible numbers of bins"); return 0x0; } Int_t usefulBins=0; for (Int_t i=1;i<=nbinsToT;i++){ if (nentrx[i]!=0){ n[usefulBins]+=nentrx[i]; if (n[usefulBins]==0 && i == nbinsToT) { break; } meanTime[usefulBins]+=vTime[i]; meanTime2[usefulBins]+=vTime2[i]; meanToT[usefulBins]+=vToT[i]; meanToT2[usefulBins]+=vToT2[i]; if (n[usefulBins]<10 && i!=nbinsToT) continue; mTime[usefulBins]=meanTime[usefulBins]/n[usefulBins]; mToT[usefulBins]=meanToT[usefulBins]/n[usefulBins]; sigmaTime[usefulBins]=TMath::Sqrt(1./n[usefulBins]/n[usefulBins] *(meanTime2[usefulBins]-meanTime[usefulBins] *meanTime[usefulBins]/n[usefulBins])); if ((1./n[usefulBins]/n[usefulBins] *(meanToT2[usefulBins]-meanToT[usefulBins] *meanToT[usefulBins]/n[usefulBins]))< 0) { AliError(" too small radical" ); //sigmaToT[usefulBins]=0; } else{ //sigmaToT[usefulBins]=TMath::Sqrt(1./n[usefulBins]/n[usefulBins] // *(meanToT2[usefulBins]-meanToT[usefulBins] // *meanToT[usefulBins]/n[usefulBins])); } usefulBins++; } } for (Int_t i=0;iFill(mToT[i],mTime[i]); histo->SetBinError(binN,sigmaTime[i]); } delete hSlewing; hSlewing=0x0; return histo; } //---------------------------------------------------------------------------- Int_t AliTOFcalib::FindBins(TH1F* h, Double_t *binsProfile) const{ // to determine the bins for ToT histo Int_t cont = 0; Int_t startBin = 1; Int_t nbin = h->GetNbinsX(); Int_t nentries = (Int_t)h->GetEntries(); Float_t max = h->GetBinLowEdge(nbin); Int_t nusefulbins=0; Int_t maxcont=0; // setting maxvalue of entries per bin if (nentries <= 60) maxcont = 2; else if (nentries <= 100) maxcont = 5; else if (nentries <= 500) maxcont = 10; else maxcont = 20; for (Int_t j=1;j<=nbin;j++) { cont += (Int_t)h->GetBinContent(j); if (j=maxcont){ nusefulbins++; binsProfile[nusefulbins-1]=h->GetBinLowEdge(startBin); cont=0; startBin=j+1; continue; } } else{ if (cont>=maxcont){ nusefulbins++; binsProfile[nusefulbins-1]=h->GetBinLowEdge(startBin); binsProfile[nusefulbins]=max; } else { binsProfile[nusefulbins]=h->GetBinLowEdge(startBin); } } } 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; } //---------------------------------------------------------------------------- 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) { AliWarning("\n\nfCorrectTExp is a DEPRECATED flag, it will do NOTHING\n\n"); } } //---------------------------------------------------------------------------- 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 */ 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 */ 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; }