From cae7016de0f605f9d03bdc87db58e33eaa6cceb5 Mon Sep 17 00:00:00 2001
From: P-A Loizeau <p.-a.loizeau@gsi.de>
Date: Tue, 30 Jun 2020 16:01:05 +0200
Subject: [PATCH] mCBM 2020: bring task classes to mCBM branch stand -
CbmCheckEvents.cxx ==> AddMUCH + digi manager support - CbmCheckTiming.h ==>
Add TRD support ==> Change sign of time diff to have T0 as reference time ==>
Set binning to clock cycle if compatible - CbmMcbm2018EventBuilder.h ==> Add
TRD support ==> Add support for CbmMuchDigi (Simu) + CbmMuchBeamTimeDigi
(real data) ==> Better monitor histos handling - CbmMcbm2019CheckPulser.h ==>
Add support for TRD + selection by address for some of the detectors
---
fles/mcbm2018/tasks/CbmCheckEvents.cxx | 3 +-
fles/mcbm2018/tasks/CbmCheckTiming.cxx | 154 +++++---
fles/mcbm2018/tasks/CbmCheckTiming.h | 14 +
.../tasks/CbmMcbm2018EventBuilder.cxx | 145 +++++++-
fles/mcbm2018/tasks/CbmMcbm2018EventBuilder.h | 21 +-
.../mcbm2018/tasks/CbmMcbm2019CheckPulser.cxx | 330 +++++++++++++++---
fles/mcbm2018/tasks/CbmMcbm2019CheckPulser.h | 64 +++-
7 files changed, 623 insertions(+), 108 deletions(-)
diff --git a/fles/mcbm2018/tasks/CbmCheckEvents.cxx b/fles/mcbm2018/tasks/CbmCheckEvents.cxx
index 3bfa711d..fc35bcbe 100644
--- a/fles/mcbm2018/tasks/CbmCheckEvents.cxx
+++ b/fles/mcbm2018/tasks/CbmCheckEvents.cxx
@@ -65,6 +65,7 @@ InitStatus CbmCheckEvents::Init()
// DigiManager
fDigiMan = CbmDigiManager::Instance();
+ fDigiMan->UseMuchBeamTimeDigi();
fDigiMan->Init();
// Get a pointer to the previous already existing data level
@@ -186,7 +187,7 @@ void CbmCheckEvents::AnalyseEvent(CbmEvent* event)
// difference between the digis
GetTimeDiffT0(event, fT0DeltaT, fT0InEvent);
GetTimeDiff<CbmStsDigi>(event, fStsDeltaT, fStsInEvent, ECbmDataType::kStsDigi);
- GetTimeDiff<CbmMuchDigi>(event, fMuchDeltaT, fMuchInEvent, ECbmDataType::kMuchDigi);
+ GetTimeDiff<CbmMuchBeamTimeDigi>(event, fMuchDeltaT, fMuchInEvent, ECbmDataType::kMuchDigi);
GetTimeDiff<CbmTofDigi>(event, fTofDeltaT, fTofInEvent, ECbmDataType::kTofDigi);
}
diff --git a/fles/mcbm2018/tasks/CbmCheckTiming.cxx b/fles/mcbm2018/tasks/CbmCheckTiming.cxx
index ad8f0d68..90f78c37 100644
--- a/fles/mcbm2018/tasks/CbmCheckTiming.cxx
+++ b/fles/mcbm2018/tasks/CbmCheckTiming.cxx
@@ -11,6 +11,7 @@
#include "CbmStsDigi.h"
#include "CbmMuchBeamTimeDigi.h"
#include "CbmRichDigi.h"
+#include "CbmTrdDigi.h"
#include "CbmTofDigi.h"
#include "CbmPsdDigi.h"
#include "CbmFlesHistosTools.h"
@@ -81,6 +82,10 @@ InitStatus CbmCheckTiming::Init()
LOG(info) << "No MUCH digis found.";
}
+ if ( ! fDigiMan->IsPresent(ECbmModuleId::kTrd) ) {
+ LOG(info) << "No TRD digis found.";
+ }
+
if ( ! fDigiMan->IsPresent(ECbmModuleId::kTof) ) {
LOG(info) << "No TOF digis found.";
}
@@ -110,6 +115,9 @@ Int_t CbmCheckTiming::CalcNrBins(Int_t offsetRange) {
fBinWidth = 100;
}
+ if( (static_cast< Double_t >(offsetRange)/ 6.25 ) == ( offsetRange / 6.25 ) )
+ return (offsetRange/6.25 *2);
+
return (offsetRange/fBinWidth *2);
}
@@ -124,107 +132,124 @@ void CbmCheckTiming::CreateHistos()
Int_t nrOfBinsSts = CalcNrBins(fStsOffsetRange);
// T0 vs. Sts
- fT0StsDiff = new TH1F("fT0StsDiff","T0-Sts;time diff [ns];Counts",
+ fT0StsDiff = new TH1D("fT0StsDiff","Sts-T0;time diff [ns];Counts",
nrOfBinsSts, -fStsOffsetRange, fStsOffsetRange);
- fT0StsDiffCharge = new TH2F("fT0StsDiffCharge","T0-Sts;time diff [ns]; Charge [a.u]; Counts",
+ fT0StsDiffCharge = new TH2F("fT0StsDiffCharge","Sts-T0;time diff [ns]; Charge [a.u]; Counts",
nrOfBinsSts, -fStsOffsetRange, fStsOffsetRange,
256, 0, 256
);
- fT0StsDiffEvo = new TH2F("fT0StsDiffEvo","T0-Sts;TS; time diff [ns];Counts",
+ fT0StsDiffEvo = new TH2F("fT0StsDiffEvo","Sts-T0;TS; time diff [ns];Counts",
1000, 0, 10000,
nrOfBinsSts, -fStsOffsetRange, fStsOffsetRange);
Int_t nrOfBinsMuch = CalcNrBins(fMuchOffsetRange);
// T0 vs. Much
- fT0MuchDiff = new TH1F("fT0MuchDiff","T0-Much;time diff [ns];Counts",
+ fT0MuchDiff = new TH1D("fT0MuchDiff","Much-T0;time diff [ns];Counts",
nrOfBinsMuch, -fMuchOffsetRange, fMuchOffsetRange);
- fT0MuchDiffCharge = new TH2F("fT0MuchDiffCharge","T0-Much;time diff [ns]; Charge [a.u]; ;Counts",
+ fT0MuchDiffCharge = new TH2F("fT0MuchDiffCharge","Much-T0;time diff [ns]; Charge [a.u]; ;Counts",
nrOfBinsMuch, -fMuchOffsetRange, fMuchOffsetRange,
256, 0, 256
);
- fT0MuchDiffEvo = new TH2F("fT0MuchDiffEvo","T0-Much;TS; time diff [ns];Counts",
+ fT0MuchDiffEvo = new TH2F("fT0MuchDiffEvo","Much-T0;TS; time diff [ns];Counts",
1000, 0, 10000,
nrOfBinsMuch, -fMuchOffsetRange, fMuchOffsetRange);
+ Int_t nrOfBinsTrd = CalcNrBins(fTrdOffsetRange);
+ // To vs. Trd
+ fT0TrdDiff = new TH1D("fT0TrdDiff","Trd-T0;time diff [ns];Counts",
+ nrOfBinsTrd, -fTrdOffsetRange, fTrdOffsetRange);
+
+ fT0TrdDiffCharge = new TH2F("fT0TrdDiffCharge","Trd-T0;time diff [ns]; Charge [a.u]; ;Counts",
+ nrOfBinsTrd, -fTrdOffsetRange, fTrdOffsetRange,
+ 256, 0, 256
+ );
+
+ fT0TrdDiffEvo = new TH2F("fT0TrdDiffEvo","Trd-T0;TS; time diff [ns];Counts",
+ 1000, 0, 10000,
+ nrOfBinsTrd, -fTrdOffsetRange, fTrdOffsetRange);
Int_t nrOfBinsTof = CalcNrBins(fTofOffsetRange);
// To vs. Tof
- fT0TofDiff = new TH1F("fT0TofDiff","T0-Tof;time diff [ns];Counts",
+ fT0TofDiff = new TH1D("fT0TofDiff","Tof-T0;time diff [ns];Counts",
nrOfBinsTof, -fTofOffsetRange, fTofOffsetRange);
- fT0TofDiffCharge = new TH2F("fT0TofDiffCharge","T0-Tof;time diff [ns]; Charge [a.u]; ;Counts",
+ fT0TofDiffCharge = new TH2F("fT0TofDiffCharge","Tof-T0;time diff [ns]; Charge [a.u]; ;Counts",
nrOfBinsTof, -fTofOffsetRange, fTofOffsetRange,
256, 0, 256
);
- fT0TofDiffEvo = new TH2F("fT0TofDiffEvo","T0-Tof;TS; time diff [ns];Counts",
+ fT0TofDiffEvo = new TH2F("fT0TofDiffEvo","Tof-T0;TS; time diff [ns];Counts",
1000, 0, 10000,
nrOfBinsTof, -fTofOffsetRange, fTofOffsetRange);
Int_t nrOfBinsRich = CalcNrBins(fRichOffsetRange);
// To vs. Rich
- fT0RichDiff = new TH1F("fT0RichDiff","T0-Rich;time diff [ns];Counts",
+ fT0RichDiff = new TH1D("fT0RichDiff","Rich-T0;time diff [ns];Counts",
nrOfBinsRich, -fRichOffsetRange, fRichOffsetRange);
- fT0RichDiffCharge = new TH2F("fT0RichDiffCharge","T0-Rich;time diff [ns]; Charge [a.u]; ;Counts",
+ fT0RichDiffCharge = new TH2F("fT0RichDiffCharge","Rich-T0;time diff [ns]; Charge [a.u]; ;Counts",
nrOfBinsRich, -fRichOffsetRange, fRichOffsetRange,
256, 0, 256
);
- fT0RichDiffEvo = new TH2F("fT0RichDiffEvo","T0-Rich;TS; time diff [ns];Counts",
+ fT0RichDiffEvo = new TH2F("fT0RichDiffEvo","Rich-T0;TS; time diff [ns];Counts",
1000, 0, 10000,
nrOfBinsRich, -fRichOffsetRange, fRichOffsetRange);
Int_t nrOfBinsPsd = CalcNrBins(fPsdOffsetRange);
// To vs. Psd
- fT0PsdDiff = new TH1F("fT0PsdDiff","T0-Psd;time diff [ns];Counts",
+ fT0PsdDiff = new TH1D("fT0PsdDiff","Psd-T0;time diff [ns];Counts",
nrOfBinsPsd, -fPsdOffsetRange, fPsdOffsetRange);
- fT0PsdDiffCharge = new TH2F("fT0PsdDiffCharge","T0-Psd;time diff [ns]; Charge [a.u]; ;Counts",
+ fT0PsdDiffCharge = new TH2F("fT0PsdDiffCharge","Psd-T0;time diff [ns]; Charge [a.u]; ;Counts",
nrOfBinsPsd, -fPsdOffsetRange, fPsdOffsetRange,
7000, 0, 70000
);
- fT0PsdDiffEvo = new TH2F("fT0PsdDiffEvo","T0-Psd;TS; time diff [ns];Counts",
+ fT0PsdDiffEvo = new TH2F("fT0PsdDiffEvo","Psd-T0;TS; time diff [ns];Counts",
1000, 0, 10000,
nrOfBinsPsd, -fPsdOffsetRange, fPsdOffsetRange);
// T0 vs. Sts
- fT0StsDiffEvoLong = new TH2F("fT0StsDiffEvoLong","T0-Sts;TS; time diff [ns];Counts",
+ fT0StsDiffEvoLong = new TH2F("fT0StsDiffEvoLong","Sts-T0;TS; time diff [ns];Counts",
1800, 0, 180000,
nrOfBinsSts, -fStsOffsetRange, fStsOffsetRange);
// T0 vs. Much
- fT0MuchDiffEvoLong = new TH2F("fT0MuchDiffEvoLong","T0-Much;TS; time diff [ns];Counts",
+ fT0MuchDiffEvoLong = new TH2F("fT0MuchDiffEvoLong","Much-T0;TS; time diff [ns];Counts",
1800, 0, 180000,
nrOfBinsMuch, -fMuchOffsetRange, fMuchOffsetRange);
+ // To vs. Trd
+ fT0TrdDiffEvoLong = new TH2F("fT0TrdDiffEvoLong","Trd-T0;TS; time diff [ns];Counts",
+ 1800, 0, 180000,
+ nrOfBinsTrd, -fTrdOffsetRange, fTrdOffsetRange);
// To vs. Tof
- fT0TofDiffEvoLong = new TH2F("fT0TofDiffEvoLong","T0-Tof;TS; time diff [ns];Counts",
+ fT0TofDiffEvoLong = new TH2F("fT0TofDiffEvoLong","Tof-T0;TS; time diff [ns];Counts",
1800, 0, 180000,
nrOfBinsTof, -fTofOffsetRange, fTofOffsetRange);
// To vs. Rich
- fT0RichDiffEvoLong = new TH2F("fT0RichDiffEvoLong","T0-Rich;TS; time diff [ns];Counts",
+ fT0RichDiffEvoLong = new TH2F("fT0RichDiffEvoLong","Rich-T0;TS; time diff [ns];Counts",
1800, 0, 180000,
nrOfBinsRich, -fRichOffsetRange, fRichOffsetRange);
// To vs. Psd
- fT0PsdDiffEvoLong = new TH2F("fT0PsdDiffEvoLong","T0-Psd;TS; time diff [ns];Counts",
+ fT0PsdDiffEvoLong = new TH2F("fT0PsdDiffEvoLong","Psd-T0;TS; time diff [ns];Counts",
1800, 0, 180000,
nrOfBinsPsd, -fPsdOffsetRange, fPsdOffsetRange);
// T0 vs. STS for the different DPBs
- fT0StsDpbDiff = new TH2F("fT0StsDpbDiff","T0-Much;DPB; time diff [ns];Counts",
+ fT0StsDpbDiff = new TH2F("fT0StsDpbDiff","Much-T0;DPB; time diff [ns];Counts",
2, -0.5, 1.5, nrOfBinsSts, -fStsOffsetRange, fStsOffsetRange);
for( UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb )
{
fT0StsDpbDiffEvo[uStsDpb] = new TH2F( Form("fT0StsDpbDiffEvo%02u", uStsDpb),
- Form( "T0-STS DPB %02u;TS; time diff [ns];Counts", uStsDpb),
+ Form( "Sts-T0 DPB %02u;TS; time diff [ns];Counts", uStsDpb),
1800, 0, 180000,
nrOfBinsSts, -fStsOffsetRange, fStsOffsetRange);
fStsDpbCntsEvo[uStsDpb] = new TH1F( Form("fStsDpbCntsEvo%02u", uStsDpb),
@@ -233,16 +258,16 @@ void CbmCheckTiming::CreateHistos()
} // for( UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb )
// T0 vs. Much for the different DPBs/AFCK
- fT0MuchRocDiff = new TH2F("fT0MuchRocDiff","T0-Much;AFCK; time diff [ns];Counts",
+ fT0MuchRocDiff = new TH2F("fT0MuchRocDiff","Much-T0;AFCK; time diff [ns];Counts",
kuMaxNbMuchDpbs, -0.5, kuMaxNbMuchDpbs - 0.5, nrOfBinsMuch, -fMuchOffsetRange, fMuchOffsetRange);
// T0 vs. Much for the different ASICs
- fT0MuchAsicDiff = new TH2F("fT0MuchAsicDiff","T0-Much;ASIC; time diff [ns];Counts",
+ fT0MuchAsicDiff = new TH2F("fT0MuchAsicDiff","Much-T0;ASIC; time diff [ns];Counts",
kuMaxNbMuchAsics, -0.5, kuMaxNbMuchAsics - 0.5, nrOfBinsMuch, -fMuchOffsetRange, fMuchOffsetRange);
for( UInt_t uMuchAsic = 0; uMuchAsic < kuMaxNbMuchAsics; ++uMuchAsic )
fT0MuchAsicDiffEvo[uMuchAsic] = new TH2F( Form("fT0MuchAsicDiffEvo%02u", uMuchAsic),
- Form( "T0-Much ASIC %02u;TS; time diff [ns];Counts", uMuchAsic),
+ Form( "Much-T0 ASIC %02u;TS; time diff [ns];Counts", uMuchAsic),
1800, 0, 180000,
nrOfBinsMuch, -fMuchOffsetRange, fMuchOffsetRange);
@@ -255,6 +280,9 @@ void CbmCheckTiming::CreateHistos()
// Much vs. Much
fMuchMuchDiff = new TH1F("fMuchMuchDiff","Much-Much_prev;time diff [ns];Counts",
iNbBinsLog, dBinsLog);
+ // Trd vs. Trd
+ fTrdTrdDiff = new TH1F("fTrdTrdDiff","Trd-Trd_prev;time diff [ns];Counts",
+ iNbBinsLog, dBinsLog);
// Tof vs. Tof
fTofTofDiff = new TH1F("fTofTofDiff","Tof-Tof_prev;time diff [ns];Counts",
iNbBinsLog, dBinsLog);
@@ -271,15 +299,17 @@ void CbmCheckTiming::CreateHistos()
fT0Channel = new TH1F("fT0Channel","T0 channel;channel nr;Counts",
100, -0.5, 99.5);
- fSelT0StsDiff = new TH1F("fSelT0StsDiff","T0-Sts if T0 in coinc with TOF;time diff [ns];Counts",
+ fSelT0StsDiff = new TH1F("fSelT0StsDiff","Sts-T0 if T0 in coinc with TOF;time diff [ns];Counts",
nrOfBinsSts, -fStsOffsetRange, fStsOffsetRange);
- fSelT0MuchDiff = new TH1F("fSelT0MuchDiff","T0-Much if T0 in coinc with TOF;time diff [ns];Counts",
+ fSelT0MuchDiff = new TH1F("fSelT0MuchDiff","Much-T0 if T0 in coinc with TOF;time diff [ns];Counts",
nrOfBinsMuch, -fMuchOffsetRange, fMuchOffsetRange);
- fSelT0TofDiff = new TH1F("fSelT0TofDiff","T0-Tof if T0 in coinc with TOF;time diff [ns];Counts",
+ fSelT0TrdDiff = new TH1F("fSelT0TrdDiff","Trd-T0 if T0 in coinc with TOF;time diff [ns];Counts",
+ nrOfBinsTrd, -fTrdOffsetRange, fTrdOffsetRange);
+ fSelT0TofDiff = new TH1F("fSelT0TofDiff","Tof-T0 if T0 in coinc with TOF;time diff [ns];Counts",
nrOfBinsTof, -fTofOffsetRange, fTofOffsetRange);
- fSelT0RichDiff = new TH1F("fSelT0RichDiff","T0-Rich if T0 in coinc with TOF;time diff [ns];Counts",
+ fSelT0RichDiff = new TH1F("fSelT0RichDiff","Rich-T0 if T0 in coinc with TOF;time diff [ns];Counts",
nrOfBinsRich, -fRichOffsetRange, fRichOffsetRange);
- fSelT0PsdDiff = new TH1F("fSelT0PsdDiff","T0-Psd if T0 in coinc with TOF;time diff [ns];Counts",
+ fSelT0PsdDiff = new TH1F("fSelT0PsdDiff","Psd-T0 if T0 in coinc with TOF;time diff [ns];Counts",
nrOfBinsPsd, -fPsdOffsetRange, fPsdOffsetRange);
/// Cleanup array of log bins
@@ -292,27 +322,32 @@ void CbmCheckTiming::CreateHistos()
if( nullptr != server ) {
server->Register("/CheckTiming", fT0StsDiff);
server->Register("/CheckTiming", fT0MuchDiff);
+ server->Register("/CheckTiming", fT0TrdDiff);
server->Register("/CheckTiming", fT0TofDiff);
server->Register("/CheckTiming", fT0RichDiff);
server->Register("/CheckTiming", fT0PsdDiff);
server->Register("/CheckTiming", fT0StsDiffCharge);
server->Register("/CheckTiming", fT0MuchDiffCharge);
+ server->Register("/CheckTiming", fT0TrdDiffCharge);
server->Register("/CheckTiming", fT0TofDiffCharge);
server->Register("/CheckTiming", fT0RichDiffCharge);
server->Register("/CheckTiming", fT0PsdDiffCharge);
server->Register("/CheckTiming", fT0StsDiffEvo);
server->Register("/CheckTiming", fT0MuchDiffEvo);
+ server->Register("/CheckTiming", fT0TrdDiffEvo);
server->Register("/CheckTiming", fT0TofDiffEvo);
server->Register("/CheckTiming", fT0RichDiffEvo);
server->Register("/CheckTiming", fT0PsdDiffEvo);
server->Register("/CheckTiming", fT0StsDiffEvoLong);
server->Register("/CheckTiming", fT0MuchDiffEvoLong);
+ server->Register("/CheckTiming", fT0TrdDiffEvoLong);
server->Register("/CheckTiming", fT0TofDiffEvoLong);
server->Register("/CheckTiming", fT0RichDiffEvoLong);
server->Register("/CheckTiming", fT0PsdDiffEvoLong);
server->Register("/CheckTiming", fT0T0Diff);
server->Register("/CheckTiming", fStsStsDiff);
server->Register("/CheckTiming", fMuchMuchDiff);
+ server->Register("/CheckTiming", fTrdTrdDiff);
server->Register("/CheckTiming", fTofTofDiff);
server->Register("/CheckTiming", fRichRichDiff);
server->Register("/CheckTiming", fPsdPsdDiff);
@@ -328,6 +363,7 @@ void CbmCheckTiming::CreateHistos()
server->Register("/CheckTiming", fSelT0StsDiff);
server->Register("/CheckTiming", fSelT0MuchDiff);
+ server->Register("/CheckTiming", fSelT0TrdDiff);
server->Register("/CheckTiming", fSelT0TofDiff);
server->Register("/CheckTiming", fSelT0RichDiff);
server->Register("/CheckTiming", fSelT0PsdDiff);
@@ -348,6 +384,9 @@ void CbmCheckTiming::Exec(Option_t* /*option*/)
if (fCheckTimeOrdering) CheckTimeOrder();
if (fCheckInterSystemOffset) CheckInterSystemOffset();
+ if( 0 < fNrTs && 0 == fNrTs % 2000 )
+ WriteHistos();
+
fNrTs++;
}
@@ -371,6 +410,12 @@ void CbmCheckTiming::CheckInterSystemOffset()
LOG(debug) << "MuchDigis: " << nrMuchDigis;
}
+ Int_t nrTrdDigis{0};
+ if (fDigiMan->IsPresent(ECbmModuleId::kTrd)) {
+ nrTrdDigis=fDigiMan->GetNofDigis(ECbmModuleId::kTrd);
+ LOG(debug) << "TrdDigis: " << nrTrdDigis;
+ }
+
Int_t nrTofDigis{0};
if (fDigiMan->IsPresent(ECbmModuleId::kTof)) {
nrTofDigis=fDigiMan->GetNofDigis(ECbmModuleId::kTof);
@@ -394,6 +439,7 @@ void CbmCheckTiming::CheckInterSystemOffset()
/// Re-initialize array references
fPrevT0FirstDigiSts = 0.;
fPrevT0FirstDigiMuch = 0.;
+ fPrevT0FirstDigiTrd = 0.;
fPrevT0FirstDigiTof = 0.;
fPrevT0FirstDigiRich = 0.;
fPrevT0FirstDigiPsd = 0.;
@@ -431,6 +477,11 @@ void CbmCheckTiming::CheckInterSystemOffset()
fT0MuchDiffEvoLong, fT0MuchRocDiff,
T0Time, fMuchOffsetRange, fPrevT0FirstDigiMuch,
kFALSE, kTRUE, kFALSE, kFALSE);
+ if (nrTrdDigis > 0 && nrTrdDigis < 1000000)
+ fPrevT0FirstDigiTrd = FillSystemOffsetHistos<CbmTrdDigi>(fT0TrdDiff, fT0TrdDiffCharge,fT0TrdDiffEvo,
+ fT0TrdDiffEvoLong, nullptr,
+ T0Time, fTrdOffsetRange, fPrevT0FirstDigiTrd,
+ kFALSE, kFALSE, kFALSE, kFALSE);
fuNbTofDigiInSync = 0;
if (nrTofDigis > 0 && nrTofDigis < 1000000)
fPrevT0FirstDigiTof = FillSystemOffsetHistos<CbmTofDigi>(fT0TofDiff, fT0TofDiffCharge,fT0TofDiffEvo,
@@ -455,6 +506,7 @@ void CbmCheckTiming::CheckInterSystemOffset()
/// Re-initialize array references
fPrevT0FirstDigiSts = 0.;
fPrevT0FirstDigiMuch = 0.;
+ fPrevT0FirstDigiTrd = 0.;
fPrevT0FirstDigiTof = 0.;
fPrevT0FirstDigiRich = 0.;
fPrevT0FirstDigiPsd = 0.;
@@ -474,6 +526,12 @@ void CbmCheckTiming::CheckInterSystemOffset()
fvdTimeSelectedT0[ uIdxSelT0 ],
fMuchOffsetRange, fPrevT0FirstDigiMuch,
kFALSE, kTRUE, kFALSE, kFALSE);
+ if (nrTrdDigis > 0 && nrTrdDigis < 1000000)
+ fPrevT0FirstDigiTrd = FillHistosSelT0<CbmTrdDigi>(
+ fSelT0TrdDiff,
+ fvdTimeSelectedT0[ uIdxSelT0 ],
+ fTrdOffsetRange, fPrevT0FirstDigiTrd,
+ kFALSE, kFALSE, kFALSE, kFALSE);
if (nrTofDigis > 0 && nrTofDigis < 1000000)
fPrevT0FirstDigiTof = FillHistosSelT0<CbmTofDigi>(
fSelT0TofDiff,
@@ -525,19 +583,21 @@ Int_t CbmCheckTiming::FillSystemOffsetHistos(TH1* histo, TH2* histoCharge,
if( ( digi->GetCharge() < 7 || 31 == digi->GetCharge() ) ||
( 0 == ( digi->GetChannel() % 2 ) ) )
continue;
-*/
+
/// Take selected PSD channel
if( kTRUE == bPsd )
- if( digi->GetAddress() != ( ( 1 << 10 ) + 8 ) )
+ if( digi->GetAddress() != (0<<10)+8 )
continue;
+*/
- Double_t diffTime = T0Time - digi->GetTime();
+// Double_t diffTime = T0Time - digi->GetTime();
+ Double_t diffTime = digi->GetTime() - T0Time; // Use T0 as reference Time
- if (diffTime > offsetRange) {
+ if (diffTime < -offsetRange) {
++ iFirstDigiInWin; // Update Index of first digi in Win to next digi
continue; // not yet in interesting range
} // if (diffTime > offsetRange)
- if (diffTime < -offsetRange) break; // already past interesting range
+ if (diffTime >offsetRange) break; // already past interesting range
histo->Fill(diffTime);
histoCharge->Fill( diffTime, digi->GetCharge() );
histoEvo->Fill(fNrTs, diffTime);
@@ -606,20 +666,21 @@ Int_t CbmCheckTiming::FillHistosSelT0( TH1* histo,
if( ( digi->GetCharge() < 7 || 31 == digi->GetCharge() ) ||
( 0 == ( digi->GetChannel() % 2 ) ) )
continue;
-*/
/// Take selected PSD channel
if( kTRUE == bPsd )
- if( digi->GetAddress() != ( ( 1 << 10 ) + 8 ) )
+ if( digi->GetAddress() != (0<<10)+8 )
continue;
+*/
- Double_t diffTime = T0Time - digi->GetTime();
+// Double_t diffTime = T0Time - digi->GetTime();
+ Double_t diffTime = digi->GetTime() - T0Time; // Use T0 as reference Time
- if (diffTime > offsetRange) {
+ if (diffTime < -offsetRange) {
++ iFirstDigiInWin; // Update Index of first digi in Win to next digi
continue; // not yet in interesting range
} // if (diffTime > offsetRange)
- if (diffTime < -offsetRange) break; // already past interesting range
+ if (diffTime > offsetRange) break; // already past interesting range
histo->Fill(diffTime);
}
@@ -652,6 +713,11 @@ void CbmCheckTiming::CheckTimeOrder()
fNrOfMuchDigis += nrMuchDigis;
fNrOfMuchErrors += CheckIfSorted<CbmMuchBeamTimeDigi>(fMuchMuchDiff, fPrevTimeMuch, "Much");
}
+ if (fDigiMan->IsPresent(ECbmModuleId::kTrd)) {
+ Int_t nrTrdDigis = fDigiMan->GetNofDigis(ECbmModuleId::kTrd);
+ fNrOfTrdDigis += nrTrdDigis;
+ fNrOfTrdErrors += CheckIfSorted<CbmTrdDigi>(fTrdTrdDiff, fPrevTimeTrd, "Trd");
+ }
if (fDigiMan->IsPresent(ECbmModuleId::kTof)) {
Int_t nrTofDigis = fDigiMan->GetNofDigis(ECbmModuleId::kTof);
fNrOfTofDigis += nrTofDigis;
@@ -750,6 +816,8 @@ void CbmCheckTiming::Finish()
LOG(info) << "Total number of Sts digis: " << fNrOfStsDigis;
LOG(info) << "Total number of Much out of order digis: " << fNrOfMuchErrors;
LOG(info) << "Total number of Much digis: " << fNrOfMuchDigis;
+ LOG(info) << "Total number of Trd out of order digis: " << fNrOfTrdErrors;
+ LOG(info) << "Total number of Trd digis: " << fNrOfTrdDigis;
LOG(info) << "Total number of Tof out of order digis: " << fNrOfTofErrors;
LOG(info) << "Total number of Tof digis: " << fNrOfTofDigis;
LOG(info) << "Total number of Rich out of order digis: " << fNrOfRichErrors;
@@ -769,24 +837,28 @@ void CbmCheckTiming::WriteHistos()
fT0StsDiff->Write();
fT0MuchDiff->Write();
+ fT0TrdDiff->Write();
fT0TofDiff->Write();
fT0RichDiff->Write();
fT0PsdDiff->Write();
fT0StsDiffCharge->Write();
fT0MuchDiffCharge->Write();
+ fT0TrdDiffCharge->Write();
fT0TofDiffCharge->Write();
fT0RichDiffCharge->Write();
fT0PsdDiffCharge->Write();
fT0StsDiffEvo->Write();
fT0MuchDiffEvo->Write();
+ fT0TrdDiffEvo->Write();
fT0TofDiffEvo->Write();
fT0RichDiffEvo->Write();
fT0PsdDiffEvo->Write();
fT0StsDiffEvoLong->Write();
fT0MuchDiffEvoLong->Write();
+ fT0TrdDiffEvoLong->Write();
fT0TofDiffEvoLong->Write();
fT0RichDiffEvoLong->Write();
fT0PsdDiffEvoLong->Write();
@@ -794,6 +866,7 @@ void CbmCheckTiming::WriteHistos()
fT0T0Diff->Write();
fStsStsDiff->Write();
fMuchMuchDiff->Write();
+ fTrdTrdDiff->Write();
fTofTofDiff->Write();
fRichRichDiff->Write();
fPsdPsdDiff->Write();
@@ -815,6 +888,7 @@ void CbmCheckTiming::WriteHistos()
fSelT0StsDiff->Write();
fSelT0MuchDiff->Write();
+ fSelT0TrdDiff->Write();
fSelT0TofDiff->Write();
fSelT0RichDiff->Write();
fSelT0PsdDiff->Write();
diff --git a/fles/mcbm2018/tasks/CbmCheckTiming.h b/fles/mcbm2018/tasks/CbmCheckTiming.h
index 4562a4f0..4936ef60 100644
--- a/fles/mcbm2018/tasks/CbmCheckTiming.h
+++ b/fles/mcbm2018/tasks/CbmCheckTiming.h
@@ -69,6 +69,9 @@ class CbmCheckTiming : public FairTask
void SetMuchOffsetSearchRange(Int_t val = 1000)
{ fMuchOffsetRange = val; }
+ void SetTrdOffsetSearchRange(Int_t val = 1000)
+ { fTrdOffsetRange = val; }
+
void SetTofOffsetSearchRange(Int_t val = 1000)
{ fTofOffsetRange = val; }
@@ -125,6 +128,7 @@ class CbmCheckTiming : public FairTask
Double_t fPrevTimeT0 = 0.;
Double_t fPrevTimeSts = 0.;
Double_t fPrevTimeMuch = 0.;
+ Double_t fPrevTimeTrd = 0.;
Double_t fPrevTimeTof = 0.;
Double_t fPrevTimeRich = 0.;
Double_t fPrevTimePsd = 0.;
@@ -133,6 +137,7 @@ class CbmCheckTiming : public FairTask
/// => Time-order means the time window for following one can only be in a later digi
Int_t fPrevT0FirstDigiSts = 0;
Int_t fPrevT0FirstDigiMuch = 0;
+ Int_t fPrevT0FirstDigiTrd = 0;
Int_t fPrevT0FirstDigiTof = 0;
Int_t fPrevT0FirstDigiRich = 0;
Int_t fPrevT0FirstDigiPsd = 0;
@@ -152,6 +157,8 @@ class CbmCheckTiming : public FairTask
Int_t fNrOfStsDigis = 0;
Int_t fNrOfMuchErrors = 0;
Int_t fNrOfMuchDigis = 0;
+ Int_t fNrOfTrdErrors = 0;
+ Int_t fNrOfTrdDigis = 0;
Int_t fNrOfTofErrors = 0;
Int_t fNrOfTofDigis = 0;
Int_t fNrOfRichErrors = 0;
@@ -165,6 +172,7 @@ class CbmCheckTiming : public FairTask
Int_t fOffsetRange = 1000;
Int_t fStsOffsetRange = 1000;
Int_t fMuchOffsetRange = 1000;
+ Int_t fTrdOffsetRange = 1000;
Int_t fTofOffsetRange = 1000;
Int_t fRichOffsetRange = 1000;
Int_t fPsdOffsetRange = 1000;
@@ -173,24 +181,28 @@ class CbmCheckTiming : public FairTask
TH1* fT0StsDiff = nullptr;
TH1* fT0MuchDiff = nullptr;
+ TH1* fT0TrdDiff = nullptr;
TH1* fT0TofDiff = nullptr;
TH1* fT0RichDiff = nullptr;
TH1* fT0PsdDiff = nullptr;
TH2* fT0StsDiffCharge = nullptr;
TH2* fT0MuchDiffCharge = nullptr;
+ TH2* fT0TrdDiffCharge = nullptr;
TH2* fT0TofDiffCharge = nullptr;
TH2* fT0RichDiffCharge = nullptr;
TH2* fT0PsdDiffCharge = nullptr;
TH2* fT0StsDiffEvo = nullptr;
TH2* fT0MuchDiffEvo = nullptr;
+ TH2* fT0TrdDiffEvo = nullptr;
TH2* fT0TofDiffEvo = nullptr;
TH2* fT0RichDiffEvo = nullptr;
TH2* fT0PsdDiffEvo = nullptr;
TH2* fT0StsDiffEvoLong = nullptr;
TH2* fT0MuchDiffEvoLong = nullptr;
+ TH2* fT0TrdDiffEvoLong = nullptr;
TH2* fT0TofDiffEvoLong = nullptr;
TH2* fT0RichDiffEvoLong = nullptr;
TH2* fT0PsdDiffEvoLong = nullptr;
@@ -198,6 +210,7 @@ class CbmCheckTiming : public FairTask
TH1* fT0T0Diff = nullptr;
TH1* fStsStsDiff = nullptr;
TH1* fMuchMuchDiff = nullptr;
+ TH1* fTrdTrdDiff = nullptr;
TH1* fTofTofDiff = nullptr;
TH1* fRichRichDiff = nullptr;
TH1* fPsdPsdDiff = nullptr;
@@ -221,6 +234,7 @@ class CbmCheckTiming : public FairTask
std::vector< Double_t > fvdTimeSelectedT0;
TH1* fSelT0StsDiff = nullptr;
TH1* fSelT0MuchDiff = nullptr;
+ TH1* fSelT0TrdDiff = nullptr;
TH1* fSelT0TofDiff = nullptr;
TH1* fSelT0RichDiff = nullptr;
TH1* fSelT0PsdDiff = nullptr;
diff --git a/fles/mcbm2018/tasks/CbmMcbm2018EventBuilder.cxx b/fles/mcbm2018/tasks/CbmMcbm2018EventBuilder.cxx
index 3b250e01..01662a38 100644
--- a/fles/mcbm2018/tasks/CbmMcbm2018EventBuilder.cxx
+++ b/fles/mcbm2018/tasks/CbmMcbm2018EventBuilder.cxx
@@ -12,12 +12,15 @@
#include "FairRunOnline.h"
#include "TClonesArray.h"
+#include "TH2.h"
#include "TH1.h"
#include "THttpServer.h"
#include <TFile.h>
#include "CbmStsDigi.h"
#include "CbmMuchBeamTimeDigi.h"
+#include "CbmMuchDigi.h"
+#include "CbmTrdDigi.h"
#include "CbmTofDigi.h"
#include "CbmRichDigi.h"
#include "CbmPsdDigi.h"
@@ -64,7 +67,8 @@ InitStatus CbmMcbm2018EventBuilder::Init()
// Get a pointer to the previous already existing data level
fDigiMan = CbmDigiManager::Instance();
- fDigiMan->UseMuchBeamTimeDigi();
+ if( kFALSE == fbUseBaseMuchDigi )
+ fDigiMan->UseMuchBeamTimeDigi();
fDigiMan->Init();
// T0 is not included in DigiManager
@@ -84,6 +88,10 @@ InitStatus CbmMcbm2018EventBuilder::Init()
LOG(info) << "No MUCH digi input.";
}
+ if ( ! fDigiMan->IsPresent(ECbmModuleId::kTrd) ) {
+ LOG(info) << "No TRD digi input.";
+ }
+
if ( ! fDigiMan->IsPresent(ECbmModuleId::kTof) ) {
LOG(info) << "No TOF digi input.";
}
@@ -104,7 +112,50 @@ InitStatus CbmMcbm2018EventBuilder::Init()
if ( ! fEvents ) LOG(fatal) << "Output branch was not created";
- fDiffTime = new TH1F("fDiffTime","Time difference between two consecutive digis;time diff [ns];Counts", 420, -100.5, 1999.5);
+ if( fFillHistos )
+ {
+ fDiffTime = new TH1F("fDiffTime","Time difference between two consecutive digis;time diff [ns];Counts", 420, -100.5, 1999.5);
+ fhEventTime = new TH1F( "hEventTime", "seed time of the events; Seed time [s]; Events",
+ 60000, 0, 600 );
+ fhEventDt = new TH1F( "fhEventDt", "interval in seed time of consecutive events; Seed time [s]; Events",
+ 2100, -100.5, 1999.5);
+ fhEventSize = new TH1F( "hEventSize",
+ "nb of all digis in the event; Nb Digis []; Events []",
+ 10000, 0, 10000 );
+ fhNbDigiPerEvtTime= new TH2I( "hNbDigiPerEvtTime",
+ "nb of all digis per event vs seed time of the events; Seed time [s]; Nb Digis []; Events []",
+ 600, 0, 600,
+ 1000, 0, 10000 );
+
+ fhNbDigiPerEvtTimeT0 = new TH2I( "hNbDigiPerEvtTimeT0",
+ "nb of T0 digis per event vs seed time of the events; Seed time [s]; Nb Digis []; Events []",
+ 600, 0, 600,
+ 4000, 0, 4000 );
+ fhNbDigiPerEvtTimeSts = new TH2I( "hNbDigiPerEvtTimeSts",
+ "nb of STS digis per event vs seed time of the events; Seed time [s]; Nb Digis []; Events []",
+ 600, 0, 600,
+ 4000, 0, 4000 );
+ fhNbDigiPerEvtTimeMuch = new TH2I( "hNbDigiPerEvtTimeMuch",
+ "nb of MUCH digis per event vs seed time of the events; Seed time [s]; Nb Digis []; Events []",
+ 600, 0, 600,
+ 4000, 0, 4000 );
+ fhNbDigiPerEvtTimeTrd = new TH2I( "hNbDigiPerEvtTimeTrd",
+ "nb of TRD digis per event vs seed time of the events; Seed time [s]; Nb Digis []; Events []",
+ 600, 0, 600,
+ 4000, 0, 4000 );
+ fhNbDigiPerEvtTimeTof = new TH2I( "hNbDigiPerEvtTimeTof",
+ "nb of TOF digis per event vs seed time of the events; Seed time [s]; Nb Digis []; Events []",
+ 600, 0, 600,
+ 4000, 0, 4000 );
+ fhNbDigiPerEvtTimeRich = new TH2I( "hNbDigiPerEvtTimeRich",
+ "nb of RICH digis per event vs seed time of the events; Seed time [s]; Nb Digis []; Events []",
+ 600, 0, 600,
+ 4000, 0, 4000 );
+ fhNbDigiPerEvtTimePsd = new TH2I( "hNbDigiPerEvtTimePsd",
+ "nb of PSD digis per event vs seed time of the events; Seed time [s]; Nb Digis []; Events []",
+ 600, 0, 600,
+ 4000, 0, 4000 );
+ } // if( fFillHistos )
return kSUCCESS;
}
@@ -127,10 +178,13 @@ void CbmMcbm2018EventBuilder::Exec(Option_t* /*option*/)
LOG(debug) << "Found " << fEventVector.size() << " events";
- FillHisto();
-
DefineGoodEvents();
+ if( fFillHistos )
+ {
+ FillHisto();
+ } // if( fFillHistos )
+
LOG(debug) << "Found " << fEventVector.size() << " triggered events";
FillOutput();
@@ -150,6 +204,7 @@ void CbmMcbm2018EventBuilder::InitSorter()
else if ( fT0DigiArr ) nrT0Digis = fT0DigiArr->GetEntriesFast();
Int_t nrStsDigis = fDigiMan->GetNofDigis( ECbmModuleId::kSts );
Int_t nrMuchDigis = fDigiMan->GetNofDigis( ECbmModuleId::kMuch );
+ Int_t nrTrdDigis = fDigiMan->GetNofDigis( ECbmModuleId::kTrd );
Int_t nrTofDigis = fDigiMan->GetNofDigis( ECbmModuleId::kTof );
Int_t nrRichDigis = fDigiMan->GetNofDigis( ECbmModuleId::kRich );
Int_t nrPsdDigis = fDigiMan->GetNofDigis( ECbmModuleId::kPsd );
@@ -157,6 +212,7 @@ void CbmMcbm2018EventBuilder::InitSorter()
LOG(debug) << "T0Digis: " << nrT0Digis;
LOG(debug) << "StsDigis: " << nrStsDigis;
LOG(debug) << "MuchDigis: " << nrMuchDigis;
+ LOG(debug) << "TrdDigis: " << nrTrdDigis;
LOG(debug) << "TofDigis: " << nrTofDigis;
LOG(debug) << "RichDigis: " << nrRichDigis;
LOG(debug) << "PsdDigis: " << nrPsdDigis;
@@ -170,7 +226,17 @@ void CbmMcbm2018EventBuilder::InitSorter()
AddDigiToSorter< CbmStsDigi >(ECbmModuleId::kSts, 0);
}
if (nrMuchDigis>0) {
- AddDigiToSorter< CbmMuchBeamTimeDigi >(ECbmModuleId::kMuch, 0);
+ if( fbUseBaseMuchDigi )
+ {
+ AddDigiToSorter< CbmMuchDigi >(ECbmModuleId::kMuch, 0);
+ } // if( fbUseBaseMuchDigi )
+ else
+ {
+ AddDigiToSorter< CbmMuchBeamTimeDigi >(ECbmModuleId::kMuch, 0);
+ } // else of if( fbUseBaseMuchDigi )
+ }
+ if (nrTrdDigis>0) {
+ AddDigiToSorter< CbmTrdDigi >(ECbmModuleId::kTrd, 0);
}
if (nrTofDigis>0) {
AddDigiToSorter< CbmTofDigi >(ECbmModuleId::kTof, 0);
@@ -221,7 +287,8 @@ void CbmMcbm2018EventBuilder::BuildEvents()
}
AddDigiToEvent(system, entry);
- if (fFillHistos) fVect.emplace_back(make_pair(system, entry));
+ if( fFillHistos )
+ fVect.emplace_back(make_pair(system, entry));
// Remove the first element from the set and insert the next digi
// from the same system
@@ -233,27 +300,39 @@ void CbmMcbm2018EventBuilder::BuildEvents()
{
AddDigiToSorter< CbmStsDigi >(system, ++entry);
break;
- } // case ECbmModuleId::kHodo
+ } // case ECbmModuleId::kSts
case ECbmModuleId::kMuch:
{
- AddDigiToSorter< CbmMuchBeamTimeDigi >(system, ++entry);
+ if( fbUseBaseMuchDigi )
+ {
+ AddDigiToSorter< CbmMuchDigi >(system, ++entry);
+ } // if( fbUseBaseMuchDigi )
+ else
+ {
+ AddDigiToSorter< CbmMuchBeamTimeDigi >(system, ++entry);
+ } // else of if( fbUseBaseMuchDigi )
break;
- } // case ECbmModuleId::kHodo
+ } // case ECbmModuleId::kMuch
+ case ECbmModuleId::kTrd:
+ {
+ AddDigiToSorter< CbmTrdDigi >(system, ++entry);
+ break;
+ } // case ECbmModuleId::kTrd
case ECbmModuleId::kTof:
{
AddDigiToSorter< CbmTofDigi >(system, ++entry);
break;
- } // case ECbmModuleId::kHodo
+ } // case ECbmModuleId::kTof
case ECbmModuleId::kRich:
{
AddDigiToSorter< CbmRichDigi >(system, ++entry);
break;
- } // case ECbmModuleId::kHodo
+ } // case ECbmModuleId::kRich
case ECbmModuleId::kPsd:
{
AddDigiToSorter< CbmPsdDigi >(system, ++entry);
break;
- } // case ECbmModuleId::kHodo
+ } // case ECbmModuleId::kPsd
case ECbmModuleId::kHodo:
{
AddDigiToSorter< CbmTofDigi >(system, ++entry);
@@ -293,6 +372,9 @@ Bool_t CbmMcbm2018EventBuilder::HasTrigger(CbmEvent* event)
if (fDigiMan->IsPresent(ECbmModuleId::kMuch) && fTriggerMinMuchDigis > 0) {
hasTrigger = hasTrigger && (event->GetNofData(ECbmDataType::kMuchDigi) >= fTriggerMinMuchDigis);
}
+ if (fDigiMan->IsPresent(ECbmModuleId::kTrd) && fTriggerMinTrdDigis > 0) {
+ hasTrigger = hasTrigger && (event->GetNofData(ECbmDataType::kTrdDigi) >= fTriggerMinTrdDigis);
+ }
if (fDigiMan->IsPresent(ECbmModuleId::kTof) && fTriggerMinTofDigis > 0) {
hasTrigger = hasTrigger && (event->GetNofData(ECbmDataType::kTofDigi) >= fTriggerMinTofDigis);
}
@@ -320,7 +402,7 @@ void CbmMcbm2018EventBuilder::FillHisto()
Int_t _entry = _pair.second;
CbmDigi* digi = static_cast<CbmDigi*>(fLinkArray[_system]->At(_entry));
Double_t difftime = digi->GetTime() - fPrevTime;
- if (fFillHistos) fDiffTime->Fill(difftime);
+ fDiffTime->Fill(difftime);
if (difftime < 0.) {
fErrors++;
LOG(info) << fixed << setprecision(15)
@@ -336,9 +418,30 @@ void CbmMcbm2018EventBuilder::FillHisto()
prevSystem = _system;
prevEntry = _entry;
}
+ */
fVect.clear();
- */
+ Double_t dPreEvtTime = -1.0;
+ for( CbmEvent * evt: fEventVector )
+ {
+ fhEventTime->Fill( evt->GetStartTime() * 1e-9 );
+ if( 0.0 <= dPreEvtTime )
+ {
+ fhEventDt->Fill( evt->GetStartTime() - dPreEvtTime );
+ } // if( 0.0 <= dPreEvtTime )
+ fhEventSize->Fill( evt->GetNofData() );
+ fhNbDigiPerEvtTime->Fill( evt->GetStartTime() * 1e-9, evt->GetNofData() );
+
+ fhNbDigiPerEvtTimeT0 ->Fill( evt->GetStartTime() * 1e-9, evt->GetNofData( ECbmDataType::kT0Digi ) );
+ fhNbDigiPerEvtTimeSts ->Fill( evt->GetStartTime() * 1e-9, evt->GetNofData( ECbmDataType::kStsDigi ) );
+ fhNbDigiPerEvtTimeMuch->Fill( evt->GetStartTime() * 1e-9, evt->GetNofData( ECbmDataType::kMuchDigi ) );
+ fhNbDigiPerEvtTimeTrd ->Fill( evt->GetStartTime() * 1e-9, evt->GetNofData( ECbmDataType::kTrdDigi ) );
+ fhNbDigiPerEvtTimeTof ->Fill( evt->GetStartTime() * 1e-9, evt->GetNofData( ECbmDataType::kTofDigi ) );
+ fhNbDigiPerEvtTimeRich->Fill( evt->GetStartTime() * 1e-9, evt->GetNofData( ECbmDataType::kRichDigi ) );
+ fhNbDigiPerEvtTimePsd ->Fill( evt->GetStartTime() * 1e-9, evt->GetNofData( ECbmDataType::kPsdDigi ) );
+
+ dPreEvtTime = evt->GetStartTime();
+ } // for( CbmEvent * evt: fEventVector )
}
void CbmMcbm2018EventBuilder::DefineGoodEvents()
@@ -407,6 +510,7 @@ void CbmMcbm2018EventBuilder::AddDigiToSorter( ECbmModuleId _system, Int_t _entr
{
case ECbmModuleId::kSts:
case ECbmModuleId::kMuch:
+ case ECbmModuleId::kTrd:
case ECbmModuleId::kTof:
case ECbmModuleId::kRich:
case ECbmModuleId::kPsd:
@@ -461,6 +565,19 @@ void CbmMcbm2018EventBuilder::Finish()
fDiffTime->Write();
+ fhEventTime->Write();
+ fhEventDt->Write();
+ fhEventSize->Write();
+ fhNbDigiPerEvtTime->Write();
+
+ fhNbDigiPerEvtTimeT0->Write();
+ fhNbDigiPerEvtTimeSts->Write();
+ fhNbDigiPerEvtTimeMuch->Write();
+ fhNbDigiPerEvtTimeTrd->Write();
+ fhNbDigiPerEvtTimeTof->Write();
+ fhNbDigiPerEvtTimeRich->Write();
+ fhNbDigiPerEvtTimePsd->Write();
+
outfile->Close();
delete outfile;
diff --git a/fles/mcbm2018/tasks/CbmMcbm2018EventBuilder.h b/fles/mcbm2018/tasks/CbmMcbm2018EventBuilder.h
index 3a121423..675f1526 100644
--- a/fles/mcbm2018/tasks/CbmMcbm2018EventBuilder.h
+++ b/fles/mcbm2018/tasks/CbmMcbm2018EventBuilder.h
@@ -22,6 +22,7 @@
class TClonesArray;
class TH1;
+class TH2;
class CbmDigiManager;
@@ -79,6 +80,8 @@ class CbmMcbm2018EventBuilder : public FairTask
virtual void Finish();
void SetFillHistos(Bool_t var) {fFillHistos = var;}
+ void SetOutFilename( TString sNameIn ) { fOutFileName = sNameIn; }
+
void SetEventBuilderAlgo(EventBuilderAlgo algo = EventBuilderAlgo::FixedTimeWindow)
{fEventBuilderAlgo = algo;}
void SetFixedTimeWindow(Double_t val) {fFixedTimeWindow = val;}
@@ -87,10 +90,12 @@ class CbmMcbm2018EventBuilder : public FairTask
void SetTriggerMinNumberT0(Int_t val) {fTriggerMinT0Digis = val;}
void SetTriggerMinNumberSts(Int_t val) {fTriggerMinStsDigis = val;}
void SetTriggerMinNumberMuch(Int_t val) {fTriggerMinMuchDigis = val;}
+ void SetTriggerMinNumberTrd(Int_t val) {fTriggerMinTrdDigis = val;}
void SetTriggerMinNumberTof(Int_t val) {fTriggerMinTofDigis = val;}
void SetTriggerMinNumberRich(Int_t val) {fTriggerMinRichDigis = val;}
void SetTriggerMinNumberPsd(Int_t val) {fTriggerMinPsdDigis = val;}
+ void SetUseBaseMuchDigi( Bool_t bFlag = kTRUE ) { fbUseBaseMuchDigi = bFlag; }
private:
void InitSorter();
@@ -110,6 +115,7 @@ class CbmMcbm2018EventBuilder : public FairTask
Int_t fNrTs{0}; //! Timeslice Counter
Double_t fPrevTime{0.}; //! Save previous time information
+ Bool_t fbUseBaseMuchDigi = kFALSE;
CbmDigiManager* fDigiMan = nullptr; //!
const std::vector<CbmTofDigi>* fT0DigiVec = nullptr; //!
TClonesArray* fT0DigiArr = nullptr; //! input container of TO digis
@@ -126,6 +132,17 @@ class CbmMcbm2018EventBuilder : public FairTask
std::vector<CbmEvent*> fEventVector; //! vector with all created events
TH1* fDiffTime{nullptr}; //! histogram with the time difference between two consecutive digis
+ TH1* fhEventTime{nullptr}; //! histogram with the seed time of the events
+ TH1* fhEventDt{nullptr}; //! histogram with the interval in seed time of consecutive events
+ TH1* fhEventSize{nullptr}; //! histogram with the nb of all digis in the event
+ TH2* fhNbDigiPerEvtTime{nullptr}; //! histogram with the nb of all digis per event vs seed time of the events
+ TH2* fhNbDigiPerEvtTimeT0{nullptr}; //! histogram with the nb of T0 digis per event vs seed time of the events
+ TH2* fhNbDigiPerEvtTimeSts{nullptr}; //! histogram with the nb of STS digis per event vs seed time of the events
+ TH2* fhNbDigiPerEvtTimeMuch{nullptr}; //! histogram with the nb of MUCH digis per event vs seed time of the events
+ TH2* fhNbDigiPerEvtTimeTrd{nullptr}; //! histogram with the nb of TRD digis per event vs seed time of the events
+ TH2* fhNbDigiPerEvtTimeTof{nullptr}; //! histogram with the nb of TOF digis per event vs seed time of the events
+ TH2* fhNbDigiPerEvtTimeRich{nullptr}; //! histogram with the nb of RICH digis per event vs seed time of the events
+ TH2* fhNbDigiPerEvtTimePsd{nullptr}; //! histogram with the nb of PSD digis per event vs seed time of the events
Bool_t fFillHistos{kTRUE}; //! Switch ON/OFF filling of histograms
/** Used event building algorithm **/
@@ -143,6 +160,8 @@ class CbmMcbm2018EventBuilder : public FairTask
Int_t fTriggerMinStsDigis{0};
/** Minimum number of Much digis needed to generate a trigger, 0 means don't use Much for trigger generation **/
Int_t fTriggerMinMuchDigis{0};
+ /** Minimum number of Trd digis needed to generate a trigger, 0 means don't use Trd for trigger generation **/
+ Int_t fTriggerMinTrdDigis{0};
/** Minimum number of Tof digis needed to generate a trigger, 0 means don't use Tof for trigger generation **/
Int_t fTriggerMinTofDigis{0};
/** Minimum number of Rich digis needed to generate a trigger, 0 means don't use Rich for trigger generation **/
@@ -151,7 +170,7 @@ class CbmMcbm2018EventBuilder : public FairTask
Int_t fTriggerMinPsdDigis{0};
/** Name of the histogram output file **/
- TString fOutFileName{"test1.root"};
+ TString fOutFileName{"HistosEventBuilder.root"};
ClassDef(CbmMcbm2018EventBuilder,2);
};
diff --git a/fles/mcbm2018/tasks/CbmMcbm2019CheckPulser.cxx b/fles/mcbm2018/tasks/CbmMcbm2019CheckPulser.cxx
index da1adfeb..0c3160d2 100644
--- a/fles/mcbm2018/tasks/CbmMcbm2019CheckPulser.cxx
+++ b/fles/mcbm2018/tasks/CbmMcbm2019CheckPulser.cxx
@@ -10,9 +10,11 @@
#include "CbmStsDigi.h"
#include "CbmMuchBeamTimeDigi.h"
#include "CbmRichDigi.h"
+#include "CbmTrdDigi.h"
#include "CbmTofDigi.h"
#include "CbmPsdDigi.h"
#include "CbmDigiManager.h"
+#include "CbmFlesHistosTools.h"
#include "FairLogger.h"
#include "FairRootManager.h"
@@ -87,6 +89,12 @@ InitStatus CbmMcbm2019CheckPulser::Init()
LOG(info) << "No MUCH digi input found.";
}
+ if ( ! fDigiMan->IsPresent(ECbmModuleId::kTrd) ) {
+ LOG(info) << "No TRD digi input found.";
+ } // if ( ! fDigiMan->IsPresent(ECbmModuleId::kTrd) )
+ else {
+ } // else of if ( ! fDigiMan->IsPresent(ECbmModuleId::kTrd) )
+
if ( ! fDigiMan->IsPresent(ECbmModuleId::kTof) ) {
LOG(info) << "No TOF digi input found.";
}
@@ -99,6 +107,11 @@ InitStatus CbmMcbm2019CheckPulser::Init()
LOG(info) << "No PSD digi input found.";
}
+ /// Access the TS metadata to know TS start tim
+ fTimeSliceMetaDataArray = dynamic_cast<TClonesArray*>(ioman->GetObject("TimesliceMetaData"));
+ if ( ! fTimeSliceMetaDataArray )
+ LOG(fatal) << "No TS metadata input found";
+
CreateHistos();
return kSUCCESS;
@@ -128,39 +141,11 @@ Int_t CbmMcbm2019CheckPulser::CalcNrBins(Int_t offsetRange) {
void CbmMcbm2019CheckPulser::CreateHistos()
{
/// Logarithmic bining for self time comparison
- // Number of log bins =
- // 9 for the sub-unit decade
- // + 9 for each unit of each decade * 10 for the subdecade range
- // + 1 for the closing bin top edge
- const Int_t iNbDecadesLog = 9;
- const Int_t iNbStepsDecade = 9;
- const Int_t iNbSubStepsInStep = 1;
- const Int_t iNbBinsLog = iNbStepsDecade
- + iNbStepsDecade * iNbSubStepsInStep * iNbDecadesLog
- + 1;
- Double_t dBinsLog[iNbBinsLog];
- // First fill sub-unit decade
- for( Int_t iSubU = 0; iSubU < iNbStepsDecade; iSubU ++ )
- dBinsLog[ iSubU ] = 0.1 * ( 1 + iSubU );
- std::cout << std::endl;
- // Then fill the main decades
- Double_t dSubstepSize = 1.0 / iNbSubStepsInStep;
- for( Int_t iDecade = 0; iDecade < iNbDecadesLog; iDecade ++)
- {
- Double_t dBase = std::pow( 10, iDecade );
- Int_t iDecadeIdx = iNbStepsDecade
- + iDecade * iNbStepsDecade * iNbSubStepsInStep;
- for( Int_t iStep = 0; iStep < iNbStepsDecade; iStep++ )
- {
- Int_t iStepIdx = iDecadeIdx + iStep * iNbSubStepsInStep;
- for( Int_t iSubStep = 0; iSubStep < iNbSubStepsInStep; iSubStep++ )
- {
- dBinsLog[ iStepIdx + iSubStep ] = dBase * (1 + iStep)
- + dBase * dSubstepSize * iSubStep;
- } // for( Int_t iSubStep = 0; iSubStep < iNbSubStepsInStep; iSubStep++ )
- } // for( Int_t iStep = 0; iStep < iNbStepsDecade; iStep++ )
- } // for( Int_t iDecade = 0; iDecade < iNbDecadesLog; iDecade ++)
- dBinsLog[ iNbBinsLog - 1 ] = std::pow( 10, iNbDecadesLog );
+ uint32_t iNbBinsLog = 0;
+ /// Parameters are NbDecadesLog, NbStepsDecade, NbSubStepsInStep
+ std::vector<double> dBinsLogVector = GenerateLogBinArray( 9, 9, 1, iNbBinsLog );
+ double* dBinsLog = dBinsLogVector.data();
+// double * dBinsLog = GenerateLogBinArray( 9, 9, 1, iNbBinsLog );
Int_t nrOfBinsSts = CalcNrBins(fStsOffsetRange);
// T0 vs. Sts
@@ -182,6 +167,16 @@ void CbmMcbm2019CheckPulser::CreateHistos()
nrOfBinsMuch, -fMuchOffsetRange, fMuchOffsetRange);
+ Int_t nrOfBinsTrd = CalcNrBins(fTrdOffsetRange);
+ // To vs. Trd
+ fT0TrdDiff = new TH1F("fT0TrdDiff","T0-Trd;time diff [ns];Counts",
+ nrOfBinsTrd, -fTrdOffsetRange, fTrdOffsetRange);
+
+ fT0TrdDiffEvo = new TH2F("fT0TrdDiffEvo","T0-Trd;TS; time diff [ns];Counts",
+ 1000, 0, 10000,
+ nrOfBinsTrd, -fTrdOffsetRange, fTrdOffsetRange);
+
+
Int_t nrOfBinsTof = CalcNrBins(fTofOffsetRange);
// To vs. Tof
fT0TofDiff = new TH1F("fT0TofDiff","T0-Tof;time diff [ns];Counts",
@@ -202,7 +197,7 @@ void CbmMcbm2019CheckPulser::CreateHistos()
nrOfBinsRich, -fRichOffsetRange, fRichOffsetRange);
Int_t nrOfBinsPsd = CalcNrBins(fPsdOffsetRange);
- // To vs. Rich
+ // To vs. Psd
fT0PsdDiff = new TH1F("fT0PsdDiff","T0-Psd;time diff [ns];Counts",
nrOfBinsPsd, -fPsdOffsetRange, fPsdOffsetRange);
@@ -224,6 +219,10 @@ void CbmMcbm2019CheckPulser::CreateHistos()
fT0MuchDiffEvoLong = new TH2F("fT0MuchDiffEvoLong","T0-Much;TS; time diff [ns];Counts",
1800, 0, 180000,
nrOfBinsMuch, -fMuchOffsetRange, fMuchOffsetRange);
+ // To vs. Trd
+ fT0TrdDiffEvoLong = new TH2F("fT0TrdDiffEvoLong","T0-Trd;TS; time diff [ns];Counts",
+ 1800, 0, 180000,
+ nrOfBinsTrd, -fTrdOffsetRange, fTrdOffsetRange);
// To vs. Tof
fT0TofDiffEvoLong = new TH2F("fT0TofDiffEvoLong","T0-Tof;TS; time diff [ns];Counts",
1800, 0, 180000,
@@ -246,6 +245,9 @@ void CbmMcbm2019CheckPulser::CreateHistos()
fT0MuchMeanEvo = new TProfile("fT0MuchMeanEvo","T0-Much; time in run [s]; Mean time diff [ns]",
4320, 0, 4320 );
// To vs. Tof
+ fT0TrdMeanEvo = new TProfile("fT0TrdMeanEvo","T0-Trd; time in run [s]; Mean time diff [ns]",
+ 4320, 0, 4320 );
+ // To vs. Tof
fT0TofMeanEvo = new TProfile("fT0TofMeanEvo","T0-Tof; time in run [s]; Mean time diff [ns]",
4320, 0, 4320 );
// To vs. Rich
@@ -288,22 +290,39 @@ void CbmMcbm2019CheckPulser::CreateHistos()
// T0 vs. T0
fT0T0Diff = new TH1F("fT0T0Diff","T0-T0_prev;time diff [ns];Counts",
- iNbBinsLog - 1, dBinsLog);
+ iNbBinsLog, dBinsLog);
// sts vs. Sts
fStsStsDiff = new TH1F("fStsStsDiff","Sts-Sts_prev;time diff [ns];Counts",
- iNbBinsLog - 1, dBinsLog);
+ iNbBinsLog, dBinsLog);
// Much vs. Much
fMuchMuchDiff = new TH1F("fMuchMuchDiff","Much-Much_prev;time diff [ns];Counts",
- iNbBinsLog - 1, dBinsLog);
+ iNbBinsLog, dBinsLog);
+ // Trd vs. Trd
+ fTrdTrdDiff = new TH1F("fTrdTrdDiff","Trd-Trd_prev;time diff [ns];Counts",
+ iNbBinsLog, dBinsLog);
// Tof vs. Tof
fTofTofDiff = new TH1F("fTofTofDiff","Tof-Tof_prev;time diff [ns];Counts",
- iNbBinsLog - 1, dBinsLog);
+ iNbBinsLog, dBinsLog);
// Rich vs. Rich
fRichRichDiff = new TH1F("fRichRichDiff","Rich-Rich_prev;time diff [ns];Counts",
- iNbBinsLog - 1, dBinsLog);
+ iNbBinsLog, dBinsLog);
// Psd vs. Psd
fPsdPsdDiff = new TH1F("fPsdPsdDiff","Psd-Psd_prev;time diff [ns];Counts",
- iNbBinsLog - 1, dBinsLog);
+ iNbBinsLog, dBinsLog);
+
+
+ fT0StsNb = new TH2F("fT0StsNb","T0-STS;Nb T0; Nb STS;TS []",
+ 100, 0, 100, 100, 0, 100);
+ fT0MuchNb = new TH2F("fT0MuchNb","T0-MUCH;Nb T0; Nb MUCH;TS []",
+ 100, 0, 100, 100, 0, 100);
+ fT0TrdNb = new TH2F("fT0TrdNb","T0-TRD;Nb T0; Nb TRD;TS []",
+ 100, 0, 100, 100, 0, 100);
+ fT0TofNb = new TH2F("fT0TofNb","T0-TOF;Nb T0; Nb TOF;TS []",
+ 100, 0, 100, 100, 0, 100);
+ fT0RichNb = new TH2F("fT0RichNb","T0-RICH;Nb T0; Nb RICH;TS []",
+ 100, 0, 100, 100, 0, 100);
+ fT0PsdNb = new TH2F("fT0PsdNb","T0-PSD;Nb T0; Nb PSD;TS []",
+ 100, 0, 100, 100, 0, 100);
fT0Address = new TH1F("fT0Address","T0 address;address;Counts",
1000000, 0, 1000000.);
@@ -311,6 +330,9 @@ void CbmMcbm2019CheckPulser::CreateHistos()
fT0Channel = new TH1F("fT0Channel","T0 channel;channel nr;Counts",
100, -0.5, 99.5);
+ /// Cleanup array of log bins
+// delete dBinsLog;
+
/// Register the histos in the HTTP server
FairRunOnline* run = FairRunOnline::Instance();
if (run) {
@@ -318,22 +340,26 @@ void CbmMcbm2019CheckPulser::CreateHistos()
if( nullptr != server ) {
server->Register("/CheckTiming", fT0StsDiff);
server->Register("/CheckTiming", fT0MuchDiff);
+ server->Register("/CheckTiming", fT0TrdDiff);
server->Register("/CheckTiming", fT0TofDiff);
server->Register("/CheckTiming", fT0RichDiff);
server->Register("/CheckTiming", fT0PsdDiff);
server->Register("/CheckTiming", fT0StsDiffEvo);
server->Register("/CheckTiming", fT0MuchDiffEvo);
+ server->Register("/CheckTiming", fT0TrdDiffEvo);
server->Register("/CheckTiming", fT0TofDiffEvo);
server->Register("/CheckTiming", fT0RichDiffEvo);
server->Register("/CheckTiming", fT0PsdDiffEvo);
server->Register("/CheckTiming", fT0StsDiffEvoLong);
server->Register("/CheckTiming", fT0MuchDiffEvoLong);
+ server->Register("/CheckTiming", fT0TrdDiffEvoLong);
server->Register("/CheckTiming", fT0TofDiffEvoLong);
server->Register("/CheckTiming", fT0RichDiffEvoLong);
server->Register("/CheckTiming", fT0PsdDiffEvoLong);
server->Register("/CheckTiming", fT0StsMeanEvo);
server->Register("/CheckTiming", fT0MuchMeanEvo);
+ server->Register("/CheckTiming", fT0TrdMeanEvo);
server->Register("/CheckTiming", fT0TofMeanEvo);
server->Register("/CheckTiming", fT0RichMeanEvo);
server->Register("/CheckTiming", fT0PsdMeanEvo);
@@ -341,10 +367,18 @@ void CbmMcbm2019CheckPulser::CreateHistos()
server->Register("/CheckTiming", fT0T0Diff);
server->Register("/CheckTiming", fStsStsDiff);
server->Register("/CheckTiming", fMuchMuchDiff);
+ server->Register("/CheckTiming", fTrdTrdDiff);
server->Register("/CheckTiming", fTofTofDiff);
server->Register("/CheckTiming", fRichRichDiff);
server->Register("/CheckTiming", fPsdPsdDiff);
+ server->Register("/CheckTiming", fT0StsNb);
+ server->Register("/CheckTiming", fT0MuchNb);
+ server->Register("/CheckTiming", fT0TrdNb);
+ server->Register("/CheckTiming", fT0TofNb);
+ server->Register("/CheckTiming", fT0RichNb);
+ server->Register("/CheckTiming", fT0PsdNb);
+
server->Register("/CheckTiming", fT0StsDpbDiff);
for( UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb )
server->Register("/CheckTiming/STS", fT0StsDpbDiffEvo[uStsDpb]);
@@ -475,21 +509,40 @@ void CbmMcbm2019CheckPulser::CheckInterSystemOffset()
else if ( fT0DigiArray ) nrT0Digis = fT0DigiArray->GetEntriesFast();
LOG(debug) << "T0Digis: " << nrT0Digis;
- Int_t nrStsDigis = fDigiMan->GetNofDigis(ECbmModuleId::kSts);
+ Int_t nrStsDigis = fDigiMan->GetNofDigis(ECbmModuleId::kSts);
Int_t nrMuchDigis = fDigiMan->GetNofDigis(ECbmModuleId::kMuch);
- Int_t nrTofDigis = fDigiMan->GetNofDigis(ECbmModuleId::kTof);
+ Int_t nrTrdDigis = fDigiMan->GetNofDigis(ECbmModuleId::kTrd);
+ Int_t nrTofDigis = fDigiMan->GetNofDigis(ECbmModuleId::kTof);
Int_t nrRichDigis = fDigiMan->GetNofDigis(ECbmModuleId::kRich);
- Int_t nrPsdDigis = fDigiMan->GetNofDigis(ECbmModuleId::kPsd);
+ Int_t nrPsdDigis = fDigiMan->GetNofDigis(ECbmModuleId::kPsd);
+/*
+ if( 0 < nrT0Digis )
+ {
+ LOG(info) << "TS: " << fNrTs;
+ LOG(info) << "T0: " << nrT0Digis;
+ LOG(info) << "STS: " << nrStsDigis;
+ LOG(info) << "MUCH: " << nrMuchDigis;
+ LOG(info) << "TRD: " << nrTrdDigis;
+ LOG(info) << "TOF: " << nrTofDigis;
+ LOG(info) << "RICH: " << nrRichDigis;
+ LOG(info) << "PSD: " << nrPsdDigis;
+ }
+*/
// if (nrT0Digis < 100000) {
if (nrT0Digis < 1000000) {
/// Re-initialize array references
fPrevT0FirstDigiSts = 0.;
fPrevT0FirstDigiMuch = 0.;
+ fPrevT0FirstDigiTrd = 0.;
fPrevT0FirstDigiTof = 0.;
fPrevT0FirstDigiRich = 0.;
fPrevT0FirstDigiPsd = 0.;
+ pTsMetaData = dynamic_cast<TimesliceMetaData*>(fTimeSliceMetaDataArray->At(0));
+ if( nullptr == pTsMetaData )
+ LOG(fatal) << Form( "No TS metadata found for TS %6u.", fNrTs );
+
for (Int_t iT0 = 0; iT0 < nrT0Digis; ++iT0) {
if (iT0%1000 == 0) LOG(debug) << "Executing entry " << iT0;
@@ -510,12 +563,15 @@ void CbmMcbm2019CheckPulser::CheckInterSystemOffset()
if( 0x00005006 != T0Address && 0x04005006 != T0Address )
continue;
+ fiT0Nb++;
+
fT0Address->Fill(T0Address);
/*
std::cout << Form( "T0 pulser in TS %5d: address 0x%08X T0 time %12.0f dt %12.0f",
fNrTs, T0Address, T0Time, T0Time - fdLastT0DigiPulser )
<< std::endl;
*/
+ fT0T0Diff->Fill( T0Time - fdLastT0DigiPulser );
fdLastT0DigiPulser = T0Time;
fT0Channel->Fill(T0Digi->GetChannel());
@@ -530,6 +586,11 @@ void CbmMcbm2019CheckPulser::CheckInterSystemOffset()
fT0MuchDiffEvoLong, fT0MuchMeanEvo, fT0MuchRocDiff,
T0Time, fMuchOffsetRange, fPrevT0FirstDigiMuch,
ECbmModuleId::kMuch);
+ if (nrTrdDigis > 0 && nrTrdDigis < 1000000 && fuMinChargePulserTrd < fuMaxChargePulserTrd )
+ fPrevT0FirstDigiTrd = FillSystemOffsetHistos<CbmTrdDigi>(fT0TrdDiff, fT0TrdDiffEvo,
+ fT0TrdDiffEvoLong, fT0TrdMeanEvo, nullptr,
+ T0Time, fTrdOffsetRange, fPrevT0FirstDigiTrd,
+ ECbmModuleId::kTrd);
if (nrTofDigis > 0 && nrTofDigis < 1000000 && fuMinTotPulserTof < fuMaxTotPulserTof )
fPrevT0FirstDigiTof = FillSystemOffsetHistos<CbmTofDigi>(fT0TofDiff, fT0TofDiffEvo,
fT0TofDiffEvoLong, fT0TofMeanEvo, nullptr,
@@ -546,7 +607,115 @@ void CbmMcbm2019CheckPulser::CheckInterSystemOffset()
T0Time, fPsdOffsetRange, fPrevT0FirstDigiPsd,
ECbmModuleId::kPsd);
}
- }
+
+ /// Count pulser candidates for each system
+ /// STS
+ for( Int_t iDigi = 0; iDigi < nrStsDigis; ++iDigi )
+ {
+ const CbmStsDigi* digi = fDigiMan->Get<CbmStsDigi>( iDigi );
+
+ UInt_t uAddr = digi->GetAddress();
+ UInt_t uChan = digi->GetChannel();
+
+ if( ( kuDefaultAddress != fuStsAddress && uAddr != fuStsAddress ) ||
+ ( kuMaxChannelSts != fuStsFirstCha && uChan < fuStsFirstCha ) ||
+ ( kuMaxChannelSts != fuStsLastChan && fuStsLastChan < uChan )
+ )
+ continue;
+
+ if( fuMaxAdcPulserSts < digi->GetCharge() || digi->GetCharge() < fuMinAdcPulserSts )
+ continue;
+
+ fiStsNb++;
+ } // for( Int_t iDigi = 0; iDigi < nrStsDigis; ++iDigi )
+ /// MUCH
+ for( Int_t iDigi = 0; iDigi < nrMuchDigis; ++iDigi )
+ {
+ const CbmMuchBeamTimeDigi* digi = fDigiMan->Get<CbmMuchBeamTimeDigi>( iDigi );
+
+ UInt_t uAsic = digi->GetNxId();
+ UInt_t uChan = digi->GetNxCh();
+
+ if( ( kuMaxNbMuchAsics != fuMuchAsic && uAsic != fuMuchAsic ) ||
+ ( kuNbChanSMX != fuMuchFirstCha && uChan < fuMuchFirstCha ) ||
+ ( kuNbChanSMX != fuMuchLastChan && fuMuchLastChan < uChan )
+ )
+ continue;
+
+ if( fuMaxAdcPulserMuch < digi->GetCharge() || digi->GetCharge() < fuMinAdcPulserMuch )
+ continue;
+
+ fiMuchNb++;
+ } // for( Int_t iDigi = 0; iDigi < nrMuchDigis; ++iDigi )
+ /// TRD
+ for( Int_t iDigi = 0; iDigi < nrTrdDigis; ++iDigi )
+ {
+ const CbmTrdDigi* digi = fDigiMan->Get<CbmTrdDigi>( iDigi );
+
+ UInt_t uAddr = digi->GetAddress();
+
+ if( ( kuDefaultAddress != fuTrdAddress && uAddr != fuTrdAddress )
+ )
+ continue;
+
+ if( fuMaxChargePulserTrd < digi->GetCharge() || digi->GetCharge() < fuMinChargePulserTrd )
+ continue;
+
+ fiTrdNb++;
+ } // for( Int_t iDigi = 0; iDigi < nrTrdDigis; ++iDigi )
+ /// TOF
+ for( Int_t iDigi = 0; iDigi < nrTofDigis; ++iDigi )
+ {
+ const CbmTofDigi* digi = fDigiMan->Get<CbmTofDigi>( iDigi );
+
+ if( fuMaxTotPulserTof < digi->GetCharge() || digi->GetCharge() < fuMinTotPulserTof )
+ continue;
+
+ fiTofNb++;
+ } // for( Int_t iDigi = 0; iDigi < nrTofDigis; ++iDigi )
+ /// RICH
+ for( Int_t iDigi = 0; iDigi < nrRichDigis; ++iDigi )
+ {
+ const CbmRichDigi* digi = fDigiMan->Get<CbmRichDigi>( iDigi );
+
+ if( fuMaxTotPulserRich < digi->GetCharge() || digi->GetCharge() < fuMinTotPulserRich )
+ continue;
+
+ fiRichNb++;
+ } // for( Int_t iDigi = 0; iDigi < nrRichDigis; ++iDigi )
+ /// PSD
+ for( Int_t iDigi = 0; iDigi < nrPsdDigis; ++iDigi )
+ {
+ const CbmPsdDigi* digi = fDigiMan->Get<CbmPsdDigi>( iDigi );
+
+ UInt_t uAddr = digi->GetAddress();
+
+ if( ( kuDefaultAddress != fuPsdAddress && uAddr != fuPsdAddress )
+ )
+ continue;
+
+ if( fuMaxAdcPulserPsd < digi->GetCharge() || digi->GetCharge() < fuMinAdcPulserPsd )
+ continue;
+
+ fiPsdNb++;
+ } // for( Int_t iDigi = 0; iDigi < nrPsdDigis; ++iDigi )
+
+ fT0StsNb->Fill( fiT0Nb, fiStsNb );
+ fT0MuchNb->Fill( fiT0Nb, fiMuchNb );
+ fT0TrdNb->Fill( fiT0Nb, fiTrdNb );
+ fT0TofNb->Fill( fiT0Nb, fiTofNb );
+ fT0RichNb->Fill( fiT0Nb, fiRichNb );
+ fT0PsdNb->Fill( fiT0Nb, fiPsdNb );
+
+ fiT0Nb = 0;
+ fiStsNb = 0;
+ fiMuchNb = 0;
+ fiTrdNb = 0;
+ fiTofNb = 0;
+ fiRichNb = 0;
+ fiPsdNb = 0;
+ } // if (nrT0Digis < 1000000)
+
/*
for (Int_t iMuch = 0; iMuch < nrMuchDigis; ++iMuch) {
@@ -610,8 +779,28 @@ Int_t CbmMcbm2019CheckPulser::FillSystemOffsetHistos(TH1* histo,
{
case ECbmModuleId::kSts: ///< Silicon Tracking System
{
+ const CbmStsDigi* stsDigi;
+ try {
+ stsDigi =
+ boost::any_cast<const CbmStsDigi*>( digi );
+ } catch( ... ) {
+ LOG( fatal ) << "Failed boost any_cast in CbmMcbm2019CheckPulser::FillSystemOffsetHistos for a digi of type "
+ << Digi::GetClassName();
+ } // try/catch
+ assert(stsDigi);
+ UInt_t uAddr = stsDigi->GetAddress();
+ UInt_t uChan = stsDigi->GetChannel();
+
+ if( ( kuDefaultAddress != fuStsAddress && uAddr != fuStsAddress ) ||
+ ( kuMaxChannelSts != fuStsFirstCha && uChan < fuStsFirstCha ) ||
+ ( kuMaxChannelSts != fuStsLastChan && fuStsLastChan < uChan )
+ )
+ continue;
+
if( fuMaxAdcPulserSts < digi->GetCharge() || digi->GetCharge() < fuMinAdcPulserSts )
continue;
+
+ fiStsNb++;
break;
} // case ECbmModuleId::kSts:
case ECbmModuleId::kMuch: ///< Muon detection system
@@ -636,26 +825,65 @@ Int_t CbmMcbm2019CheckPulser::FillSystemOffsetHistos(TH1* histo,
if( fuMaxAdcPulserMuch < digi->GetCharge() || digi->GetCharge() < fuMinAdcPulserMuch )
continue;
+
+ fiMuchNb++;
break;
+ } // case ECbmModuleId::kMuch:
+ case ECbmModuleId::kTrd: ///< Time-of-flight Detector
+ {
+/*
+ const CbmTrdDigi* trdDigi;
+ try {
+ trdDigi =
+ boost::any_cast<const CbmTrdDigi*>( digi );
+ } catch( ... ) {
+ LOG( fatal ) << "Failed boost any_cast in CbmMcbm2019CheckPulser::FillSystemOffsetHistos for a digi of type "
+ << Digi::GetClassName();
+ } // try/catch
+ assert(trdDigi);
+*/
+ UInt_t uAddr = digi->GetAddress();
+ if( ( kuDefaultAddress != fuTrdAddress && uAddr != fuTrdAddress )
+ )
+ continue;
- } // case ECbmModuleId::kMuch:
+ if( fuMaxChargePulserTrd < digi->GetCharge() || digi->GetCharge() < fuMinChargePulserTrd )
+ continue;
+
+ fiTrdNb++;
+ break;
+ } // case ECbmModuleId::kTrd:
case ECbmModuleId::kTof: ///< Time-of-flight Detector
{
if( fuMaxTotPulserTof < digi->GetCharge() || digi->GetCharge() < fuMinTotPulserTof )
continue;
+
+ fiTofNb++;
break;
} // case ECbmModuleId::kTof:
case ECbmModuleId::kRich: ///< Ring-Imaging Cherenkov Detector
{
if( fuMaxTotPulserRich < digi->GetCharge() || digi->GetCharge() < fuMinTotPulserRich )
continue;
+
+ fiRichNb++;
break;
} // case ECbmModuleId::kRich:
case ECbmModuleId::kPsd: ///< Projectile spectator detector
{
+ UInt_t uAddr = digi->GetAddress();
+
+ if( ( kuDefaultAddress != fuPsdAddress && uAddr != fuPsdAddress )
+ )
+ continue;
+
if( fuMaxAdcPulserPsd < digi->GetCharge() || digi->GetCharge() < fuMinAdcPulserPsd )
continue;
+ if( digi->GetAddress() != (9<<10)+8 )
+ continue;
+
+ fiPsdNb++;
break;
} // case ECbmModuleId::kPsd:
default:
@@ -731,6 +959,7 @@ void CbmMcbm2019CheckPulser::WriteHistos()
fT0StsDiff->Write();
fT0MuchDiff->Write();
+ fT0TrdDiff->Write();
fT0TofDiff->Write();
fT0RichDiff->Write();
fT0PsdDiff->Write();
@@ -738,18 +967,21 @@ void CbmMcbm2019CheckPulser::WriteHistos()
fT0StsDiffEvo->Write();
fT0MuchDiffEvo->Write();
+ fT0TrdDiffEvo->Write();
fT0TofDiffEvo->Write();
fT0RichDiffEvo->Write();
fT0PsdDiffEvo->Write();
fT0StsDiffEvoLong->Write();
fT0MuchDiffEvoLong->Write();
+ fT0TrdDiffEvoLong->Write();
fT0TofDiffEvoLong->Write();
fT0RichDiffEvoLong->Write();
fT0PsdDiffEvoLong->Write();
fT0StsMeanEvo->Write();
fT0MuchMeanEvo->Write();
+ fT0TrdMeanEvo->Write();
fT0TofMeanEvo->Write();
fT0RichMeanEvo->Write();
fT0PsdMeanEvo->Write();
@@ -757,10 +989,18 @@ void CbmMcbm2019CheckPulser::WriteHistos()
fT0T0Diff->Write();
fStsStsDiff->Write();
fMuchMuchDiff->Write();
+ fTrdTrdDiff->Write();
fTofTofDiff->Write();
fRichRichDiff->Write();
fPsdPsdDiff->Write();
+ fT0StsNb->Write();
+ fT0MuchNb->Write();
+ fT0TrdNb->Write();
+ fT0TofNb->Write();
+ fT0RichNb->Write();
+ fT0PsdNb->Write();
+
fT0Address->Write();
fT0Channel->Write();
diff --git a/fles/mcbm2018/tasks/CbmMcbm2019CheckPulser.h b/fles/mcbm2018/tasks/CbmMcbm2019CheckPulser.h
index eadb3f36..fc4ddac3 100644
--- a/fles/mcbm2018/tasks/CbmMcbm2019CheckPulser.h
+++ b/fles/mcbm2018/tasks/CbmMcbm2019CheckPulser.h
@@ -8,13 +8,19 @@
#ifndef CBMMCBM2019CHECKPULSER_H
#define CBMMCBM2019CHECKPULSER_H
-#include <vector>
+/// CBMROOT headers
#include "CbmDefs.h"
+#include "TimesliceMetaData.h"
+#include "CbmTofDigi.h"
+/// FAIRROOT headers
#include "FairTask.h"
+/// External headers (ROOT, boost, ...)
#include "TString.h"
-#include "CbmTofDigi.h"
+
+/// C/C++ headers
+#include <vector>
class TClonesArray;
class TH1;
@@ -64,6 +70,9 @@ class CbmMcbm2019CheckPulser : public FairTask
void SetMuchOffsetSearchRange(Int_t val = 1000)
{ fMuchOffsetRange = val; }
+ void SetTrdOffsetSearchRange(Int_t val = 1000)
+ { fTrdOffsetRange = val; }
+
void SetTofOffsetSearchRange(Int_t val = 1000)
{ fTofOffsetRange = val; }
@@ -77,8 +86,10 @@ class CbmMcbm2019CheckPulser : public FairTask
{ fuMinTotPulserT0 = uMin; fuMaxTotPulserT0 = uMax; }
inline void SetStsPulserAdcLimits( UInt_t uMin, UInt_t uMax )
{ fuMinAdcPulserSts = uMin; fuMaxAdcPulserSts = uMax; }
- inline void SetMuchPulseradcLimits( UInt_t uMin, UInt_t uMax )
+ inline void SetMuchPulserAdcLimits( UInt_t uMin, UInt_t uMax )
{ fuMinAdcPulserMuch = uMin; fuMaxAdcPulserMuch = uMax; }
+ inline void SetTrdPulserChargeLimits( UInt_t uMin, UInt_t uMax )
+ { fuMinChargePulserTrd = uMin; fuMaxChargePulserTrd = uMax; }
inline void SetTofPulserTotLimits( UInt_t uMin, UInt_t uMax )
{ fuMinTotPulserTof = uMin; fuMaxTotPulserTof = uMax; }
inline void SetRichPulserTotLimits( UInt_t uMin, UInt_t uMax )
@@ -88,9 +99,12 @@ class CbmMcbm2019CheckPulser : public FairTask
inline void SetOutFilename( TString sNameIn ) { fOutFileName = sNameIn; }
+ inline void SetStsAddress( UInt_t uAddress ) { fuStsAddress = uAddress; }
inline void SetMuchAsic( UInt_t uAsic ) { fuMuchAsic = uAsic; }
inline void SetMuchChanRange( UInt_t uFirstChan, UInt_t uLastChan = kuNbChanSMX )
{ fuMuchFirstCha = uFirstChan; fuMuchLastChan = uLastChan; }
+ inline void SetTrdAddress( UInt_t uAddress ) { fuTrdAddress = uAddress; }
+ inline void SetPsdAddress( UInt_t uAddress ) { fuPsdAddress = uAddress; }
private:
@@ -115,17 +129,22 @@ class CbmMcbm2019CheckPulser : public FairTask
CbmDigiManager* fDigiMan = nullptr; //!
const std::vector<CbmTofDigi>* fT0DigiVector = nullptr; //!
TClonesArray* fT0DigiArray = nullptr; //!
+ TClonesArray* fTimeSliceMetaDataArray = nullptr; //!
+ const TimesliceMetaData* pTsMetaData = nullptr;
/// Constants
- static const UInt_t kuNbChanSMX = 128;
- static const UInt_t kuMaxNbStsDpbs = 2;
- static const UInt_t kuMaxNbMuchDpbs = 6;
- static const UInt_t kuMaxNbMuchAsics = 36;
+ static const UInt_t kuNbChanSMX = 128;
+ static const UInt_t kuMaxNbStsDpbs = 2;
+ static const UInt_t kuMaxNbMuchDpbs = 6;
+ static const UInt_t kuMaxNbMuchAsics = 36;
+ static const UInt_t kuDefaultAddress = 0xFFFFFFFF;
+ static const UInt_t kuMaxChannelSts = 3000;
/// Variables to store the previous digi time
Double_t fPrevTimeT0 = 0.;
Double_t fPrevTimeSts = 0.;
Double_t fPrevTimeMuch = 0.;
+ Double_t fPrevTimeTrd = 0.;
Double_t fPrevTimeTof = 0.;
Double_t fPrevTimeRich = 0.;
Double_t fPrevTimePsd = 0.;
@@ -134,26 +153,36 @@ class CbmMcbm2019CheckPulser : public FairTask
/// => Time-order means the time window for following one can only be in a later digi
Int_t fPrevT0FirstDigiSts = 0;
Int_t fPrevT0FirstDigiMuch = 0;
+ Int_t fPrevT0FirstDigiTrd = 0;
Int_t fPrevT0FirstDigiTof = 0;
Int_t fPrevT0FirstDigiRich = 0;
Int_t fPrevT0FirstDigiPsd = 0;
/// User settings: Data correction parameters
+ /// Charge cut
UInt_t fuMinTotPulserT0 = 182;
UInt_t fuMaxTotPulserT0 = 190;
UInt_t fuMinAdcPulserSts = 90;
UInt_t fuMaxAdcPulserSts = 100;
UInt_t fuMinAdcPulserMuch = 5;
UInt_t fuMaxAdcPulserMuch = 15;
+ UInt_t fuMinChargePulserTrd = 0;
+ UInt_t fuMaxChargePulserTrd = 70000;
UInt_t fuMinTotPulserTof = 182;
UInt_t fuMaxTotPulserTof = 190;
UInt_t fuMinTotPulserRich = 90;
UInt_t fuMaxTotPulserRich = 105;
UInt_t fuMinAdcPulserPsd = 90;
UInt_t fuMaxAdcPulserPsd = 100;
+ /// Channel selection
+ UInt_t fuStsAddress = kuDefaultAddress;
+ UInt_t fuStsFirstCha = kuMaxChannelSts;
+ UInt_t fuStsLastChan = kuMaxChannelSts;
UInt_t fuMuchAsic = kuMaxNbMuchAsics;
UInt_t fuMuchFirstCha = kuNbChanSMX;
UInt_t fuMuchLastChan = kuNbChanSMX;
+ UInt_t fuTrdAddress = kuDefaultAddress;
+ UInt_t fuPsdAddress = kuDefaultAddress;
//
Int_t fNrTs = 0;
@@ -161,6 +190,7 @@ class CbmMcbm2019CheckPulser : public FairTask
Int_t fOffsetRange = 1000;
Int_t fStsOffsetRange = 1000;
Int_t fMuchOffsetRange = 1000;
+ Int_t fTrdOffsetRange = 1000;
Int_t fTofOffsetRange = 1000;
Int_t fRichOffsetRange = 1000;
Int_t fPsdOffsetRange = 1000;
@@ -169,6 +199,7 @@ class CbmMcbm2019CheckPulser : public FairTask
TH1* fT0StsDiff = nullptr;
TH1* fT0MuchDiff = nullptr;
+ TH1* fT0TrdDiff = nullptr;
TH1* fT0TofDiff = nullptr;
TH1* fT0RichDiff = nullptr;
TH1* fT0PsdDiff = nullptr;
@@ -176,12 +207,14 @@ class CbmMcbm2019CheckPulser : public FairTask
TH2* fT0StsDiffEvo = nullptr;
TH2* fT0MuchDiffEvo = nullptr;
+ TH2* fT0TrdDiffEvo = nullptr;
TH2* fT0TofDiffEvo = nullptr;
TH2* fT0RichDiffEvo = nullptr;
TH2* fT0PsdDiffEvo = nullptr;
TH2* fT0StsDiffEvoLong = nullptr;
TH2* fT0MuchDiffEvoLong = nullptr;
+ TH2* fT0TrdDiffEvoLong = nullptr;
TH2* fT0TofDiffEvoLong = nullptr;
TH2* fT0RichDiffEvoLong = nullptr;
TH2* fT0PsdDiffEvoLong = nullptr;
@@ -189,6 +222,7 @@ class CbmMcbm2019CheckPulser : public FairTask
Double_t fdStartTime = -1;
TProfile* fT0StsMeanEvo = nullptr;
TProfile* fT0MuchMeanEvo = nullptr;
+ TProfile* fT0TrdMeanEvo = nullptr;
TProfile* fT0TofMeanEvo = nullptr;
TProfile* fT0RichMeanEvo = nullptr;
TProfile* fT0PsdMeanEvo = nullptr;
@@ -196,10 +230,26 @@ class CbmMcbm2019CheckPulser : public FairTask
TH1* fT0T0Diff = nullptr;
TH1* fStsStsDiff = nullptr;
TH1* fMuchMuchDiff = nullptr;
+ TH1* fTrdTrdDiff = nullptr;
TH1* fTofTofDiff = nullptr;
TH1* fRichRichDiff = nullptr;
TH1* fPsdPsdDiff = nullptr;
+ TH2* fT0StsNb = nullptr;
+ TH2* fT0MuchNb = nullptr;
+ TH2* fT0TrdNb = nullptr;
+ TH2* fT0TofNb = nullptr;
+ TH2* fT0RichNb = nullptr;
+ TH2* fT0PsdNb = nullptr;
+
+ Int_t fiT0Nb = 0;
+ Int_t fiStsNb = 0;
+ Int_t fiMuchNb = 0;
+ Int_t fiTrdNb = 0;
+ Int_t fiTofNb = 0;
+ Int_t fiRichNb = 0;
+ Int_t fiPsdNb = 0;
+
TH1* fT0Address = nullptr;
TH1* fT0Channel = nullptr;
--
GitLab