Skip to content
Snippets Groups Projects
Commit 5b6a547e authored by Volker Friese's avatar Volker Friese Committed by Florian Uhlig
Browse files

Applied clang-format to modified files.

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