diff --git a/reco/detectors/sts/CbmRecoSts.cxx b/reco/detectors/sts/CbmRecoSts.cxx
index 19e8fb05be0d38e4fcd3471b41018ae671223cf9..15929c29615eb690813a8fb2d6762a21516f8b0d 100644
--- a/reco/detectors/sts/CbmRecoSts.cxx
+++ b/reco/detectors/sts/CbmRecoSts.cxx
@@ -5,11 +5,6 @@
#include "CbmRecoSts.h"
-#include <TClonesArray.h>
-#include <TGeoBBox.h>
-#include <TGeoPhysicalNode.h>
-#include <iomanip>
-
#include "CbmAddress.h"
#include "CbmDigiManager.h"
#include "CbmEvent.h"
@@ -22,10 +17,17 @@
#include "CbmStsRecoModule.h"
#include "CbmStsRecoModuleOrtho.h"
#include "CbmStsSetup.h"
+
#include <FairField.h>
#include <FairRun.h>
#include <FairRuntimeDb.h>
+#include <TClonesArray.h>
+#include <TGeoBBox.h>
+#include <TGeoPhysicalNode.h>
+
+#include <iomanip>
+
using std::fixed;
using std::left;
using std::right;
@@ -38,13 +40,13 @@ ClassImp(CbmRecoSts)
// ----- Constructor ---------------------------------------------------
- CbmRecoSts::CbmRecoSts(ECbmRecoMode mode,
- Bool_t writeClusters,
- Bool_t runParallel)
+ CbmRecoSts::CbmRecoSts(ECbmRecoMode mode, Bool_t writeClusters, Bool_t runParallel)
: FairTask("RecoSts", 1)
, fMode(mode)
, fWriteClusters(writeClusters)
- , fRunParallel(runParallel) {}
+ , fRunParallel(runParallel)
+{
+}
// -------------------------------------------------------------------------
@@ -54,7 +56,8 @@ CbmRecoSts::~CbmRecoSts() {}
// ----- Initialise the cluster finding modules ------------------------
-UInt_t CbmRecoSts::CreateModules() {
+UInt_t CbmRecoSts::CreateModules()
+{
assert(fSetup);
for (Int_t iModule = 0; iModule < fSetup->GetNofModules(); iModule++) {
@@ -69,24 +72,19 @@ UInt_t CbmRecoSts::CreateModules() {
Int_t sensorAddress = Int_t(setupSensor->GetAddress());
// --- Parameter sets from database or user-defined
- CbmStsParSetModule* modulePars = (fUserParSetModule ? fUserParSetModule : fParSetModule);
- CbmStsParSetSensor* sensorPars = (fUserParSetSensor ? fUserParSetSensor : fParSetSensor);
+ CbmStsParSetModule* modulePars = (fUserParSetModule ? fUserParSetModule : fParSetModule);
+ CbmStsParSetSensor* sensorPars = (fUserParSetSensor ? fUserParSetSensor : fParSetSensor);
CbmStsParSetSensorCond* sensorConds = (fUserParSetCond ? fUserParSetCond : fParSetCond);
// --- Module parameters
- const CbmStsParModule& modPar =
- (fUserParModule ? *fUserParModule
- : modulePars->GetParModule(moduleAddress));
+ const CbmStsParModule& modPar = (fUserParModule ? *fUserParModule : modulePars->GetParModule(moduleAddress));
// --- Sensor parameters
- const CbmStsParSensor& sensPar =
- (fUserParSensor ? *fUserParSensor
- : sensorPars->GetParSensor(sensorAddress));
+ const CbmStsParSensor& sensPar = (fUserParSensor ? *fUserParSensor : sensorPars->GetParSensor(sensorAddress));
// --- Sensor conditions
const CbmStsParSensorCond& sensCond =
- (fUserParSensorCond ? *fUserParSensorCond
- : sensorConds->GetParSensor(sensorAddress));
+ (fUserParSensorCond ? *fUserParSensorCond : sensorConds->GetParSensor(sensorAddress));
// --- Calculate and set average Lorentz shift
// --- This will be used in hit finding for correcting the position.
@@ -94,8 +92,7 @@ UInt_t CbmRecoSts::CreateModules() {
Double_t lorentzB = 0.;
if (fParSim->LorentzShift()) {
- TGeoBBox* shape =
- dynamic_cast<TGeoBBox*>(setupSensor->GetPnode()->GetShape());
+ TGeoBBox* shape = dynamic_cast<TGeoBBox*>(setupSensor->GetPnode()->GetShape());
assert(shape);
Double_t dZ = 2. * shape->GetDZ(); // Sensor thickness
@@ -118,8 +115,7 @@ UInt_t CbmRecoSts::CreateModules() {
} //? Lorentz-shift correction
// --- Create reco module
- CbmStsRecoModule* recoModule = new CbmStsRecoModule(setupModule, modPar, sensPar,
- lorentzF, lorentzB);
+ CbmStsRecoModule* recoModule = new CbmStsRecoModule(setupModule, modPar, sensPar, lorentzF, lorentzB);
assert(recoModule);
auto result = fModules.insert({moduleAddress, recoModule});
assert(result.second);
@@ -132,7 +128,8 @@ UInt_t CbmRecoSts::CreateModules() {
// ----- Task execution ------------------------------------------------
-void CbmRecoSts::Exec(Option_t*) {
+void CbmRecoSts::Exec(Option_t*)
+{
// --- Clear output array
fHits->Delete();
@@ -147,8 +144,7 @@ void CbmRecoSts::Exec(Option_t*) {
else {
assert(fEvents);
Int_t nEvents = fEvents->GetEntriesFast();
- LOG(info) << setw(20) << left << GetName() << ": Processing time slice "
- << fNofTimeslices << " with " << nEvents
+ LOG(info) << setw(20) << left << GetName() << ": Processing time slice " << fNofTimeslices << " with " << nEvents
<< (nEvents == 1 ? " event" : " events");
for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
CbmEvent* event = dynamic_cast<CbmEvent*>(fEvents->At(iEvent));
@@ -163,7 +159,8 @@ void CbmRecoSts::Exec(Option_t*) {
// ----- End-of-run action ---------------------------------------------
-void CbmRecoSts::Finish() {
+void CbmRecoSts::Finish()
+{
std::cout << std::endl;
LOG(info) << "=====================================";
@@ -172,20 +169,14 @@ void CbmRecoSts::Finish() {
// --- 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 / 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 ";
+ LOG(info) << "Time per TSlice : " << fTimeTot / Double_t(fNofTimeslices) << " s ";
} //? time-slice mode
@@ -193,15 +184,11 @@ void CbmRecoSts::Finish() {
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 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 ";
+ LOG(info) << "Time per event : " << fTimeTot / Double_t(fNofEvents) << " s ";
} //? event mode
fTimeTot /= Double_t(fNofEvents);
@@ -209,25 +196,22 @@ void CbmRecoSts::Finish() {
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 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) << "=====================================";
}
// -------------------------------------------------------------------------
// ----- Initialisation ------------------------------------------------
-InitStatus CbmRecoSts::Init() {
+InitStatus CbmRecoSts::Init()
+{
// --- Something for the screen
std::cout << std::endl;
@@ -247,8 +231,7 @@ InitStatus CbmRecoSts::Init() {
LOG(info) << GetName() << ": Using event-by-event mode";
fEvents = dynamic_cast<TClonesArray*>(ioman->GetObject("CbmEvent"));
if (nullptr == fEvents) {
- LOG(warn) << GetName()
- << ": Event mode selected but no event array found!";
+ LOG(warn) << GetName() << ": Event mode selected but no event array found!";
return kFATAL;
} //? Event branch not present
} //? Event mode
@@ -256,20 +239,15 @@ InitStatus CbmRecoSts::Init() {
LOG(info) << GetName() << ": Using time-based mode";
// --- Check input array (StsDigis)
- if (!fDigiManager->IsPresent(ECbmModuleId::kSts))
- LOG(fatal) << GetName() << ": No StsDigi branch in input!";
+ if (!fDigiManager->IsPresent(ECbmModuleId::kSts)) LOG(fatal) << GetName() << ": No StsDigi branch in input!";
// --- Register output array
fClusters = new TClonesArray("CbmStsCluster", 1);
- ioman->Register("StsCluster",
- "Clusters in STS",
- fClusters,
- IsOutputBranchPersistent("StsCluster"));
+ ioman->Register("StsCluster", "Clusters in STS", fClusters, IsOutputBranchPersistent("StsCluster"));
// --- Register output array
fHits = new TClonesArray("CbmStsHit", 1);
- ioman->Register(
- "StsHit", "Hits in STS", fHits, IsOutputBranchPersistent("StsHit"));
+ ioman->Register("StsHit", "Hits in STS", fHits, IsOutputBranchPersistent("StsHit"));
// --- Simulation settings
assert(fParSim);
@@ -306,10 +284,8 @@ InitStatus CbmRecoSts::Init() {
// ----- Calculate the mean Lorentz shift in a sensor ------------------
-std::pair<Double_t, Double_t>
-CbmRecoSts::LorentzShift(const CbmStsParSensorCond& conditions,
- Double_t dZ,
- Double_t bY) {
+std::pair<Double_t, Double_t> CbmRecoSts::LorentzShift(const CbmStsParSensorCond& conditions, Double_t dZ, Double_t bY)
+{
Double_t vBias = conditions.GetVbias(); // Bias voltage
Double_t vFd = conditions.GetVfd(); // Full-depletion voltage
@@ -340,7 +316,8 @@ CbmRecoSts::LorentzShift(const CbmStsParSensorCond& conditions,
// ----- Process one time slice or event -------------------------------
-void CbmRecoSts::ProcessData(CbmEvent* event) {
+void CbmRecoSts::ProcessData(CbmEvent* event)
+{
// --- Reset all modules
fTimer.Start();
@@ -358,16 +335,14 @@ void CbmRecoSts::ProcessData(CbmEvent* event) {
// --- Number of input digis
fTimer.Start();
- Int_t nDigis = (event ? event->GetNofData(ECbmDataType::kStsDigi)
- : fDigiManager->GetNofDigis(ECbmModuleId::kSts));
+ Int_t nDigis = (event ? event->GetNofData(ECbmDataType::kStsDigi) : fDigiManager->GetNofDigis(ECbmModuleId::kSts));
// --- Distribute digis to modules
Int_t digiIndex = -1;
//#pragma omp parallel for schedule(static) if(fParallelism_enabled)
for (Int_t iDigi = 0; iDigi < nDigis; iDigi++) {
- digiIndex =
- (event ? event->GetIndex(ECbmDataType::kStsDigi, iDigi) : iDigi);
+ digiIndex = (event ? event->GetIndex(ECbmDataType::kStsDigi, iDigi) : iDigi);
const CbmStsDigi* digi = fDigiManager->Get<const CbmStsDigi>(digiIndex);
assert(digi);
@@ -379,12 +354,10 @@ void CbmRecoSts::ProcessData(CbmEvent* event) {
}
// Get proper reco module
- Int_t moduleAddress =
- CbmStsAddress::GetMotherAddress(digi->GetAddress(), kStsModule);
- auto it = fModules.find(moduleAddress);
+ Int_t moduleAddress = CbmStsAddress::GetMotherAddress(digi->GetAddress(), kStsModule);
+ auto it = fModules.find(moduleAddress);
if (it == fModules.end()) {
- LOG(warn) << "Unknown module address: "
- << CbmStsAddress::ToString(moduleAddress);
+ LOG(warn) << "Unknown module address: " << CbmStsAddress::ToString(moduleAddress);
;
}
assert(it != fModules.end());
@@ -418,9 +391,8 @@ void CbmRecoSts::ProcessData(CbmEvent* event) {
ULong64_t offsetClustersB = 0;
for (UInt_t it = 0; it < fModuleIndex.size(); it++) {
- const vector<CbmStsCluster>& moduleClustersF =
- fModuleIndex[it]->GetClustersF();
- offsetClustersF = fClusters->GetEntriesFast();
+ const vector<CbmStsCluster>& moduleClustersF = fModuleIndex[it]->GetClustersF();
+ offsetClustersF = fClusters->GetEntriesFast();
for (auto& cluster : moduleClustersF) {
UInt_t index = fClusters->GetEntriesFast();
new ((*fClusters)[index]) CbmStsCluster(cluster);
@@ -428,9 +400,8 @@ void CbmRecoSts::ProcessData(CbmEvent* event) {
nClusters++;
} //# front-side clusters in module
- const vector<CbmStsCluster>& moduleClustersB =
- fModuleIndex[it]->GetClustersB();
- offsetClustersB = fClusters->GetEntriesFast();
+ const vector<CbmStsCluster>& moduleClustersB = fModuleIndex[it]->GetClustersB();
+ offsetClustersB = fClusters->GetEntriesFast();
for (auto& cluster : moduleClustersB) {
UInt_t index = fClusters->GetEntriesFast();
new ((*fClusters)[index]) CbmStsCluster(cluster);
@@ -467,32 +438,26 @@ 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(info) << 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(info) << setw(20) << left << GetName() << "[" << fixed << setprecision(4) << realTime << " s] : TSlice "
+ << right << setw(6) << fNofTimeslices << ", digis: " << nDigis << ", ignored: " << nDigisIgnored
+ << ", clusters: " << nClusters << ", hits " << nHits;
}
}
// -------------------------------------------------------------------------
// ----- Connect parameter container -----------------------------------
-void CbmRecoSts::SetParContainers() {
+void CbmRecoSts::SetParContainers()
+{
FairRuntimeDb* db = FairRun::Instance()->GetRuntimeDb();
- fParSim = dynamic_cast<CbmStsParSim*>(db->getContainer("CbmStsParSim"));
- fParSetModule =
- dynamic_cast<CbmStsParSetModule*>(db->getContainer("CbmStsParSetModule"));
- fParSetSensor =
- dynamic_cast<CbmStsParSetSensor*>(db->getContainer("CbmStsParSetSensor"));
- fParSetCond = dynamic_cast<CbmStsParSetSensorCond*>(
- db->getContainer("CbmStsParSetSensorCond"));
+ fParSim = dynamic_cast<CbmStsParSim*>(db->getContainer("CbmStsParSim"));
+ fParSetModule = dynamic_cast<CbmStsParSetModule*>(db->getContainer("CbmStsParSetModule"));
+ fParSetSensor = dynamic_cast<CbmStsParSetSensor*>(db->getContainer("CbmStsParSetSensor"));
+ fParSetCond = dynamic_cast<CbmStsParSetSensorCond*>(db->getContainer("CbmStsParSetSensorCond"));
}
// -------------------------------------------------------------------------
diff --git a/reco/detectors/sts/CbmRecoSts.h b/reco/detectors/sts/CbmRecoSts.h
index 318d3ac3044bf655f29e74a180225a69c825cf1c..2eff777971943df57e72b7bc52bd8c0542ef1630 100644
--- a/reco/detectors/sts/CbmRecoSts.h
+++ b/reco/detectors/sts/CbmRecoSts.h
@@ -9,6 +9,7 @@
#include <FairTask.h>
+
#include <TStopwatch.h>
@@ -31,7 +32,11 @@ class CbmStsSetup;
/** @enum ECbmMode
** @brief Time-slice or event-by-event mode
**/
-enum ECbmRecoMode { kCbmRecoTimeslice, kCbmRecoEvent };
+enum ECbmRecoMode
+{
+ kCbmRecoTimeslice,
+ kCbmRecoEvent
+};
/** @class CbmRecoSts
@@ -55,9 +60,7 @@ class CbmRecoSts : public FairTask {
public:
/** @brief Constructor **/
- CbmRecoSts(ECbmRecoMode mode = kCbmRecoTimeslice,
- Bool_t writeClusters = kFALSE,
- Bool_t runParallel = kFALSE);
+ CbmRecoSts(ECbmRecoMode mode = kCbmRecoTimeslice, Bool_t writeClusters = kFALSE, Bool_t runParallel = kFALSE);
/** @brief Copy constructor (disabled) **/
@@ -98,9 +101,7 @@ public:
**
** Alternative to using SetMode.
**/
- void SetEventMode(Bool_t choice = kTRUE) {
- fMode = (choice ? kCbmRecoEvent : kCbmRecoTimeslice);
- }
+ void SetEventMode(Bool_t choice = kTRUE) { fMode = (choice ? kCbmRecoEvent : kCbmRecoTimeslice); }
/** @brief Set execution mode
@@ -181,9 +182,7 @@ public:
** If defined, these condition parameters will be used for all sensors instead
** of those found in the runtimeDb.
*/
- void UseSensorCond(CbmStsParSensorCond* sensorCond) {
- fUserParSensorCond = sensorCond;
- }
+ void UseSensorCond(CbmStsParSensorCond* sensorCond) { fUserParSensorCond = sensorCond; }
/** @brief User-defined module parameter set
** @param parModule Module parameter set object
@@ -219,8 +218,7 @@ private:
**
** The Lorentz shift will be corrected for in hit finding.
**/
- std::pair<Double_t, Double_t>
- LorentzShift(const CbmStsParSensorCond& conditions, Double_t dZ, Double_t bY);
+ std::pair<Double_t, Double_t> LorentzShift(const CbmStsParSensorCond& conditions, Double_t dZ, Double_t bY);
/** @brief Instantiate reconstruction modules
@@ -270,12 +268,12 @@ private:
// --- Settings
ECbmRecoMode fMode = kCbmRecoEvent; ///< Time-slice or event
- Double_t fTimeCutDigisSig = 3.; ///< Time cut for cluster finding
- Double_t fTimeCutDigisAbs = -1.; ///< Time cut for cluster finding [ns]
- Double_t fTimeCutClustersSig = 4.; ///< Time cut for hit finding
- Double_t fTimeCutClustersAbs = -1.; ///< Time cut for hit finding [ns]
- Bool_t fWriteClusters = kFALSE; ///< Write clusters to tree
- Bool_t fRunParallel = kFALSE; ///< Use OpenMP multithreading
+ Double_t fTimeCutDigisSig = 3.; ///< Time cut for cluster finding
+ Double_t fTimeCutDigisAbs = -1.; ///< Time cut for cluster finding [ns]
+ Double_t fTimeCutClustersSig = 4.; ///< Time cut for hit finding
+ Double_t fTimeCutClustersAbs = -1.; ///< Time cut for hit finding [ns]
+ Bool_t fWriteClusters = kFALSE; ///< Write clusters to tree
+ Bool_t fRunParallel = kFALSE; ///< Use OpenMP multithreading
// --- Counters
TStopwatch fTimer {}; //! ROOT timer
diff --git a/reco/detectors/sts/CbmStsRecoModule.cxx b/reco/detectors/sts/CbmStsRecoModule.cxx
index 491e2061a39b6aed1cd56bb1148efc500de8700a..b2b83b41e62ac6ac34be4388afe5b303020a80e8 100644
--- a/reco/detectors/sts/CbmStsRecoModule.cxx
+++ b/reco/detectors/sts/CbmStsRecoModule.cxx
@@ -5,14 +5,6 @@
#include "CbmStsRecoModule.h"
-#include <TGeoBBox.h>
-#include <TGeoPhysicalNode.h>
-#include <TMath.h>
-
-#include <FairField.h>
-#include <FairLogger.h>
-#include <FairRun.h>
-
#include "CbmStsAlgoAnaCluster.h"
#include "CbmStsAlgoFindClusters.h"
#include "CbmStsAlgoFindHits.h"
@@ -22,6 +14,14 @@
#include "CbmStsParSensor.h"
#include "CbmStsSensor.h"
+#include <FairField.h>
+#include <FairLogger.h>
+#include <FairRun.h>
+
+#include <TGeoBBox.h>
+#include <TGeoPhysicalNode.h>
+#include <TMath.h>
+
using std::pair;
@@ -29,21 +29,21 @@ ClassImp(CbmStsRecoModule)
// ----- Standard constructor ------------------------------------------
- CbmStsRecoModule::CbmStsRecoModule() {}
+ CbmStsRecoModule::CbmStsRecoModule()
+{
+}
// -------------------------------------------------------------------------
// ----- Default constructor -------------------------------------------
-CbmStsRecoModule::CbmStsRecoModule(CbmStsModule* setupModule,
- const CbmStsParModule& parModule,
- const CbmStsParSensor& parSensor,
- Double_t lorentzShiftF,
- Double_t lorentzShiftB)
+CbmStsRecoModule::CbmStsRecoModule(CbmStsModule* setupModule, const CbmStsParModule& parModule,
+ const CbmStsParSensor& parSensor, Double_t lorentzShiftF, Double_t lorentzShiftB)
: fSetupModule(setupModule)
, fParModule(&parModule)
, fParSensor(&parSensor)
, fLorentzShiftF(lorentzShiftF)
- , fLorentzShiftB(lorentzShiftB) {
+ , fLorentzShiftB(lorentzShiftB)
+{
Init();
}
// -------------------------------------------------------------------------
@@ -55,14 +55,13 @@ CbmStsRecoModule::~CbmStsRecoModule() {}
// --------------- Add digi to queues ----------------------------------
-void CbmStsRecoModule::AddDigiToQueue(const CbmStsDigi* digi, Int_t digiIndex) {
+void CbmStsRecoModule::AddDigiToQueue(const CbmStsDigi* digi, Int_t digiIndex)
+{
fLock.lock();
- Int_t moduleAddress =
- CbmStsAddress::GetMotherAddress(digi->GetAddress(), kStsModule);
+ Int_t moduleAddress = CbmStsAddress::GetMotherAddress(digi->GetAddress(), kStsModule);
assert(moduleAddress == fSetupModule->GetAddress());
assert(digi->GetChannel() < fNofStripsF + fNofStripsB);
- if (digi->GetChannel() < fNofStripsF)
- fDigisF.push_back({digi, digiIndex});
+ if (digi->GetChannel() < fNofStripsF) fDigisF.push_back({digi, digiIndex});
else
fDigisB.push_back({digi, digiIndex});
fLock.unlock();
@@ -71,41 +70,24 @@ void CbmStsRecoModule::AddDigiToQueue(const CbmStsDigi* digi, Int_t digiIndex) {
// ----- Reconstruction ------------------------------------------------
-void CbmStsRecoModule::Reconstruct() {
+void CbmStsRecoModule::Reconstruct()
+{
// --- Sort the digi queues by digi time stamp
- std::sort(fDigisF.begin(),
- fDigisF.end(),
- [](pair<const CbmStsDigi*, Int_t> digi1,
- pair<const CbmStsDigi*, Int_t> digi2) {
+ std::sort(fDigisF.begin(), fDigisF.end(),
+ [](pair<const CbmStsDigi*, Int_t> digi1, pair<const CbmStsDigi*, Int_t> digi2) {
return digi1.first->GetTime() < digi2.first->GetTime();
});
- std::sort(fDigisB.begin(),
- fDigisB.end(),
- [](pair<const CbmStsDigi*, Int_t> digi1,
- pair<const CbmStsDigi*, Int_t> digi2) {
+ std::sort(fDigisB.begin(), fDigisB.end(),
+ [](pair<const CbmStsDigi*, Int_t> digi1, pair<const CbmStsDigi*, Int_t> digi2) {
return digi1.first->GetTime() < digi2.first->GetTime();
});
// --- Perform cluster finding
- fClusterFinder->Exec(fDigisF,
- fClustersF,
- fSetupModule->GetAddress(),
- fNofStripsF,
- 0,
- fTimeCutDigiSig,
- fTimeCutDigiAbs,
- fConnectEdgeFront,
- fParModule);
- fClusterFinder->Exec(fDigisB,
- fClustersB,
- fSetupModule->GetAddress(),
- fNofStripsB,
- fNofStripsF,
- fTimeCutDigiSig,
- fTimeCutDigiAbs,
- fConnectEdgeBack,
- fParModule);
+ fClusterFinder->Exec(fDigisF, fClustersF, fSetupModule->GetAddress(), fNofStripsF, 0, fTimeCutDigiSig,
+ fTimeCutDigiAbs, fConnectEdgeFront, fParModule);
+ fClusterFinder->Exec(fDigisB, fClustersB, fSetupModule->GetAddress(), fNofStripsB, fNofStripsF, fTimeCutDigiSig,
+ fTimeCutDigiAbs, fConnectEdgeBack, fParModule);
// --- Perform cluster analysis
for (auto& cluster : fClustersF)
@@ -114,46 +96,29 @@ void CbmStsRecoModule::Reconstruct() {
fClusterAna->Exec(cluster, fParModule);
// --- Sort clusters by time
- std::sort(fClustersF.begin(),
- fClustersF.end(),
- [](const CbmStsCluster& cluster1, const CbmStsCluster& cluster2) {
- return (cluster1.GetTime() < cluster2.GetTime());
- });
- std::sort(fClustersB.begin(),
- fClustersB.end(),
- [](const CbmStsCluster& cluster1, const CbmStsCluster& cluster2) {
- return (cluster1.GetTime() < cluster2.GetTime());
- });
+ std::sort(fClustersF.begin(), fClustersF.end(), [](const CbmStsCluster& cluster1, const CbmStsCluster& cluster2) {
+ return (cluster1.GetTime() < cluster2.GetTime());
+ });
+ std::sort(fClustersB.begin(), fClustersB.end(), [](const CbmStsCluster& cluster1, const CbmStsCluster& cluster2) {
+ return (cluster1.GetTime() < cluster2.GetTime());
+ });
// --- Perform hit finding
- if (fHitFinder) fHitFinder->Exec(fClustersF,
- fClustersB,
- fHits,
- fSetupModule->GetAddress(),
- fTimeCutClusterSig,
- fTimeCutClusterAbs,
- fDyActive,
- fNofStripsF,
- fStripPitchF,
- fStereoFront,
- fStereoBack,
- fLorentzShiftF,
- fLorentzShiftB,
- fMatrix);
- else if ( fHitFinderOrtho ) fHitFinderOrtho->Exec(fClustersF, fClustersB, fHits,
- fSetupModule->GetAddress(),
- fTimeCutClusterSig,
- fTimeCutClusterAbs,
- fNofStripsF, fNofStripsB,
- fStripPitchF, fStripPitchB,
- fLorentzShiftF, fLorentzShiftB,
- fMatrix);
+ if (fHitFinder)
+ fHitFinder->Exec(fClustersF, fClustersB, fHits, fSetupModule->GetAddress(), fTimeCutClusterSig, fTimeCutClusterAbs,
+ fDyActive, fNofStripsF, fStripPitchF, fStereoFront, fStereoBack, fLorentzShiftF, fLorentzShiftB,
+ fMatrix);
+ else if (fHitFinderOrtho)
+ fHitFinderOrtho->Exec(fClustersF, fClustersB, fHits, fSetupModule->GetAddress(), fTimeCutClusterSig,
+ fTimeCutClusterAbs, fNofStripsF, fNofStripsB, fStripPitchF, fStripPitchB, fLorentzShiftF,
+ fLorentzShiftB, fMatrix);
}
// -------------------------------------------------------------------------
// ----- Reset before new time slice -----------------------------------
-void CbmStsRecoModule::Reset() {
+void CbmStsRecoModule::Reset()
+{
fDigisF.clear();
fDigisB.clear();
}
@@ -161,7 +126,8 @@ void CbmStsRecoModule::Reset() {
// ----- Get the sensor parameters -------------------------------------
-void CbmStsRecoModule::Init() {
+void CbmStsRecoModule::Init()
+{
// Reconstruction is currently implemented for double-sided strip
// sensors (class DssdStereo or DssdOrtho)
@@ -188,8 +154,8 @@ void CbmStsRecoModule::Init() {
// --- Number of strips must be the same on both sides
// --- Number of strips, strip pitch and stereo angle
- fNofStripsF = fParSensor->GetParInt(4);
- fNofStripsB = fParSensor->GetParInt(5);
+ fNofStripsF = fParSensor->GetParInt(4);
+ fNofStripsB = fParSensor->GetParInt(5);
fStripPitchF = fParSensor->GetPar(6);
fStripPitchB = fParSensor->GetPar(7);
fStereoFront = fParSensor->GetPar(8);
@@ -200,18 +166,18 @@ void CbmStsRecoModule::Init() {
assert(fStripPitchB > 0.);
// --- For DssdStereo, number of strips and pitch must be the same on both sides
- if ( type == CbmStsSensorClass::kDssdStereo ) {
- assert ( fNofStripsB == fNofStripsF );
- assert ( fStripPitchB == fStripPitchF );
+ if (type == CbmStsSensorClass::kDssdStereo) {
+ assert(fNofStripsB == fNofStripsF);
+ assert(fStripPitchB == fStripPitchF);
}
// --- Check consistency with geometric extensions
- if ( type == CbmStsSensorClass::kDssdStereo ) {
+ if (type == CbmStsSensorClass::kDssdStereo) {
assert(Double_t(fNofStripsF) * fStripPitchF <= fParSensor->GetPar(0));
fDyActive = fParSensor->GetPar(3);
assert(fDyActive <= fParSensor->GetPar(1));
}
- else if ( type == CbmStsSensorClass::kDssdOrtho ) {
+ else if (type == CbmStsSensorClass::kDssdOrtho) {
assert(Double_t(fNofStripsF) * fStripPitchF <= fParSensor->GetPar(0));
assert(Double_t(fNofStripsB) * fStripPitchB <= fParSensor->GetPar(1));
}
@@ -226,10 +192,11 @@ void CbmStsRecoModule::Init() {
fConnectEdgeBack = kFALSE;
// Algorithms
- fClusterAna = new CbmStsAlgoAnaCluster();
- fClusterFinder = new CbmStsAlgoFindClusters();
+ fClusterAna = new CbmStsAlgoAnaCluster();
+ fClusterFinder = new CbmStsAlgoFindClusters();
if (type == CbmStsSensorClass::kDssdStereo) fHitFinder = new CbmStsAlgoFindHits();
- else fHitFinderOrtho = new CbmStsAlgoFindHitsOrtho();
+ else
+ fHitFinderOrtho = new CbmStsAlgoFindHitsOrtho();
// Name
fName = fSetupModule->GetName();
@@ -238,7 +205,8 @@ void CbmStsRecoModule::Init() {
// ----- Info to string -------------------------------------------------
-std::string CbmStsRecoModule::ToString() const {
+std::string CbmStsRecoModule::ToString() const
+{
std::stringstream ss;
ss << fSetupModule->ToString() << " Strips " << fNofStripsF << " / " << fNofStripsB;
return ss.str();
diff --git a/reco/detectors/sts/CbmStsRecoModule.h b/reco/detectors/sts/CbmStsRecoModule.h
index 62227af1e764558c15510cd6f0c453b03d41848f..8870f3b378799e353732c9d6ec578131940085b6 100644
--- a/reco/detectors/sts/CbmStsRecoModule.h
+++ b/reco/detectors/sts/CbmStsRecoModule.h
@@ -9,7 +9,9 @@
#include "CbmStsCluster.h"
#include "CbmStsHit.h"
+
#include <TNamed.h>
+
#include <mutex>
class TGeoHMatrix;
@@ -59,11 +61,8 @@ public:
** The Lorentz shift will be used to correct the hit position in
** hit finding.
**/
- CbmStsRecoModule(CbmStsModule* setupModule,
- const CbmStsParModule& parModule,
- const CbmStsParSensor& parSensor,
- Double_t lorentzShiftF,
- Double_t lorentzShiftB);
+ CbmStsRecoModule(CbmStsModule* setupModule, const CbmStsParModule& parModule, const CbmStsParSensor& parSensor,
+ Double_t lorentzShiftF, Double_t lorentzShiftB);
/** @brief Copy constructor (disabled) **/
@@ -137,11 +136,11 @@ private:
UInt_t fNofStripsB = 0; ///< Number of sensor strips back side
Double_t fStripPitchF = 0.; ///< Sensor strip pitch front side [cm]
Double_t fStripPitchB = 0.; ///< Sensor strip pitch back side [cm]
- Double_t fStereoFront = 0.; ///< Strip stereo angle front side [deg]
- Double_t fStereoBack = 0.; ///< Strip stereo angle back side [deg]
- TGeoHMatrix* fMatrix = nullptr; ///< Sensor position in global C.S. [cm]
- Double_t fLorentzShiftF = 0.; ///< Average Lorentz shift front side [cm|
- Double_t fLorentzShiftB = 0.; ///< Average Lorentz shift back side [cm|
+ Double_t fStereoFront = 0.; ///< Strip stereo angle front side [deg]
+ Double_t fStereoBack = 0.; ///< Strip stereo angle back side [deg]
+ TGeoHMatrix* fMatrix = nullptr; ///< Sensor position in global C.S. [cm]
+ Double_t fLorentzShiftF = 0.; ///< Average Lorentz shift front side [cm|
+ Double_t fLorentzShiftB = 0.; ///< Average Lorentz shift back side [cm|
// --- Data
std::vector<std::pair<const CbmStsDigi*, Long64_t>> fDigisF {}; //!
@@ -151,12 +150,12 @@ private:
std::vector<CbmStsHit> fHits {}; //!
// --- Settings
- Double_t fTimeCutDigiSig = 3.; ///< Time cut for cluster finding (in sigma)
- Double_t fTimeCutDigiAbs = -1.; ///< Time cut for cluster finding (in ns)
- Double_t fTimeCutClusterSig = 4.; ///< Time cut for hit finding (in ns)
- Double_t fTimeCutClusterAbs = -1.; ///< Time cut for hit finding (in sigma)
- Bool_t fConnectEdgeFront = kFALSE; ///< Round-the edge clustering front side
- Bool_t fConnectEdgeBack = kFALSE; ///< Round-the edge clustering back side
+ Double_t fTimeCutDigiSig = 3.; ///< Time cut for cluster finding (in sigma)
+ Double_t fTimeCutDigiAbs = -1.; ///< Time cut for cluster finding (in ns)
+ Double_t fTimeCutClusterSig = 4.; ///< Time cut for hit finding (in ns)
+ Double_t fTimeCutClusterAbs = -1.; ///< Time cut for hit finding (in sigma)
+ Bool_t fConnectEdgeFront = kFALSE; ///< Round-the edge clustering front side
+ Bool_t fConnectEdgeBack = kFALSE; ///< Round-the edge clustering back side
ClassDef(CbmStsRecoModule, 1);