#include "TF1.h"
#include "TFile.h"
#include "TH1F.h"
+#include "TH1C.h"
#include "TH2F.h"
//#include "TList.h"
//#include "TROOT.h"
#include "AliTOFCTPLatency.h"
#include "AliTOFT0Fill.h"
#include "AliTOFRunParams.h"
+#include "AliLHCClockPhase.h"
#include "AliTOFResponseParams.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
fCTPLatency(NULL),
fT0Fill(NULL),
fRunParams(NULL),
+ fLHCClockPhase(NULL),
fResponseParams(NULL),
fReadoutEfficiency(NULL),
+ fProblematic(NULL),
fInitFlag(kFALSE),
fRemoveMeanT0(kTRUE),
+ fUseLHCClockPhase(kFALSE),
fCalibrateTOFsignal(kTRUE),
- fCorrectTExp(kFALSE)
+ fCorrectTExp(kFALSE),
+ fRunParamsSpecificVersion(-1)
{
//TOF Calibration Class ctor
fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
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)
+ fCorrectTExp(calib.fCorrectTExp),
+ fRunParamsSpecificVersion(calib.fRunParamsSpecificVersion)
{
fTOFCalOnline = new TObjArray(fNChannels);
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);
}
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;
}
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;
}
}
nusefulbins = FindBins(hToT,&binsProfile[0]);
- meantime/=ntracksTotal;
+ if (ntracksTotal != 0){
+ meantime/=ntracksTotal;
+ }
AliDebug(2, Form("meantime = %f",meantime));
for (Int_t j=1;j<=nusefulbins;j++) {
//----------------------------------------------------------------------------
+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)
{
*/
AliCDBManager *man = AliCDBManager::Instance();
- AliCDBEntry *entry = man->Get(Form("%s/RunParams", sel),nrun);
+ AliCDBEntry *entry = man->Get(Form("%s/RunParams", sel),nrun, fRunParamsSpecificVersion);
if (!entry) {
AliFatal("No RunParams entry found in CDB");
exit(0);
//----------------------------------------------------------------------------
+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)
{
//----------------------------------------------------------------------------
+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)
{
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()) {
}
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;
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.;
//----------------------------------------------------------------------------
Bool_t
-AliTOFcalib::IsChannelEnabled(Int_t index, Bool_t checkEfficiency)
+AliTOFcalib::IsChannelEnabled(Int_t index, Bool_t checkEfficiency, Bool_t checkProblematic)
{
/*
* is channel enabled
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::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
{
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff