diff --git a/MQ/mcbm/CbmDeviceBmonMonitor.h b/MQ/mcbm/CbmDeviceBmonMonitor.h
index fc607dc8cb6b983c202646d58db2adeb48ed4f2a..4069b2ae66f87f945b1c11f27f941b4a959cf6f4 100644
--- a/MQ/mcbm/CbmDeviceBmonMonitor.h
+++ b/MQ/mcbm/CbmDeviceBmonMonitor.h
@@ -49,7 +49,7 @@ protected:
private:
/// Constants
- static constexpr std::uint16_t fkFlesBmon = static_cast<std::uint16_t>(fles::SubsystemIdentifier::T0);
+ static constexpr std::uint16_t fkFlesBmon = static_cast<std::uint16_t>(fles::Subsystem::T0);
/// Control flags
diff --git a/MQ/mcbm/CbmDeviceUnpack.h b/MQ/mcbm/CbmDeviceUnpack.h
index 2cd1b89810a7939d5e4ad85d23e70479f6125cf6..7b47e5951aaaf193e6c2acdb04beb8ecb2925300 100644
--- a/MQ/mcbm/CbmDeviceUnpack.h
+++ b/MQ/mcbm/CbmDeviceUnpack.h
@@ -77,15 +77,15 @@ protected:
private:
/// Constants
- static constexpr std::uint16_t fkFlesBmon = static_cast<std::uint16_t>(fles::SubsystemIdentifier::T0);
- static constexpr std::uint16_t fkFlesMvd = static_cast<std::uint16_t>(fles::SubsystemIdentifier::MVD);
- static constexpr std::uint16_t fkFlesSts = static_cast<std::uint16_t>(fles::SubsystemIdentifier::STS);
- static constexpr std::uint16_t fkFlesMuch = static_cast<std::uint16_t>(fles::SubsystemIdentifier::MUCH);
- static constexpr std::uint16_t fkFlesTrd = static_cast<std::uint16_t>(fles::SubsystemIdentifier::TRD);
- static constexpr std::uint16_t fkFlesTrd2D = static_cast<std::uint16_t>(fles::SubsystemIdentifier::TRD2D);
- static constexpr std::uint16_t fkFlesTof = static_cast<std::uint16_t>(fles::SubsystemIdentifier::RPC);
- static constexpr std::uint16_t fkFlesRich = static_cast<std::uint16_t>(fles::SubsystemIdentifier::RICH);
- static constexpr std::uint16_t fkFlesPsd = static_cast<std::uint16_t>(fles::SubsystemIdentifier::PSD);
+ static constexpr std::uint16_t fkFlesBmon = static_cast<std::uint16_t>(fles::Subsystem::T0);
+ static constexpr std::uint16_t fkFlesMvd = static_cast<std::uint16_t>(fles::Subsystem::MVD);
+ static constexpr std::uint16_t fkFlesSts = static_cast<std::uint16_t>(fles::Subsystem::STS);
+ static constexpr std::uint16_t fkFlesMuch = static_cast<std::uint16_t>(fles::Subsystem::MUCH);
+ static constexpr std::uint16_t fkFlesTrd = static_cast<std::uint16_t>(fles::Subsystem::TRD);
+ static constexpr std::uint16_t fkFlesTrd2D = static_cast<std::uint16_t>(fles::Subsystem::TRD2D);
+ static constexpr std::uint16_t fkFlesTof = static_cast<std::uint16_t>(fles::Subsystem::TOF);
+ static constexpr std::uint16_t fkFlesRich = static_cast<std::uint16_t>(fles::Subsystem::RICH);
+ static constexpr std::uint16_t fkFlesPsd = static_cast<std::uint16_t>(fles::Subsystem::PSD);
/// Control flags
diff --git a/algo/base/Definitions.h b/algo/base/Definitions.h
index d07a3add58dd57d5c7601a08dd741177752a9768..7741095975211faaf827c480cf8e36f38347b68e 100644
--- a/algo/base/Definitions.h
+++ b/algo/base/Definitions.h
@@ -4,7 +4,7 @@
#ifndef CBM_BASE_TYPES_H
#define CBM_BASE_TYPES_H
-#include "MicrosliceDescriptor.hpp" // For fles::SubsystemIdentifier
+#include "MicrosliceDescriptor.hpp" // For fles::Subsystem
#include "util/EnumDict.h"
@@ -27,26 +27,27 @@ namespace cbm::algo
} // namespace cbm::algo
-CBM_ENUM_DICT(fles::SubsystemIdentifier,
+CBM_ENUM_DICT(fles::Subsystem,
// CBM detectors
- {"STS", fles::SubsystemIdentifier::STS},
- {"MVD", fles::SubsystemIdentifier::MVD},
- {"RICH", fles::SubsystemIdentifier::RICH},
- {"TRD", fles::SubsystemIdentifier::TRD},
- {"TRD2D", fles::SubsystemIdentifier::TRD2D},
- {"MUCH", fles::SubsystemIdentifier::MUCH},
- {"RPC", fles::SubsystemIdentifier::RPC},
- {"ECAL", fles::SubsystemIdentifier::ECAL},
- {"PSD", fles::SubsystemIdentifier::PSD},
+ {"STS", fles::Subsystem::STS},
+ {"MVD", fles::Subsystem::MVD},
+ {"RICH", fles::Subsystem::RICH},
+ {"TRD", fles::Subsystem::TRD},
+ {"TRD2D", fles::Subsystem::TRD2D},
+ {"MUCH", fles::Subsystem::MUCH},
+ {"TOF", fles::Subsystem::TOF},
// Other detectors (experimental)
- {"T0", fles::SubsystemIdentifier::T0},
- {"TRB3", fles::SubsystemIdentifier::TRB3},
- {"HODOSCOPE", fles::SubsystemIdentifier::Hodoscope},
- {"CHERENKOV", fles::SubsystemIdentifier::Cherenkov},
+ {"ECAL", fles::Subsystem::ECAL},
+ {"PSD", fles::Subsystem::PSD},
+ {"T0", fles::Subsystem::T0},
+ {"TRB3", fles::Subsystem::TRB3},
+ {"Hodoscope", fles::Subsystem::Hodoscope},
+ {"Cherenkov", fles::Subsystem::Cherenkov},
+ {"LeadGlass", fles::Subsystem::LeadGlass},
// FLES (pattern generators)
- {"FLES", fles::SubsystemIdentifier::FLES},
+ {"FLES", fles::Subsystem::FLES},
);
CBM_ENUM_DICT(cbm::algo::Step,
diff --git a/algo/base/Options.cxx b/algo/base/Options.cxx
index 779b4ebbcfca986d2c1f738e4ebec35fe3703f7b..9e3a72dcf4c18cde4e11be85e798a2ecc07d8dbe 100644
--- a/algo/base/Options.cxx
+++ b/algo/base/Options.cxx
@@ -71,7 +71,7 @@ Options::Options(int argc, char** argv)
"comma seperated list of reconstruction output types (hit, digi, ...)")
("steps", po::value(&fRecoSteps)->multitoken()->default_value({Step::LocalReco})->value_name("<steps>"),
"comma seperated list of reconstruction steps (upack, digitrigger, localreco, ...)")
- ("systems,s", po::value(&fDetectors)->multitoken()->default_value({fles::SubsystemIdentifier::STS})->value_name("<detectors>"),
+ ("systems,s", po::value(&fDetectors)->multitoken()->default_value({fles::Subsystem::STS})->value_name("<detectors>"),
"comma seperated list of detectors to process (sts, mvd, ...)")
("num-ts,n", po::value(&fNumTimeslices)->default_value(-1)->value_name("<num>"),
"Stop after <num> timeslices (-1 = all)")
diff --git a/algo/base/Options.h b/algo/base/Options.h
index a164ed7378443a877c1db861f419b75cd2e45ec1..58c5574ec345b20e9db2295bae14552ff3cc0709 100644
--- a/algo/base/Options.h
+++ b/algo/base/Options.h
@@ -39,8 +39,8 @@ namespace cbm::algo
return std::find(fOutputTypes.begin(), fOutputTypes.end(), recoData) != fOutputTypes.end();
}
- const std::vector<fles::SubsystemIdentifier>& Detectors() const { return fDetectors; }
- bool HasDetector(fles::SubsystemIdentifier detector) const
+ const std::vector<fles::Subsystem>& Detectors() const { return fDetectors; }
+ bool HasDetector(fles::Subsystem detector) const
{
return std::find(fDetectors.begin(), fDetectors.end(), detector) != fDetectors.end();
}
@@ -58,7 +58,7 @@ namespace cbm::algo
int fSkipTimeslices = 0;
std::vector<Step> fRecoSteps;
std::vector<RecoData> fOutputTypes;
- std::vector<fles::SubsystemIdentifier> fDetectors;
+ std::vector<fles::Subsystem> fDetectors;
};
} // namespace cbm::algo
diff --git a/algo/detectors/sts/UnpackStsXpu.cxx b/algo/detectors/sts/UnpackStsXpu.cxx
index bc62c0583967f7e1a45400488181a05af46b5d68..6c6b10b467db0d7af0cda2586ed19b54b91e4a4b 100644
--- a/algo/detectors/sts/UnpackStsXpu.cxx
+++ b/algo/detectors/sts/UnpackStsXpu.cxx
@@ -118,8 +118,8 @@ namespace cbm::algo
for (uint64_t tsComp = 0; tsComp < ts->num_components(); tsComp++) {
// --- Skip if TS component is not from STS (equipment IDs are non-unique across systems)
- auto systemId = static_cast<fles::SubsystemIdentifier>(ts->descriptor(tsComp, 0).sys_id);
- if (systemId != fles::SubsystemIdentifier::STS) continue;
+ auto subsystem = static_cast<fles::Subsystem>(ts->descriptor(tsComp, 0).sys_id);
+ if (subsystem != fles::Subsystem::STS) continue;
if (equip == ts->descriptor(tsComp, 0).eq_id) {
const uint64_t numMsInComp = ts->num_microslices(tsComp);
diff --git a/algo/global/Reco.cxx b/algo/global/Reco.cxx
index 2e08ad96be42cdc79ee35b9a6ec46eae44e24702..dfad5dc7a5650b61631853209d5b159c8cb515af 100644
--- a/algo/global/Reco.cxx
+++ b/algo/global/Reco.cxx
@@ -26,7 +26,7 @@ void Reco::Validate(const Options& opts)
for (auto detector : opts.Detectors()) {
switch (detector) {
- case fles::SubsystemIdentifier::STS: break;
+ case fles::Subsystem::STS: break;
default: throw std::runtime_error(fmt::format("Unsupported system: {}", ToString(detector)));
}
}
diff --git a/algo/unpack/Unpack.cxx b/algo/unpack/Unpack.cxx
index 403e0bcf21678b13cdbd8811ec06900dc249c8c1..d706b5ac0798297f9db024a39c10bda75ade088a 100644
--- a/algo/unpack/Unpack.cxx
+++ b/algo/unpack/Unpack.cxx
@@ -13,6 +13,7 @@
#include "log.hpp"
using namespace std;
+using fles::Subsystem;
namespace cbm::algo
{
@@ -26,13 +27,13 @@ namespace cbm::algo
CbmDigiTimeslice& digiTs = result.first;
UnpackMonitorData& monitor = result.second;
- if (DetectorEnabled(fles::SubsystemIdentifier::STS)) {
- ParallelMsLoop(fles::SubsystemIdentifier::STS, digiTs.fData.fSts.fDigis, monitor.fSts, *timeslice, fAlgoSts,
+ if (DetectorEnabled(Subsystem::STS)) {
+ ParallelMsLoop(Subsystem::STS, digiTs.fData.fSts.fDigis, monitor.fSts, *timeslice, fAlgoSts,
0x20);
}
- if (DetectorEnabled(fles::SubsystemIdentifier::RPC)) {
- ParallelMsLoop(fles::SubsystemIdentifier::RPC, digiTs.fData.fTof.fDigis, monitor.fTof, *timeslice, fAlgoTof,
+ if (DetectorEnabled(Subsystem::TOF)) {
+ ParallelMsLoop(Subsystem::TOF, digiTs.fData.fTof.fDigis, monitor.fTof, *timeslice, fAlgoTof,
0x00);
}
@@ -40,11 +41,11 @@ namespace cbm::algo
for (uint64_t comp = 0; comp < timeslice->num_components(); comp++) {
// System ID of current component
- const auto systemId = static_cast<fles::SubsystemIdentifier>(timeslice->descriptor(comp, 0).sys_id);
+ const auto subsystem = static_cast<Subsystem>(timeslice->descriptor(comp, 0).sys_id);
- if (!DetectorEnabled(systemId)) continue;
+ if (!DetectorEnabled(subsystem)) continue;
- xpu::scoped_timer t1(fles::to_string(systemId));
+ xpu::scoped_timer t1(fles::to_string(subsystem));
xpu::t_add_bytes(timeslice->size_component(comp));
// Equipment ID of current component
@@ -55,25 +56,25 @@ namespace cbm::algo
// In the future, different data formats will be supported by instantiating different
// algorithms depending on the version.
- // if (systemId == fles::SubsystemIdentifier::STS) {
+ // if (subsystem == Subsystem::STS) {
// MsLoop(timeslice, fAlgoSts, comp, equipmentId, &digiTs.fData.fSts.fDigis, monitor, &monitor.fSts, 0x20);
// }
- if (systemId == fles::SubsystemIdentifier::MUCH) {
+ if (subsystem == Subsystem::MUCH) {
MsLoop(timeslice, fAlgoMuch, comp, equipmentId, &digiTs.fData.fMuch.fDigis, monitor, &monitor.fMuch, 0x20);
}
- // if (systemId == fles::SubsystemIdentifier::RPC) {
+ // if (subsystem == Subsystem::TOF) {
// MsLoop(timeslice, fAlgoTof, comp, equipmentId, &digiTs.fData.fTof.fDigis, monitor, &monitor.fTof, 0x00);
// }
- if (systemId == fles::SubsystemIdentifier::T0) {
+ if (subsystem == Subsystem::T0) {
MsLoop(timeslice, fAlgoBmon, comp, equipmentId, &digiTs.fData.fT0.fDigis, monitor, &monitor.fBmon, 0x00);
}
- if (systemId == fles::SubsystemIdentifier::TRD) {
+ if (subsystem == Subsystem::TRD) {
MsLoop(timeslice, fAlgoTrd, comp, equipmentId, &digiTs.fData.fTrd.fDigis, monitor, &monitor.fTrd, 0x01);
}
- if (systemId == fles::SubsystemIdentifier::TRD2D) {
+ if (subsystem == Subsystem::TRD2D) {
MsLoop(timeslice, fAlgoTrd2d, comp, equipmentId, &digiTs.fData.fTrd2d.fDigis, monitor, &monitor.fTrd2d, 0x02);
}
- if (systemId == fles::SubsystemIdentifier::RICH) {
+ if (subsystem == Subsystem::RICH) {
MsLoop(timeslice, fAlgoRich, comp, equipmentId, &digiTs.fData.fRich.fDigis, monitor, &monitor.fRich, 0x03);
}
} //# component
@@ -96,7 +97,7 @@ namespace cbm::algo
// ----------------------------------------------------------------------------
- std::pair<size_t, size_t> Unpack::ParallelInit(const fles::Timeslice& ts, fles::SubsystemIdentifier sysId,
+ std::pair<size_t, size_t> Unpack::ParallelInit(const fles::Timeslice& ts, Subsystem subsystem,
std::vector<u16>& msEqIds,
std::vector<fles::MicrosliceDescriptor>& msDesc,
std::vector<const u8*>& msContent)
@@ -104,8 +105,8 @@ namespace cbm::algo
size_t numMs = 0;
size_t sizeBytes = 0;
for (uint64_t comp = 0; comp < ts.num_components(); comp++) {
- auto systemId = static_cast<fles::SubsystemIdentifier>(ts.descriptor(comp, 0).sys_id);
- if (systemId == sysId) {
+ auto this_subsystem = static_cast<Subsystem>(ts.descriptor(comp, 0).sys_id);
+ if (this_subsystem == subsystem) {
const u64 numMsInComp = ts.num_microslices(comp);
const u16 componentId = ts.descriptor(comp, 0).eq_id;
sizeBytes += ts.size_component(comp);
@@ -126,16 +127,16 @@ namespace cbm::algo
// ----------------------------------------------------------------------------
template<class Digi, class UnpackAlgo, class Monitor>
- void Unpack::ParallelMsLoop(const fles::SubsystemIdentifier sysId, std::vector<Digi>& digisOut,
+ void Unpack::ParallelMsLoop(const Subsystem subsystem, std::vector<Digi>& digisOut,
std::vector<Monitor>& monitorOut, const fles::Timeslice& ts,
const std::map<u16, UnpackAlgo>& algos, u8 sys_ver)
{
- xpu::scoped_timer t_(fles::to_string(sysId));
+ xpu::scoped_timer t_(fles::to_string(subsystem));
std::vector<u16> msEqIds; // equipment ids of microslices
std::vector<fles::MicrosliceDescriptor> msDesc; // microslice descriptors
std::vector<const u8*> msContent; // pointer to microslice content
- auto [numMs, sizeBytes] = ParallelInit(ts, sysId, msEqIds, msDesc, msContent);
+ auto [numMs, sizeBytes] = ParallelInit(ts, subsystem, msEqIds, msDesc, msContent);
std::vector<std::vector<Digi>> msDigis(numMs); // unpacked digis per microslice
std::vector<Monitor> monitor(numMs); // unpacking monitoring data per microslice
@@ -218,7 +219,7 @@ namespace cbm::algo
const auto duration = std::chrono::duration_cast<std::chrono::microseconds>(endtime - starttime);
L_(debug) << "Unpack(): Component " << comp << ", subsystem "
- << fles::to_string(static_cast<fles::SubsystemIdentifier>(timeslice->descriptor(comp, 0).sys_id))
+ << fles::to_string(static_cast<Subsystem>(timeslice->descriptor(comp, 0).sys_id))
<< ", microslices " << numMsInComp << " input size " << numBytesInComp << " bytes,"
<< " digis " << numDigisInComp << ", CPU time " << duration.count() / 1000. << " ms";
@@ -231,9 +232,9 @@ namespace cbm::algo
// ----- Initialisation ---------------------------------------------------
- void Unpack::Init(std::vector<fles::SubsystemIdentifier> subIds)
+ void Unpack::Init(std::vector<Subsystem> subIds)
{
- fSubIds = subIds;
+ fSubsystems = subIds;
// --- Common parameters for all components for STS
uint32_t numChansPerAsicSts = 128; // R/O channels per ASIC for STS
@@ -251,7 +252,7 @@ namespace cbm::algo
auto mapEntry = fStsConfig.Map(equip, elink);
elinkPar.fAddress = mapEntry.first; // Module address for this elink
elinkPar.fAsicNr = mapEntry.second; // ASIC number within module
- elinkPar.fTimeOffset = fSystemTimeOffset[fles::SubsystemIdentifier::STS];
+ elinkPar.fTimeOffset = fSystemTimeOffset[Subsystem::STS];
elinkPar.fAdcOffset = 1.;
elinkPar.fAdcGain = 1.;
if (fApplyWalkCorrection) elinkPar.fWalk = fStsConfig.WalkMap(elinkPar.fAddress, elinkPar.fAsicNr);
@@ -270,7 +271,7 @@ namespace cbm::algo
for (size_t elink = 0; elink < numElinks; elink++) {
UnpackMuchElinkPar elinkPar;
elinkPar.fAddress = fMuchConfig.Map(equip, elink); // Vector of MUCH addresses for this elink
- elinkPar.fTimeOffset = fSystemTimeOffset[fles::SubsystemIdentifier::MUCH];
+ elinkPar.fTimeOffset = fSystemTimeOffset[Subsystem::MUCH];
par->fElinkParams.push_back(elinkPar);
}
fAlgoMuch[equip].SetParams(std::move(par));
@@ -285,7 +286,7 @@ namespace cbm::algo
for (size_t elink = 0; elink < numElinks; elink++) {
UnpackTofElinkPar elinkPar;
elinkPar.fChannelUId = fTofConfig.Map(equip, elink); // Vector of TOF addresses for this elink
- elinkPar.fTimeOffset = fSystemTimeOffset[fles::SubsystemIdentifier::RPC];
+ elinkPar.fTimeOffset = fSystemTimeOffset[Subsystem::TOF];
par->fElinkParams.push_back(elinkPar);
}
fAlgoTof[equip].SetParams(std::move(par));
@@ -300,7 +301,7 @@ namespace cbm::algo
for (size_t elink = 0; elink < numElinks; elink++) {
UnpackBmonElinkPar elinkPar;
elinkPar.fChannelUId = fBmonConfig.Map(equip, elink); // Vector of T0 addresses for this elink
- elinkPar.fTimeOffset = fSystemTimeOffset[fles::SubsystemIdentifier::T0];
+ elinkPar.fTimeOffset = fSystemTimeOffset[Subsystem::T0];
par->fElinkParams.push_back(elinkPar);
}
fAlgoBmon[equip].SetParams(std::move(par));
@@ -315,7 +316,7 @@ namespace cbm::algo
for (auto const& val : compMap) {
uint32_t address = val.first;
par->fElinkParams[address].fToTshift = val.second;
- par->fElinkParams[address].fTimeOffset = fSystemTimeOffset[fles::SubsystemIdentifier::RICH];
+ par->fElinkParams[address].fTimeOffset = fSystemTimeOffset[Subsystem::RICH];
}
fAlgoRich[equip].SetParams(std::move(par));
L_(info) << "--- Configured equipment " << equip << " with " << fRichConfig.GetNumElinks(equip) << " elinks";
@@ -337,7 +338,7 @@ namespace cbm::algo
auto addresses = fTrdConfig.Map(equip, crob, elink);
elinkPar.fAddress = addresses.first; // Asic address for this elink
elinkPar.fChanAddress = addresses.second; // Channel addresses for this elink
- elinkPar.fTimeOffset = fSystemTimeOffset[fles::SubsystemIdentifier::TRD];
+ elinkPar.fTimeOffset = fSystemTimeOffset[Subsystem::TRD];
crobPar.fElinkParams.push_back(elinkPar);
}
par->fCrobParams.push_back(crobPar);
@@ -366,7 +367,7 @@ namespace cbm::algo
asicPar.fChanParams.push_back(chanPar);
}
auto comppars = fTrd2dConfig.CompMap(equip);
- par->fSystemTimeOffset = fSystemTimeOffset[fles::SubsystemIdentifier::TRD2D];
+ par->fSystemTimeOffset = fSystemTimeOffset[Subsystem::TRD2D];
par->fModId = comppars.first;
par->fCrobId = comppars.second;
par->fAsicParams.push_back(asicPar);
diff --git a/algo/unpack/Unpack.h b/algo/unpack/Unpack.h
index 081914a0bf7d415a10c1b03242c1e8d9a3882d34..795169109e0c769dcc3532f1ebf2fc7e200b0222 100644
--- a/algo/unpack/Unpack.h
+++ b/algo/unpack/Unpack.h
@@ -71,6 +71,7 @@ namespace cbm::algo
public:
typedef std::pair<CbmDigiTimeslice, UnpackMonitorData> resultType;
+ using Subsystem = fles::Subsystem;
/** @brief Algorithm execution
** @param fles timeslice to unpack
@@ -115,19 +116,19 @@ namespace cbm::algo
* @param subIds: vector of subsystem identifiers to unpack, default: all
* @see Init()
**/
- void Init(std::vector<fles::SubsystemIdentifier> subIds = {
- fles::SubsystemIdentifier::STS,
- fles::SubsystemIdentifier::MUCH,
- fles::SubsystemIdentifier::RPC,
- fles::SubsystemIdentifier::T0,
- fles::SubsystemIdentifier::TRD,
- fles::SubsystemIdentifier::TRD2D,
- fles::SubsystemIdentifier::RICH,
+ void Init(std::vector<fles::Subsystem> subIds = {
+ Subsystem::STS,
+ Subsystem::MUCH,
+ Subsystem::TOF,
+ Subsystem::T0,
+ Subsystem::TRD,
+ Subsystem::TRD2D,
+ Subsystem::RICH,
});
- bool DetectorEnabled(fles::SubsystemIdentifier subId)
+ bool DetectorEnabled(Subsystem subsystem)
{
- return std::find(fSubIds.begin(), fSubIds.end(), subId) != fSubIds.end();
+ return std::find(fSubsystems.begin(), fSubsystems.end(), subsystem) != fSubsystems.end();
}
private: // methods
@@ -139,11 +140,11 @@ namespace cbm::algo
/** @brief Parallel microslice loop **/
template<class Digi, class UnpackAlgo, class Monitor>
- void ParallelMsLoop(const fles::SubsystemIdentifier sysId, std::vector<Digi>& digisOut,
+ void ParallelMsLoop(const Subsystem subsystem, std::vector<Digi>& digisOut,
std::vector<Monitor>& monitor, const fles::Timeslice& ts,
const std::map<u16, UnpackAlgo>& algos, u8 sys_ver);
- std::pair<size_t, size_t> ParallelInit(const fles::Timeslice& ts, fles::SubsystemIdentifier sysId,
+ std::pair<size_t, size_t> ParallelInit(const fles::Timeslice& ts, Subsystem subsystem,
std::vector<u16>& eqIds, std::vector<fles::MicrosliceDescriptor>& msDesc,
std::vector<const u8*>& msContent);
@@ -154,7 +155,7 @@ namespace cbm::algo
private: // members
bool fApplyWalkCorrection = true; ///< Apply walk correction
- std::vector<fles::SubsystemIdentifier> fSubIds = {}; ///< Detector identifiers to unpack
+ std::vector<Subsystem> fSubsystems = {}; ///< Detector identifiers to unpack
/** @brief STS unpackers **/
std::map<uint16_t, UnpackSts> fAlgoSts = {};
@@ -178,11 +179,11 @@ namespace cbm::algo
std::map<uint16_t, UnpackRich> fAlgoRich = {};
/** @brief System time offsets **/
- std::map<fles::SubsystemIdentifier, int32_t> fSystemTimeOffset = {
- {fles::SubsystemIdentifier::STS, -970}, {fles::SubsystemIdentifier::MUCH, -980},
- {fles::SubsystemIdentifier::RICH, 100}, {fles::SubsystemIdentifier::RPC, 40},
- {fles::SubsystemIdentifier::T0, 0}, {fles::SubsystemIdentifier::TRD, 1300},
- {fles::SubsystemIdentifier::TRD2D, -510}};
+ std::map<Subsystem, int32_t> fSystemTimeOffset = {
+ {Subsystem::STS, -970}, {Subsystem::MUCH, -980},
+ {Subsystem::RICH, 100}, {Subsystem::TOF, 40},
+ {Subsystem::T0, 0}, {Subsystem::TRD, 1300},
+ {Subsystem::TRD2D, -510}};
};
} // namespace cbm::algo
diff --git a/algo/unpack/UnpackChain.cxx b/algo/unpack/UnpackChain.cxx
index 7263bcf754663f3c49b8e7982ca25be8ce23e95b..82fd6f76ad790137464085167919c910c59c1575 100644
--- a/algo/unpack/UnpackChain.cxx
+++ b/algo/unpack/UnpackChain.cxx
@@ -9,12 +9,12 @@ void UnpackChain::Init()
{
// Disable walk correction for now. 2022 data crashes unpacker with hardcoded 2021 params.
fUnpack.SetApplyWalkCorrection(true);
- fUnpack.Init(std::vector<fles::SubsystemIdentifier> {
- fles::SubsystemIdentifier::STS,
- // fles::SubsystemIdentifier::MUCH,
- fles::SubsystemIdentifier::RPC, fles::SubsystemIdentifier::T0,
- // fles::SubsystemIdentifier::TRD,
- // fles::SubsystemIdentifier::TRD2D,
+ fUnpack.Init(std::vector<fles::Subsystem> {
+ fles::Subsystem::STS,
+ // fles::Subsystem::MUCH,
+ fles::Subsystem::TOF, fles::Subsystem::T0,
+ // fles::Subsystem::TRD,
+ // fles::Subsystem::TRD2D,
});
}
diff --git a/external/InstallFlesnet.cmake b/external/InstallFlesnet.cmake
index 77dbfd3a1b0bea821048c678f412555294489c2f..02a72d36275ffd6b4b1066cc3e2910fda2672a41 100644
--- a/external/InstallFlesnet.cmake
+++ b/external/InstallFlesnet.cmake
@@ -3,7 +3,7 @@
# The included libraries provide the interface to the experiment data in timeslices
# both online and in timeslice archive (.tsa) files.
-set(FLESNET_VERSION 9f18207773bba0c27689a904f900e893745b4ed8) # 2022-07-29
+set(FLESNET_VERSION 7d8bb6819671e9718da8cce052d9c070fe0c9cfc) # 2023-07-04
set(FLESNET_SRC_URL "https://github.com/cbm-fles/flesnet")
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmPulser.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmPulser.cxx
index 70e138af0f559785ac0cf95d47977a5de6569887..e4bf3ba76ca308c77d698debf6150d84e07c9d09 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmPulser.cxx
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmPulser.cxx
@@ -196,12 +196,12 @@ Bool_t CbmMcbm2018MonitorMcbmPulser::ReInitContainers()
void CbmMcbm2018MonitorMcbmPulser::AddMsComponentToList(size_t component, UShort_t usDetectorId)
{
switch (usDetectorId) {
- case 0x10: //fles::SubsystemIdentifier::STS:
+ case 0x10: //fles::Subsystem::STS:
{
AddMsComponentToListSts(component);
break;
} // case 0x10:
- case 0x60: //fles::SubsystemIdentifier::RPC:
+ case 0x60: //fles::Subsystem::TOF:
{
AddMsComponentToListTof(component);
break;
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmRate.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmRate.cxx
index 955fef0c0ff196d4487b7687435ad8846f048b80..0ae6457883f92acd65c2ebf4edd574babf80ea7f 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmRate.cxx
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmRate.cxx
@@ -208,12 +208,12 @@ Bool_t CbmMcbm2018MonitorMcbmRate::ReInitContainers()
void CbmMcbm2018MonitorMcbmRate::AddMsComponentToList(size_t component, UShort_t usDetectorId)
{
switch (usDetectorId) {
- case 0x10: //fles::SubsystemIdentifier::STS:
+ case 0x10: //fles::Subsystem::STS:
{
AddMsComponentToListSts(component);
break;
} // case 0x10:
- case 0x60: //fles::SubsystemIdentifier::RPC:
+ case 0x60: //fles::Subsystem::TOF:
{
AddMsComponentToListTof(component);
break;
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmSync.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmSync.cxx
index dfa5ed7e4a3503841c88add58081b080adca368e..1d504609113dee0a9ca70765a71f14e051578e44 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmSync.cxx
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMcbmSync.cxx
@@ -208,12 +208,12 @@ Bool_t CbmMcbm2018MonitorMcbmSync::ReInitContainers()
void CbmMcbm2018MonitorMcbmSync::AddMsComponentToList(size_t component, UShort_t usDetectorId)
{
switch (usDetectorId) {
- case 0x10: //fles::SubsystemIdentifier::STS:
+ case 0x10: //fles::Subsystem::STS:
{
AddMsComponentToListSts(component);
break;
} // case 0x10:
- case 0x60: //fles::SubsystemIdentifier::RPC:
+ case 0x60: //fles::Subsystem::TOF:
{
AddMsComponentToListTof(component);
break;
diff --git a/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerTaskTrdR.cxx b/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerTaskTrdR.cxx
index 655ffeface45a11ba1ac51f17c42870e8ca48932..f3f395f661cfb873010806fb2d89e08bd94a9749 100644
--- a/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerTaskTrdR.cxx
+++ b/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerTaskTrdR.cxx
@@ -23,7 +23,7 @@ CbmMcbm2018UnpackerTaskTrdR::CbmMcbm2018UnpackerTaskTrdR()
, fbWriteOutput(kTRUE)
, fbDebugWriteOutput(kFALSE)
, fbBaselineAvg(kFALSE)
- , fSystemIdentifier((std::uint8_t) fles::SubsystemIdentifier::TRD)
+ , fSystemIdentifier((std::uint8_t) fles::Subsystem::TRD)
, fdMsSizeInNs(1.28e6) // default value corresponds to mCbm 2020 value
, fMonitorHistoFileName("")
, fIsActiveHistoVec(CbmMcbm2018UnpackerAlgoTrdR::kEndDefinedHistos, false)
diff --git a/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerTaskTrdR.h b/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerTaskTrdR.h
index bd86e06791388d168ab9be3645b2489e20a1c30f..3892a614b7e4080f46e3298b31133c2d84e6a7a2 100644
--- a/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerTaskTrdR.h
+++ b/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerTaskTrdR.h
@@ -105,7 +105,7 @@ private:
Bool_t fbDebugWriteOutput; ///< If ON the output vector of raw messages is filled and written to disk.
Bool_t fbDebugSortOutput = kTRUE; ///< If ON the output vector of raw messages is sorted in time.
Bool_t fbBaselineAvg; ///< Set to true if Baseline Averaging is activated in Spadic.
- std::uint8_t fSystemIdentifier; ///< by default set to: fles::SubsystemIdentifier::TRD, changable via setter
+ std::uint8_t fSystemIdentifier; ///< by default set to: fles::Subsystem::TRD, changable via setter
Double_t
fdMsSizeInNs; ///< microslice size in ns to be passed to the unpacker // TODO handle this with asic parameter files
diff --git a/reco/mq/CbmDevUnpack.cxx b/reco/mq/CbmDevUnpack.cxx
index 7f015c7f09384b98c1e56bd9d257efa335df6c2d..a8c831c934d117e4061e55497c39fdaddc0b9712 100644
--- a/reco/mq/CbmDevUnpack.cxx
+++ b/reco/mq/CbmDevUnpack.cxx
@@ -244,9 +244,9 @@ CbmDigiTimeslice CbmDevUnpack::DoUnpack(const fles::Timeslice& timeslice)
TStopwatch compTimer;
compTimer.Start();
- auto systemId = static_cast<fles::SubsystemIdentifier>(timeslice.descriptor(comp, 0).sys_id);
+ auto systemId = static_cast<fles::Subsystem>(timeslice.descriptor(comp, 0).sys_id);
- if (systemId == fles::SubsystemIdentifier::STS) {
+ if (systemId == fles::Subsystem::STS) {
const uint16_t equipmentId = timeslice.descriptor(comp, 0).eq_id;
const auto algoIt = fAlgoSts.find(equipmentId);
assert(algoIt != fAlgoSts.end());
@@ -276,7 +276,7 @@ CbmDigiTimeslice CbmDevUnpack::DoUnpack(const fles::Timeslice& timeslice)
numCompUsed++;
} // system STS
- if (systemId == fles::SubsystemIdentifier::MUCH) {
+ if (systemId == fles::Subsystem::MUCH) {
const uint16_t equipmentId = timeslice.descriptor(comp, 0).eq_id;
const auto algoIt = fAlgoMuch.find(equipmentId);
assert(algoIt != fAlgoMuch.end());
diff --git a/reco/steer/CbmRecoUnpack.cxx b/reco/steer/CbmRecoUnpack.cxx
index f82013ad34630761fcfc72e6b9b4d52cabf401d7..aa551236ee3011d1af980e5a8cce3e72ce12131b 100644
--- a/reco/steer/CbmRecoUnpack.cxx
+++ b/reco/steer/CbmRecoUnpack.cxx
@@ -32,6 +32,7 @@
#include <vector>
+using fles::Subsystem;
using fles::Timeslice;
using std::unique_ptr;
@@ -111,40 +112,40 @@ Bool_t CbmRecoUnpack::Init()
// --- Psd
if (fPsdConfig) {
fPsdConfig->InitOutput();
- RegisterOutputs(ioman, fPsdConfig); /// Framework bound work = kept in this Task
+ RegisterOutputs(ioman, fPsdConfig); /// Framework bound work = kept in this Task
fPsdConfig->SetAlgo();
initParContainers(fPsdConfig->GetParContainerRequest()); /// Framework bound work = kept in this Task
fPsdConfig->InitAlgo();
- initPerformanceMaps(fkFlesPsd, "PSD");
+ initPerformanceMaps(Subsystem::PSD, "PSD");
}
// --- Rich
if (fRichConfig) {
fRichConfig->InitOutput();
- RegisterOutputs(ioman, fRichConfig); /// Framework bound work = kept in this Task
+ RegisterOutputs(ioman, fRichConfig); /// Framework bound work = kept in this Task
fRichConfig->SetAlgo();
initParContainers(fRichConfig->GetParContainerRequest()); /// Framework bound work = kept in this Task
fRichConfig->InitAlgo();
- initPerformanceMaps(fkFlesRich, "RICH");
+ initPerformanceMaps(Subsystem::RICH, "RICH");
}
// --- Sts
if (fStsConfig) {
fStsConfig->InitOutput();
- RegisterOutputs(ioman, fStsConfig); /// Framework bound work = kept in this Task
+ RegisterOutputs(ioman, fStsConfig); /// Framework bound work = kept in this Task
fStsConfig->SetAlgo();
initParContainers(fStsConfig->GetParContainerRequest()); /// Framework bound work = kept in this Task
fStsConfig->InitAlgo();
- initPerformanceMaps(fkFlesSts, "STS");
+ initPerformanceMaps(Subsystem::STS, "STS");
}
// --- Much
if (fMuchConfig) {
fMuchConfig->InitOutput();
- RegisterOutputs(ioman, fMuchConfig); /// Framework bound work = kept in this Task
+ RegisterOutputs(ioman, fMuchConfig); /// Framework bound work = kept in this Task
fMuchConfig->SetAlgo();
initParContainers(fMuchConfig->GetParContainerRequest()); /// Framework bound work = kept in this Task
fMuchConfig->InitAlgo();
- initPerformanceMaps(fkFlesMuch, "MUCH");
+ initPerformanceMaps(Subsystem::MUCH, "MUCH");
}
@@ -153,19 +154,19 @@ Bool_t CbmRecoUnpack::Init()
fTofConfig->InitOutput();
RegisterOutputs(ioman, fTofConfig); /// Framework bound work = kept in this Task
fTofConfig->SetAlgo();
- fTofConfig->LoadParFileName(); /// Needed to change the Parameter file name before it is used!!!
+ fTofConfig->LoadParFileName(); /// Needed to change the Parameter file name before it is used!!!
initParContainers(fTofConfig->GetParContainerRequest()); /// Framework bound work = kept in this Task
fTofConfig->InitAlgo();
- initPerformanceMaps(fkFlesTof, "TOF");
+ initPerformanceMaps(Subsystem::TOF, "TOF");
}
// --- Trd
if (fTrd1DConfig) {
fTrd1DConfig->InitOutput();
- RegisterOutputs(ioman, fTrd1DConfig); /// Framework bound work = kept in this Task
+ RegisterOutputs(ioman, fTrd1DConfig); /// Framework bound work = kept in this Task
fTrd1DConfig->SetAlgo();
initParContainers(fTrd1DConfig->GetParContainerRequest()); /// Framework bound work = kept in this Task
fTrd1DConfig->InitAlgo();
- initPerformanceMaps(fkFlesTrd, "TRD1D");
+ initPerformanceMaps(Subsystem::TRD, "TRD1D");
}
// --- TRD2D
if (fTrd2DConfig) {
@@ -180,7 +181,7 @@ Bool_t CbmRecoUnpack::Init()
fTrd2DConfig->SetAlgo();
initParContainers(fTrd2DConfig->GetParContainerRequest()); /// Framework bound work = kept in this Task
fTrd2DConfig->InitAlgo();
- initPerformanceMaps(fkFlesTrd2D, "TRD2D");
+ initPerformanceMaps(Subsystem::TRD2D, "TRD2D");
}
// This is an ugly work around, because the TRD and TRD2D want to access the same vector and there is no
// function to retrieve a writeable vector<obj> from the FairRootManager, especially before the branches
@@ -193,10 +194,10 @@ Bool_t CbmRecoUnpack::Init()
fBmonConfig->InitOutput();
RegisterOutputs(ioman, fBmonConfig); /// Framework bound work = kept in this Task
fBmonConfig->SetAlgo();
- fBmonConfig->LoadParFileName(); /// Needed to change the Parameter file name before it is used!!!
+ fBmonConfig->LoadParFileName(); /// Needed to change the Parameter file name before it is used!!!
initParContainers(fBmonConfig->GetParContainerRequest()); /// Framework bound work = kept in this Task
fBmonConfig->InitAlgo();
- initPerformanceMaps(fkFlesBmon, "Bmon");
+ initPerformanceMaps(Subsystem::T0, "Bmon");
}
if (fDoPerfProfPerTs) {
@@ -229,33 +230,33 @@ Bool_t CbmRecoUnpack::Init()
// ----- initPerformanceMaps ----------------------------------------------
-void CbmRecoUnpack::initPerformanceMaps(std::uint16_t subsysid, std::string name)
+void CbmRecoUnpack::initPerformanceMaps(Subsystem subsystem, std::string name)
{
if (fDoPerfProf) {
- fNameMap.emplace(std::make_pair(subsysid, std::make_pair(name, 0)));
- fTimeMap.emplace(std::make_pair(subsysid, std::make_pair(0, 0)));
- fDataSizeMap.emplace(std::make_pair(subsysid, std::make_pair(0, 0)));
+ fNameMap.emplace(std::make_pair(subsystem, std::make_pair(name, 0)));
+ fTimeMap.emplace(std::make_pair(subsystem, std::make_pair(0, 0)));
+ fDataSizeMap.emplace(std::make_pair(subsystem, std::make_pair(0, 0)));
}
if (fDoPerfProfPerTs) {
- fNameMapPerTs.emplace(std::make_pair(subsysid, std::make_pair(name, 0)));
- fTimeMapPerTs.emplace(std::make_pair(subsysid, std::make_pair(0, 0)));
- fDataSizeMapPerTs.emplace(std::make_pair(subsysid, std::make_pair(0, 0)));
+ fNameMapPerTs.emplace(std::make_pair(subsystem, std::make_pair(name, 0)));
+ fTimeMapPerTs.emplace(std::make_pair(subsystem, std::make_pair(0, 0)));
+ fDataSizeMapPerTs.emplace(std::make_pair(subsystem, std::make_pair(0, 0)));
if (fPublishProfMoni) { //
- fDataSizeMapCurrSec.emplace(std::make_pair(subsysid, std::make_pair(0, 0)));
+ fDataSizeMapCurrSec.emplace(std::make_pair(subsystem, std::make_pair(0, 0)));
}
fvhInpRatioPerTs.emplace(std::make_pair(
- subsysid,
+ subsystem,
new TH1D(Form("hInpRatioPerTs%s", name.c_str()),
Form("ratio of input data size in total input data size vs TS for %s; TS; Size Ratio []", name.c_str()),
6000, 0, 6000)));
fvhOutRatioPerTs.emplace(std::make_pair(
- subsysid,
+ subsystem,
new TH1D(Form("hOutRatioPerTs%s", name.c_str()),
Form("ratio of unpacked digi size in total output size vs TS for %s; TS; Size Ratio []", name.c_str()),
6000, 0, 6000)));
fvhUnpRatioPerTs.emplace(std::make_pair(
- subsysid,
+ subsystem,
new TH1D(Form("hUnpRatioPerTs%s", name.c_str()),
Form("ratio of unpacked digi size to raw data size vs TS for %s; TS; O/I Size Ratio []", name.c_str()),
6000, 0, 6000)));
@@ -495,68 +496,69 @@ void CbmRecoUnpack::Unpack(unique_ptr<Timeslice> ts)
for (uint64_t component = 0; component < nComponents; component++) {
- auto systemId = static_cast<std::uint16_t>(ts->descriptor(component, 0).sys_id);
+ auto subsystem = static_cast<Subsystem>(ts->descriptor(component, 0).sys_id);
- switch (systemId) {
- case fkFlesMuch: {
+ switch (subsystem) {
+ case Subsystem::MUCH: {
if (fMuchConfig) {
- fCbmTsEventHeader->AddNDigisMuch(unpack(systemId, ×lice, component, fMuchConfig,
+ fCbmTsEventHeader->AddNDigisMuch(unpack(subsystem, ×lice, component, fMuchConfig,
fMuchConfig->GetOptOutAVec(), fMuchConfig->GetOptOutBVec()));
}
break;
}
- case fkFlesPsd: {
+ case Subsystem::PSD: {
if (fPsdConfig) {
- fCbmTsEventHeader->AddNDigisPsd(unpack(systemId, ×lice, component, fPsdConfig,
+ fCbmTsEventHeader->AddNDigisPsd(unpack(subsystem, ×lice, component, fPsdConfig,
fPsdConfig->GetOptOutAVec(), fPsdConfig->GetOptOutBVec()));
}
break;
}
- case fkFlesRich: {
+ case Subsystem::RICH: {
if (fRichConfig) {
- fCbmTsEventHeader->AddNDigisRich(unpack(systemId, ×lice, component, fRichConfig,
+ fCbmTsEventHeader->AddNDigisRich(unpack(subsystem, ×lice, component, fRichConfig,
fRichConfig->GetOptOutAVec(), fRichConfig->GetOptOutBVec()));
}
break;
}
- case fkFlesSts: {
+ case Subsystem::STS: {
if (fStsConfig) {
- fCbmTsEventHeader->AddNDigisSts(unpack(systemId, ×lice, component, fStsConfig,
+ fCbmTsEventHeader->AddNDigisSts(unpack(subsystem, ×lice, component, fStsConfig,
fStsConfig->GetOptOutAVec(), fStsConfig->GetOptOutBVec()));
}
break;
}
- case fkFlesTof: {
+ case Subsystem::TOF: {
if (fTofConfig) {
- fCbmTsEventHeader->AddNDigisTof(unpack(systemId, ×lice, component, fTofConfig,
+ fCbmTsEventHeader->AddNDigisTof(unpack(subsystem, ×lice, component, fTofConfig,
fTofConfig->GetOptOutAVec(), fTofConfig->GetOptOutBVec()));
}
break;
}
- case fkFlesTrd: {
+ case Subsystem::TRD: {
if (fTrd1DConfig) {
- fCbmTsEventHeader->AddNDigisTrd1D(unpack(systemId, ×lice, component, fTrd1DConfig,
+ fCbmTsEventHeader->AddNDigisTrd1D(unpack(subsystem, ×lice, component, fTrd1DConfig,
fTrd1DConfig->GetOptOutAVec(), fTrd1DConfig->GetOptOutBVec()));
}
break;
}
- case fkFlesTrd2D: {
+ case Subsystem::TRD2D: {
if (fTrd2DConfig) {
- fCbmTsEventHeader->AddNDigisTrd2D(unpack(systemId, ×lice, component, fTrd2DConfig,
+ fCbmTsEventHeader->AddNDigisTrd2D(unpack(subsystem, ×lice, component, fTrd2DConfig,
fTrd2DConfig->GetOptOutAVec(), fTrd2DConfig->GetOptOutBVec()));
}
break;
}
- case fkFlesBmon: {
+ case Subsystem::T0: {
if (fBmonConfig) {
- fCbmTsEventHeader->AddNDigisBmon(unpack(systemId, ×lice, component, fBmonConfig,
+ fCbmTsEventHeader->AddNDigisBmon(unpack(subsystem, ×lice, component, fBmonConfig,
fBmonConfig->GetOptOutAVec(), fBmonConfig->GetOptOutBVec()));
}
break;
}
default: {
- if (fDoDebugPrints) LOG(error) << "Unpack: Unknown system ID " << systemId << " for component " << component;
+ if (fDoDebugPrints)
+ LOG(error) << "Unpack: Unknown subsystem " << fles::to_string(subsystem) << " for component " << component;
break;
}
}
diff --git a/reco/steer/CbmRecoUnpack.h b/reco/steer/CbmRecoUnpack.h
index 89e0c6303a37cf7b5600bf6e90dfa074affdd004..4533077c7750011825c4ca2d69596e10841fc802 100644
--- a/reco/steer/CbmRecoUnpack.h
+++ b/reco/steer/CbmRecoUnpack.h
@@ -178,15 +178,7 @@ public:
void Unpack(std::unique_ptr<fles::Timeslice> ts);
private:
- static constexpr std::uint16_t fkFlesMvd = static_cast<std::uint16_t>(fles::SubsystemIdentifier::MVD);
- static constexpr std::uint16_t fkFlesSts = static_cast<std::uint16_t>(fles::SubsystemIdentifier::STS);
- static constexpr std::uint16_t fkFlesRich = static_cast<std::uint16_t>(fles::SubsystemIdentifier::RICH);
- static constexpr std::uint16_t fkFlesPsd = static_cast<std::uint16_t>(fles::SubsystemIdentifier::PSD);
- static constexpr std::uint16_t fkFlesMuch = static_cast<std::uint16_t>(fles::SubsystemIdentifier::MUCH);
- static constexpr std::uint16_t fkFlesTrd = static_cast<std::uint16_t>(fles::SubsystemIdentifier::TRD);
- static constexpr std::uint16_t fkFlesTrd2D = static_cast<std::uint16_t>(fles::SubsystemIdentifier::TRD2D);
- static constexpr std::uint16_t fkFlesTof = static_cast<std::uint16_t>(fles::SubsystemIdentifier::RPC);
- static constexpr std::uint16_t fkFlesBmon = static_cast<std::uint16_t>(fles::SubsystemIdentifier::T0);
+ using Subsystem = fles::Subsystem;
/** @brief Flag if extended debug output is to be printed or not*/
bool fDoDebugPrints = false; //!
@@ -206,39 +198,39 @@ private:
/** @brief Flag if perf data should be published to moni DB using data time (false) or processing time (true).*/
bool fPubMoniProcTime = true;
- /** @brief Map to store a name for the unpackers and the processed amount of digis, key = fkFlesId*/
- std::map<std::uint16_t, std::pair<std::string, size_t>> fNameMap = {}; //!
+ /** @brief Map to store a name for the unpackers and the processed amount of digis, key = Subsystem */
+ std::map<Subsystem, std::pair<std::string, size_t>> fNameMap = {}; //!
- /** @brief Map to store the cpu and wall time, key = fkFlesId*/
- std::map<std::uint16_t, std::pair<double, double>> fTimeMap = {}; //!
+ /** @brief Map to store the cpu and wall time, key = Subsystem */
+ std::map<Subsystem, std::pair<double, double>> fTimeMap = {}; //!
- /** @brief Map to store the in and out data amount, key = fkFlesId*/
- std::map<std::uint16_t, std::pair<double, double>> fDataSizeMap = {}; //!
+ /** @brief Map to store the in and out data amount, key = Subsystem */
+ std::map<Subsystem, std::pair<double, double>> fDataSizeMap = {}; //!
- /** @brief Map to store a name for the unpackers and the processed amount of digis for a single TS, key = fkFlesId*/
- std::map<std::uint16_t, std::pair<std::string, size_t>> fNameMapPerTs = {}; //!
+ /** @brief Map to store a name for the unpackers and the processed amount of digis for a single TS, key = Subsystem */
+ std::map<Subsystem, std::pair<std::string, size_t>> fNameMapPerTs = {}; //!
- /** @brief Map to store the cpu and wall time for a single TS, key = fkFlesId*/
- std::map<std::uint16_t, std::pair<double, double>> fTimeMapPerTs = {}; //!
+ /** @brief Map to store the cpu and wall time for a single TS, key = Subsystem */
+ std::map<Subsystem, std::pair<double, double>> fTimeMapPerTs = {}; //!
- /** @brief Map to store the in and out data amount for a single TS, key = fkFlesId*/
- std::map<std::uint16_t, std::pair<double, double>> fDataSizeMapPerTs = {}; //!
+ /** @brief Map to store the in and out data amount for a single TS, key = Subsystem */
+ std::map<Subsystem, std::pair<double, double>> fDataSizeMapPerTs = {}; //!
TStopwatch* fTimerTs = nullptr;
TH1* fhCpuTimePerTs = nullptr; //! Processing time per TS
TH1* fhRealTimePerTs = nullptr; //! Processing time per TS
TH1* fhCpuTimePerTsHist = nullptr; //! Plotting time per TS
TH1* fhRealTimePerTsHist = nullptr; //! Plotting time per TS
- std::map<std::uint16_t, TH1*> fvhInpRatioPerTs = {}; //! ratio of system data in total input size vs TS in run
- std::map<std::uint16_t, TH1*> fvhOutRatioPerTs = {}; //! ratio of system digi size in total output size vs TS in run
- std::map<std::uint16_t, TH1*> fvhUnpRatioPerTs = {}; //! ratio of selected digi vs TS in run
+ std::map<Subsystem, TH1*> fvhInpRatioPerTs = {}; //! ratio of system data in total input size vs TS in run
+ std::map<Subsystem, TH1*> fvhOutRatioPerTs = {}; //! ratio of system digi size in total output size vs TS in run
+ std::map<Subsystem, TH1*> fvhUnpRatioPerTs = {}; //! ratio of selected digi vs TS in run
TH1* fhUnpackingRatioPerTs = nullptr; //! ratio of total unpacked size to input size vs TS in run
std::unique_ptr<cbm::Monitor> fMonitor; //! The application's monitoring object
std::string fMoniCurrrentHostname = "";
std::string fMoniJobId = "";
std::chrono::system_clock::time_point fMonitorSecCurrentTs = std::chrono::system_clock::time_point(); //!
- std::map<std::uint16_t, std::pair<double, double>> fDataSizeMapCurrSec = {}; //!
+ std::map<Subsystem, std::pair<double, double>> fDataSizeMapCurrSec = {}; //!
/** @brief Run the performance profiling based on the fTimeMap and fDataSizeMap members. */
void performanceProfiling();
@@ -249,10 +241,10 @@ private:
/**
* @brief Init the performance profiling maps for a given unpacker
*
- * @param subsysid Subsystem Identifier casted to std::uint16_t
+ * @param subsystem Subsystem as assigned during readout
* @param name Name of the unpacker
*/
- void initPerformanceMaps(std::uint16_t subsysid, std::string name);
+ void initPerformanceMaps(Subsystem subsystem, std::string name);
template<class TConfig>
@@ -349,7 +341,7 @@ private:
* @return std::pair<ndigis, std::pair<cputime, walltime>>
*/
template<class TConfig, class TOptOutA = std::nullptr_t, class TOptOutB = std::nullptr_t>
- size_t unpack(const std::uint16_t subsysid, const fles::Timeslice* ts, std::uint16_t icomp, TConfig config,
+ size_t unpack(const Subsystem subsystem, const fles::Timeslice* ts, std::uint16_t icomp, TConfig config,
std::vector<TOptOutA>* optouttargetvecA = nullptr, std::vector<TOptOutB>* optouttargetvecB = nullptr)
{
@@ -414,27 +406,27 @@ private:
<< "this timeslice.";
if (fDoPerfProf) {
- auto timeit = fTimeMap.find(subsysid);
+ auto timeit = fTimeMap.find(subsystem);
timeit->second.first += cputime;
timeit->second.second += walltime;
- auto datait = fDataSizeMap.find(subsysid);
+ auto datait = fDataSizeMap.find(subsystem);
datait->second.first += ts->size_component(icomp) / 1.0e6;
datait->second.second += nDigis * algo->GetOutputObjSize() / 1.0e6;
- fNameMap.find(subsysid)->second.second += nDigis;
+ fNameMap.find(subsystem)->second.second += nDigis;
}
if (fDoPerfProfPerTs) {
- auto timeit = fTimeMapPerTs.find(subsysid);
+ auto timeit = fTimeMapPerTs.find(subsystem);
timeit->second.first += cputime;
timeit->second.second += walltime;
- auto datait = fDataSizeMapPerTs.find(subsysid);
+ auto datait = fDataSizeMapPerTs.find(subsystem);
datait->second.first += ts->size_component(icomp) / 1.0e6;
datait->second.second += nDigis * algo->GetOutputObjSize() / 1.0e6;
- fNameMapPerTs.find(subsysid)->second.second += nDigis;
+ fNameMapPerTs.find(subsystem)->second.second += nDigis;
}
return nDigis;