diff --git a/macro/run/run_reco.C b/macro/run/run_reco.C
index 3e6bac62d04b646bc50620f4d2206e470126eddc..6260b7401e69644c4020c7336806347038c869cd 100644
--- a/macro/run/run_reco.C
+++ b/macro/run/run_reco.C
@@ -283,7 +283,7 @@ void run_reco(TString input = "", Int_t nTimeSlices = -1, Int_t firstTimeSlice =
// ------------------------------------------------------------------------
// ----------- QA for raw event builder -----------------------------------
- if (eventBased) {
+ if (eventBased && useMC) {
CbmBuildEventsQA* evBuildQA = new CbmBuildEventsQA();
run->AddTask(evBuildQA);
}
@@ -372,7 +372,7 @@ void run_reco(TString input = "", Int_t nTimeSlices = -1, Int_t firstTimeSlice =
// ----- Local reconstruction in TOF ----------------------------------
if (useTof) {
- CbmTofSimpClusterizer* tofCluster = new CbmTofSimpClusterizer("TOF Simple Clusterizer", 0);
+ CbmTofSimpClusterizer* tofCluster = new CbmTofSimpClusterizer("TofSimpClusterizer", 0);
tofCluster->SetOutputBranchPersistent("TofHit", kTRUE);
tofCluster->SetOutputBranchPersistent("TofDigiMatch", kTRUE);
run->AddTask(tofCluster);
diff --git a/reco/detectors/psd/CbmPsdHitProducer.cxx b/reco/detectors/psd/CbmPsdHitProducer.cxx
index fe2ab8d5bda0784578ad60789895de852541e770..f65ca867e0d8f94767d4eba0c79a7e1db78459d5 100644
--- a/reco/detectors/psd/CbmPsdHitProducer.cxx
+++ b/reco/detectors/psd/CbmPsdHitProducer.cxx
@@ -27,12 +27,14 @@ using std::endl;
using std::fixed;
using std::left;
using std::pair;
+using std::right;
using std::setprecision;
using std::setw;
+using std::stringstream;
// ----- Default constructor -------------------------------------------
-CbmPsdHitProducer::CbmPsdHitProducer() : FairTask("Ideal Psd Hit Producer", 1), fXi(), fYi() {}
+CbmPsdHitProducer::CbmPsdHitProducer() : FairTask("PsdHitProducer", 1), fXi(), fYi() {}
// -------------------------------------------------------------------------
@@ -145,13 +147,14 @@ void CbmPsdHitProducer::Exec(Option_t* /*opt*/)
// --- Timeslice log and statistics
timer.Stop();
- if (fEvents)
- LOG(info) << std::setw(20) << std::left << GetName() << fixed << setprecision(2) << " [" << timer.RealTime() * 1000.
- << " ms] TS " << fNofTs << ", events " << nEvents << ", digis " << nDigis << " / " << nDigisAll
- << ", hits " << nHits;
- else
- LOG(info) << std::setw(20) << std::left << GetName() << fixed << setprecision(2) << " [" << timer.RealTime() * 1000.
- << " ms] TS " << fNofTs << ", digis " << nDigis << " / " << nDigisAll << ", hits " << nHits;
+ stringstream logOut;
+ logOut << setw(20) << left << GetName() << " [";
+ logOut << fixed << setw(8) << setprecision(1) << right << timer.RealTime() * 1000. << " ms] ";
+ logOut << "TS " << fNofTs;
+ if (fEvents) logOut << ", events " << nEvents;
+ logOut << ", digis " << nDigis << " / " << nDigisAll;
+ logOut << ", hits " << nHits;
+ LOG(info) << logOut.str();
fNofTs++;
fNofEvents += nEvents;
fNofDigis += nDigis;
diff --git a/reco/detectors/rich/CbmRichHitProducer.cxx b/reco/detectors/rich/CbmRichHitProducer.cxx
index b285815a516a5a71f4f42ed6907ae7c0e7cc38c6..722670b87789c97367ba6221fc27e63ee3ba9c2c 100644
--- a/reco/detectors/rich/CbmRichHitProducer.cxx
+++ b/reco/detectors/rich/CbmRichHitProducer.cxx
@@ -19,112 +19,122 @@
#include <Logger.h>
#include "TClonesArray.h"
+#include <TStopwatch.h>
+#include <iomanip>
#include <iostream>
using namespace std;
-CbmRichHitProducer::CbmRichHitProducer()
- : FairTask("CbmRichHitProducer")
- , fDigiMan(nullptr)
- , fRichHits(NULL)
- , fCbmEvents(NULL)
- , fEventNum(0)
- , fRotationNeeded(true)
- , fHitError(0.6 / sqrt(12.))
+CbmRichHitProducer::CbmRichHitProducer() : FairTask("CbmRichHitProducer") {}
-{}
-
-CbmRichHitProducer::~CbmRichHitProducer() {
+CbmRichHitProducer::~CbmRichHitProducer()
+{
FairRootManager* manager = FairRootManager::Instance();
manager->Write();
}
void CbmRichHitProducer::SetParContainers() {}
-InitStatus CbmRichHitProducer::Init() {
+InitStatus CbmRichHitProducer::Init()
+{
FairRootManager* manager = FairRootManager::Instance();
fCbmEvents = dynamic_cast<TClonesArray*>(manager->GetObject("CbmEvent"));
- if (fCbmEvents == nullptr) {
- LOG(info) << ": CbmEvent NOT found \n \n \n";
- } else {
+ if (fCbmEvents == nullptr) { LOG(info) << ": CbmEvent NOT found \n \n \n"; }
+ else {
LOG(info) << ": CbmEvent found \n \n \n";
}
fDigiMan = CbmDigiManager::Instance();
fDigiMan->Init();
- if (!fDigiMan->IsPresent(ECbmModuleId::kRich)) {
- Fatal("CbmRichHitProducer::Init", "No RichDigi array!");
- }
+ if (!fDigiMan->IsPresent(ECbmModuleId::kRich)) { Fatal("CbmRichHitProducer::Init", "No RichDigi array!"); }
fRichHits = new TClonesArray("CbmRichHit");
- manager->Register(
- "RichHit", "RICH", fRichHits, IsOutputBranchPersistent("RichHit"));
+ manager->Register("RichHit", "RICH", fRichHits, IsOutputBranchPersistent("RichHit"));
+
+ CbmRichDigiMapManager::GetInstance();
return kSUCCESS;
}
-void CbmRichHitProducer::Exec(Option_t* /*option*/) {
- fEventNum++;
- LOG(info) << "CbmRichHitProducer Event (or TimeSlice) " << fEventNum;
+void CbmRichHitProducer::Exec(Option_t* /*option*/)
+{
+ TStopwatch timer;
+ timer.Start();
+ Int_t nDigisAll = fDigiMan->GetNofDigis(ECbmModuleId::kRich);
+ Int_t nDigisUsed = 0;
+ Int_t nEvents = 0;
+ Int_t result = 0;
fRichHits->Delete();
- // if CbmEvent does not exist then process standard event.
- // if CbmEvent exists then proceed all events in time slice.
- Int_t nUnits = (fCbmEvents != nullptr) ? fCbmEvents->GetEntriesFast() : 1;
+ // Time-slice processing
+ if (fCbmEvents == nullptr) nDigisUsed = ProcessData(nullptr);
- for (Int_t iUnit = 0; iUnit < nUnits; iUnit++) {
- CbmEvent* event = (fCbmEvents != nullptr)
- ? static_cast<CbmEvent*>(fCbmEvents->At(iUnit))
- : nullptr;
- ProcessData(event);
+ // Event processing
+ else {
+ nEvents = fCbmEvents->GetEntriesFast();
+ for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
+ CbmEvent* event = static_cast<CbmEvent*>(fCbmEvents->At(iEvent));
+ result = ProcessData(event);
+ nDigisUsed += result;
+ }
}
+
+ timer.Stop();
+ stringstream logOut;
+ logOut << setw(20) << left << GetName() << " [";
+ logOut << fixed << setw(8) << setprecision(1) << right << timer.RealTime() * 1000. << " ms] ";
+ logOut << "TS " << fNofTs;
+ if (fCbmEvents != nullptr) logOut << ", events " << nEvents;
+ logOut << ", digis " << nDigisUsed << " / " << nDigisAll;
+ LOG(info) << logOut.str();
+ fNofTs++;
+ fNofDigisAll += nDigisAll;
+ fNofDigisUsed += nDigisUsed;
+ fTime += timer.RealTime();
}
-void CbmRichHitProducer::ProcessData(CbmEvent* event) {
+Int_t CbmRichHitProducer::ProcessData(CbmEvent* event)
+{
+ Int_t nDigis = 0;
if (event != NULL) {
- LOG(info) << "CbmRichHitProducer CbmEvent mode. CbmEvent # "
- << event->GetNumber();
Int_t nofDigis = event->GetNofData(ECbmDataType::kRichDigi);
- LOG(info) << "nofDigis: " << nofDigis;
-
+ LOG(debug) << GetName() << ": Event mode. Event # " << event->GetNumber() << ", digis: " << nofDigis;
for (Int_t iDigi = 0; iDigi < nofDigis; iDigi++) {
Int_t digiIndex = event->GetIndex(ECbmDataType::kRichDigi, iDigi);
ProcessDigi(event, digiIndex);
}
-
- } else {
- for (Int_t iDigi = 0; iDigi < fDigiMan->GetNofDigis(ECbmModuleId::kRich);
- iDigi++) {
+ nDigis = nofDigis;
+ }
+ else {
+ nDigis = fDigiMan->GetNofDigis(ECbmModuleId::kRich);
+ for (Int_t iDigi = 0; iDigi < fDigiMan->GetNofDigis(ECbmModuleId::kRich); iDigi++) {
ProcessDigi(event, iDigi);
}
}
+ return nDigis;
}
-void CbmRichHitProducer::ProcessDigi(CbmEvent* event, Int_t digiIndex) {
+void CbmRichHitProducer::ProcessDigi(CbmEvent* event, Int_t digiIndex)
+{
const CbmRichDigi* digi = fDigiMan->Get<CbmRichDigi>(digiIndex);
if (digi == nullptr) return;
if (digi->GetAddress() < 0) return;
- CbmRichPixelData* data =
- CbmRichDigiMapManager::GetInstance().GetPixelDataByAddress(
- digi->GetAddress());
+ CbmRichPixelData* data = CbmRichDigiMapManager::GetInstance().GetPixelDataByAddress(digi->GetAddress());
TVector3 posPoint;
posPoint.SetXYZ(data->fX, data->fY, data->fZ);
TVector3 detPoint;
- CbmRichGeoManager::GetInstance().RotatePoint(
- &posPoint, &detPoint, !fRotationNeeded);
+ CbmRichGeoManager::GetInstance().RotatePoint(&posPoint, &detPoint, !fRotationNeeded);
AddHit(event, detPoint, digi->GetTime(), digiIndex);
}
-void CbmRichHitProducer::AddHit(CbmEvent* event,
- TVector3& posHit,
- Double_t time,
- Int_t index) {
+void CbmRichHitProducer::AddHit(CbmEvent* event, TVector3& posHit, Double_t time, Int_t index)
+{
Int_t nofHits = fRichHits->GetEntriesFast();
new ((*fRichHits)[nofHits]) CbmRichHit();
CbmRichHit* hit = (CbmRichHit*) fRichHits->At(nofHits);
@@ -137,7 +147,19 @@ void CbmRichHitProducer::AddHit(CbmEvent* event,
if (event != NULL) { event->AddData(ECbmDataType::kRichHit, nofHits); }
}
-void CbmRichHitProducer::Finish() { fRichHits->Clear(); }
+void CbmRichHitProducer::Finish()
+{
+ fRichHits->Clear();
+ std::cout << std::endl;
+ LOG(info) << "=====================================";
+ LOG(info) << GetName() << ": Run summary";
+ LOG(info) << "Time slices : " << fNofTs;
+ if (fCbmEvents) LOG(info) << "Events : " << fNofEvents;
+ LOG(info) << "Digis / TS : " << fixed << setprecision(2) << Double_t(fNofDigisAll) / Double_t(fNofTs);
+ LOG(info) << "Used digis / TS : " << fixed << setprecision(2) << Double_t(fNofDigisUsed) / Double_t(fNofTs);
+ LOG(info) << "Time / TS : " << fixed << setprecision(2) << 1000. * fTime / Double_t(fNofTs) << " ms";
+ LOG(info) << "=====================================\n";
+}
ClassImp(CbmRichHitProducer)
diff --git a/reco/detectors/rich/CbmRichHitProducer.h b/reco/detectors/rich/CbmRichHitProducer.h
index b877291051a2c29128e05f8ed4262000e770c0d5..e76d660734b3f3566f80864a170cc4e026089103 100644
--- a/reco/detectors/rich/CbmRichHitProducer.h
+++ b/reco/detectors/rich/CbmRichHitProducer.h
@@ -11,6 +11,7 @@
#define CBM_RICH_HIT_PRODUCER
#include "CbmRichRecGeoPar.h"
+
#include "FairTask.h"
#include <TClonesArray.h> // for ROOTCLING
@@ -62,7 +63,7 @@ public:
/**
* Processblock of data either event-by-event or CbmEvent
*/
- void ProcessData(CbmEvent* event);
+ Int_t ProcessData(CbmEvent* event);
/**
* Process RichDigi. CbmEvent can be NULL.
@@ -73,15 +74,19 @@ public:
private:
- CbmDigiManager* fDigiMan; //!
- TClonesArray* fRichHits; // RICH hits
- TClonesArray* fCbmEvents; // CbmEvent for time-based simulations
+ CbmDigiManager* fDigiMan = nullptr; //!
+ TClonesArray* fRichHits = nullptr; // RICH hits
+ TClonesArray* fCbmEvents = nullptr; // CbmEvent for time-based simulations
- Int_t fEventNum; // event number
+ Int_t fNofTs = 0; // number of timeslices
+ Int_t fNofEvents = 0; // number of events
+ Long64_t fNofDigisAll = 0; // all digis in input
+ Long64_t fNofDigisUsed = 0; // digis used for hit finding
+ Double_t fTime = 0.; // processing time
- Bool_t fRotationNeeded;
+ Bool_t fRotationNeeded = kTRUE;
- Double_t fHitError;
+ Double_t fHitError = 0.6 / sqrt(12);
/**
* \brief Add hit to the output array (and) CbmEvent if it is not NULL.
diff --git a/reco/detectors/sts/CbmRecoSts.cxx b/reco/detectors/sts/CbmRecoSts.cxx
index b20235041647956889227ed1c18be5917b6c03e7..211b8746f6b4b53796b838d83151048b2ca81bba 100644
--- a/reco/detectors/sts/CbmRecoSts.cxx
+++ b/reco/detectors/sts/CbmRecoSts.cxx
@@ -32,6 +32,7 @@ using std::left;
using std::right;
using std::setprecision;
using std::setw;
+using std::stringstream;
using std::vector;
@@ -130,29 +131,69 @@ UInt_t CbmRecoSts::CreateModules()
void CbmRecoSts::Exec(Option_t*)
{
- // --- Clear output array
+ // --- Time
+ TStopwatch timer;
+ timer.Start();
+
+ // --- Clear hit output array
fHits->Delete();
- // --- Reset output array
+ // --- Reset cluster output array
fClusters->Delete();
+ // --- Local variables
+ Int_t nEvents = 0;
+ fNofDigis = 0;
+ fNofDigisUsed = 0;
+ fNofDigisIgnored = 0;
+ fNofClusters = 0;
+ fNofHits = 0;
+ fTimeTot = 0.;
+ fTime1 = 0.;
+ fTime2 = 0.;
+ fTime3 = 0.;
+ fTime4 = 0.;
+ CbmEvent* event = nullptr;
+
// --- Time-slice mode: process entire array
if (fMode == kCbmRecoTimeslice) ProcessData(nullptr);
// --- Event mode: loop over events
else {
assert(fEvents);
- Int_t nEvents = fEvents->GetEntriesFast();
- LOG(info) << setw(20) << left << GetName() << ": Processing time slice " << fNofTimeslices << " with " << nEvents
- << (nEvents == 1 ? " event" : " events");
+ nEvents = fEvents->GetEntriesFast();
+ LOG(debug) << setw(20) << left << GetName() << ": Processing time slice " << fNofTs << " with " << nEvents
+ << (nEvents == 1 ? " event" : " events");
for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
- CbmEvent* event = dynamic_cast<CbmEvent*>(fEvents->At(iEvent));
+ event = dynamic_cast<CbmEvent*>(fEvents->At(iEvent));
assert(event);
ProcessData(event);
} //# events
} //? event mode
- fNofTimeslices++;
+ // --- Timeslice log
+ timer.Stop();
+ stringstream logOut;
+ logOut << setw(20) << left << GetName() << " [";
+ logOut << fixed << setw(8) << setprecision(1) << right << timer.RealTime() * 1000. << " ms] ";
+ logOut << "TS " << fNofTs;
+ if (fEvents) logOut << ", events " << nEvents;
+ logOut << ", digis " << fNofDigisUsed << " / " << fNofDigis;
+ logOut << ", clusters " << fNofClusters << ", hits " << fNofHits;
+ LOG(info) << logOut.str();
+
+ // --- Update run counters
+ fNofTs++;
+ fNofEvents += nEvents;
+ fNofDigisRun += fNofDigis;
+ fNofDigisUsedRun += fNofDigisUsed;
+ fNofClustersRun += fNofClusters;
+ fNofHitsRun += fNofHits;
+ fTimeRun += fTimeTot;
+ fTime1Run += fTime1;
+ fTime2Run += fTime2;
+ fTime3Run += fTime3;
+ fTime4Run += fTime4;
}
// -------------------------------------------------------------------------
@@ -162,47 +203,34 @@ void CbmRecoSts::Finish()
{
std::cout << std::endl;
+ Double_t digiCluster = Double_t(fNofDigisUsed) / Double_t(fNofClusters);
+ Double_t clusterHit = Double_t(fNofClusters) / Double_t(fNofHits);
LOG(info) << "=====================================";
LOG(info) << GetName() << ": Run summary";
- LOG(info) << "Time slices : " << fNofTimeslices;
-
- // --- Time-slice mode
- if (fMode == kCbmRecoTimeslice) {
- LOG(info) << "Digis / TSlice : " << fNofDigis / Double_t(fNofTimeslices);
- LOG(info) << "Digis used / TSlice : " << fNofDigisUsed / Double_t(fNofTimeslices);
- LOG(info) << "Digis ignored / TSlice : " << fNofDigisIgnored / Double_t(fNofTimeslices);
- LOG(info) << "Clusters / TSlice : " << fNofClusters / Double_t(fNofTimeslices);
- LOG(info) << "Hits / TSlice : " << fNofHits / Double_t(fNofTimeslices);
- LOG(info) << "Digis per cluster : " << fNofDigisUsed / fNofClusters;
- LOG(info) << "Clusters per hit : " << fNofClusters / fNofHits;
- LOG(info) << "Time per TSlice : " << fTimeTot / Double_t(fNofTimeslices) << " s ";
-
- } //? time-slice mode
-
- // --- Event-by-event mode
- else {
- LOG(info) << "Events : " << fNofEvents;
- LOG(info) << "Digis / event : " << fNofDigis / Double_t(fNofEvents);
- LOG(info) << "Digis used / event : " << fNofDigisUsed / Double_t(fNofEvents);
- LOG(info) << "Digis ignored / event : " << fNofDigisIgnored / Double_t(fNofEvents);
- LOG(info) << "Clusters / event : " << fNofClusters / Double_t(fNofEvents);
- LOG(info) << "Digis per cluster : " << fNofDigisUsed / fNofClusters;
- LOG(info) << "Time per event : " << fTimeTot / Double_t(fNofEvents) << " s ";
- } //? event mode
-
- fTimeTot /= Double_t(fNofEvents);
- fTime1 /= Double_t(fNofEvents);
- fTime2 /= Double_t(fNofEvents);
- fTime3 /= Double_t(fNofEvents);
- fTime4 /= Double_t(fNofEvents);
- LOG(info) << "Time Reset : " << fixed << setprecision(1) << setw(6) << 1000. * fTime1 << " ms ("
- << setprecision(1) << setw(4) << 100. * fTime1 / fTimeTot << " %)";
- LOG(info) << "Time Distribute : " << fixed << setprecision(1) << setw(6) << 1000. * fTime2 << " ms ("
- << setprecision(1) << 100. * fTime2 / fTimeTot << " %)";
- LOG(info) << "Time Reconstruct : " << fixed << setprecision(1) << setw(6) << 1000. * fTime3 << " ms ("
- << setprecision(1) << setw(4) << 100. * fTime3 / fTimeTot << " %)";
- LOG(info) << "Time Output : " << fixed << setprecision(1) << setw(6) << 1000. * fTime4 << " ms ("
- << setprecision(1) << setw(4) << 100. * fTime4 / fTimeTot << " %)";
+ LOG(info) << "Time slices : " << fNofTs;
+ if (fMode == kCbmRecoEvent) LOG(info) << "Events : " << fNofEvents;
+ LOG(info) << "Digis / TSlice : " << fixed << setprecision(2) << fNofDigisRun / Double_t(fNofTs);
+ LOG(info) << "Digis used / TSlice : " << fixed << setprecision(2) << fNofDigisUsed / Double_t(fNofTs);
+ LOG(info) << "Digis ignored / TSlice : " << fixed << setprecision(2) << fNofDigisIgnored / Double_t(fNofTs);
+ LOG(info) << "Clusters / TSlice : " << fixed << setprecision(2) << fNofClusters / Double_t(fNofTs);
+ LOG(info) << "Hits / TSlice : " << fixed << setprecision(2) << fNofHits / Double_t(fNofTs);
+ LOG(info) << "Digis per cluster : " << fixed << setprecision(2) << digiCluster;
+ LOG(info) << "Clusters per hit : " << fixed << setprecision(2) << clusterHit;
+ LOG(info) << "Time per TSlice : " << fixed << setprecision(2) << 1000. * fTimeRun / Double_t(fNofTs) << " s ";
+
+ fTimeRun /= Double_t(fNofEvents);
+ fTime1Run /= Double_t(fNofEvents);
+ fTime2Run /= Double_t(fNofEvents);
+ fTime3Run /= Double_t(fNofEvents);
+ fTime4Run /= Double_t(fNofEvents);
+ LOG(info) << "Time Reset : " << fixed << setprecision(1) << setw(6) << 1000. * fTime1Run << " ms ("
+ << setprecision(1) << setw(4) << 100. * fTime1Run / fTimeRun << " %)";
+ LOG(info) << "Time Distribute : " << fixed << setprecision(1) << setw(6) << 1000. * fTime2Run << " ms ("
+ << setprecision(1) << 100. * fTime2Run / fTimeRun << " %)";
+ LOG(info) << "Time Reconstruct : " << fixed << setprecision(1) << setw(6) << 1000. * fTime3Run << " ms ("
+ << setprecision(1) << setw(4) << 100. * fTime3Run / fTimeRun << " %)";
+ LOG(info) << "Time Output : " << fixed << setprecision(1) << setw(6) << 1000. * fTime4Run << " ms ("
+ << setprecision(1) << setw(4) << 100. * fTime4Run / fTimeRun << " %)";
LOG(info) << "=====================================";
}
// -------------------------------------------------------------------------
@@ -320,7 +348,6 @@ void CbmRecoSts::ProcessData(CbmEvent* event)
// --- Reset all modules
fTimer.Start();
- Int_t nDigisGood = 0;
Int_t nDigisIgnored = 0;
Int_t nClusters = 0;
Int_t nHits = 0;
@@ -423,9 +450,8 @@ void CbmRecoSts::ProcessData(CbmEvent* event)
// --- Bookkeeping
Double_t realTime = time1 + time2 + time3 + time4;
- fNofEvents++;
fNofDigis += nDigis;
- fNofDigisUsed += nDigisGood;
+ fNofDigisUsed += nDigis - nDigisIgnored;
fNofDigisIgnored += nDigisIgnored;
fNofClusters += nClusters;
fNofHits += nHits;
@@ -437,14 +463,14 @@ void CbmRecoSts::ProcessData(CbmEvent* event)
// --- Screen log
if (event) {
- LOG(info) << setw(20) << left << GetName() << "[" << fixed << setprecision(4) << realTime << " s] : Event " << right
- << setw(6) << event->GetNumber() << ", digis: " << nDigis << ", ignored: " << nDigisIgnored
- << ", clusters: " << nClusters << ", hits " << nHits;
+ LOG(debug) << setw(20) << left << GetName() << "[" << fixed << setprecision(4) << realTime << " s] : Event "
+ << right << setw(6) << event->GetNumber() << ", digis: " << nDigis << ", ignored: " << nDigisIgnored
+ << ", clusters: " << nClusters << ", hits " << nHits;
} //? event mode
else {
- LOG(info) << setw(20) << left << GetName() << "[" << fixed << setprecision(4) << realTime << " s] : TSlice "
- << right << setw(6) << fNofTimeslices << ", digis: " << nDigis << ", ignored: " << nDigisIgnored
- << ", clusters: " << nClusters << ", hits " << nHits;
+ LOG(debug) << setw(20) << left << GetName() << "[" << fixed << setprecision(4) << realTime << " s] : TSlice "
+ << right << setw(6) << fNofTs << ", digis: " << nDigis << ", ignored: " << nDigisIgnored
+ << ", clusters: " << nClusters << ", hits " << nHits;
}
}
// -------------------------------------------------------------------------
diff --git a/reco/detectors/sts/CbmRecoSts.h b/reco/detectors/sts/CbmRecoSts.h
index 2eff777971943df57e72b7bc52bd8c0542ef1630..ec71914b81e234b9a7a913361a156857e9436ce7 100644
--- a/reco/detectors/sts/CbmRecoSts.h
+++ b/reco/detectors/sts/CbmRecoSts.h
@@ -275,21 +275,34 @@ private:
Bool_t fWriteClusters = kFALSE; ///< Write clusters to tree
Bool_t fRunParallel = kFALSE; ///< Use OpenMP multithreading
- // --- Counters
- TStopwatch fTimer {}; //! ROOT timer
- Int_t fNofTimeslices = 0; ///< Number of time slices processed
- Int_t fNofEvents = 0; ///< Number of events processed
- Double_t fNofDigis = 0; ///< Total number of digis processed
- Double_t fNofDigisUsed = 0; ///< Total number of used digis
- Double_t fNofDigisIgnored = 0; ///< Total number of ignored digis
- Double_t fNofClusters = 0; ///< Total number of clusters produced
- Double_t fNofHits = 0; ///< Total number of clusters produced
+ // --- Timeslice counters
+ Long64_t fNofDigis = 0; ///< Total number of digis processed
+ Long64_t fNofDigisUsed = 0; ///< Total number of used digis
+ Long64_t fNofDigisIgnored = 0; ///< Total number of ignored digis
+ Long64_t fNofClusters = 0; ///< Total number of clusters produced
+ Long64_t fNofHits = 0; ///< Total number of clusters produced
Double_t fTimeTot = 0.; ///< Total execution time
Double_t fTime1 = 0.; ///< Time for resetting modules
Double_t fTime2 = 0.; ///< Time for distributing data
Double_t fTime3 = 0.; ///< Time for reconstruction
Double_t fTime4 = 0.; ///< Time for output results
+ // --- Run counters
+ TStopwatch fTimer {}; //! ROOT timer
+ Int_t fNofTs = 0; ///< Number of time slices processed
+ Int_t fNofEvents = 0; ///< Number of events processed
+ Double_t fNofDigisRun = 0; ///< Total number of digis processed
+ Double_t fNofDigisUsedRun = 0; ///< Total number of used digis
+ Double_t fNofDigisIgnoredRun = 0; ///< Total number of ignored digis
+ Double_t fNofClustersRun = 0; ///< Total number of clusters produced
+ Double_t fNofHitsRun = 0; ///< Total number of clusters produced
+ Double_t fTimeRun = 0.; ///< Total execution time
+ Double_t fTime1Run = 0.; ///< Time for resetting modules
+ Double_t fTime2Run = 0.; ///< Time for distributing data
+ Double_t fTime3Run = 0.; ///< Time for reconstruction
+ Double_t fTime4Run = 0.; ///< Time for output results
+
+
// --- Reconstruction modules
std::map<UInt_t, CbmStsRecoModule*> fModules {}; //!
std::vector<CbmStsRecoModule*> fModuleIndex {}; //!
diff --git a/reco/detectors/sts/CbmStsFindTracksEvents.cxx b/reco/detectors/sts/CbmStsFindTracksEvents.cxx
index 8112844df55df06e0e1b21e9e6f00c827578b794..2213bbd9d2bec17c984b132a4dcd44618887e361 100644
--- a/reco/detectors/sts/CbmStsFindTracksEvents.cxx
+++ b/reco/detectors/sts/CbmStsFindTracksEvents.cxx
@@ -9,17 +9,18 @@
#include "CbmStsFindTracksEvents.h"
#include "CbmEvent.h"
-#include <cassert>
-
#include "CbmStsHit.h"
#include "CbmStsTrack.h"
#include "CbmStsTrackFinderIdeal.h"
+#include <cassert>
+
// Includes from base
#include "FairField.h"
#include "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
+#include <Logger.h>
// Includes from ROOT
#include "TClonesArray.h"
@@ -32,13 +33,14 @@ using std::cout;
using std::endl;
using std::fixed;
using std::left;
+using std::pair;
using std::right;
using std::setprecision;
using std::setw;
+using std::stringstream;
// ----- Standard constructor ------------------------------------------
-CbmStsFindTracksEvents::CbmStsFindTracksEvents(CbmStsTrackFinder* finder,
- Bool_t useMvd)
+CbmStsFindTracksEvents::CbmStsFindTracksEvents(CbmStsTrackFinder* finder, Bool_t useMvd)
: FairTask("StsFindTracksEvents")
, fUseMvd(useMvd)
, fFinder(finder)
@@ -50,14 +52,16 @@ CbmStsFindTracksEvents::CbmStsFindTracksEvents(CbmStsTrackFinder* finder,
, fNofEvents(0)
, fNofHits(0.)
, fNofTracks(0.)
- , fTime(0.) {
+ , fTime(0.)
+{
if (!finder) fFinder = new CbmStsTrackFinderIdeal();
}
// -------------------------------------------------------------------------
// ----- Destructor ----------------------------------------------------
-CbmStsFindTracksEvents::~CbmStsFindTracksEvents() {
+CbmStsFindTracksEvents::~CbmStsFindTracksEvents()
+{
fTracks->Delete();
if (fFinder) delete fFinder;
}
@@ -65,30 +69,59 @@ CbmStsFindTracksEvents::~CbmStsFindTracksEvents() {
// ----- Task execution ------------------------------------------------
-void CbmStsFindTracksEvents::Exec(Option_t* /*opt*/) {
+void CbmStsFindTracksEvents::Exec(Option_t* /*opt*/)
+{
+
+ // --- Local variables
+ Long64_t nEvents = 0;
+ Long64_t nHits = 0;
+ Long64_t nTracks = 0;
+ pair<UInt_t, UInt_t> result;
+ TStopwatch timer;
+ timer.Start();
// --- Clear output array
fTracks->Delete();
// --- Event loop (from event objects)
if (fEvents) {
- Int_t nEvents = fEvents->GetEntriesFast();
- LOG(debug) << GetName() << ": reading time slice with " << nEvents
- << " events ";
+ nEvents = fEvents->GetEntriesFast();
+ LOG(debug) << GetName() << ": reading time slice with " << nEvents << " events ";
for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
CbmEvent* event = static_cast<CbmEvent*>(fEvents->At(iEvent));
- ProcessEvent(event);
+ result = ProcessEvent(event);
+ nHits += result.first;
+ nTracks += result.second;
} //# events
} //? event branch present
- else // Old event-by-event simulation without event branch
- ProcessEvent(NULL);
+ else { // Timeslice reconstruction without events
+ ProcessEvent(nullptr);
+ nHits = result.first;
+ nTracks = result.second;
+ }
+
+ // --- Timeslice log and statistics
+ timer.Stop();
+ stringstream logOut;
+ logOut << setw(20) << left << GetName() << " [";
+ logOut << fixed << setw(8) << setprecision(1) << right << timer.RealTime() * 1000. << " ms] ";
+ logOut << "TS " << fNofTs;
+ if (fEvents) logOut << ", events " << nEvents;
+ logOut << ", hits " << nHits << ", tracks " << nTracks;
+ LOG(info) << logOut.str();
+ fNofTs++;
+ fNofEvents += nEvents;
+ fNofHits += nHits;
+ fNofTracks += nTracks;
+ fTime += timer.RealTime();
}
// -------------------------------------------------------------------------
// ----- Initialisation ------------------------------------------------
-InitStatus CbmStsFindTracksEvents::Init() {
+InitStatus CbmStsFindTracksEvents::Init()
+{
LOG(info) << "=====================================";
LOG(info) << GetName() << ": initialising";
@@ -99,9 +132,7 @@ InitStatus CbmStsFindTracksEvents::Init() {
// --- Get input array (Events)
fEvents = dynamic_cast<TClonesArray*>(ioman->GetObject("CbmEvent"));
- if (nullptr == fEvents) {
- LOG(warn) << GetName() << ": No event array! Will process entire tree.";
- }
+ if (nullptr == fEvents) { LOG(warn) << GetName() << ": No event array! Will process entire tree."; }
// --- Get input array (StsHits)
fStsHits = (TClonesArray*) ioman->GetObject("StsHit");
@@ -111,17 +142,16 @@ InitStatus CbmStsFindTracksEvents::Init() {
if (fUseMvd) {
fMvdHits = (TClonesArray*) ioman->GetObject("MvdHit");
if (fMvdHits == nullptr) {
- LOG(error) << GetName()
- << ": Use of MVD hits selected, but no hit branch present! "
+ LOG(error) << GetName() << ": Use of MVD hits selected, but no hit branch present! "
<< "Tracking will be done without MVD hits.";
- } else
+ }
+ else
LOG(info) << GetName() << ": including MVD hits in tracking";
}
// Create and register output array for StsTracks
fTracks = new TClonesArray("CbmStsTrack", 100);
- ioman->Register(
- "StsTrack", "STS", fTracks, IsOutputBranchPersistent("StsTrack"));
+ ioman->Register("StsTrack", "STS", fTracks, IsOutputBranchPersistent("StsTrack"));
// Check for Track finder
if (!fFinder) {
@@ -146,22 +176,29 @@ InitStatus CbmStsFindTracksEvents::Init() {
// ----- End-of-run action ---------------------------------------------
-void CbmStsFindTracksEvents::Finish() {
+void CbmStsFindTracksEvents::Finish()
+{
std::cout << std::endl;
LOG(info) << "=====================================";
LOG(info) << GetName() << ": Run summary";
- LOG(info) << "Events processed : " << fNofEvents;
- LOG(info) << "Hits / event : " << fNofHits / Double_t(fNofEvents);
- LOG(info) << "Tracks / event : " << fNofTracks / Double_t(fNofEvents);
- LOG(info) << "Hits per track : " << fNofHits / fNofTracks;
- LOG(info) << "Time per event : " << fTime / Double_t(fNofEvents) << " s ";
+ LOG(info) << "Time slices : " << fNofTs;
+ LOG(info) << "Hits / TS : " << fixed << setprecision(2) << Double_t(fNofHits) / Double_t(fNofTs);
+ LOG(info) << "Tracks / TS : " << fixed << setprecision(2) << Double_t(fNofTracks) / Double_t(fNofTs);
+ LOG(info) << "Hits per track : " << fNofHits / fNofTracks;
+ LOG(info) << "Time per TS : " << 1000. * fTime / Double_t(fNofTs) << " ms ";
+ if (fEvents) {
+ LOG(info) << "Events processed : " << fNofEvents;
+ LOG(info) << "Hits / event : " << fNofHits / Double_t(fNofEvents);
+ LOG(info) << "Tracks / event : " << fNofTracks / Double_t(fNofEvents);
+ }
LOG(info) << "=====================================";
}
// -------------------------------------------------------------------------
// ------ Process one event --------------------------------------------
-void CbmStsFindTracksEvents::ProcessEvent(CbmEvent* event) {
+pair<UInt_t, UInt_t> CbmStsFindTracksEvents::ProcessEvent(CbmEvent* event)
+{
// --- Call track finder
fTimer.Start();
@@ -170,18 +207,11 @@ void CbmStsFindTracksEvents::ProcessEvent(CbmEvent* event) {
// --- Event log
Int_t eventNumber = (event ? event->GetNumber() : fNofEvents);
- Int_t nHits = (event ? event->GetNofData(ECbmDataType::kStsHit)
- : fStsHits->GetEntriesFast());
- LOG(info) << "+ " << setw(20) << GetName() << ": Event " << setw(6) << right
- << eventNumber << ", real time " << fixed << setprecision(6)
- << fTimer.RealTime() << " s, hits: " << nHits
- << ", tracks: " << nTracks;
-
- // --- Counters
- fNofEvents++;
- fNofHits += Double_t(nHits);
- fNofTracks += Double_t(nTracks);
- fTime += fTimer.RealTime();
+ Int_t nHits = (event ? event->GetNofData(ECbmDataType::kStsHit) : fStsHits->GetEntriesFast());
+ LOG(debug) << "+ " << setw(20) << GetName() << ": Event " << setw(6) << right << eventNumber << ", real time "
+ << fixed << setprecision(6) << fTimer.RealTime() << " s, hits: " << nHits << ", tracks: " << nTracks;
+
+ return std::make_pair(nHits, nTracks);
}
// -------------------------------------------------------------------------
diff --git a/reco/detectors/sts/CbmStsFindTracksEvents.h b/reco/detectors/sts/CbmStsFindTracksEvents.h
index 96289fd5ef167a6d9bb254edb74132f1b26dd029..4dc04688ba177b17c90826a2db9cde7726a3bdbc 100644
--- a/reco/detectors/sts/CbmStsFindTracksEvents.h
+++ b/reco/detectors/sts/CbmStsFindTracksEvents.h
@@ -9,7 +9,9 @@
#include "CbmStsTrackFinder.h"
+
#include "FairTask.h"
+
#include "TStopwatch.h"
@@ -35,8 +37,7 @@ public:
** @param finder Track finder engine. Default: Ideal track finder.
** @param useMvd Include MVD hits in track finding. Default kFALSE.
**/
- CbmStsFindTracksEvents(CbmStsTrackFinder* finder = NULL,
- Bool_t useMvd = kFALSE);
+ CbmStsFindTracksEvents(CbmStsTrackFinder* finder = NULL, Bool_t useMvd = kFALSE);
/** Destructor **/
@@ -62,7 +63,8 @@ public:
/** Set track finding engine
** @param finder Pointer to track finding engine
**/
- void UseFinder(CbmStsTrackFinder* finder) {
+ void UseFinder(CbmStsTrackFinder* finder)
+ {
if (fFinder) delete fFinder;
fFinder = finder;
};
@@ -76,6 +78,7 @@ private:
TClonesArray* fStsHits; //! Input array of STS hits
TClonesArray* fTracks; //! Output array of CbmStsTracks
TStopwatch fTimer; //! Timer
+ Int_t fNofTs = 0; ///< Number of processed timeslices
Int_t fNofEvents; ///< Number of events with success
Double_t fNofHits; ///< Number of hits
Double_t fNofTracks; ///< Number of tracks created
@@ -90,8 +93,11 @@ private:
virtual void Finish();
- /** Process one event **/
- void ProcessEvent(CbmEvent* event);
+ /** @brief Process one event or timeslice
+ ** @param event Pointer to event object. If null, entire timeslice is processed.
+ ** @return Number of input hits and output tracks
+ **/
+ std::pair<UInt_t, UInt_t> ProcessEvent(CbmEvent* event);
/** Prevent usage of copy constructor and assignment operator **/
diff --git a/reco/detectors/tof/CbmTofSimpClusterizer.cxx b/reco/detectors/tof/CbmTofSimpClusterizer.cxx
index 3cb93a23f7ca699cb8e2b3bdb752cc7c650cf5d1..a2e0d313c45938a4768e7e94564a535f72cbf4d3 100644
--- a/reco/detectors/tof/CbmTofSimpClusterizer.cxx
+++ b/reco/detectors/tof/CbmTofSimpClusterizer.cxx
@@ -51,12 +51,15 @@
// C++ Classes and includes
#include <iomanip>
+#include <iostream>
using std::fixed;
using std::left;
using std::pair;
+using std::right;
using std::setprecision;
using std::setw;
+using std::stringstream;
// const Int_t DetMask = 4194303; (VF) not used
const Int_t nbClWalkBinX = 20;
@@ -373,14 +376,14 @@ void CbmTofSimpClusterizer::Exec(Option_t* /*option*/)
fTimer.Stop();
// --- Timeslice log
- if (fEvents)
- LOG(info) << std::setw(20) << std::left << GetName() << fixed << setprecision(2) << " ["
- << fTimer.RealTime() * 1000. << " ms] TS " << fiNofTs << ", events " << nEvents << ", digis " << nDigis
- << " / " << nDigisAll << ", hits " << nHits;
- else
- LOG(info) << std::setw(20) << std::left << GetName() << fixed << setprecision(2) << " ["
- << fTimer.RealTime() * 1000. << " ms] TS " << fiNofTs << ", digis " << nDigis << " / " << nDigisAll
- << ", hits " << nHits;
+ stringstream logOut;
+ logOut << setw(20) << left << GetName() << " [";
+ logOut << fixed << setw(8) << setprecision(1) << right << fTimer.RealTime() * 1000. << " ms] ";
+ logOut << "TS " << fiNofTs;
+ if (fEvents) logOut << ", events " << nEvents;
+ logOut << ", digis " << nDigis << " / " << nDigisAll;
+ logOut << ", hits " << nHits;
+ LOG(info) << logOut.str();
// --- Update Counters
diff --git a/reco/detectors/trd/CbmTrdClusterFinder.cxx b/reco/detectors/trd/CbmTrdClusterFinder.cxx
index 40a92b48c0ffcb6abe5631a37a89439ed39e0cf0..9df01ca72065cc1c6a452df8c01b969e9e2dc50d 100644
--- a/reco/detectors/trd/CbmTrdClusterFinder.cxx
+++ b/reco/detectors/trd/CbmTrdClusterFinder.cxx
@@ -35,6 +35,13 @@
#include <cmath>
+using std::fixed;
+using std::left;
+using std::right;
+using std::setprecision;
+using std::setw;
+using std::stringstream;
+
Int_t CbmTrdClusterFinder::fgConfig = 0;
Float_t CbmTrdClusterFinder::fgMinimumChargeTH = .5e-06;
@@ -273,7 +280,12 @@ void CbmTrdClusterFinder::Exec(Option_t* /*option*/)
fClusters->Delete();
TStopwatch timer;
- UInt_t nDigis = 0;
+ TStopwatch timerTs;
+ timerTs.Start();
+ Long64_t nDigisAll = CbmDigiManager::Instance()->GetNofDigis(ECbmModuleId::kTrd);
+ Long64_t nDigisUsed = 0;
+ UInt_t nDigis = 0;
+ UInt_t nEvents = 0;
if (UseOnlyEventDigis()) {
for (auto eventobj : *fEvents) {
@@ -282,6 +294,8 @@ void CbmTrdClusterFinder::Exec(Option_t* /*option*/)
nDigis = addDigisToModules(event);
processDigisInModules(nDigis, event);
fNrEvents++;
+ nEvents++;
+ nDigisUsed += nDigis;
timer.Stop();
if (DoDebugPrintouts()) {
LOG(info) << GetName() << "::Exec : Event Nr: " << fNrEvents;
@@ -297,6 +311,7 @@ void CbmTrdClusterFinder::Exec(Option_t* /*option*/)
nDigis = addDigisToModules();
processDigisInModules(nDigis);
fNrEvents++;
+ nDigisUsed = nDigis;
timer.Stop();
if (DoDebugPrintouts()) {
LOG(info) << GetName() << "::Exec : Event Nr: " << fNrEvents;
@@ -305,6 +320,16 @@ void CbmTrdClusterFinder::Exec(Option_t* /*option*/)
fProcessTime += timer.RealTime();
timer.Reset();
}
+
+ timerTs.Stop();
+ stringstream logOut;
+ logOut << setw(20) << left << GetName() << " [";
+ logOut << fixed << setw(8) << setprecision(1) << right << timerTs.RealTime() * 1000. << " ms] ";
+ logOut << "TS " << fNrTs;
+ if (UseOnlyEventDigis()) logOut << ", events " << nEvents;
+ logOut << ", digis " << nDigisUsed << " / " << nDigisAll;
+ LOG(info) << logOut.str();
+ fNrTs++;
}
//_____________________________________________________________________
diff --git a/reco/detectors/trd/CbmTrdClusterFinder.h b/reco/detectors/trd/CbmTrdClusterFinder.h
index 4c8ac96027375953a5637915775b5c633ad3280c..f9f30eeca1ddfbc871d92fc0357bef606f4648ef 100644
--- a/reco/detectors/trd/CbmTrdClusterFinder.h
+++ b/reco/detectors/trd/CbmTrdClusterFinder.h
@@ -205,6 +205,9 @@ private:
CbmTrdParSetGain* fGainPar = nullptr; ///< parameter list for keV->ADC gain conversion
CbmTrdParSetGeo* fGeoPar = nullptr; ///< parameter list for modules geometry
+ /** @brief Number of processed time slices */
+ UInt_t fNrTs = 0;
+
/** @brief Number of processed events (without CbmEvent corresponds to nr of exec calls) */
UInt_t fNrEvents = 0;
diff --git a/reco/detectors/trd/CbmTrdHitProducer.cxx b/reco/detectors/trd/CbmTrdHitProducer.cxx
index 1962f1b4ddff10756d2c627ab268607767a5be2c..5d4fc302f618012bd4311c197fd17e1517b5fff1 100644
--- a/reco/detectors/trd/CbmTrdHitProducer.cxx
+++ b/reco/detectors/trd/CbmTrdHitProducer.cxx
@@ -32,6 +32,14 @@
#include <iomanip>
#include <map>
+
+using std::fixed;
+using std::left;
+using std::right;
+using std::setprecision;
+using std::setw;
+using std::stringstream;
+
//____________________________________________________________________________________
CbmTrdHitProducer::CbmTrdHitProducer() : FairTask("TrdHitProducer") {}
@@ -262,8 +270,12 @@ void CbmTrdHitProducer::Exec(Option_t*)
fHits->Delete();
TStopwatch timer;
+ TStopwatch timerTs;
+ timerTs.Start();
- UInt_t hitCounter = 0;
+ Long64_t nClusters = fClusters->GetEntriesFast();
+ UInt_t hitCounter = 0;
+ UInt_t nEvents = 0;
if (CbmTrdClusterFinder::UseOnlyEventDigis()) {
for (auto eventobj : *fEvents) {
@@ -273,6 +285,7 @@ void CbmTrdHitProducer::Exec(Option_t*)
if (!event) continue;
hitCounter += processClusters(event);
fNrEvents++;
+ nEvents++;
timer.Stop();
if (CbmTrdClusterFinder::DoDebugPrintouts()) {
LOG(info) << GetName() << "::Exec : Event Nr: " << fNrEvents;
@@ -298,9 +311,19 @@ void CbmTrdHitProducer::Exec(Option_t*)
timer.Stop();
+ timerTs.Stop();
if (CbmTrdClusterFinder::DoDebugPrintouts())
LOG(info) << GetName() << "::Exec: real time=" << timer.RealTime() << " CPU time=" << timer.CpuTime();
fProcessTime += timer.RealTime();
+
+ stringstream logOut;
+ logOut << setw(20) << left << GetName() << " [";
+ logOut << fixed << setw(8) << setprecision(1) << right << timerTs.RealTime() * 1000. << " ms] ";
+ logOut << "TS " << fNrTs;
+ if (CbmTrdClusterFinder::UseOnlyEventDigis()) logOut << ", events " << nEvents;
+ logOut << ", clusters " << nClusters << ", hits " << hitCounter;
+ LOG(info) << logOut.str();
+ fNrTs++;
}
//____________________________________________________________________________________
diff --git a/reco/detectors/trd/CbmTrdHitProducer.h b/reco/detectors/trd/CbmTrdHitProducer.h
index 670ad864ccd1284bdb4e81ed116be2fc80e88707..ac98ee4a6970f8a9e7ab814ebb3b0910d2ce13fc 100644
--- a/reco/detectors/trd/CbmTrdHitProducer.h
+++ b/reco/detectors/trd/CbmTrdHitProducer.h
@@ -117,6 +117,9 @@ private:
CbmTrdParSetGain* fGainPar = nullptr; ///< parameter list for keV->ADC gain conversion
CbmTrdParSetGeo* fGeoPar = nullptr; ///< parameter list for modules geometry
+ /** @brief Number of processed time slices */
+ UInt_t fNrTs = 0;
+
/** @brief Number of processed events (without CbmEvent corresponds to nr of exec calls) */
UInt_t fNrEvents = 0;
diff --git a/reco/eventbuilder/digis/CbmBuildEventsIdeal.cxx b/reco/eventbuilder/digis/CbmBuildEventsIdeal.cxx
index 3f083a5a6dfb1f716b3ffb55579d69f025bd7f72..bad5ee7ddb82ddda00f3cff5a93578960dd0ddad 100644
--- a/reco/eventbuilder/digis/CbmBuildEventsIdeal.cxx
+++ b/reco/eventbuilder/digis/CbmBuildEventsIdeal.cxx
@@ -34,7 +34,8 @@ CbmBuildEventsIdeal::~CbmBuildEventsIdeal() {}
// ===== Number if different pairs (input,event) in a match object =======
-UInt_t CbmBuildEventsIdeal::EventsInMatch(const CbmMatch* match) {
+UInt_t CbmBuildEventsIdeal::EventsInMatch(const CbmMatch* match)
+{
// --- No or empty match object
if (match == nullptr) return 0;
@@ -56,7 +57,8 @@ UInt_t CbmBuildEventsIdeal::EventsInMatch(const CbmMatch* match) {
// ===== Task execution ==================================================
-void CbmBuildEventsIdeal::Exec(Option_t*) {
+void CbmBuildEventsIdeal::Exec(Option_t*)
+{
// --- Timer and counters
TStopwatch timer;
@@ -109,58 +111,51 @@ void CbmBuildEventsIdeal::Exec(Option_t*) {
auto it = eventMap.find(make_pair(mcInput, mcEvent));
if (it == eventMap.end()) {
assert(nEvents == fEvents->GetEntriesFast());
- event = new ((*fEvents)[nEvents]) CbmEvent(nEvents);
+ event = new ((*fEvents)[nEvents]) CbmEvent(nEvents);
eventMap[make_pair(mcInput, mcEvent)] = event;
nEvents++;
- } else
+ }
+ else
event = it->second;
// --- Fill digi index into event
switch (system) {
- case ECbmModuleId::kMvd:
- event->AddData(ECbmDataType::kMvdDigi, iDigi);
- break;
- case ECbmModuleId::kSts:
- event->AddData(ECbmDataType::kStsDigi, iDigi);
- break;
- case ECbmModuleId::kRich:
- event->AddData(ECbmDataType::kRichDigi, iDigi);
- break;
- case ECbmModuleId::kMuch:
- event->AddData(ECbmDataType::kMuchDigi, iDigi);
- break;
- case ECbmModuleId::kTrd:
- event->AddData(ECbmDataType::kTrdDigi, iDigi);
- break;
- case ECbmModuleId::kTof:
- event->AddData(ECbmDataType::kTofDigi, iDigi);
- break;
- case ECbmModuleId::kPsd:
- event->AddData(ECbmDataType::kPsdDigi, iDigi);
- break;
+ case ECbmModuleId::kMvd: event->AddData(ECbmDataType::kMvdDigi, iDigi); break;
+ case ECbmModuleId::kSts: event->AddData(ECbmDataType::kStsDigi, iDigi); break;
+ case ECbmModuleId::kRich: event->AddData(ECbmDataType::kRichDigi, iDigi); break;
+ case ECbmModuleId::kMuch: event->AddData(ECbmDataType::kMuchDigi, iDigi); break;
+ case ECbmModuleId::kTrd: event->AddData(ECbmDataType::kTrdDigi, iDigi); break;
+ case ECbmModuleId::kTof: event->AddData(ECbmDataType::kTofDigi, iDigi); break;
+ case ECbmModuleId::kPsd: event->AddData(ECbmDataType::kPsdDigi, iDigi); break;
default: break;
} //? detector
} //# digis
- LOG(info) << GetName() << ": Detector "
- << CbmModuleList::GetModuleNameCaps(system) << ", digis "
- << nDigis << " (" << nAmbig << " ambiguous), noise " << nNoise;
+ LOG(debug) << GetName() << ": Detector " << CbmModuleList::GetModuleNameCaps(system) << ", digis " << nDigis << " ("
+ << nAmbig << " ambiguous), noise " << nNoise;
nDigisTot += nDigis;
nDigisAmbig += nAmbig;
nDigisNoise += nNoise;
} //# detector systems
- timer.Stop();
assert(nEvents == fEvents->GetEntriesFast());
- // --- Execution log
- std::cout << std::endl;
- Double_t execTime = 1000. * timer.RealTime();
- LOG(info) << setw(20) << left << GetName() << "[" << fixed << setprecision(4)
- << execTime << " ms] : TSlice " << right << fNofEntries
- << ", events: " << nEvents << ", digis: " << nDigisTot << " ("
- << nDigisAmbig << " ambiguous), noise: " << nDigisNoise;
+ // --- Timeslice log and statistics
+ timer.Stop();
+ stringstream logOut;
+ logOut << setw(20) << left << GetName() << " [";
+ logOut << fixed << setw(8) << setprecision(1) << right << timer.RealTime() * 1000. << "] ms: ";
+ logOut << "TS " << fNofEntries;
+ if (fEvents) logOut << ", events " << nEvents;
+ logOut << ", digis " << nDigisTot << " (" << nDigisAmbig << " ambiguous), noise: " << nDigisNoise;
+ LOG(info) << logOut.str();
+ fNofEntries++;
+ fNofEvents += nEvents;
+ fNofDigisTotal += nDigisTot;
+ fNofDigisAmbig += nDigisAmbig;
+ fNofDigisNoise += nDigisNoise;
+ fTime += timer.RealTime();
// --- For debug: event info
if (fair::Logger::Logging(fair::Severity::debug)) {
@@ -169,14 +164,33 @@ void CbmBuildEventsIdeal::Exec(Option_t*) {
LOG(info) << event->ToString();
}
}
-
- fNofEntries++;
}
// ===========================================================================
+// ===== End-of-timeslice action =========================================
+void CbmBuildEventsIdeal::Finish()
+{
+
+ std::cout << std::endl;
+ LOG(info) << "=====================================";
+ LOG(info) << GetName() << ": Run summary";
+ LOG(info) << "Time slices : " << fNofEntries;
+ LOG(info) << "All digis / TS : " << fixed << setprecision(2) << fNofDigisTotal / Double_t(fNofEntries);
+ LOG(info) << "Ambiguous digis / TS : " << fixed << setprecision(2) << fNofDigisAmbig / Double_t(fNofEntries) << " = "
+ << 100. * fNofDigisAmbig / fNofDigisTotal << " %";
+ LOG(info) << "Noise digis / TS : " << fixed << setprecision(2) << fNofDigisNoise / Double_t(fNofEntries) << " = "
+ << 100. * fNofDigisNoise / fNofDigisTotal << " %";
+ LOG(info) << "Events : " << fNofEvents;
+ LOG(info) << "Time / TS : " << fixed << setprecision(2) << 1000. * fTime / Double_t(fNofEntries) << " ms";
+ LOG(info) << "=====================================";
+}
+// -------------------------------------------------------------------------
+
+
// ===== Task initialisation =============================================
-InitStatus CbmBuildEventsIdeal::Init() {
+InitStatus CbmBuildEventsIdeal::Init()
+{
// --- Get FairRootManager instance
FairRootManager* ioman = FairRootManager::Instance();
@@ -192,12 +206,9 @@ InitStatus CbmBuildEventsIdeal::Init() {
// --- Check input data
- for (ECbmModuleId system = ECbmModuleId::kMvd;
- system < ECbmModuleId::kNofSystems;
- ++system) {
+ for (ECbmModuleId system = ECbmModuleId::kMvd; system < ECbmModuleId::kNofSystems; ++system) {
if (fDigiMan->IsMatchPresent(system)) {
- LOG(info) << GetName() << ": Found match branch for "
- << CbmModuleList::GetModuleNameCaps(system);
+ LOG(info) << GetName() << ": Found match branch for " << CbmModuleList::GetModuleNameCaps(system);
fSystems.push_back(system);
}
}
@@ -212,8 +223,7 @@ InitStatus CbmBuildEventsIdeal::Init() {
return kFATAL;
}
fEvents = new TClonesArray("CbmEvent", 100);
- ioman->Register(
- "CbmEvent", "Cbm_Event", fEvents, IsOutputBranchPersistent("CbmEvent"));
+ ioman->Register("CbmEvent", "Cbm_Event", fEvents, IsOutputBranchPersistent("CbmEvent"));
if (!fEvents) {
LOG(fatal) << GetName() << ": Output branch could not be created!";
return kFATAL;
diff --git a/reco/eventbuilder/digis/CbmBuildEventsIdeal.h b/reco/eventbuilder/digis/CbmBuildEventsIdeal.h
index f093135592700e6fcfb6ff05108ddaffdd6beb27..7e59b2ecd4f1d226d9707e119b0e3cc9d737dcc6 100644
--- a/reco/eventbuilder/digis/CbmBuildEventsIdeal.h
+++ b/reco/eventbuilder/digis/CbmBuildEventsIdeal.h
@@ -9,7 +9,9 @@
#include "CbmDefs.h"
+
#include <FairTask.h>
+
#include <vector>
class TClonesArray;
@@ -46,6 +48,9 @@ public:
/** @brief Task execution **/
virtual void Exec(Option_t* opt);
+ /** @brief Finish timeslice **/
+ virtual void Finish();
+
/** @brief Assignment operator (disabled) **/
CbmBuildEventsIdeal& operator=(const CbmBuildEventsIdeal&) = delete;
@@ -62,8 +67,13 @@ private: // methods
private: // members
CbmDigiManager* fDigiMan = nullptr; //!
std::vector<ECbmModuleId> fSystems {}; // List of detector systems
- TClonesArray* fEvents = nullptr; //! Output array (class CbmEvent)
- Int_t fNofEntries = 0; // Number of processed time slices
+ TClonesArray* fEvents = nullptr; //! Output array (class CbmEvent)
+ Int_t fNofEntries = 0; // Number of processed time slices
+ Long64_t fNofEvents = 0;
+ Double_t fNofDigisTotal = 0.;
+ Double_t fNofDigisAmbig = 0.;
+ Double_t fNofDigisNoise = 0.;
+ Double_t fTime = 0.;
ClassDef(CbmBuildEventsIdeal, 3);
diff --git a/reco/eventbuilder/digis/CbmTaskBuildRawEvents.cxx b/reco/eventbuilder/digis/CbmTaskBuildRawEvents.cxx
index 38ed5dae023f7643df563cc8a988da14881f993e..df10ef3f62539ada3a1077a707351c014d1b1446 100644
--- a/reco/eventbuilder/digis/CbmTaskBuildRawEvents.cxx
+++ b/reco/eventbuilder/digis/CbmTaskBuildRawEvents.cxx
@@ -24,7 +24,18 @@
#include <iomanip>
-CbmTaskBuildRawEvents::CbmTaskBuildRawEvents() : FairTask("CbmTaskBuildRawEvents")
+using std::cout;
+using std::endl;
+using std::fixed;
+using std::left;
+using std::pair;
+using std::right;
+using std::setprecision;
+using std::setw;
+using std::stringstream;
+
+
+CbmTaskBuildRawEvents::CbmTaskBuildRawEvents() : FairTask("BuildRawEvents")
{
/// Create Algo. To be made generic/switchable when more event building algo are available!
fpAlgo = new CbmAlgoBuildRawEvents();
@@ -169,6 +180,8 @@ InitStatus CbmTaskBuildRawEvents::ReInit() { return kSUCCESS; }
void CbmTaskBuildRawEvents::Exec(Option_t* /*option*/)
{
if (fTimer != nullptr) { fTimer->Start(kFALSE); }
+ TStopwatch timer;
+ timer.Start();
LOG(debug2) << "CbmTaskBuildRawEvents::Exec => Starting sequence";
//Warning: Int_t must be used for the loop counters instead of UInt_t,
@@ -281,6 +294,18 @@ void CbmTaskBuildRawEvents::Exec(Option_t* /*option*/)
LOG(debug2) << "CbmTaskBuildRawEvents::Exec => Done";
if (fTimer != nullptr) { fTimer->Stop(); }
+
+ // --- Timeslice log and statistics
+ timer.Stop();
+ stringstream logOut;
+ logOut << setw(20) << left << GetName() << " [";
+ logOut << fixed << setw(8) << setprecision(1) << right << timer.RealTime() * 1000. << " ms] ";
+ logOut << "TS " << fNofTs;
+ if (fEvents) logOut << ", events " << fEvents->GetEntriesFast();
+ LOG(info) << logOut.str();
+ fNofTs++;
+ fNofEvents += fEvents->GetEntriesFast();
+ fTime += timer.RealTime();
}
void CbmTaskBuildRawEvents::FillSeedTimesFromDetList()
@@ -401,6 +426,14 @@ void CbmTaskBuildRawEvents::Finish()
fpAlgo->Finish();
if (fbFillHistos) { SaveHistos(); }
if (fbGetTimings) { PrintTimings(); }
+
+ std::cout << std::endl;
+ LOG(info) << "=====================================";
+ LOG(info) << GetName() << ": Run summary";
+ LOG(info) << "Time slices : " << fNofTs;
+ LOG(info) << "Events : " << fNofEvents;
+ LOG(info) << "Time / TS : " << fixed << setprecision(2) << 1000. * fTime / Double_t(fNofTs) << " ms";
+ LOG(info) << "=====================================";
}
void CbmTaskBuildRawEvents::FillOutput()
diff --git a/reco/eventbuilder/digis/CbmTaskBuildRawEvents.h b/reco/eventbuilder/digis/CbmTaskBuildRawEvents.h
index 62adf739004c26b56b3957f7f256b140ddfc3a98..e639ac3eb3d8de726dd8cf0053a8d7bf469d898f 100644
--- a/reco/eventbuilder/digis/CbmTaskBuildRawEvents.h
+++ b/reco/eventbuilder/digis/CbmTaskBuildRawEvents.h
@@ -167,6 +167,10 @@ private:
/** Name of the histogram output file **/
TString fsOutFileName {"data/HistosEvtWin.root"};
+ Int_t fNofTs = 0;
+ Long64_t fNofEvents = 0;
+ Double_t fTime = 0.;
+
ClassDef(CbmTaskBuildRawEvents, 1);
};
diff --git a/reco/global/CbmFindPrimaryVertex.cxx b/reco/global/CbmFindPrimaryVertex.cxx
index ccbba618a316b9af43b2a48d9798e0d93ef08692..e882246617303ade212926c7bc480d7c5cf83b15 100644
--- a/reco/global/CbmFindPrimaryVertex.cxx
+++ b/reco/global/CbmFindPrimaryVertex.cxx
@@ -154,13 +154,13 @@ void CbmFindPrimaryVertex::Exec(Option_t*)
// Log to screen
timer.Stop();
- if (fEvents)
- LOG(info) << std::setw(20) << std::left << GetName() << fixed << setprecision(2) << " [" << timer.RealTime() * 1000.
- << " ms]: TS " << fNofTs << ", events " << nEvents << ", tracks used " << nTracksUsed << " / " << nTracks;
- else
- LOG(info) << std::setw(20) << std::left << GetName() << fixed << setprecision(2) << " [" << timer.RealTime() * 1000.
- << " ms] TS " << fNofTs << ", vertex " << fPrimVert->ToString() << ", tracks used " << nTracksUsed
- << " / " << nTracks;
+ stringstream logOut;
+ logOut << setw(20) << left << GetName() << " [";
+ logOut << fixed << setw(8) << setprecision(1) << right << timer.RealTime() * 1000. << " ms] ";
+ logOut << "TS " << fNofTs;
+ if (fEvents) logOut << ", events " << nEvents;
+ logOut << ", tracks used " << nTracksUsed << " / " << nTracks;
+ LOG(info) << logOut.str();
// Counters
fNofTs++;
diff --git a/reco/littrack/cbm/reco/CbmLitFindGlobalTracks.cxx b/reco/littrack/cbm/reco/CbmLitFindGlobalTracks.cxx
index 685a351ded717941a7cfc90929f69924201e8a43..6a86deac90a9cee43579e4605a6f52f1b82b1209 100644
--- a/reco/littrack/cbm/reco/CbmLitFindGlobalTracks.cxx
+++ b/reco/littrack/cbm/reco/CbmLitFindGlobalTracks.cxx
@@ -5,15 +5,6 @@
**/
#include "CbmLitFindGlobalTracks.h"
-#include "base/CbmLitToolFactory.h"
-#include "base/CbmLitTrackingGeometryConstructor.h"
-#include "data/CbmLitHit.h"
-#include "data/CbmLitPixelHit.h"
-#include "data/CbmLitStripHit.h"
-#include "data/CbmLitTrack.h"
-#include "propagation/CbmLitTGeoTrackPropagator.h"
-#include "utils/CbmLitConverter.h"
-#include "utils/CbmLitMemoryManagment.h"
#include "CbmGlobalTrack.h"
#include "CbmHit.h"
@@ -25,15 +16,37 @@
#include "CbmStsTrack.h"
#include "CbmTofTrack.h"
#include "CbmTrdTrack.h"
+#include "base/CbmLitToolFactory.h"
+#include "base/CbmLitTrackingGeometryConstructor.h"
+#include "data/CbmLitHit.h"
+#include "data/CbmLitPixelHit.h"
+#include "data/CbmLitStripHit.h"
+#include "data/CbmLitTrack.h"
+#include "propagation/CbmLitTGeoTrackPropagator.h"
+#include "utils/CbmLitConverter.h"
+#include "utils/CbmLitMemoryManagment.h"
+
#include "FairRootManager.h"
#include "TClonesArray.h"
-#include <cmath>
+#include <iomanip>
#include <iostream>
+#include <cmath>
+
+using std::cout;
+using std::endl;
+using std::fixed;
+using std::left;
+using std::pair;
+using std::right;
+using std::setprecision;
+using std::setw;
+using std::stringstream;
+
CbmLitFindGlobalTracks::CbmLitFindGlobalTracks()
- : FairTask("CbmLitFindGlobalTracks")
+ : FairTask("LitFindGlobalTracks")
, fDet()
,
@@ -73,11 +86,14 @@ CbmLitFindGlobalTracks::CbmLitFindGlobalTracks()
, fMergerWatch()
,
- fEventNo(0) {}
+ fEventNo(0)
+{
+}
CbmLitFindGlobalTracks::~CbmLitFindGlobalTracks() {}
-InitStatus CbmLitFindGlobalTracks::Init() {
+InitStatus CbmLitFindGlobalTracks::Init()
+{
std::cout << std::endl;
LOG(info) << "=========================================";
LOG(info) << GetName() << ": Initializing ";
@@ -97,16 +113,32 @@ InitStatus CbmLitFindGlobalTracks::Init() {
return kSUCCESS;
}
-void CbmLitFindGlobalTracks::Exec(Option_t* opt) {
+void CbmLitFindGlobalTracks::Exec(Option_t* opt)
+{
+
+ UInt_t nEvents = 0;
+ UInt_t nStsTracks = 0;
+ UInt_t nMuchHits = 0;
+ UInt_t nTrdHits = 0;
+ UInt_t nTofHits = 0;
+ UInt_t nGlbTracks = 0;
+
+ if (fStsTracks) nStsTracks = fStsTracks->GetEntriesFast();
+ if (fMuchPixelHits) nMuchHits = fMuchPixelHits->GetEntriesFast();
+ if (fTrdHits) nTrdHits = fTrdHits->GetEntriesFast();
+ if (fTofHits) nTofHits = fTofHits->GetEntriesFast();
+
+ TStopwatch timer;
+ timer.Start();
+
if (fTrdTracks != NULL) fTrdTracks->Delete();
if (fMuchTracks != NULL) fMuchTracks->Delete();
if (fTofTracks != NULL) fTofTracks->Delete();
fGlobalTracks->Clear();
if (fEvents) {
- Int_t nEvents = fEvents->GetEntriesFast();
- LOG(debug) << GetName() << ": reading time slice with " << nEvents
- << " events ";
+ nEvents = fEvents->GetEntriesFast();
+ LOG(debug) << GetName() << ": reading time slice with " << nEvents << " events ";
for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
CbmEvent* event = static_cast<CbmEvent*>(fEvents->At(iEvent));
@@ -116,8 +148,7 @@ void CbmLitFindGlobalTracks::Exec(Option_t* opt) {
CalculateLength(event);
CalculatePrimaryVertexParameters(event);
ClearArrays();
- std::cout << "CbmLitFindGlobalTracks::Exec event: " << event->GetNumber()
- << std::endl;
+ LOG(debug) << "CbmLitFindGlobalTracks::Exec event: " << event->GetNumber();
} //# events
} //? event branch present
else { // Old event-by-event simulation without event branch
@@ -127,16 +158,59 @@ void CbmLitFindGlobalTracks::Exec(Option_t* opt) {
CalculateLength(0);
CalculatePrimaryVertexParameters(0);
ClearArrays();
- std::cout << "CbmLitFindGlobalTracks::Exec event: " << fEventNo++
- << std::endl;
+ LOG(debug) << "CbmLitFindGlobalTracks::Exec timeslice: " << fEventNo++;
}
+
+ // --- Timeslice log and statistics
+ timer.Stop();
+ nGlbTracks = fGlobalTracks->GetEntriesFast();
+ timer.Stop();
+ stringstream logOut;
+ logOut << setw(20) << left << GetName() << " [";
+ logOut << fixed << setw(8) << setprecision(1) << right << timer.RealTime() * 1000. << " ms] ";
+ logOut << "TS " << fNofTs;
+ if (fEvents) logOut << ", events " << nEvents;
+ logOut << ", STS tracks " << nStsTracks << ", Hits MUCH " << nMuchHits << " TRD " << nTrdHits;
+ logOut << " TOF " << nTofHits << ", global tracks " << nGlbTracks;
+ LOG(info) << logOut.str();
+ fNofTs++;
+ fNofEvents += nEvents;
+ fNofStsTracks += nStsTracks;
+ fNofMuchHits += nMuchHits;
+ fNofTrdHits += nTrdHits;
+ fNofTofHits += nTofHits;
+ fNofGlbTracks += nGlbTracks;
+ fTime += timer.RealTime();
}
+
void CbmLitFindGlobalTracks::SetParContainers() {}
-void CbmLitFindGlobalTracks::Finish() { PrintStopwatchStatistics(); }
+void CbmLitFindGlobalTracks::Finish()
+{
-void CbmLitFindGlobalTracks::ReadInputBranches() {
+ std::cout << std::endl;
+ LOG(info) << "=====================================";
+ LOG(info) << GetName() << ": Run summary";
+ LOG(info) << "Time slices : " << fNofTs;
+ LOG(info) << "STS tracks / TS : " << fixed << setprecision(2) << Double_t(fNofStsTracks) / Double_t(fNofTs);
+ LOG(info) << "MUCH hits / TS : " << fixed << setprecision(2) << Double_t(fNofMuchHits) / Double_t(fNofTs);
+ LOG(info) << "TRD hits / TS : " << fixed << setprecision(2) << Double_t(fNofTrdHits) / Double_t(fNofTs);
+ LOG(info) << "TOF hits / TS : " << fixed << setprecision(2) << Double_t(fNofTofHits) / Double_t(fNofTs);
+ LOG(info) << "Global tracks / TS : " << fixed << setprecision(2) << Double_t(fNofGlbTracks) / Double_t(fNofTs);
+ ;
+ LOG(info) << "Time per TS : " << 1000. * fTime / Double_t(fNofTs) << " ms ";
+ if (fEvents) {
+ LOG(info) << "Events processed : " << fNofEvents;
+ LOG(info) << "Global tracks / evt : " << Double_t(fNofGlbTracks) / Double_t(fNofEvents);
+ }
+ PrintStopwatchStatistics();
+ LOG(info) << "=====================================";
+}
+
+
+void CbmLitFindGlobalTracks::ReadInputBranches()
+{
FairRootManager* ioman = FairRootManager::Instance();
assert(ioman);
@@ -146,7 +220,8 @@ void CbmLitFindGlobalTracks::ReadInputBranches() {
if (!fMvdHits) {
LOG(warn) << GetName() << ": No MvdHit branch!";
fDet.SetDet(ECbmModuleId::kMvd, false);
- } else
+ }
+ else
LOG(info) << GetName() << ": Found MvdHit branch";
} //? MVD in geometry
@@ -155,7 +230,8 @@ void CbmLitFindGlobalTracks::ReadInputBranches() {
if (!fStsHits) {
LOG(FATAL) << GetName() << ": No StsHit branch!";
fDet.SetDet(ECbmModuleId::kSts, false);
- } else
+ }
+ else
LOG(INFO) << GetName() << ": Found StsHit branch";
// --- STS tracks
@@ -163,19 +239,19 @@ void CbmLitFindGlobalTracks::ReadInputBranches() {
if (!fStsTracks) {
LOG(FATAL) << GetName() << ": No StsTrack branch!";
fDet.SetDet(ECbmModuleId::kSts, false);
- } else
+ }
+ else
LOG(INFO) << GetName() << ": Found StsTrack branch";
// --- MUCH hits
if (fDet.GetDet(ECbmModuleId::kMuch)) {
- fMuchPixelHits =
- dynamic_cast<TClonesArray*>(ioman->GetObject("MuchPixelHit"));
+ fMuchPixelHits = dynamic_cast<TClonesArray*>(ioman->GetObject("MuchPixelHit"));
if (!fMuchPixelHits) {
LOG(WARNING) << GetName() << "No MuchPixelHit branch!";
fDet.SetDet(ECbmModuleId::kMuch, false);
- } else {
- if (fMuchPixelHits)
- LOG(INFO) << GetName() << ": Found MuchPixelHit branch";
+ }
+ else {
+ if (fMuchPixelHits) LOG(INFO) << GetName() << ": Found MuchPixelHit branch";
}
} //? MUCH in geometry
@@ -195,82 +271,76 @@ void CbmLitFindGlobalTracks::ReadInputBranches() {
if (NULL == fTofHits) {
LOG(WARNING) << GetName() << ": No TofHit branch!";
fDet.SetDet(ECbmModuleId::kTof, false);
- } else
+ }
+ else
LOG(INFO) << GetName() << ": Found TofHit branch";
} //? TOF in geometry
// --- Events
fEvents = dynamic_cast<TClonesArray*>(ioman->GetObject("CbmEvent"));
- if (fEvents)
- LOG(INFO) << GetName() << ": Found Event branch";
+ if (fEvents) LOG(INFO) << GetName() << ": Found Event branch";
else
LOG(INFO) << GetName() << ": No Event branch; run in time-based mode";
// --- Primary vertex
fPrimVertex = dynamic_cast<CbmVertex*>(ioman->GetObject("PrimaryVertex."));
- if (nullptr == fPrimVertex) {
- fPrimVertex = dynamic_cast<CbmVertex*>(ioman->GetObject("PrimaryVertex"));
- }
- if (nullptr == fPrimVertex)
- LOG(WARNING) << GetName() << ": No PrimaryVertex branch!";
+ if (nullptr == fPrimVertex) { fPrimVertex = dynamic_cast<CbmVertex*>(ioman->GetObject("PrimaryVertex")); }
+ if (nullptr == fPrimVertex) LOG(WARNING) << GetName() << ": No PrimaryVertex branch!";
else
LOG(INFO) << GetName() << ": Found PrimaryVertex branch";
}
-void CbmLitFindGlobalTracks::RegisterOutputBranches() {
+void CbmLitFindGlobalTracks::RegisterOutputBranches()
+{
FairRootManager* ioman = FairRootManager::Instance();
assert(ioman);
// --- MuchTrack
if (fDet.GetDet(ECbmModuleId::kMuch)) {
fMuchTracks = new TClonesArray("CbmMuchTrack", 100);
- ioman->Register(
- "MuchTrack", "Much", fMuchTracks, IsOutputBranchPersistent("MuchTrack"));
+ ioman->Register("MuchTrack", "Much", fMuchTracks, IsOutputBranchPersistent("MuchTrack"));
LOG(INFO) << GetName() << ": Register MuchTrack branch";
}
// --- TrdTrack
if (fDet.GetDet(ECbmModuleId::kTrd)) {
fTrdTracks = new TClonesArray("CbmTrdTrack", 100);
- ioman->Register(
- "TrdTrack", "Trd", fTrdTracks, IsOutputBranchPersistent("TrdTrack"));
+ ioman->Register("TrdTrack", "Trd", fTrdTracks, IsOutputBranchPersistent("TrdTrack"));
LOG(INFO) << GetName() << ": Register TrdTrack branch";
}
// --- TofTrack
if (fDet.GetDet(ECbmModuleId::kTof)) {
fTofTracks = new TClonesArray("CbmTofTrack", 100);
- ioman->Register(
- "TofTrack", "Tof", fTofTracks, IsOutputBranchPersistent("TofTrack"));
+ ioman->Register("TofTrack", "Tof", fTofTracks, IsOutputBranchPersistent("TofTrack"));
LOG(INFO) << GetName() << ": Register TofTrack branch";
}
// --- GlobalTrack
fGlobalTracks = new TClonesArray("CbmGlobalTrack", 100);
- ioman->Register("GlobalTrack",
- "Global",
- fGlobalTracks,
- IsOutputBranchPersistent("GlobalTrack"));
+ ioman->Register("GlobalTrack", "Global", fGlobalTracks, IsOutputBranchPersistent("GlobalTrack"));
LOG(INFO) << GetName() << ": Register GlobalTrack branch";
}
-void CbmLitFindGlobalTracks::InitTrackReconstruction() {
+void CbmLitFindGlobalTracks::InitTrackReconstruction()
+{
if (fDet.GetElectronSetup()) {
- if (fTrackingType == "branch" || fTrackingType == "nn"
- || fTrackingType == "nn_parallel") {
+ if (fTrackingType == "branch" || fTrackingType == "nn" || fTrackingType == "nn_parallel") {
std::string st("e_");
st += fTrackingType;
fFinder = CbmLitToolFactory::CreateTrackFinder(st);
- } else {
+ }
+ else {
TObject::Fatal("CbmLitFindGlobalTracks", "Tracking type not found");
}
- } else {
- if (fTrackingType == "branch" || fTrackingType == "nn"
- || fTrackingType == "nn_parallel") {
+ }
+ else {
+ if (fTrackingType == "branch" || fTrackingType == "nn" || fTrackingType == "nn_parallel") {
std::string st("mu_");
st += fTrackingType;
fFinder = CbmLitToolFactory::CreateTrackFinder(st);
- } else {
+ }
+ else {
TObject::Fatal("CbmLitFindGlobalTracks", "Tracking type not found");
}
}
@@ -278,67 +348,55 @@ void CbmLitFindGlobalTracks::InitTrackReconstruction() {
if (fDet.GetDet(ECbmModuleId::kTof)) {
if (fMergerType == "nearest_hit" || fMergerType == "all_hits") {
fMerger = CbmLitToolFactory::CreateHitToTrackMerger("tof_" + fMergerType);
- } else {
+ }
+ else {
TObject::Fatal("CbmLitFindGlobalTracks", "Merger type not found");
}
}
- if (fFitterType == "lit_kalman") {
- fFitter = CbmLitToolFactory::CreateTrackFitter("lit_kalman");
- } else {
+ if (fFitterType == "lit_kalman") { fFitter = CbmLitToolFactory::CreateTrackFitter("lit_kalman"); }
+ else {
TObject::Fatal("CbmLitFindGlobalTracks", "Fitter type not found");
}
fPropagator = CbmLitToolFactory::CreateTrackPropagator("lit");
}
-void CbmLitFindGlobalTracks::ConvertInputData(CbmEvent* event) {
+void CbmLitFindGlobalTracks::ConvertInputData(CbmEvent* event)
+{
CbmLitConverter::StsTrackArrayToTrackVector(event, fStsTracks, fLitStsTracks);
- std::cout << "-I- CbmLitFindGlobalTracks: Number of STS tracks: "
- << fLitStsTracks.size() << std::endl;
+ LOG(debug2) << "-I- CbmLitFindGlobalTracks: Number of STS tracks: " << fLitStsTracks.size();
if (fMuchPixelHits) {
- CbmLitConverter::HitArrayToHitVector(
- event, ECbmDataType::kMuchPixelHit, fMuchPixelHits, fLitHits);
+ CbmLitConverter::HitArrayToHitVector(event, ECbmDataType::kMuchPixelHit, fMuchPixelHits, fLitHits);
}
if (fTrdHits) {
- CbmLitConverter::HitArrayToHitVector(
- event, ECbmDataType::kTrdHit, fTrdHits, fLitHits);
+ CbmLitConverter::HitArrayToHitVector(event, ECbmDataType::kTrdHit, fTrdHits, fLitHits);
//If MUCH-TRD setup, than shift plane id for the TRD hits
if (fDet.GetDet(ECbmModuleId::kMuch) && fDet.GetDet(ECbmModuleId::kTrd)) {
- Int_t nofStations =
- CbmLitTrackingGeometryConstructor::Instance()->GetNofMuchStations();
+ Int_t nofStations = CbmLitTrackingGeometryConstructor::Instance()->GetNofMuchStations();
for (Int_t i = 0; i < fLitHits.size(); i++) {
CbmLitHit* hit = fLitHits[i];
- if (hit->GetSystem() == kLITTRD) {
- hit->SetDetectorId(kLITTRD, hit->GetStation() + nofStations);
- }
+ if (hit->GetSystem() == kLITTRD) { hit->SetDetectorId(kLITTRD, hit->GetStation() + nofStations); }
}
}
}
- std::cout << "-I- CbmLitFindGlobalTracks: Number of hits: " << fLitHits.size()
- << std::endl;
+ LOG(debug2) << "-I- CbmLitFindGlobalTracks: Number of hits: " << fLitHits.size();
if (fTofHits) {
- CbmLitConverter::HitArrayToHitVector(
- event, ECbmDataType::kTofHit, fTofHits, fLitTofHits);
- std::cout << "-I- CbmLitFindGlobalTracks: Number of TOF hits: "
- << fLitTofHits.size() << std::endl;
+ CbmLitConverter::HitArrayToHitVector(event, ECbmDataType::kTofHit, fTofHits, fLitTofHits);
+ LOG(debug2) << "-I- CbmLitFindGlobalTracks: Number of TOF hits: " << fLitTofHits.size();
}
}
-void CbmLitFindGlobalTracks::ConvertOutputData(CbmEvent* event) {
- CbmLitConverter::LitTrackVectorToGlobalTrackArray(event,
- fLitOutputTracks,
- fLitOutputTofTracks,
- fGlobalTracks,
- fStsTracks,
- fTrdTracks,
- fMuchTracks,
- fTofTracks);
+void CbmLitFindGlobalTracks::ConvertOutputData(CbmEvent* event)
+{
+ CbmLitConverter::LitTrackVectorToGlobalTrackArray(event, fLitOutputTracks, fLitOutputTofTracks, fGlobalTracks,
+ fStsTracks, fTrdTracks, fMuchTracks, fTofTracks);
}
-void CbmLitFindGlobalTracks::CalculateLength(CbmEvent* event) {
+void CbmLitFindGlobalTracks::CalculateLength(CbmEvent* event)
+{
if (fTofTracks == NULL || fGlobalTracks == NULL) return;
CbmVertex* primVertex = event ? event->GetVertex() : fPrimVertex;
@@ -347,13 +405,11 @@ void CbmLitFindGlobalTracks::CalculateLength(CbmEvent* event) {
* starting with (0, 0, 0) and adding all
* distances between hits
*/
- Int_t nofTofTracks = event ? event->GetNofData(ECbmDataType::kTofTrack)
- : fTofTracks->GetEntriesFast();
+ Int_t nofTofTracks = event ? event->GetNofData(ECbmDataType::kTofTrack) : fTofTracks->GetEntriesFast();
for (Int_t i = 0; i < nofTofTracks; ++i) {
- Int_t itt = event ? event->GetIndex(ECbmDataType::kTofTrack, i) : i;
- CbmTofTrack* tofTrack = static_cast<CbmTofTrack*>(fTofTracks->At(itt));
- CbmGlobalTrack* globalTrack = static_cast<CbmGlobalTrack*>(
- fGlobalTracks->At(tofTrack->GetTrackIndex()));
+ Int_t itt = event ? event->GetIndex(ECbmDataType::kTofTrack, i) : i;
+ CbmTofTrack* tofTrack = static_cast<CbmTofTrack*>(fTofTracks->At(itt));
+ CbmGlobalTrack* globalTrack = static_cast<CbmGlobalTrack*>(fGlobalTracks->At(tofTrack->GetTrackIndex()));
if (globalTrack == NULL) { continue; }
std::vector<Double_t> X, Y, Z;
@@ -361,7 +417,8 @@ void CbmLitFindGlobalTracks::CalculateLength(CbmEvent* event) {
X.push_back(0.);
Y.push_back(0.);
Z.push_back(0.);
- } else {
+ }
+ else {
X.push_back(primVertex->GetX());
Y.push_back(primVertex->GetY());
Z.push_back(primVertex->GetZ());
@@ -374,9 +431,8 @@ void CbmLitFindGlobalTracks::CalculateLength(CbmEvent* event) {
Int_t tofId = tofTrack->GetTofHitIndex(); //globalTrack->GetTofHitIndex();
if (stsId > -1) {
- const CbmStsTrack* stsTrack =
- static_cast<const CbmStsTrack*>(fStsTracks->At(stsId));
- Int_t nofStsHits = stsTrack->GetNofStsHits();
+ const CbmStsTrack* stsTrack = static_cast<const CbmStsTrack*>(fStsTracks->At(stsId));
+ Int_t nofStsHits = stsTrack->GetNofStsHits();
for (Int_t ih = 0; ih < nofStsHits; ih++) {
CbmStsHit* hit = (CbmStsHit*) fStsHits->At(stsTrack->GetHitIndex(ih));
X.push_back(hit->GetX());
@@ -386,14 +442,12 @@ void CbmLitFindGlobalTracks::CalculateLength(CbmEvent* event) {
}
if (muchId > -1) {
- const CbmTrack* muchTrack =
- static_cast<const CbmTrack*>(fMuchTracks->At(muchId));
- Int_t nofMuchHits = muchTrack->GetNofHits();
+ const CbmTrack* muchTrack = static_cast<const CbmTrack*>(fMuchTracks->At(muchId));
+ Int_t nofMuchHits = muchTrack->GetNofHits();
for (Int_t ih = 0; ih < nofMuchHits; ih++) {
HitType hitType = muchTrack->GetHitType(ih);
if (hitType == ToIntegralType(ECbmDataType::kMuchPixelHit)) {
- CbmPixelHit* hit =
- (CbmPixelHit*) fMuchPixelHits->At(muchTrack->GetHitIndex(ih));
+ CbmPixelHit* hit = (CbmPixelHit*) fMuchPixelHits->At(muchTrack->GetHitIndex(ih));
X.push_back(hit->GetX());
Y.push_back(hit->GetY());
Z.push_back(hit->GetZ());
@@ -402,12 +456,10 @@ void CbmLitFindGlobalTracks::CalculateLength(CbmEvent* event) {
}
if (trdId > -1) {
- const CbmTrack* trdTrack =
- static_cast<const CbmTrack*>(fTrdTracks->At(trdId));
- Int_t nofTrdHits = trdTrack->GetNofHits();
+ const CbmTrack* trdTrack = static_cast<const CbmTrack*>(fTrdTracks->At(trdId));
+ Int_t nofTrdHits = trdTrack->GetNofHits();
for (Int_t ih = 0; ih < nofTrdHits; ih++) {
- CbmPixelHit* hit =
- (CbmPixelHit*) fTrdHits->At(trdTrack->GetHitIndex(ih));
+ CbmPixelHit* hit = (CbmPixelHit*) fTrdHits->At(trdTrack->GetHitIndex(ih));
X.push_back(hit->GetX());
Y.push_back(hit->GetY());
Z.push_back(hit->GetZ());
@@ -415,8 +467,7 @@ void CbmLitFindGlobalTracks::CalculateLength(CbmEvent* event) {
}
if (tofId > -1) {
- const CbmPixelHit* hit =
- static_cast<const CbmPixelHit*>(fTofHits->At(tofId));
+ const CbmPixelHit* hit = static_cast<const CbmPixelHit*>(fTofHits->At(tofId));
X.push_back(hit->GetX());
Y.push_back(hit->GetY());
Z.push_back(hit->GetZ());
@@ -431,8 +482,7 @@ void CbmLitFindGlobalTracks::CalculateLength(CbmEvent* event) {
length += std::sqrt(dX * dX + dY * dY + dZ * dZ);
}
- if (globalTrack->GetTofHitIndex() == tofTrack->GetTofHitIndex())
- globalTrack->SetLength(length);
+ if (globalTrack->GetTofHitIndex() == tofTrack->GetTofHitIndex()) globalTrack->SetLength(length);
tofTrack->SetTrackLength(length);
}
}
@@ -478,38 +528,36 @@ void CbmLitFindGlobalTracks::CalculateLength(CbmEvent* event) {
// for_each(litTracks.begin(), litTracks.end(), DeleteObject());
//}
-void CbmLitFindGlobalTracks::CalculatePrimaryVertexParameters(CbmEvent* event) {
+void CbmLitFindGlobalTracks::CalculatePrimaryVertexParameters(CbmEvent* event)
+{
if (0 == fGlobalTracks) return;
CbmVertex* primVertex = event ? event->GetVertex() : fPrimVertex;
if (0 == primVertex) return;
- Int_t nofGlobalTracks = event ? event->GetNofData(ECbmDataType::kGlobalTrack)
- : fGlobalTracks->GetEntriesFast();
+ Int_t nofGlobalTracks = event ? event->GetNofData(ECbmDataType::kGlobalTrack) : fGlobalTracks->GetEntriesFast();
for (Int_t i0 = 0; i0 < nofGlobalTracks; ++i0) {
- Int_t i = event ? event->GetIndex(ECbmDataType::kGlobalTrack, i0) : i0;
- CbmGlobalTrack* globalTrack =
- static_cast<CbmGlobalTrack*>(fGlobalTracks->At(i));
- Int_t stsId = globalTrack->GetStsTrackIndex();
- CbmStsTrack* stsTrack = static_cast<CbmStsTrack*>(fStsTracks->At(stsId));
+ Int_t i = event ? event->GetIndex(ECbmDataType::kGlobalTrack, i0) : i0;
+ CbmGlobalTrack* globalTrack = static_cast<CbmGlobalTrack*>(fGlobalTracks->At(i));
+ Int_t stsId = globalTrack->GetStsTrackIndex();
+ CbmStsTrack* stsTrack = static_cast<CbmStsTrack*>(fStsTracks->At(stsId));
FairTrackParam vtxTrackParam;
float chiSqPrimary = 0.f;
- CbmKFParticleInterface::ExtrapolateTrackToPV(
- stsTrack, primVertex, &vtxTrackParam, chiSqPrimary);
+ CbmKFParticleInterface::ExtrapolateTrackToPV(stsTrack, primVertex, &vtxTrackParam, chiSqPrimary);
globalTrack->SetParamPrimaryVertex(&vtxTrackParam);
}
}
-void CbmLitFindGlobalTracks::ClearArrays() {
+void CbmLitFindGlobalTracks::ClearArrays()
+{
// Free memory
for_each(fLitStsTracks.begin(), fLitStsTracks.end(), DeleteObject());
for_each(fLitOutputTracks.begin(), fLitOutputTracks.end(), DeleteObject());
for_each(fLitHits.begin(), fLitHits.end(), DeleteObject());
for_each(fLitTofHits.begin(), fLitTofHits.end(), DeleteObject());
- for_each(
- fLitOutputTofTracks.begin(), fLitOutputTofTracks.end(), DeleteObject());
+ for_each(fLitOutputTofTracks.begin(), fLitOutputTofTracks.end(), DeleteObject());
fLitStsTracks.clear();
fLitOutputTracks.clear();
fLitHits.clear();
@@ -517,7 +565,8 @@ void CbmLitFindGlobalTracks::ClearArrays() {
fLitOutputTofTracks.clear();
}
-void CbmLitFindGlobalTracks::RunTrackReconstruction() {
+void CbmLitFindGlobalTracks::RunTrackReconstruction()
+{
// Track finding in TRD or MUCH
if (fDet.GetDet(ECbmModuleId::kMuch) || fDet.GetDet(ECbmModuleId::kTrd)) {
fTrackingWatch.Start(kFALSE);
@@ -527,23 +576,17 @@ void CbmLitFindGlobalTracks::RunTrackReconstruction() {
// Merging of TOF hits to global tracks
if (fDet.GetDet(ECbmModuleId::kTof)) {
// If there are no TRD or MUCH than merge STS tracks with TOF
- if (!(fDet.GetDet(ECbmModuleId::kMuch)
- || fDet.GetDet(ECbmModuleId::kTrd))) {
- for (TrackPtrIterator it = fLitStsTracks.begin();
- it != fLitStsTracks.end();
- it++) {
+ if (!(fDet.GetDet(ECbmModuleId::kMuch) || fDet.GetDet(ECbmModuleId::kTrd))) {
+ for (TrackPtrIterator it = fLitStsTracks.begin(); it != fLitStsTracks.end(); it++) {
CbmLitTrack* track = new CbmLitTrack(*(*it));
fLitOutputTracks.push_back(track);
}
}
// Selection of tracks to be merged with TOF
- if (fDet.GetDet(ECbmModuleId::kMuch) || fDet.GetDet(ECbmModuleId::kTrd)) {
- SelectTracksForTofMerging();
- } else {
- for (TrackPtrIterator it = fLitOutputTracks.begin();
- it != fLitOutputTracks.end();
- it++) {
+ if (fDet.GetDet(ECbmModuleId::kMuch) || fDet.GetDet(ECbmModuleId::kTrd)) { SelectTracksForTofMerging(); }
+ else {
+ for (TrackPtrIterator it = fLitOutputTracks.begin(); it != fLitOutputTracks.end(); it++) {
(*it)->SetQuality(kLITGOODMERGE);
}
}
@@ -554,30 +597,26 @@ void CbmLitFindGlobalTracks::RunTrackReconstruction() {
}
// Refit found tracks
- for (TrackPtrIterator it = fLitOutputTracks.begin();
- it != fLitOutputTracks.end();
- it++) {
+ for (TrackPtrIterator it = fLitOutputTracks.begin(); it != fLitOutputTracks.end(); it++) {
CbmLitTrack* track = *it;
fFitter->Fit(track);
}
}
-void CbmLitFindGlobalTracks::SelectTracksForTofMerging() {
+void CbmLitFindGlobalTracks::SelectTracksForTofMerging()
+{
// The aim of this procedure is to select only those tracks
// which have at least one hit in the last station group.
// Only those tracks will be propagated further and merged
// with TOF hits.
- Int_t nofStations =
- CbmLitTrackingGeometryConstructor::Instance()->GetNofMuchTrdStations();
+ Int_t nofStations = CbmLitTrackingGeometryConstructor::Instance()->GetNofMuchTrdStations();
// Int_t stationCut = nofStations - 4;
// TODO: Fix this issue in a better way. This is done only as an ugly fix
// FU 19.09.13
Int_t stationCut = nofStations - 3;
- for (TrackPtrIterator it = fLitOutputTracks.begin();
- it != fLitOutputTracks.end();
- it++) {
+ for (TrackPtrIterator it = fLitOutputTracks.begin(); it != fLitOutputTracks.end(); it++) {
CbmLitTrack* track = *it;
if (track->GetQuality() == kLITBAD) { continue; }
const CbmLitHit* hit = track->GetHit(track->GetNofHits() - 1);
@@ -588,18 +627,17 @@ void CbmLitFindGlobalTracks::SelectTracksForTofMerging() {
}
}
-void CbmLitFindGlobalTracks::PrintStopwatchStatistics() {
+void CbmLitFindGlobalTracks::PrintStopwatchStatistics()
+{
std::cout << "Stopwatch: " << std::endl;
std::cout << "tracking: counts=" << fTrackingWatch.Counter()
- << ", real=" << fTrackingWatch.RealTime() / fTrackingWatch.Counter()
- << "/" << fTrackingWatch.RealTime()
- << " s, cpu=" << fTrackingWatch.CpuTime() / fTrackingWatch.Counter()
- << "/" << fTrackingWatch.CpuTime() << std::endl;
+ << ", real=" << fTrackingWatch.RealTime() / fTrackingWatch.Counter() << "/" << fTrackingWatch.RealTime()
+ << " s, cpu=" << fTrackingWatch.CpuTime() / fTrackingWatch.Counter() << "/" << fTrackingWatch.CpuTime()
+ << std::endl;
std::cout << "fitter: real=" << fMergerWatch.Counter()
- << ", real=" << fMergerWatch.RealTime() / fMergerWatch.Counter()
- << "/" << fMergerWatch.RealTime()
- << " s, cpu=" << fMergerWatch.CpuTime() / fMergerWatch.Counter()
- << "/" << fMergerWatch.CpuTime() << std::endl;
+ << ", real=" << fMergerWatch.RealTime() / fMergerWatch.Counter() << "/" << fMergerWatch.RealTime()
+ << " s, cpu=" << fMergerWatch.CpuTime() / fMergerWatch.Counter() << "/" << fMergerWatch.CpuTime()
+ << std::endl;
}
ClassImp(CbmLitFindGlobalTracks);
diff --git a/reco/littrack/cbm/reco/CbmLitFindGlobalTracks.h b/reco/littrack/cbm/reco/CbmLitFindGlobalTracks.h
index 5bad4abf382dba60569aa5d1f0d189cfc2f9310d..5371b1925cb6557dee5ae3c29148b67b1a4aabd7 100644
--- a/reco/littrack/cbm/reco/CbmLitFindGlobalTracks.h
+++ b/reco/littrack/cbm/reco/CbmLitFindGlobalTracks.h
@@ -17,14 +17,14 @@
#ifndef CBMLITFINDGLOBALTRACKS_H_
#define CBMLITFINDGLOBALTRACKS_H_
-#include "FairTask.h"
-
#include "CbmVertex.h"
#include "base/CbmLitDetectorSetup.h"
#include "base/CbmLitPtrTypes.h"
#include "base/CbmLitTypes.h"
#include "data/CbmLitHit.h"
+#include "FairTask.h"
+
#include "TStopwatch.h"
#include <string>
@@ -69,9 +69,7 @@ public:
virtual void SetParContainers();
/* Setters */
- void SetTrackingType(const string& trackingType) {
- fTrackingType = trackingType;
- }
+ void SetTrackingType(const string& trackingType) { fTrackingType = trackingType; }
void SetMergerType(const string& mergerType) { fMergerType = mergerType; }
void SetFitterType(const string& fitterType) { fFitterType = fitterType; }
@@ -184,7 +182,16 @@ private:
TStopwatch fTrackingWatch; // stopwatch for tracking
TStopwatch fMergerWatch; // stopwatch for merger
- Int_t fEventNo; // event counter
+ // counters
+ Long64_t fNofTs = 0; // timeslice counter
+ Long64_t fNofEvents = 0; // event counter
+ Long64_t fNofStsTracks = 0; // STS tracks
+ Long64_t fNofMuchHits = 0; // MUCH hits
+ Long64_t fNofTrdHits = 0; // TRD hits
+ Long64_t fNofTofHits = 0; // TOF hits
+ Long64_t fNofGlbTracks = 0; // Global tracks
+ Double_t fTime = 0.; // Processing time
+ Long64_t fEventNo; // event counter (old)
CbmLitFindGlobalTracks(const CbmLitFindGlobalTracks&);
CbmLitFindGlobalTracks& operator=(const CbmLitFindGlobalTracks&);
diff --git a/reco/littrack/std/finder/CbmLitTrackFinderBranch.cxx b/reco/littrack/std/finder/CbmLitTrackFinderBranch.cxx
index a6ff28daa57dcefe9be8956c723e9d65eef91310..436f28a4a74b634ba377bb46ba7aac3d90ea1712 100644
--- a/reco/littrack/std/finder/CbmLitTrackFinderBranch.cxx
+++ b/reco/littrack/std/finder/CbmLitTrackFinderBranch.cxx
@@ -41,13 +41,14 @@ CbmLitTrackFinderBranch::CbmLitTrackFinderBranch()
, fPDG()
, fChiSqStripHitCut()
, fChiSqPixelHitCut()
- , fSigmaCoef() {}
+ , fSigmaCoef()
+{
+}
CbmLitTrackFinderBranch::~CbmLitTrackFinderBranch() {}
-LitStatus CbmLitTrackFinderBranch::DoFind(HitPtrVector& hits,
- TrackPtrVector& trackSeeds,
- TrackPtrVector& tracks) {
+LitStatus CbmLitTrackFinderBranch::DoFind(HitPtrVector& hits, TrackPtrVector& trackSeeds, TrackPtrVector& tracks)
+{
fTracks.clear();
fUsedSeedsSet.clear();
fUsedHitsSet.clear();
@@ -69,13 +70,12 @@ LitStatus CbmLitTrackFinderBranch::DoFind(HitPtrVector& hits,
}
static Int_t eventNo = 0;
- std::cout << "-I- CbmLitTrackFinderBranch: " << eventNo++
- << " events processed" << std::endl;
+ //std::cout << "-I- CbmLitTrackFinderBranch: " << eventNo++ << " events processed" << std::endl;
return kLITSUCCESS;
}
-void CbmLitTrackFinderBranch::ArrangeHits(HitPtrIterator itBegin,
- HitPtrIterator itEnd) {
+void CbmLitTrackFinderBranch::ArrangeHits(HitPtrIterator itBegin, HitPtrIterator itEnd)
+{
for (HitPtrIterator it = itBegin; it != itEnd; it++) {
CbmLitHit* hit = *it;
if (fUsedHitsSet.find(hit->GetRefId()) != fUsedHitsSet.end()) { continue; }
@@ -84,8 +84,8 @@ void CbmLitTrackFinderBranch::ArrangeHits(HitPtrIterator itBegin,
fHitData.Arrange();
}
-void CbmLitTrackFinderBranch::InitTrackSeeds(TrackPtrIterator itBegin,
- TrackPtrIterator itEnd) {
+void CbmLitTrackFinderBranch::InitTrackSeeds(TrackPtrIterator itBegin, TrackPtrIterator itEnd)
+{
for (TrackPtrIterator it = itBegin; it != itEnd; it++) {
(*it)->SetQuality(kLITGOOD);
}
@@ -95,10 +95,7 @@ void CbmLitTrackFinderBranch::InitTrackSeeds(TrackPtrIterator itBegin,
for (TrackPtrIterator it = itBegin; it != itEnd; it++) {
CbmLitTrack* track = *it;
if (track->GetQuality() == kLITBAD) { continue; }
- if (fUsedSeedsSet.find(track->GetPreviousTrackId())
- != fUsedSeedsSet.end()) {
- continue;
- }
+ if (fUsedSeedsSet.find(track->GetPreviousTrackId()) != fUsedSeedsSet.end()) { continue; }
CbmLitTrack* newTrack = new CbmLitTrack(*track);
newTrack->SetPDG(fPDG[fIteration]);
newTrack->SetChi2(0.);
@@ -106,8 +103,8 @@ void CbmLitTrackFinderBranch::InitTrackSeeds(TrackPtrIterator itBegin,
}
}
-void CbmLitTrackFinderBranch::FollowTracks(TrackPtrIterator itBegin,
- TrackPtrIterator itEnd) {
+void CbmLitTrackFinderBranch::FollowTracks(TrackPtrIterator itBegin, TrackPtrIterator itEnd)
+{
// Loop over the track seeds
for (TrackPtrIterator itTrack = itBegin; itTrack != itEnd; itTrack++) {
CbmLitTrack* track = *itTrack;
@@ -117,33 +114,26 @@ void CbmLitTrackFinderBranch::FollowTracks(TrackPtrIterator itBegin,
// Initially start with one branch which is the same as track seed
branches.push_back(new CbmLitTrack(*track));
- for (Int_t iStation = 0; iStation < fNofStations;
- iStation++) { // Loop over stations
+ for (Int_t iStation = 0; iStation < fNofStations; iStation++) { // Loop over stations
litfloat zMin = fHitData.GetMinZPos(iStation);
const vector<Int_t>& bins = fHitData.GetZPosBins(iStation);
// map<bin index, pair<track parameter for the bin, true if track was propagated correctly >>
map<Int_t, pair<CbmLitTrackParam, Bool_t>> binParamMap;
vector<Int_t>::const_iterator itBins;
for (itBins = bins.begin(); itBins != bins.end(); itBins++) {
- binParamMap[*itBins] =
- make_pair<CbmLitTrackParam, Bool_t>(CbmLitTrackParam(), true);
+ binParamMap[*itBins] = make_pair<CbmLitTrackParam, Bool_t>(CbmLitTrackParam(), true);
}
// Number of branches can change in the next loop turn
// since branches array is filled with additional track branches
// which were created on current station
Int_t nofBranches = branches.size();
- for (Int_t iBranch = 0; iBranch < nofBranches;
- iBranch++) { // Loop over branches
+ for (Int_t iBranch = 0; iBranch < nofBranches; iBranch++) { // Loop over branches
CbmLitTrack* branch = branches[iBranch];
// Check for the missing hits
- if (branch->GetNofMissingHits() > fMaxNofMissingHits[fIteration]) {
- continue;
- }
+ if (branch->GetNofMissingHits() > fMaxNofMissingHits[fIteration]) { continue; }
CbmLitTrackParam par(*branch->GetParamLast());
- if (fPropagator->Propagate(&par, zMin, fPDG[fIteration]) == kLITERROR) {
- break;
- }
+ if (fPropagator->Propagate(&par, zMin, fPDG[fIteration]) == kLITERROR) { break; }
// Extrapolate track parameters to each Z position in the map.
// This is done to improve calculation speed.
@@ -152,10 +142,8 @@ void CbmLitTrackFinderBranch::FollowTracks(TrackPtrIterator itBegin,
map<Int_t, pair<CbmLitTrackParam, Bool_t>>::iterator itMap;
for (itMap = binParamMap.begin(); itMap != binParamMap.end(); itMap++) {
(*itMap).second.first = par;
- litfloat z = fHitData.GetZPosByBin(iStation, (*itMap).first);
- if (fPropagator->Propagate(
- &(*itMap).second.first, z, fPDG[fIteration])
- == kLITERROR) {
+ litfloat z = fHitData.GetZPosByBin(iStation, (*itMap).first);
+ if (fPropagator->Propagate(&(*itMap).second.first, z, fPDG[fIteration]) == kLITERROR) {
(*itMap).second.second = false;
}
}
@@ -163,13 +151,11 @@ void CbmLitTrackFinderBranch::FollowTracks(TrackPtrIterator itBegin,
// Loop over hits
map<litfloat, pair<const CbmLitHit*, CbmLitTrackParam>> chiHitPar;
const HitPtrVector& hits = fHitData.GetHits(iStation);
- for (HitPtrConstIterator itHit = hits.begin(); itHit != hits.end();
- itHit++) {
+ for (HitPtrConstIterator itHit = hits.begin(); itHit != hits.end(); itHit++) {
const CbmLitHit* hit = *itHit;
Int_t bin = fHitData.GetBinByZPos(iStation, hit->GetZ());
assert(binParamMap.find(bin) != binParamMap.end());
- if (!binParamMap[bin].second)
- continue; // Track parameters are wrong for this propagation
+ if (!binParamMap[bin].second) continue; // Track parameters are wrong for this propagation
CbmLitTrackParam tpar(binParamMap[bin].first);
// Check preliminary if hit is in the validation gate.
@@ -177,22 +163,15 @@ void CbmLitTrackFinderBranch::FollowTracks(TrackPtrIterator itBegin,
// Based on the predicted track position (w/o KF update step)
// and maximum hit position error.
if (hit->GetType() == kLITPIXELHIT) {
- const CbmLitPixelHit* pixelHit =
- static_cast<const CbmLitPixelHit*>(hit);
- litfloat maxErrX = fHitData.GetMaxErrX(iStation);
- litfloat devX = fSigmaCoef[fIteration]
- * (sqrt(tpar.GetCovariance(0) + maxErrX * maxErrX));
- litfloat maxErrY = fHitData.GetMaxErrY(iStation);
- litfloat devY = fSigmaCoef[fIteration]
- * (sqrt(tpar.GetCovariance(6) + maxErrY * maxErrY));
- litfloat maxErrT = fHitData.GetMaxErrT(iStation);
- litfloat devT =
- fSigmaCoef[fIteration]
- * (sqrt(tpar.GetCovariance(20) + maxErrT * maxErrT));
- bool hitInside = (pixelHit->GetX() < (tpar.GetX() + devX))
- && (pixelHit->GetX() > (tpar.GetX() - devX))
- && (pixelHit->GetY() < (tpar.GetY() + devY))
- && (pixelHit->GetY() > (tpar.GetY() - devY))
+ const CbmLitPixelHit* pixelHit = static_cast<const CbmLitPixelHit*>(hit);
+ litfloat maxErrX = fHitData.GetMaxErrX(iStation);
+ litfloat devX = fSigmaCoef[fIteration] * (sqrt(tpar.GetCovariance(0) + maxErrX * maxErrX));
+ litfloat maxErrY = fHitData.GetMaxErrY(iStation);
+ litfloat devY = fSigmaCoef[fIteration] * (sqrt(tpar.GetCovariance(6) + maxErrY * maxErrY));
+ litfloat maxErrT = fHitData.GetMaxErrT(iStation);
+ litfloat devT = fSigmaCoef[fIteration] * (sqrt(tpar.GetCovariance(20) + maxErrT * maxErrT));
+ bool hitInside = (pixelHit->GetX() < (tpar.GetX() + devX)) && (pixelHit->GetX() > (tpar.GetX() - devX))
+ && (pixelHit->GetY() < (tpar.GetY() + devY)) && (pixelHit->GetY() > (tpar.GetY() - devY))
&& (pixelHit->GetT() < (tpar.GetTime() + devT))
&& (pixelHit->GetT() > (tpar.GetTime() - devT));
if (!hitInside) continue;
@@ -200,11 +179,8 @@ void CbmLitTrackFinderBranch::FollowTracks(TrackPtrIterator itBegin,
litfloat chi = std::numeric_limits<litfloat>::max();
fFilter->Update(&tpar, hit, chi);
- bool hitInValidationGate =
- (hit->GetType() == kLITPIXELHIT
- && chi < fChiSqPixelHitCut[fIteration])
- || (hit->GetType() == kLITSTRIPHIT
- && chi < fChiSqStripHitCut[fIteration]);
+ bool hitInValidationGate = (hit->GetType() == kLITPIXELHIT && chi < fChiSqPixelHitCut[fIteration])
+ || (hit->GetType() == kLITSTRIPHIT && chi < fChiSqStripHitCut[fIteration]);
if (hitInValidationGate) { // Check if hit is inside validation gate
chiHitPar[chi] = make_pair(hit, tpar);
}
@@ -214,25 +190,22 @@ void CbmLitTrackFinderBranch::FollowTracks(TrackPtrIterator itBegin,
// Check if hit was added
if (nofHitsInValidationGate == 1) {
// Only one hit added, no additional branches are created, just update branch parameters
- const map<litfloat,
- pair<const CbmLitHit*, CbmLitTrackParam>>::const_iterator
- it = chiHitPar.begin();
+ const map<litfloat, pair<const CbmLitHit*, CbmLitTrackParam>>::const_iterator it = chiHitPar.begin();
branch->AddHit((*it).second.first);
branch->SetLastStationId(iStation);
branch->SetParamLast(&(*it).second.second);
branch->SetChi2(branch->GetChi2() + (*it).first);
branch->SetNDF(lit::NDF(branch));
- } else if (nofHitsInValidationGate > 1) {
+ }
+ else if (nofHitsInValidationGate > 1) {
// If more than one hit is in the validation gate, than create additional branches.
// For the first hit use the same branch.
Int_t counter = 0;
CbmLitTrack tt(*branch);
- map<litfloat,
- pair<const CbmLitHit*, CbmLitTrackParam>>::const_iterator it;
+ map<litfloat, pair<const CbmLitHit*, CbmLitTrackParam>>::const_iterator it;
for (it = chiHitPar.begin(); it != chiHitPar.end(); it++) {
// Create new branch starting with the second hit
- CbmLitTrack* tbranch =
- (it != chiHitPar.begin()) ? new CbmLitTrack(tt) : branch;
+ CbmLitTrack* tbranch = (it != chiHitPar.begin()) ? new CbmLitTrack(tt) : branch;
if (it != chiHitPar.begin()) branches.push_back(tbranch);
tbranch->AddHit((*it).second.first);
tbranch->SetLastStationId(iStation);
@@ -248,7 +221,8 @@ void CbmLitTrackFinderBranch::FollowTracks(TrackPtrIterator itBegin,
if (nofBranches > fMaxNofBranches) break;
//if (branches.size() > fMaxNofBranches) break;
}
- } else { // Missing hit
+ }
+ else { // Missing hit
branch->SetNofMissingHits(branch->GetNofMissingHits() + 1);
}
} // Loop over branches
@@ -270,8 +244,8 @@ void CbmLitTrackFinderBranch::FollowTracks(TrackPtrIterator itBegin,
}
}
-void CbmLitTrackFinderBranch::RemoveHits(TrackPtrIterator itBegin,
- TrackPtrIterator itEnd) {
+void CbmLitTrackFinderBranch::RemoveHits(TrackPtrIterator itBegin, TrackPtrIterator itEnd)
+{
for (TrackPtrIterator it = itBegin; it != itEnd; it++) {
CbmLitTrack* track = *it;
if (track->GetQuality() == kLITBAD) { continue; }
@@ -281,9 +255,8 @@ void CbmLitTrackFinderBranch::RemoveHits(TrackPtrIterator itBegin,
}
}
-void CbmLitTrackFinderBranch::CopyToOutput(TrackPtrIterator itBegin,
- TrackPtrIterator itEnd,
- TrackPtrVector& tracks) {
+void CbmLitTrackFinderBranch::CopyToOutput(TrackPtrIterator itBegin, TrackPtrIterator itEnd, TrackPtrVector& tracks)
+{
for (TrackPtrIterator it = itBegin; it != itEnd; it++) {
CbmLitTrack* track = *it;
if (track->GetQuality() == kLITBAD) { continue; }