9#include <trg/cdc/modules/unpacker/CDCTriggerUnpackerModule.h>
10#include <framework/core/ModuleParam.templateDetails.h>
11#include <trg/cdc/dbobjects/CDCTriggerNeuroConfig.h>
20using namespace CDCTriggerUnpacker;
33using dataWord = std::bitset<wordWidth>;
57 unsigned inEventWidth,
unsigned inOffset,
58 int inHeaderSize,
const std::vector<int>& inNodeID,
const std::vector<int>& inNodeID_pcie40,
59 unsigned inNInnerMergers,
int& inDelay,
63 inHeaderSize, inNodeID, inNodeID_pcie40, inDelay, inCnttrg, inDebugLevel),
72 void reserve(
int subDetectorId, std::array<int, nFinesse> nWords,
bool pciedata)
override
84 if (subDetectorId != iNode_i) {
91 size_t entries =
arrayPtr->getEntries();
93 for (
unsigned i = 0; i < nClocks; ++i) {
96 B2DEBUG(20,
name <<
": " << nClocks <<
" clocks");
97 }
else if (entries != nClocks) {
98 B2DEBUG(20,
"Number of clocks in " <<
name <<
" conflicts with others!");
104 std::array<int*, 48> data32tab,
105 std::array<int, 48> nWords,
106 bool pciedata)
override
118 if (subDetectorId != iNode_i) {
122 B2DEBUG(20,
"The module " <<
name <<
" does not have enough data (" <<
123 nWords[iFinesse_i] <<
"). Nothing will be unpacked.");
131 auto mergerClock = (*arrayPtr)[iclock];
132 B2DEBUG(100,
"clock " << iclock);
137 dataWord word(data32tab[iFinesse_i][i + j]);
139 mergerClock->m_signal[iMerger].set(pos *
wordWidth + k, word[k]);
148 for (
int i = 0; i < std::accumulate(nMergers.begin(), nMergers.end(), 0); ++i) {
149 B2DEBUG(99, (*
arrayPtr)[0]->m_signal[i].to_string());
159 const std::string& inName,
unsigned inEventWidth,
unsigned inOffset,
160 unsigned inHeaderSize,
const std::vector<int>& inNodeID,
const std::vector<int>& inNodeID_pcie40,
161 unsigned inNumTS,
int& inDelay,
164 SubTrigger(inName, inEventWidth, inOffset /
wordWidth, inHeaderSize, inNodeID, inNodeID_pcie40,
165 inDelay, inCnttrg, inDebugLevel),
167 iTracker(
std::stoul(inName.substr(inName.length() - 1))),
189 void reserve(
int subDetectorId, std::array<int, nFinesse> nWords,
bool pciedata)
override
203 if (subDetectorId == iNode_i) {
205 for (
unsigned i = 0; i < nClocks; ++i) {
209 for (
unsigned j = 0; j < nTrackers; ++j) {
210 for (
unsigned iAxialTSF = 0; iAxialTSF < nAxialTSF; ++iAxialTSF) {
211 inputClock->
m_signal[iAxialTSF][j].fill(zero_val);
213 outputClock->
m_signal.at(j).fill(zero_val);
216 B2DEBUG(20,
name <<
": " << nClocks <<
" clocks");
217 }
else if (entries != nClocks) {
218 B2DEBUG(20,
"Number of clocks in " <<
name <<
" conflicts with others!");
232 std::array<int*, 48> data32tab,
233 std::array<int, 48> nWords,
234 bool pciedata)
override
246 if (subDetectorId != iNode_i) {
253 using halfDataWord = std::bitset<16>;
254 std::vector<halfDataWord> counters;
256 for (
int iclock = 0; iclock <
inputArrayPtr->getEntries(); ++iclock) {
257 counters.emplace_back(data32tab[iFinesse_i]
259 B2DEBUG(100,
"iclock " << iclock <<
" --> " << counters.at(iclock).to_ulong() <<
" : " << std::hex << counters.at(iclock));
261 bool counter_correct_error =
false;
262 while (counters.at(1).to_ulong() - counters.at(0).to_ulong() != 4) {
263 std::rotate(counters.begin(), counters.begin() + 1, counters.end());
272 B2DEBUG(90,
"PHYSJG: clock counter rotation over one cycle: " << ccShift);
273 for (
const auto& c : counters) {
274 B2DEBUG(90,
"" << c.to_ulong() <<
" : " << std::hex << c);
276 counter_correct_error =
true;
280 if (counter_correct_error) {
281 B2DEBUG(20,
"PHYSJG: " <<
name <<
" too many clock counter rotation corrections: " << ccShift <<
" data object skipped.");
285 if (! std::is_sorted(counters.begin(), counters.end(),
286 [](halfDataWord i, halfDataWord j) {
287 return (j.to_ulong() - i.to_ulong() == 4);
289 B2DEBUG(20,
"clock counters are still out of order");
290 for (
const auto& c : counters) {
291 B2DEBUG(90,
"" << c.to_ulong());
296 B2DEBUG(15,
"shifting the first " << ccShift <<
297 " clock(s) to the end for " <<
name);
308 auto inputClock = (*inputArrayPtr)[iclock];
309 auto outputClock = (*outputArrayPtr)[iclock];
311 outputClock->m_signal.at(
iTracker).fill(zero_val);
312 B2DEBUG(90,
"unpacker clock " << iclock);
318 std::array<dataWord, 2> ccword({
319 data32tab[iFinesse_i][i + 2], data32tab[iFinesse_i][i + 3]
323 for (
unsigned iTSF = 0; iTSF < nAxialTSF; ++iTSF) {
325 inputClock->m_signal[nAxialTSF - 1 - iTSF][
iTracker].fill(zero_val);
341 for (
unsigned pos = 0; pos < clockCounterWidth; ++pos) {
342 const int j = (pos + iTSF * clockCounterWidth) /
wordWidth;
343 const int k = (pos + iTSF * clockCounterWidth) %
wordWidth;
360 inputClock->m_signal[nAxialTSF - 1 - iTSF][
iTracker][pos] =
365 for (
unsigned pos = 0; pos <
numTS * lenTS; ++pos) {
368 dataWord word(data32tab[iFinesse_i][i + j]);
372 inputClock->m_signal[nAxialTSF - 1 - iTSF][
iTracker]
373 [clockCounterWidth + pos] = std_logic(word[
wordWidth - 1 - k]);
389 unsigned TSFWidth = clockCounterWidth +
numTS * lenTS;
390 for (
unsigned pos = 0; pos < TSFWidth; ++pos) {
393 dataWord word(data32tab[iFinesse_i][i + j]);
394 inputClock->m_signal[nAxialTSF - 1 - iTSF][
iTracker][pos] =
399 display_hex(inputClock->m_signal[nAxialTSF - 1 - iTSF][
iTracker]);
408 const int outputOffset = nAxialTSF *
numTS * lenTS;
409 const int oldtrackWidth = 6;
410 for (
unsigned pos = 0; pos < 732; ++pos) {
413 dataWord word(data32tab[iFinesse_i][i + j]);
414 outputClock->m_signal.at(
iTracker).at(clockCounterWidth + oldtrackWidth + pos)
425 for (
unsigned pos = 0; pos < T2DOutputWidth; ++pos) {
426 const int j = (pos + outputOffset) /
wordWidth;
427 const int k = (pos + outputOffset) %
wordWidth;
428 dataWord word(data32tab[iFinesse_i][i + j]);
430 outputClock->m_signal.at(
iTracker).at(clockCounterWidth + pos)
432 }
catch (
const std::out_of_range& e) {
433 B2DEBUG(20,
"Out-of-range access to outputClock->m_signal.at(iTracker).at(clockCounterWidth + pos)"
435 <<
LogVar(
"clockCounterWidth", clockCounterWidth)
442 display_hex(outputClock->m_signal.at(
iTracker));
449 template <
int bitw
idth,
typename T_bitstream>
453 const std::string& inName,
unsigned inEventWidth,
unsigned inOffset,
454 unsigned inHeaderSize,
const std::vector<int>& inNodeID,
const std::vector<int>& inNodeID_pcie40,
int& inDelay,
457 SubTrigger(inName, inEventWidth, inOffset /
wordWidth, inHeaderSize, inNodeID, inNodeID_pcie40,
458 inDelay, inCnttrg, inDebugLevel),
460 iTracker(
std::stoul(inName.substr(inName.length() - 1))),
470 void reserve(
int subDetectorId, std::array<int, nFinesse> nWords,
bool pciedata)
override
483 size_t entries =
ArrayPtr->getEntries();
484 if (subDetectorId == iNode_i) {
486 for (
unsigned i = 0; i < nClocks; ++i) {
487 T_bitstream* nnclock =
ArrayPtr->appendNew();
489 for (
unsigned j = 0; j < nTrackers; ++j) {
490 nnclock->m_signal[j].fill(zero_val);
493 B2DEBUG(20,
name <<
": " << nClocks <<
" clocks");
494 }
else if (entries != nClocks) {
495 B2DEBUG(20,
"Number of clocks in " <<
name <<
" conflicts with others!");
501 std::array<int*, nFinesse> data32tab,
502 std::array<int, nFinesse> nWords,
503 bool pciedata)
override
515 if (subDetectorId != iNode_i) {
522 auto nnclock = (*ArrayPtr)[iclock];
523 B2DEBUG(20,
"clock " << iclock);
529 for (
unsigned pos = 0; pos < bitwidth; ++pos) {
532 std::bitset<wordWidth> word(data32tab[iFinesse_i][i + j]);
536 display_hex(nnclock->m_signal[
iTracker]);
552 "whether to unpack merger data (recorded by Merger Reader / TSF)",
false);
554 "whether to unpack 2D tracker data",
false);
556 "whether to unpacker neurotrigger data",
false);
558 "flag to decode 2D finder track",
false);
560 "flag to decode input TS to 2D",
false);
562 "flag to decode neurotrigger data",
false);
572 "list of COPPER and HSLB ID of Merger reader (TSF)", defaultMergerNodeID);
580 "list of COPPER and HSLB ID of 2D tracker", defaultTracker2DNodeID);
581 NodeList defaultTracker2DNodeID_pcie40 = {
588 "list of PCIe40 ch ID of 2D tracker", defaultTracker2DNodeID_pcie40);
597 "list of COPPER and HSLB ID of neurotrigger", defaultNeuroNodeID);
598 NodeList defaultNeuroNodeID_pcie40 = {
605 "list of PCIe40 ch ID of neurotrigger", defaultNeuroNodeID_pcie40);
608 "number of words (number of bits / 32) of the B2L header", 3);
610 "Whether to align out-of-sync Belle2Link data between different sub-modules",
true);
612 "Use values stored in the payload of the ConditionsDB."
613 "This affects the output scaling of the Neurotrigger as well as the"
614 "bit configuration of its unpacker. If false, an old unpacker version with fixed scalings and old bit addresses is used.",
617 "Name for unpacked Neurotrack",
618 (std::string)
"CDCTriggerNeuroTracks");
620 "Name for unpacked Neurotrigger input all stereo TSs",
621 (std::string)
"CDCTriggerNNInputAllStereoSegmentHits");
623 "Name for unpacked Neurotrigger selected TSs",
624 (std::string)
"CDCTriggerNNInputSegmentHits");
626 "Name for unpacked Neurotrigger input 2d tracks",
627 (std::string)
"CDCTriggerNNInput2DFinderTracks");
629 "Name for unpacked Neurotrigger input ETF T0",
630 (std::string)
"CDCTriggerNeuroETFT0");
632 "Name for unpacked Neurotrigger scaled input",
633 (std::string)
"CDCTriggerNeuroTracksInput");
635 "Simulate 13 bit drift time by using 2d clock counter value.",
638 "flag to unpack DNN trigger data",
false);
640 "name of stored config, keep empty for neurotrigger config", (std::string)
"");
648 m_mergerBits.registerInDataStore(
"CDCTriggerMergerBits");
651 m_bitsTo2D.registerInDataStore(
"CDCTriggerTSFTo2DBits");
652 m_bits2DTo3D.registerInDataStore(
"CDCTrigger2DTo3DBits");
655 m_bitsDNN.registerInDataStore(
"CDCTriggerDNNBits");
656 m_bitsNN.registerInDataStore(
"CDCTriggerNNBits");
660 m_TSHits.registerInDataStore(
"CDCTriggerSegmentHits");
685 for (
int iSL = 0; iSL < 9; iSL += 2) {
687 const int nInnerMergers = std::accumulate(
nMergers.begin(),
689 B2DEBUG(20,
"in: " << nInnerMergers);
706 int datasize_2D = 64;
713 for (
int iTracker = 0; iTracker < 4; ++iTracker) {
717 "Tracker2D" + std::to_string(iTracker), datasize_2D, 82,
m_headerSize,
727 "Neuro" + std::to_string(iTracker), (
int)DNN_WIDTH / 32, 0,
m_headerSize,
733 "Neuro" + std::to_string(iTracker), (
int)NN_WIDTH / 32, 0,
m_headerSize,
752 m_exp = bevt->getExperiment();
753 m_run = bevt->getRun();
756 B2FATAL(
"CDCTriggerNeuroConfig is not valid.");
758 B2DEBUG(2,
"Load Neurotrigger configuration for network " << (*m_cdctriggerneuroconfig)->getNNName() <<
" from database ");
759 B2DEBUG(10, padright(
"Name", 50) << padright(
"start", 10) << padright(
"end", 10) << padright(
"offset", 10));
760 for (
auto x : (*m_cdctriggerneuroconfig)->getB2Format()) {
761 B2DEBUG(10, padright(x.name, 48) <<
": " << padright(std::to_string(x.start), 10) << padright(std::to_string(x.end),
762 10) << padright(std::to_string(x.offset), 10));
774 B2DEBUG(10, padright(
" ", 100));
775 B2DEBUG(10,
"----------------------------------------------------------------------------------------------------");
776 B2DEBUG(10, padright(
" ", 100));
778 std::string experimentstring =
"Experiment " + std::to_string(eventMetaData->getExperiment()) +
" Run " +
779 std::to_string(eventMetaData->getRun()) +
" Event " + std::to_string(eventMetaData->getEvent());
780 B2DEBUG(10, padright(experimentstring, 100));
785 B2DEBUG(20,
"exp<7: skip cdctrg unpacker for DQM");
790 B2DEBUG(99,
m_rawTriggers.getEntries() <<
" COPPERs in RawTRGs");
796 if (rawTRG.GetMaxNumOfCh(0) == 48) {
m_pciedata =
true; }
797 else if (rawTRG.GetMaxNumOfCh(0) == 4) {
m_pciedata =
false; }
798 else { B2FATAL(
"CDCTriggerUnpackerModule: Invalid value of GetMaxNumOfCh from raw data: " <<
LogVar(
"Number of ch: ", rawTRG.GetMaxNumOfCh(0))); }
800 const int subDetectorId = rawTRG.GetNodeID(0);
803 const int nEntriesRawTRG = rawTRG.GetNumEntries();
806 B2DEBUG(99,
"nEntries of rawTRG: " << nEntriesRawTRG);
807 for (
int j = 0; j < nEntriesRawTRG; ++j) {
811 std::array<int, nFinesse> nWords;
812 std::array<int*, nFinesse> data32tab;
815 for (
int iFinesse = 0; iFinesse < rawTRG.GetMaxNumOfCh(0); ++iFinesse) {
816 nWords[iFinesse] = rawTRG.GetDetectorNwords(j, iFinesse);
817 if (nWords[iFinesse] == 0) {
820 data32tab[iFinesse] = (
int*)rawTRG.GetDetectorBuffer(j, iFinesse);
825 if (trg->getHeaders(subDetectorId, data32tab, nWords,
m_pciedata)) {
827 trg->reserve(subDetectorId, nWords,
m_pciedata);
828 B2DEBUG(99,
"starting to unpack a subTrigger, subDetectorId" << std::hex << subDetectorId);
830 trg->unpack(subDetectorId, data32tab, nWords,
m_pciedata);
835 B2DEBUG(99,
"looped over entries and filled words " << nEntriesRawTRG);
837 B2DEBUG(99,
"looped over rawTriggers, unpacking 2D ");
841 for (
short iclock = 0; iclock <
m_bits2DTo3D.getEntries(); ++iclock) {
849 B2DEBUG(99,
"unpack 2D Input TS ");
851 std::array<int, 4> clockCounter2D = {0, 0, 0, 0};
852 std::array<int, 4> timeOffset2D = {0, 0, 0, 0};
854 for (
int iTracker = 0; iTracker < nTrackers; ++iTracker) {
859 std::string strInput = slv_to_bin_string(trackerData);
860 clockCounter2D[iTracker] = std::stoi(strInput.substr(0, clockCounterWidth), 0, 2);
861 int clockCounterDiff = clockCounter2D[iTracker] - clockCounter2D[0];
871 if (clockCounterDiff > 1250) {
872 clockCounterDiff -= 1280;
873 }
else if (clockCounterDiff < -1250) {
874 clockCounterDiff += 1280;
876 timeOffset2D[iTracker] = clockCounterDiff;
877 if (clockCounterDiff != 0) {
878 B2DEBUG(100,
"Adding " << clockCounterDiff <<
" clock(s) to 2D" << iTracker <<
" found time");
880 if (std::abs(clockCounterDiff) > 2) {
881 B2DEBUG(20,
"Clock counters between 2D [0," << iTracker <<
"] differ by " << clockCounterDiff <<
" clocks! (" \
882 << clockCounter2D[0] <<
", " << clockCounter2D[iTracker] <<
")");
885 for (
short iclock = 0; iclock <
m_bitsTo2D.getEntries(); ++iclock) {
886 B2DEBUG(30,
"clock " << iclock);
890 B2DEBUG(99,
"now unpack neuro ");
905 B2DEBUG(99,
" all is unpacked ##### ");
SignalBus m_signal
SignalBus of the Bitstream.
static constexpr std::array< int, 9 > nMergers
data width of a single merger unit
std::string m_neuro_track_name
name for neurotrigger array
int m_debugLevel
debug level specified in the steering file
StoreArray< RawTRG > m_rawTriggers
array containing the raw trigger data object
bool m_pciedata
PCIe40 data or copper data.
NodeList m_tracker2DNodeID_pcie40
list of (PCIe40 ID, ch ID) of 2D tracker
std::string m_neurotrigger_config_name
name for config saved in datastore
int m_headerSize
number of words (number of bits / 32) of the B2L header
int m_mergerDelay
Belle2Link delay of the merger reader.
bool m_sim13dt
bool value whether to simulate 13 bit drift time by using 2dcc
StoreArray< MergerBits > m_mergerBits
merger output bitstream
StoreArray< CDCTriggerMLPInput > m_NeuroInputs
decoded input vector for neural network
int m_NeuroCnttrg
NN cnttrg.
void initialize() override
Register input and output data.
int m_NeuroDelay
Belle2Link delay of the neurotrigger.
void event() override
convert raw data (in B2L buffer to bitstream)
bool m_isDNN
flag for unpacking DNN or not
std::string m_neuro_in_sTS_name
name for unpacked Neurotrigger input all stereo TSs array
NodeList m_neuroNodeID
list of (COPPER ID, HSLB ID) of neurotrigger
StoreArray< CDCTriggerUnpacker::T2DOutputBitStream > m_bits2DTo3D
bitstream of 2D output to 3D/Neuro
std::string m_neuro_in_etf_name
name for unpacked Neurotrigger input ETF T0 array
bool m_decodeNeuro
flag to decode neurotrigger data
void terminate() override
Delete dynamically allocated variables.
int m_2DFinderDelay
Belle2Link delay of the 2D finder.
StoreArray< CDCTriggerSegmentHit > m_TSHits
decoded track segment hit
bool m_alignFoundTime
flag to align found time in different sub-modules
bool m_unpackTracker2D
flag to unpack 2D tracker data
CDCTriggerUnpackerModule()
Constructor: Sets the description, the properties and the parameters of the module.
NodeList m_tracker2DNodeID
list of (COPPER ID, HSLB ID) of 2D tracker
StoreArray< CDCTriggerSegmentHit > m_NNInputTSHitsAll
all decoded stereo track segment hits from the neural network input
std::string m_neuro_in_2dtrack_name
name for unpacked Neurotrigger input 2d tracks array
StoreArray< CDCTriggerTrack > m_2DFinderTracks
decoded 2D finder track
void beginRun() override
begin Run
bool m_decodeTSHit
flag to decode track segment
StoreArray< CDCTriggerUnpacker::DNNBitStream > m_bitsDNN
bitstream of DNN input and output (including intermediate results)
StoreArray< CDCTriggerTrack > m_NeuroTracks
decoded Neuro tracks
StoreArray< CDCTriggerTrack > m_NNInput2DFinderTracks
decoded 2D finder tracks from the neural network input
DBObjPtr< CDCTrigger2DConfig > m_dbn2DTS
condition database for number of TS in 2D
int m_2DFinderCnttrg
2D cnttrg
StoreObjPtr< BinnedEventT0 > m_ETFTime
store object for unpacked etf event time from neuro b2link
std::string m_neuro_scaled_input_name
name for unpacked Neurotrigger scaled input array
bool m_decode2DFinderInputTS
flag to decode 2D finder input TS
NodeList m_neuroNodeID_pcie40
list of (PCIe40 ID, ch ID) of neurotrigger
StoreArray< CDCTriggerUnpacker::NNBitStream > m_bitsNN
bitstream of Neuro input and output (including intermediate results)
std::string m_neuro_select_TS_name
name for unpacked Neurotrigger selected TSs array
NodeList m_mergerNodeID
list of (COPPER ID, HSLB ID) of Merger reader (TSF)
std::unique_ptr< DBObjPtr< CDCTriggerNeuroConfig > > m_cdctriggerneuroconfig
current neurotrigger config from database; used for unscaling network target
StoreArray< CDCTriggerFinderClone > m_2DFinderClones
additional information of the 2D finder track
StoreArray< CDCTriggerUnpacker::TSFOutputBitStream > m_bitsTo2D
bitstream of TSF output to 2D tracker
int m_n2DTS
flag to unpack 2D tracker data with 15TS
StoreArray< CDCTriggerSegmentHit > m_NNInputTSHits
decoded track segment hits from the neural network input
bool m_unpackNeuro
flag to unpack neurotrigger data
std::vector< SubTrigger * > m_subTrigger
vector holding the pointers to all the dynamically allocated SubTriggers
bool m_decode2DFinderTrack
flag to decode 2D finder track
bool m_useDB
bool value for whether to use the conditions database
bool m_unpackMerger
flag to unpack merger data (recorded by Merger Reader / TSF)
int getDebugLevel() const
Returns the configured debug messaging level.
LogConfig & getLogConfig()
Returns the log system configuration.
void setDescription(const std::string &description)
Sets the description of the module.
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
void setReturnValue(int value)
Sets the return value for this module as integer.
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
Accessor to arrays stored in the data store.
Type-safe access to single objects in the data store.
Class to store variables with their name which were sent to the logging service.
void addParam(const std::string &name, T ¶mVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
static constexpr int wordWidth
width of a single word in the raw int buffer
static constexpr int mergerWidth
Merger data width.
std::vector< std::vector< int > > NodeList
Node list.
Abstract base class for different kinds of events.
unpacker for the merger reader (TSF which reads the merger output)
StoreArray< MergerBits > * arrayPtr
pointer to the merger output Bitstream
void unpack(int subDetectorId, std::array< int *, 48 > data32tab, std::array< int, 48 > nWords, bool pciedata) override
Unpack function.
unsigned nInnerMergers
number of merger units in the inner super layer than this one
Merger(StoreArray< MergerBits > *inArrayPtr, const std::string &inName, unsigned inEventWidth, unsigned inOffset, int inHeaderSize, const std::vector< int > &inNodeID, const std::vector< int > &inNodeID_pcie40, unsigned inNInnerMergers, int &inDelay, int &inCnttrg, int inDebugLevel)
Constructor.
void reserve(int subDetectorId, std::array< int, nFinesse > nWords, bool pciedata) override
reserve enough number of clocks (entries) in the Bitstream StoreArray
Neuro(StoreArray< T_bitstream > *arrPtr, const std::string &inName, unsigned inEventWidth, unsigned inOffset, unsigned inHeaderSize, const std::vector< int > &inNodeID, const std::vector< int > &inNodeID_pcie40, int &inDelay, int &inCnttrg, int inDebugLevel)
Constructor.
void unpack(int subDetectorId, std::array< int *, nFinesse > data32tab, std::array< int, nFinesse > nWords, bool pciedata) override
Unpack the Belle2Link data and fill the Bitstream.
StoreArray< T_bitstream > * ArrayPtr
Array pointer for NN.
unsigned offsetBitWidth
Offset bit width.
unsigned iTracker
Tracker board ID.
void reserve(int subDetectorId, std::array< int, nFinesse > nWords, bool pciedata) override
Calculate the number of clocks in the data, reserve that much of clocks in the Bitstream(s)
enum class SubTriggerType : unsigned char {Merger, TSF, T2D, T3D, Neuro, ETF};
int iNode_pcie40
PCIe40 id of the board.
int headerSize
Size of the B2L header in words.
unsigned offset
The starting point of the data in an event.
int debugLevel
debug level in the steering file
SubTrigger(const std::string &inName, unsigned inEventWidth, unsigned inOffset, int inHeaderSize, const std::vector< int > &inNodeID, const std::vector< int > &inNodeID_pcie40, int &inDelay, int &inCnttrg, int inDebugLevel=0)
constructor
std::string firmwareVersion
version of the FPGA firmware
int iFinesse
FINESSE (HSLB) id) of the board.
int iFinesse_pcie40
PCIe40 ch id of the board.
std::string name
Name of the UT3.
unsigned eventWidth
Size of an event in the Belle2Link data in 32-bit words.
int iNode
COPPER id of the board.
unpacker for the 2D tracker
Tracker2D(StoreArray< TSFOutputBitStream > *inArrayPtr, StoreArray< T2DOutputBitStream > *outArrayPtr, const std::string &inName, unsigned inEventWidth, unsigned inOffset, unsigned inHeaderSize, const std::vector< int > &inNodeID, const std::vector< int > &inNodeID_pcie40, unsigned inNumTS, int &inDelay, int &inCnttrg, int inDebugLevel)
constructor
StoreArray< T2DOutputBitStream > * outputArrayPtr
pointer to the Bitstream of 2D output to 3D/Neuro
void unpack(int subDetectorId, std::array< int *, 48 > data32tab, std::array< int, 48 > nWords, bool pciedata) override
Unpack the Belle2Link data and fill the Bitstream.
unsigned offsetBitWidth
starting point of the input data in an Belle2Link event
unsigned iTracker
ID of the 2D tracker (0 to 3)
unsigned numTS
Number of TS sent to 2D (0 to 20)
StoreArray< TSFOutputBitStream > * inputArrayPtr
pointer to the Bitstream of 2D input
void reserve(int subDetectorId, std::array< int, nFinesse > nWords, bool pciedata) override
Calculate the number of clocks in the data, reserve that much of clocks in the Bitstream(s)