17#include <trg/cdc/dataobjects/Bitstream.h>
18#include <trg/cdc/dataobjects/CDCTriggerTrack.h>
19#include <trg/cdc/dataobjects/CDCTriggerSegmentHit.h>
20#include <trg/cdc/dataobjects/CDCTriggerFinderClone.h>
21#include <trg/cdc/dataobjects/CDCTriggerMLPInput.h>
22#include <framework/gearbox/Const.h>
23#include <trg/cdc/dbobjects/CDCTriggerNeuroConfig.h>
24#include <framework/dataobjects/BinnedEventT0.h>
32 namespace CDCTriggerUnpacker {
34 constexpr double pi() {
return std::atan(1) * 4; }
37 static constexpr std::array<int, 9> nMergers = {10, 10, 12, 14, 16, 18, 20, 22, 24};
42 static constexpr int TSFOutputWidth = TSF_TO_2D_WIDTH;
43 static constexpr int nTrackers = NUM_2D;
44 static constexpr int nAxialTSF = NUM_TSF;
45 static constexpr int nStereoTSF = 4;
46 static constexpr int T2DOutputWidth = T2D_TO_3D_WIDTH;
47 static constexpr unsigned lenTS = 21;
48 static constexpr unsigned lenSTS = 87;
50 static constexpr int nMax2DTracksPerClock = 4;
53 static constexpr int clockCounterWidth = 9;
56 static constexpr std::array<int, nAxialTSF> nAxialMergers = {10, 12, 16, 20, 24};
58 static constexpr std::array<int, 9> nWiresInSuperLayer = {
59 160, 160, 192, 224, 256, 288, 320, 352, 384
62 static constexpr int nCellsInLayer = 16;
66 using TSFOutputVector = std::array<char, TSFOutputWidth>;
67 using TSFOutputArray = std::array<TSFOutputVector, nTrackers>;
68 using TSFOutputBus = std::array<TSFOutputArray, nAxialTSF>;
69 using TSFOutputBitStream = Bitstream<TSFOutputBus>;
71 using T2DOutputVector = std::array<char, T2DOutputWidth>;
72 using T2DOutputBus = std::array<T2DOutputVector, nTrackers>;
73 using T2DOutputBitStream = Bitstream<T2DOutputBus>;
75 using NNVector = std::array<char, NN_WIDTH>;
76 using NNBus = std::array<NNVector, nTrackers>;
77 using NNBitStream = Bitstream<NNBus>;
79 using DNNVector = std::array<char, DNN_WIDTH>;
80 using DNNBus = std::array<DNNVector, nTrackers>;
81 using DNNBitStream = Bitstream<DNNBus>;
92 std::string padto(std::string s,
unsigned l)
95 s.insert(s.begin(), l - s.size(),
' ');
99 std::string padright(std::string s,
unsigned l)
102 s.insert(s.end(), l - s.size(),
' ');
107 void printBuffer(
int* buf,
int nwords)
109 for (
int j = 0; j < nwords; ++j) {
110 printf(
" %.8x", buf[j]);
111 if ((j + 1) % 8 == 0) {
119 std::string rawIntToAscii(
int buf)
121 std::ostringstream firmwareTypeStream;
122 firmwareTypeStream << std::hex << buf;
123 std::string firmwareTypeHex(firmwareTypeStream.str());
124 std::string firmwareType(4,
'0');
125 for (
int i = 0; i < 4; i++) {
126 std::istringstream firmwareTypeIStream(firmwareTypeHex.substr(i * 2, 2));
128 firmwareTypeIStream >> std::hex >> character;
129 firmwareType[i] = character;
134 std::string rawIntToString(
int buf)
136 std::ostringstream firmwareVersionStream;
137 firmwareVersionStream << std::hex << buf;
138 return firmwareVersionStream.str();
158 const char* std_logic_literal[] = {
"U",
"X",
"0",
"1",
"Z",
"W",
"L",
"H",
"-"};
160 const char one_val = 3;
162 const char zero_val = 2;
164 char std_logic(
bool inBit)
166 char outBit = zero_val;
173 std::string display_value(
const char* count,
int size)
176 for (
int i = 0; i < size; i++) {
177 if (count[i] >= 0 && count[i] < 9) {
178 res += std_logic_literal[(int) count[i]];
180 B2DEBUG(20,
"invalid signal detected: " <<
static_cast<int>(count[i]));
188 std::string slv_to_bin_string(std::array<char, N> signal,
bool padding =
false)
190 int ini = padding ? 4 - signal.size() % 4 : 0;
191 std::string res(ini,
'0');
192 for (
auto const& bit : signal) {
193 if (bit >= 0 && bit < 9) {
194 res += std_logic_literal[(int) bit];
196 B2DEBUG(20,
"invalid signal detected: " <<
static_cast<int>(bit));
204 void display_hex(
const std::array<char, N>& signal)
206 std::ios oldState(
nullptr);
207 oldState.copyfmt(std::cout);
208 if (std::any_of(signal.begin(), signal.end(), [](
char i)
209 {return i != zero_val && i != one_val;})) {
210 B2DEBUG(20,
"Some bit in the signal vector is neither 0 nor 1. \n" <<
211 "Displaying binary values instead.");
212 std::cout << slv_to_bin_string(signal) << std::endl;
214 std::string binString = slv_to_bin_string(signal,
true);
215 std::cout << std::setfill(
'0');
216 for (
unsigned i = 0; i < signal.size(); i += 4) {
217 std::bitset<4> set(binString.substr(i, 4));
218 std::cout << std::setw(1) << std::hex << set.to_ulong();
222 std::cout.copyfmt(oldState);
232 template<
size_t nbits,
size_t min,
size_t max>
233 std::bitset < max - min + 1 > subset(std::bitset<nbits> set)
235 const size_t outWidth = max - min + 1;
236 std::string str = set.to_string();
237 return std::bitset<outWidth>(str.substr(nbits - max - 1, outWidth));
248 unsigned short globalSegmentID(
unsigned short localID,
unsigned short iSL)
250 auto itr = nWiresInSuperLayer.begin();
251 unsigned short globalID = std::accumulate(itr, itr + iSL, 0);
256 static const double realNaN = std::numeric_limits<double>::quiet_NaN();
258 using tsOut = std::array<unsigned, 4>;
259 using extraHitTimeOut = std::array<unsigned, 12>;
261 using tsOutArray = std::array<tsOut, 5>;
263 struct TRG2DFinderTrack {
264 TRG2DFinderTrack() :
omega(realNaN),
phi0(realNaN) {}
287 std::array<int, 9> rawinputID;
290 std::array<int, 9> rawinputT;
293 std::array<int, 9> rawinputAlpha;
296 std::array<std::array<float, 11>, 4> rawinputExtraT;
298 std::array<tsOut, 9>
ts;
299 std::array<extraHitTimeOut, 9> TSExtraT;
306 struct B2LDataField_DNN {
313 if (
int(b2line.
offset + foundtime) >= 0 &&
316 CDCTriggerUnpacker::DNNBitStream* bitsn = (*bitsNN)[foundtime + b2line.
offset];
318 if (
int(slv_to_bin_string(bitsn->
signal()[iTracker]).size()) >= (DNN_WIDTH - b2line.
start)) {
319 data = slv_to_bin_string(bitsn->
signal()[iTracker]).substr(DNN_WIDTH - 1 - b2line.
end, b2line.
end - b2line.
start + 1);
334 struct B2LDataField {
341 if (
int(b2line.
offset + foundtime) >= 0 &&
344 NNBitStream* bitsn = (*bitsNN)[foundtime + b2line.
offset];
346 if (
int(slv_to_bin_string(bitsn->
signal()[iTracker]).size()) >= (NN_WIDTH - b2line.
start)) {
347 data = slv_to_bin_string(bitsn->
signal()[iTracker]).substr(NN_WIDTH - 1 - b2line.
end, b2line.
end - b2line.
start + 1);
360 std::vector<bool> decodedriftthreshold(std::string p_driftthreshold)
362 std::vector<bool> res;
363 for (
unsigned i = 0; i < p_driftthreshold.size(); ++i) {
364 if (p_driftthreshold.substr(i, 1) ==
"1") {
366 }
else if (p_driftthreshold.substr(i, 1) ==
"0") {
367 res.push_back(
false);
369 B2WARNING(
"Invalid input in NNBitstream appending 'false'!");
370 res.push_back(
false);
375 std::vector<bool> decodefoundoldtrack(std::string p_foundoldtrack)
377 std::vector<bool> res;
378 for (
unsigned i = 0; i < p_foundoldtrack.size(); ++i) {
379 if (p_foundoldtrack.substr(i, 1) ==
"1") {
381 }
else if (p_foundoldtrack.substr(i, 1) ==
"0") {
382 res.push_back(
false);
384 B2WARNING(
"Invalid input in NNBitstream appending 'false'!");
385 res.push_back(
false);
390 bool decodevalstereobit(
const std::string& p_valstereobit)
393 if (p_valstereobit ==
"1") {
395 }
else if (p_valstereobit ==
"0") {
398 B2WARNING(
"Invalid input in NNBitstream appending 'false'!");
403 bool decodebool(
const std::string& boolstring)
406 if (boolstring ==
"1") {
408 }
else if (boolstring ==
"0") {
411 B2WARNING(
"Invalid input in NNBitstream, appending 'false'!");
427 unsigned TSIDInSL(
unsigned tsIDInTracker,
unsigned iSL,
unsigned iTracker)
429 const unsigned nCellsInSL = nMergers[iSL] * nCellsInLayer;
431 unsigned iTS = tsIDInTracker + nCellsInSL * iTracker / nTrackers;
433 if (iTS >= nCellsInSL) {
448 int mlp_bin_to_signed_int(std::string signal)
450 constexpr unsigned len = 13;
451 std::bitset<len> signal_bit(signal);
452 const unsigned shift = 16 - len;
455 int signal_out = (int16_t (signal_bit.to_ulong() << shift)) >> shift;
462 int recalcETF(std::string driftinput, std::vector<unsigned> tsvector, CDCTriggerTrack* track)
465 float scale = 1. / (1 << (driftinput.size() - 1) / 9);
471 std::vector<std::vector<int>> table;
472 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
474 int reldt =
static_cast<int>(fabs((mlp_bin_to_signed_int(driftinput.substr((8 - iSL) * driftinput.size() / 9,
475 driftinput.size() / 9)) * scale * 256)));
476 int tstime =
static_cast<int>(tsvector[iSL]);
478 if (reldt != 0 && reldt < 255) {
479 for (std::vector<int>& x : table) {
481 if (x[0] == tstime - reldt) {
486 if (!stor) {table.push_back({tstime - reldt, 1});}
492 for (std::vector<int>& x : table) {
499 if (table.size() > 1) {track->setQualityVector(128);}
511 tsOut decodeTSHit(std::string tsIn)
513 constexpr unsigned lenID = 8;
514 constexpr unsigned lenPriorityTime = 9;
515 constexpr unsigned lenLR = 2;
516 constexpr unsigned lenPriorityPosition = 2;
517 constexpr std::array<unsigned, 4> tsLens = {
518 lenID, lenPriorityTime, lenLR, lenPriorityPosition
520 std::array<unsigned, 5> tsPos = { 0 };
521 std::partial_sum(tsLens.begin(), tsLens.end(), tsPos.begin() + 1);
523 tsOutput[0] = std::bitset<tsLens[0]>(tsIn.substr(tsPos[0], tsLens[0])).to_ulong();
524 tsOutput[1] = std::bitset<tsLens[1]>(tsIn.substr(tsPos[1], tsLens[1])).to_ulong();
525 tsOutput[2] = std::bitset<tsLens[2]>(tsIn.substr(tsPos[2], tsLens[2])).to_ulong();
526 tsOutput[3] = std::bitset<tsLens[3]>(tsIn.substr(tsPos[3], tsLens[3])).to_ulong();
529 tsOut decodeTSHit_sim(std::string tsIn, std::string twodcc)
531 constexpr unsigned lenID = 8;
532 constexpr unsigned lenPriorityTime = 9;
533 constexpr unsigned lenLR = 2;
534 constexpr unsigned lenPriorityPosition = 2;
535 constexpr std::array<unsigned, 4> tsLens = {
536 lenID, lenPriorityTime, lenLR, lenPriorityPosition
538 std::string C = tsIn.substr(lenID + 5, 4);
539 std::string B = tsIn.substr(lenID, 5);
540 std::string Bp = twodcc.substr(4, 5);
541 std::string Ap = twodcc.substr(0, 4);
544 if (std::stoul(B, 0, 2) <= std::stoul(Bp, 0, 2)) {
547 B2DEBUG(14,
"2DCC overflow detected!");
548 pts = std::bitset<4>(std::stoul(Ap, 0, 2) - 1).to_string() + B + C;
550 pt = std::stoul(pts, 0, 2);
551 std::array<unsigned, 5> tsPos = { 0 };
552 std::partial_sum(tsLens.begin(), tsLens.end(), tsPos.begin() + 1);
554 tsOutput[0] = std::bitset<tsLens[0]>(tsIn.substr(tsPos[0], tsLens[0])).to_ulong();
556 tsOutput[2] = std::bitset<tsLens[2]>(tsIn.substr(tsPos[2], tsLens[2])).to_ulong();
557 tsOutput[3] = std::bitset<tsLens[3]>(tsIn.substr(tsPos[3], tsLens[3])).to_ulong();
560 extraHitTimeOut decodeTSHitExtra_sim(std::string tsIn, std::string twodcc)
562 constexpr unsigned extraDrift = 5;
563 constexpr unsigned offset = 32;
564 extraHitTimeOut etimeout;
565 etimeout[0] = std::bitset<11>(tsIn.substr(offset - 11, 11)).to_ulong();
566 std::string Bp = twodcc.substr(4, 5);
567 std::string Ap = twodcc.substr(0, 4);
568 for (
int i = 0; i < 11; i++) {
569 std::string B = tsIn.substr(offset + extraDrift * i, extraDrift);
570 std::string C =
"0000";
573 if (std::stoul(B, 0, 2) <= std::stoul(Bp, 0, 2)) {
576 B2DEBUG(14,
"2DCC overflow detected!");
577 pts = std::bitset<4>(std::stoul(Ap, 0, 2) - 1).to_string() + B + C;
579 pt = std::stoul(pts, 0, 2);
580 etimeout[i + 1] = pt;
585 extraHitTimeOut decodeTSHitExtra(std::string tsIn)
587 constexpr unsigned extraDrift = 5;
588 constexpr unsigned offset = 32;
589 std::string C =
"0000";
590 extraHitTimeOut etimeout;
591 etimeout[0] = std::bitset<11>(tsIn.substr(offset - 11, 11)).to_ulong();
592 for (
int i = 0; i < 11; i++) {
593 std::string B = tsIn.substr(offset + extraDrift * i, extraDrift);
594 etimeout[i] = std::stoul(B + C, 0, 2);
599 tsOut decodeTSHit_ext(std::string tsIn, std::string expt)
601 constexpr unsigned lenID = 8;
602 constexpr unsigned lenPriorityTime = 9;
603 constexpr unsigned lenLR = 2;
604 constexpr unsigned lenPriorityPosition = 2;
605 constexpr std::array<unsigned, 4> tsLens = {
606 lenID, lenPriorityTime, lenLR, lenPriorityPosition
608 unsigned pt = std::stoul(expt, 0, 2);
609 std::array<unsigned, 5> tsPos = { 0 };
610 std::partial_sum(tsLens.begin(), tsLens.end(), tsPos.begin() + 1);
612 tsOutput[0] = std::bitset<tsLens[0]>(tsIn.substr(tsPos[0], tsLens[0])).to_ulong();
614 tsOutput[2] = std::bitset<tsLens[2]>(tsIn.substr(tsPos[2], tsLens[2])).to_ulong();
615 tsOutput[3] = std::bitset<tsLens[3]>(tsIn.substr(tsPos[3], tsLens[3])).to_ulong();
628 TRG2DFinderTrack decode2DTrack(
const std::string& p_charge __attribute__((unused)),
631 const std::string& p_ts0,
632 const std::string& p_ts2,
633 const std::string& p_ts4,
634 const std::string& p_ts6,
635 const std::string& p_ts8,
637 const std::string& p_2dcc,
641 unsigned shift = 16 - p_omega.size();
643 int omega = std::stoi(p_omega, 0, 2);
646 int omegafirm = (int16_t (omega << shift)) >> shift;
647 trackout.hwOmega = omegafirm;
650 const double BField = 1.5e-4;
658 int phi = std::stoi(p_phi, 0, 2);
659 trackout.hwPhi0 = phi;
661 double globalPhi0 = pi() / 4 + pi() / 2 / 80 * (phi + 1) + pi() / 2 * iTracker;
664 trackout.ts[0] = (sim13dt) ? decodeTSHit_sim(p_ts0, p_2dcc) : decodeTSHit(p_ts0);
665 trackout.ts[1] = (sim13dt) ? decodeTSHit_sim(p_ts2, p_2dcc) : decodeTSHit(p_ts2);
666 trackout.ts[2] = (sim13dt) ? decodeTSHit_sim(p_ts4, p_2dcc) : decodeTSHit(p_ts4);
667 trackout.ts[3] = (sim13dt) ? decodeTSHit_sim(p_ts6, p_2dcc) : decodeTSHit(p_ts6);
668 trackout.ts[4] = (sim13dt) ? decodeTSHit_sim(p_ts8, p_2dcc) : decodeTSHit(p_ts8);
670 if (globalPhi0 > pi() * 2) {
671 globalPhi0 -= pi() * 2;
673 trackout.phi0 = globalPhi0;
674 B2DEBUG(20,
"Unpacking 2DTrack in Tracker: " << iTracker);
675 B2DEBUG(20,
" Omega: " << std::to_string(omega) <<
", Omegafirm: " << std::to_string(omegafirm) <<
", converted to: " <<
676 std::to_string(trackout.omega));
677 B2DEBUG(20,
" Phi: " << std::to_string(phi) <<
", converted to: " << std::to_string(trackout.phi0));
683 constexpr unsigned lenCharge = 2;
684 constexpr unsigned lenOmega = 7;
685 constexpr unsigned lenPhi0 = 7;
686 constexpr std::array<unsigned, 3> trackLens = {lenCharge, lenOmega, lenPhi0};
687 std::array<unsigned, 4> trackPos{ 0 };
688 std::partial_sum(trackLens.begin(), trackLens.end(), trackPos.begin() + 1);
689 const unsigned shift = 16 - lenOmega;
691 std::bitset<trackLens[1]> omega(trackIn.substr(trackPos[1], trackLens[1]));
694 int omegaFirm = (int16_t (omega.to_ulong() << shift)) >> shift;
695 trackOut.hwOmega = omegaFirm;
697 const double BField = 1.5e-4;
702 int phi0 = std::bitset<trackLens[2]>(trackIn.substr(trackPos[2], trackLens[2])).to_ulong();
703 trackOut.hwPhi0 = phi0;
704 trackOut.phi0 = pi() / 4 + pi() / 2 / 80 * (phi0 + 1);
705 for (
unsigned i = 0; i < 5; ++i) {
706 trackOut.ts[i] = decodeTSHit(trackIn.substr(trackPos.back() + i * lenTS, lenTS));
710 double globalPhi0 = trackOut.phi0 + pi() / 2 * iTracker;
711 if (globalPhi0 > pi() * 2) {
712 globalPhi0 -= pi() * 2;
714 trackOut.phi0 = globalPhi0;
727 std::string p_mlpout_theta,
728 std::string p_tsfsel,
729 std::string p_mlpin_alpha,
730 std::string p_mlpin_drifttime,
731 std::string p_mlpin_id,
732 std::string p_netsel,
733 const DBObjPtr<CDCTriggerNeuroConfig>& neurodb,
734 const std::string& p_2dcc,
739 float scale_z = 1. / (1 << (p_mlpout_z.size() - 1));
740 float scale_theta = 1. / (1 << (p_mlpout_theta.size() - 1));
741 float scale_alpha = 1. / (1 << (p_mlpin_alpha.size() - 1) / 9);
742 float scale_drifttime = 1. / (1 << (p_mlpin_drifttime.size() - 1) / 9);
743 float scale_id = 1. / (1 << (p_mlpin_id.size() - 1) / 9);
745 int theta_raw = mlp_bin_to_signed_int(p_mlpout_theta);
746 int z_raw = mlp_bin_to_signed_int(p_mlpout_z);
747 foundTrack.hwZ = z_raw;
748 foundTrack.hwTheta = theta_raw;
749 std::vector<float> unscaledT = neurodb->getMLPs()[0].unscaleTarget({(z_raw * scale_z), (theta_raw * scale_theta)});
750 foundTrack.z = unscaledT[0];
751 foundTrack.theta = unscaledT[1];
752 foundTrack.sector = std::stoi(p_netsel, 0, 2);
753 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
754 foundTrack.inputAlpha[iSL] =
755 mlp_bin_to_signed_int(p_mlpin_alpha.substr((8 - iSL) * p_mlpin_alpha.size() / 9, p_mlpin_alpha.size() / 9)) * scale_alpha;
756 foundTrack.inputT[iSL] =
757 mlp_bin_to_signed_int(p_mlpin_drifttime.substr((8 - iSL) * p_mlpin_drifttime.size() / 9,
758 p_mlpin_drifttime.size() / 9)) * scale_drifttime;
759 foundTrack.inputID[iSL] =
760 mlp_bin_to_signed_int(p_mlpin_id.substr((8 - iSL) * p_mlpin_drifttime.size() / 9, p_mlpin_drifttime.size() / 9)) * scale_id;
761 foundTrack.rawinputAlpha[iSL] = mlp_bin_to_signed_int(p_mlpin_alpha.substr((8 - iSL) * p_mlpin_alpha.size() / 9,
762 p_mlpin_alpha.size() / 9));
763 foundTrack.rawinputT[iSL] = mlp_bin_to_signed_int(p_mlpin_drifttime.substr((8 - iSL) * p_mlpin_drifttime.size() / 9,
764 p_mlpin_drifttime.size() / 9));
765 foundTrack.rawinputID[iSL] = mlp_bin_to_signed_int(p_mlpin_id.substr((8 - iSL) * p_mlpin_drifttime.size() / 9,
766 p_mlpin_drifttime.size() / 9));
768 foundTrack.ts[iSL] = decodeTSHit_sim(p_tsfsel.substr((8 - iSL) * lenTS, lenTS), p_2dcc);
770 if (p_extendedpts.name !=
"None") {
771 foundTrack.ts[iSL] = decodeTSHit_ext(p_tsfsel.substr((8 - iSL) * lenTS, lenTS), p_extendedpts.data.substr((8 - iSL) * 13, 13));
773 foundTrack.ts[iSL] = decodeTSHit(p_tsfsel.substr((8 - iSL) * lenTS, lenTS));
791 std::string p_mlpout_theta,
792 std::string p_mlpout_prob,
793 std::string p_tsfsel,
794 std::string p_mlpin_alpha,
795 std::string p_mlpin_drifttime,
796 std::string p_mlpin_id,
797 std::string p_mlpin_extratime,
798 std::string p_netsel,
799 const DBObjPtr<CDCTriggerNeuroConfig>& neurodb,
800 const std::string& p_2dcc,
805 float scale_z = 1. / (1 << (p_mlpout_z.size() - 1));
806 float scale_theta = 1. / (1 << (p_mlpout_theta.size() - 1));
807 float scale_prob = 1. / (1 << (p_mlpout_prob.size() - 1));
808 float scale_alpha = 1. / (1 << (p_mlpin_alpha.size() - 1) / 9);
809 float scale_drifttime = 1. / (1 << (p_mlpin_drifttime.size() - 1) / 9);
810 float scale_id = 1. / (1 << (p_mlpin_id.size() - 1) / 9);
811 float scale_extratime = 1. / (1 << (p_mlpin_extratime.size() - 1) / 44);
813 int theta_raw = mlp_bin_to_signed_int(p_mlpout_theta);
814 int z_raw = mlp_bin_to_signed_int(p_mlpout_z);
815 int prob_raw = mlp_bin_to_signed_int(p_mlpout_prob);
818 foundTrack.hwZ = z_raw;
819 foundTrack.hwTheta = theta_raw;
820 foundTrack.hwProb = prob_raw;
821 std::vector<float> unscaledT = neurodb->getMLPs()[0].unscaleTarget({(z_raw * scale_z), (theta_raw * scale_theta)});
822 foundTrack.z = unscaledT[0];
823 foundTrack.theta = unscaledT[1];
825 foundTrack.prob = prob_raw * scale_prob;
826 foundTrack.sector = std::stoi(p_netsel, 0, 2);
827 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
828 foundTrack.inputAlpha[iSL] =
829 mlp_bin_to_signed_int(p_mlpin_alpha.substr((8 - iSL) * p_mlpin_alpha.size() / 9, p_mlpin_alpha.size() / 9)) * scale_alpha;
830 foundTrack.inputT[iSL] =
831 mlp_bin_to_signed_int(p_mlpin_drifttime.substr((8 - iSL) * p_mlpin_drifttime.size() / 9,
832 p_mlpin_drifttime.size() / 9)) * scale_drifttime;
833 foundTrack.inputID[iSL] =
834 mlp_bin_to_signed_int(p_mlpin_id.substr((8 - iSL) * p_mlpin_drifttime.size() / 9, p_mlpin_drifttime.size() / 9)) * scale_id;
835 foundTrack.rawinputAlpha[iSL] = mlp_bin_to_signed_int(p_mlpin_alpha.substr((8 - iSL) * p_mlpin_alpha.size() / 9,
836 p_mlpin_alpha.size() / 9));
837 foundTrack.rawinputT[iSL] = mlp_bin_to_signed_int(p_mlpin_drifttime.substr((8 - iSL) * p_mlpin_drifttime.size() / 9,
838 p_mlpin_drifttime.size() / 9));
839 foundTrack.rawinputID[iSL] = mlp_bin_to_signed_int(p_mlpin_id.substr((8 - iSL) * p_mlpin_drifttime.size() / 9,
840 p_mlpin_drifttime.size() / 9));
842 foundTrack.ts[iSL] = decodeTSHit_sim(p_tsfsel.substr((8 - iSL) * lenSTS, lenSTS), p_2dcc);
844 if (p_extendedpts.name !=
"None") {
845 foundTrack.ts[iSL] = decodeTSHit_ext(p_tsfsel.substr((8 - iSL) * lenSTS, lenSTS), p_extendedpts.data.substr((8 - iSL) * 13, 13));
847 foundTrack.ts[iSL] = decodeTSHit(p_tsfsel.substr((8 - iSL) * lenSTS, lenSTS));
851 if (p_tsfsel.size() % 87 == 0) {
852 foundTrack.TSExtraT[iSL] = sim13dt ? decodeTSHitExtra_sim(p_tsfsel.substr((8 - iSL) * lenSTS, lenSTS),
853 p_2dcc) : decodeTSHitExtra(p_tsfsel.substr((8 - iSL) * lenSTS, lenSTS));
855 foundTrack.TSExtraT[iSL] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
858 for (
unsigned iSL = 0; iSL < 4; ++iSL) {
859 for (
unsigned iwire = 0; iwire < 11; ++iwire) {
860 foundTrack.inputExtraT[iSL][iwire] = mlp_bin_to_signed_int(p_mlpin_extratime.substr((((3 - iSL) *
861 11) + (10 - iwire)) * p_mlpin_extratime.size() / 44, p_mlpin_extratime.size() / 44)) * scale_extratime;
862 foundTrack.rawinputExtraT[iSL][iwire] = mlp_bin_to_signed_int(p_mlpin_extratime.substr((((3 - iSL) *
863 11) + (10 - iwire)) * p_mlpin_extratime.size() / 44, p_mlpin_extratime.size() / 44));
868 TRGNeuroTrack decodeNNTrack_old(std::string trackIn, std::string selectIn)
870 constexpr unsigned lenMLP = 13;
871 float scale = 1. / (1 << (lenMLP - 1));
873 int theta_raw = mlp_bin_to_signed_int(trackIn.substr(1, lenMLP));
874 foundTrack.theta = theta_raw * scale * M_PI_2 + M_PI_2;
875 int z_raw = mlp_bin_to_signed_int(trackIn.substr(lenMLP + 1, lenMLP));
876 foundTrack.z = z_raw * scale * 50.;
877 foundTrack.sector = std::bitset<3>(trackIn.substr(2 * lenMLP + 1, 3)).to_ulong();
878 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
879 foundTrack.inputAlpha[iSL] =
880 mlp_bin_to_signed_int(selectIn.substr((2 + (8 - iSL)) * lenMLP + 4, lenMLP)) * scale;
881 foundTrack.inputT[iSL] =
882 mlp_bin_to_signed_int(selectIn.substr((11 + (8 - iSL)) * lenMLP + 4, lenMLP)) * scale;
883 foundTrack.inputID[iSL] =
884 mlp_bin_to_signed_int(selectIn.substr((20 + (8 - iSL)) * lenMLP + 4, lenMLP)) * scale;
886 decodeTSHit(selectIn.substr(29 * lenMLP + 4 + (8 - iSL) * lenTS, lenTS));
895 CDCTriggerSegmentHit* addTSHit(tsOut ts,
unsigned iSL,
unsigned iTracker,
896 StoreArray<CDCTriggerSegmentHit>* tsHits,
897 int foundTime = 0, extraHitTimeOut exTime = {})
899 unsigned iTS = TSIDInSL(ts[0], iSL, iTracker);
901 CDCTriggerSegmentHit* hit =
nullptr;
915 if (exTime[0] != 0) {
916 std::vector<float> hittime(exTime.begin() + 1, exTime.end());
917 hit = tsHits->appendNew(iSL, iTS, ts[3], ts[2], ts[1], 0, foundTime, iTracker, hittime, exTime[0]);
919 hit = tsHits->appendNew(iSL, iTS, ts[3], ts[2], ts[1], 0, foundTime, iTracker);
921 B2DEBUG(15,
"make hit at SL " << iSL <<
" ID " << iTS <<
" clock " << foundTime <<
" iTracker " << iTracker);
940 void decode2DOutput(
short foundTime,
941 T2DOutputBitStream* bits,
942 StoreArray<CDCTriggerTrack>* storeTracks,
943 StoreArray<CDCTriggerFinderClone>* storeClones,
944 StoreArray<CDCTriggerSegmentHit>* tsHits)
946 const unsigned lenTrack = 121;
947 const unsigned oldTrackWidth = 6;
948 const unsigned foundWidth = 6;
949 std::array<int, 4> posTrack;
950 for (
unsigned i = 0; i < posTrack.size(); ++i) {
951 posTrack[i] = oldTrackWidth + foundWidth + lenTrack * i;
953 for (
unsigned iTracker = 0; iTracker < nTrackers; ++iTracker) {
954 const auto slv = bits->signal()[iTracker];
955 std::string strOutput = slv_to_bin_string(slv).
956 substr(clockCounterWidth, T2DOutputWidth - clockCounterWidth);
957 for (
unsigned i = 0; i < nMax2DTracksPerClock; ++i) {
959 if (slv[clockCounterWidth + oldTrackWidth + i] == one_val) {
960 TRG2DFinderTrack trk = decode2DTrack(strOutput.substr(posTrack[i], lenTrack), iTracker);
961 B2DEBUG(15,
"2DOut phi0:" << trk.phi0 <<
", omega:" << trk.omega
962 <<
", at clock " << foundTime <<
", tracker " << iTracker);
963 CDCTriggerTrack* track =
964 storeTracks->appendNew(trk.phi0, trk.omega, 0., foundTime, iTracker);
965 CDCTriggerFinderClone* clone =
966 storeClones->appendNew(slv[clockCounterWidth + i] == one_val, iTracker);
967 clone->addRelationTo(track);
974 for (
unsigned iAx = 0; iAx < nAxialTSF; ++iAx) {
975 const auto& ts = trk.ts[iAx];
977 unsigned iTS = TSIDInSL(ts[0], 2 * iAx, iTracker);
978 CDCTriggerSegmentHit* hit =
979 tsHits->appendNew(2 * iAx,
990 2000 + iTracker * 100 + foundTime,
992 track->addRelationTo(hit);
1012 void decode2DInput(
short foundTime,
1013 std::array<int, 4> timeOffset,
1014 TSFOutputBitStream* bits,
1015 StoreArray<CDCTriggerSegmentHit>* tsHits)
1018 for (
unsigned iAx = 0; iAx < nAxialTSF; ++iAx) {
1019 for (
unsigned iTracker = 0; iTracker < nTrackers; ++iTracker) {
1020 const auto& tracker = bits->signal()[iAx][iTracker];
1021 std::string strInput = slv_to_bin_string(tracker);
1022 bool noMoreHit =
false;
1023 for (
unsigned pos = clockCounterWidth; pos < TSFOutputWidth; pos += lenTS) {
1024 std::string tsHitStr = strInput.substr(pos, lenTS);
1025 B2DEBUG(50, tsHitStr);
1026 tsOut ts = decodeTSHit(tsHitStr);
1031 }
else if (noMoreHit) {
1032 B2DEBUG(20,
"Discontinuous TS hit detected!");
1034 unsigned iTS = TSIDInSL(ts[0], 2 * iAx, iTracker);
1036 CDCTriggerSegmentHit hit(2 * iAx,
1042 foundTime + timeOffset[iTracker],
1055 if (std::none_of(tsHits->begin(), tsHits->end(),
1056 [hit](CDCTriggerSegmentHit storeHit) {
1057 return (storeHit.getSegmentID() == hit.getSegmentID() &&
1058 storeHit.foundTime() == hit.foundTime());
1060 B2DEBUG(40,
"found TS hit ID " << hit.getSegmentID() <<
1061 ", SL" << 2 * iAx <<
", local ID " << iTS <<
1062 ", 2D" << iTracker);
1063 tsHits->appendNew(hit);
1065 B2DEBUG(45,
"skipping redundant hit ID " << hit.getSegmentID() <<
" in 2D" << iTracker);
1088 CDCTriggerTrack* decodeNNInput(
short iclock,
1090 NNBitStream* bitsIn,
1091 StoreArray<CDCTriggerTrack>* store2DTracks,
1092 StoreArray<CDCTriggerSegmentHit>* tsHits)
1094 CDCTriggerTrack* track2D =
nullptr;
1095 constexpr unsigned lenTrack = 135;
1097 const auto slvIn = bitsIn->signal()[iTracker];
1098 std::string strIn = slv_to_bin_string(slvIn);
1099 strIn = strIn.substr(NN_WIDTH - 570 - 496, 982);
1101 for (
unsigned iSt = 0; iSt < nStereoTSF; ++iSt) {
1102 for (
unsigned iHit = 0; iHit < 10; ++iHit) {
1104 unsigned pos = ((nStereoTSF - iSt - 1) * 10 + iHit) * lenTS;
1105 tsOut ts = decodeTSHit(strIn.substr(pos, lenTS));
1107 addTSHit(ts, iSt * 2 + 1, iTracker, tsHits, iclock);
1111 std::string strTrack = strIn.substr(nStereoTSF * 10 * lenTS, lenTrack);
1112 if (!std::all_of(strTrack.begin(), strTrack.end(), [](
char i) {return i ==
'0';})) {
1113 std::string infobits = strTrack.substr(5 * lenTS + 14, 16);
1114 strTrack =
"00" + strTrack.substr(5 * lenTS, 14) + strTrack.substr(0,
1117 B2DEBUG(15,
"NNIn phi0:" << trk2D.phi0 <<
", omega:" << trk2D.omega
1118 <<
", at clock " << iclock <<
", tracker " << iTracker);
1119 B2DEBUG(300,
"Content of new infobits: " << infobits);
1120 std::vector<bool> foundoldtrack;
1121 std::vector<bool> driftthreshold;
1124 for (i = 0; i < 6; i++) {
1125 if (infobits.substr(i, 1) ==
"1") {
1126 foundoldtrack.push_back(
true);
1127 }
else if (infobits.substr(i, 1) ==
"0") {
1128 foundoldtrack.push_back(
false);
1130 B2WARNING(
"Invalid input in NNBitstream appending 'false'!");
1131 foundoldtrack.push_back(
false);
1135 if (infobits.substr(i, 1) ==
"1") {
1136 valstereobit =
true;
1137 }
else if (infobits.substr(i, 1) ==
"0") {
1138 valstereobit =
false;
1140 B2WARNING(
"Invalid input in NNBitstream appending 'false'!");
1141 valstereobit =
false;
1143 for (i = 7; i < 16; i++) {
1144 if (infobits.substr(i, 1) ==
"1") {
1145 driftthreshold.push_back(
true);
1146 }
else if (infobits.substr(i, 1) ==
"0") {
1147 driftthreshold.push_back(
false);
1149 B2WARNING(
"Invalid input in NNBitstream appending 'false'!");
1150 driftthreshold.push_back(
false);
1153 B2DEBUG(15,
"bits for foundoldtrack: " << foundoldtrack[0]
1158 << foundoldtrack[5]);
1159 B2DEBUG(15,
"bits for driftthreshold: " << driftthreshold[0]
1160 << driftthreshold[1]
1161 << driftthreshold[2]
1162 << driftthreshold[3]
1163 << driftthreshold[4]
1164 << driftthreshold[5]
1165 << driftthreshold[6]
1166 << driftthreshold[7]
1167 << driftthreshold[8]);
1168 B2DEBUG(15,
"bits for valstereobit: " << valstereobit);
1179 B2DEBUG(15,
"make new 2D track with phi " << trk2D.phi0 <<
" omega " << trk2D.omega <<
" clock " << iclock);
1180 track2D = store2DTracks->appendNew(trk2D.phi0, trk2D.omega, 0., foundoldtrack, driftthreshold, valstereobit, iclock, iTracker);
1182 for (
unsigned iAx = 0; iAx < nAxialTSF; ++iAx) {
1183 const auto& ts = trk2D.ts[iAx];
1185 CDCTriggerSegmentHit* hit =
1186 addTSHit(ts, 2 * iAx, iTracker, tsHits, iclock);
1187 track2D->addRelationTo(hit);
1215 void decodeNNOutput_old(
short foundTime,
1217 NNBitStream* bitsOut,
1218 NNBitStream* bitsSelectTS,
1219 StoreArray<CDCTriggerTrack>* storeNNTracks,
1220 StoreArray<CDCTriggerSegmentHit>* tsHits,
1221 StoreArray<CDCTriggerMLPInput>* storeNNInputs,
1222 CDCTriggerTrack* track2D)
1224 const auto slvOut = bitsOut->signal()[iTracker];
1225 std::string strTrack = slv_to_bin_string(slvOut);
1226 strTrack = strTrack.substr(496, 570);
1227 const auto slvSelect = bitsSelectTS->signal()[iTracker];
1228 std::string strSelect = slv_to_bin_string(slvSelect);
1229 strSelect = strSelect.substr(496, 570);
1230 TRGNeuroTrack trkNN = decodeNNTrack_old(strTrack, strSelect);
1231 B2DEBUG(15,
"make new NN track with , z:" << trkNN.z <<
", theta:" << trkNN.theta <<
1232 ", sector:" << trkNN.sector <<
", clock " << foundTime);
1236 phi0 = track2D->getPhi0();
1237 omega = track2D->getOmega();
1239 std::vector<unsigned> tsvector(9, 0);
1240 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
1241 tsvector[iSL] = trkNN.ts[iSL][2];
1243 CDCTriggerTrack* trackNN = storeNNTracks->appendNew(phi0, omega, 0.,
1244 trkNN.z, cos(trkNN.theta) / sin(trkNN.theta), 0., track2D->getFoundOldTrack(), track2D->getDriftThreshold(),
1245 track2D->getValidStereoBit(), trkNN.sector, tsvector, foundTime, iTracker);
1246 std::vector<float> inputVector(27, 0.);
1247 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
1248 inputVector[3 * iSL] = trkNN.inputID[iSL];
1249 inputVector[3 * iSL + 1] = trkNN.inputT[iSL];
1250 inputVector[3 * iSL + 2] = trkNN.inputAlpha[iSL];
1252 CDCTriggerMLPInput* storeInput =
1253 storeNNInputs->appendNew(inputVector, trkNN.sector);
1254 trackNN->addRelationTo(storeInput);
1255 track2D->addRelationTo(trackNN);
1257 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
1258 if (trkNN.ts[iSL][3] > 0) {
1259 CDCTriggerSegmentHit* hit = addTSHit(trkNN.ts[iSL], iSL, iTracker, tsHits, foundTime);
1260 trackNN->addRelationTo(hit);
1289 StoreArray<CDCTriggerUnpacker::NNBitStream>* bitsNN,
1290 StoreArray<CDCTriggerTrack>* store2DTracks,
1291 StoreArray<CDCTriggerTrack>* storeNNTracks,
1292 StoreArray<CDCTriggerSegmentHit>* tsHits,
1293 StoreArray<CDCTriggerSegmentHit>* tsHitsAll,
1294 StoreArray<CDCTriggerMLPInput>* storeNNInputs,
1295 StoreObjPtr<BinnedEventT0> storeETFTime,
1296 const DBObjPtr<CDCTriggerNeuroConfig> neurodb,
1299 for (
unsigned iTracker = 0; iTracker < nTrackers; ++iTracker) {
1300 B2DEBUG(21,
"----------------------------------------------------------------------------------------------------");
1301 B2DEBUG(21, padright(
" Unpacking Tracker: " + std::to_string(iTracker), 100));
1304 for (
short iclock = 0; iclock < bitsNN->getEntries(); ++iclock) {
1306 B2LDataField p_nnenable(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"NNEnable"));
1307 if (p_nnenable.name ==
"None") {
1308 B2DEBUG(5,
"Neurotrigger: NNENable position unknown, skipping ... ");
1310 }
else if (p_nnenable.data ==
"1") {
1311 B2DEBUG(10, padright(
"Tracker: " + std::to_string(iTracker) +
", Clock: " + std::to_string(iclock) +
" : NNEnable set!", 100));
1313 B2DEBUG(21, padright(
" UnpackerClock: " + std::to_string(iclock), 100));
1317 CDCTriggerNeuroConfig::B2FormatLine nnall;
1321 nnall.name =
"nnall";
1323 B2DEBUG(22, padright(
" all bits: ", 100));
1324 B2DEBUG(22, padright(
" " + p_nnall.data, 100));
1326 B2LDataField p_driftthreshold(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"DriftThreshold"));
1327 if ((p_driftthreshold.name !=
"None") && (p_driftthreshold.data.size() == 0)) {
1328 B2DEBUG(10,
"Could not load Datafield: " << p_driftthreshold.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1333 B2LDataField p_valstereobit(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"ValStereoBit"));
1334 if ((p_valstereobit.name !=
"None") && (p_valstereobit.data.size() == 0)) {
1335 B2DEBUG(10,
"Could not load Datafield: " << p_valstereobit.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1340 B2LDataField p_foundoldtrack(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"FoundOldTrack"));
1341 if ((p_foundoldtrack.name !=
"None") && (p_foundoldtrack.data.size() == 0)) {
1342 B2DEBUG(10,
"Could not load Datafield: " << p_foundoldtrack.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1347 B2LDataField p_phi(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"Phi"));
1348 if ((p_phi.name !=
"None") && (p_phi.data.size() == 0)) {
1349 B2DEBUG(10,
"Could not load Datafield: " << p_phi.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1353 B2LDataField p_omega(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"Omega"));
1354 if ((p_omega.name !=
"None") && (p_omega.data.size() == 0)) {
1355 B2DEBUG(10,
"Could not load Datafield: " << p_omega.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1359 B2LDataField p_ts8(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TS8"));
1360 if ((p_ts8.name !=
"None") && (p_ts8.data.size() == 0)) {
1361 B2DEBUG(10,
"Could not load Datafield: " << p_ts8.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1365 B2LDataField p_ts6(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TS6"));
1366 if ((p_ts6.name !=
"None") && (p_ts6.data.size() == 0)) {
1367 B2DEBUG(10,
"Could not load Datafield: " << p_ts6.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1371 B2LDataField p_ts4(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TS4"));
1372 if ((p_ts4.name !=
"None") && (p_ts4.data.size() == 0)) {
1373 B2DEBUG(10,
"Could not load Datafield: " << p_ts4.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1377 B2LDataField p_ts2(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TS2"));
1378 if ((p_ts2.name !=
"None") && (p_ts2.data.size() == 0)) {
1379 B2DEBUG(10,
"Could not load Datafield: " << p_ts2.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1383 B2LDataField p_ts0(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TS0"));
1384 if ((p_ts0.name !=
"None") && (p_ts0.data.size() == 0)) {
1385 B2DEBUG(10,
"Could not load Datafield: " << p_ts0.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1389 B2LDataField p_tsf1(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TSF1"));
1390 if ((p_tsf1.name !=
"None") && (p_tsf1.data.size() == 0)) {
1391 B2DEBUG(10,
"Could not load Datafield: " << p_tsf1.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1395 B2LDataField p_tsf3(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TSF3"));
1396 if ((p_tsf3.name !=
"None") && (p_tsf3.data.size() == 0)) {
1397 B2DEBUG(10,
"Could not load Datafield: " << p_tsf3.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1401 B2LDataField p_tsf5(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TSF5"));
1402 if ((p_tsf5.name !=
"None") && (p_tsf5.data.size() == 0)) {
1403 B2DEBUG(10,
"Could not load Datafield: " << p_tsf5.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1407 B2LDataField p_tsf7(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TSF7"));
1408 if ((p_tsf7.name !=
"None") && (p_tsf7.data.size() == 0)) {
1409 B2DEBUG(10,
"Could not load Datafield: " << p_tsf7.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1413 B2LDataField p_tsfsel(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TSFsel"));
1414 if ((p_tsfsel.name !=
"None") && (p_tsfsel.data.size() == 0)) {
1415 B2DEBUG(10,
"Could not load Datafield: " << p_tsfsel.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1419 B2LDataField p_mlpin_alpha(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPIn_alpha"));
1420 if ((p_mlpin_alpha.name !=
"None") && (p_mlpin_alpha.data.size() == 0)) {
1421 B2DEBUG(10,
"Could not load Datafield: " << p_mlpin_alpha.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1426 B2LDataField p_mlpin_drifttime(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPIn_driftt"));
1427 if ((p_mlpin_drifttime.name !=
"None") && (p_mlpin_drifttime.data.size() == 0)) {
1428 B2DEBUG(10,
"Could not load Datafield: " << p_mlpin_drifttime.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1433 B2LDataField p_mlpin_id(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPIn_id"));
1434 if ((p_mlpin_id.name !=
"None") && (p_mlpin_id.data.size() == 0)) {
1435 B2DEBUG(10,
"Could not load Datafield: " << p_mlpin_id.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1440 B2LDataField p_netsel(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"Netsel"));
1441 if ((p_netsel.name !=
"None") && (p_netsel.data.size() == 0)) {
1442 B2DEBUG(10,
"Could not load Datafield: " << p_netsel.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1446 B2LDataField p_mlpout_z(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPOut_z"));
1447 if ((p_mlpout_z.name !=
"None") && (p_mlpout_z.data.size() == 0)) {
1448 B2DEBUG(10,
"Could not load Datafield: " << p_mlpout_z.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1453 B2LDataField p_mlpout_theta(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPOut_theta"));
1454 if ((p_mlpout_theta.name !=
"None") && (p_mlpout_theta.data.size() == 0)) {
1455 B2DEBUG(10,
"Could not load Datafield: " << p_mlpout_theta.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1460 B2LDataField p_2dcc(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"2dcc"));
1461 if ((p_2dcc.name !=
"None") && (p_2dcc.data.size() == 0)) {
1462 B2DEBUG(10,
"Could not load Datafield: " << p_2dcc.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1466 B2LDataField p_extendedpts(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"extendedPriorityTimes"));
1467 if ((p_extendedpts.name !=
"None") && (p_extendedpts.data.size() == 0)) {
1468 B2DEBUG(10,
"Could not load Datafield: " << p_extendedpts.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1472 B2LDataField p_etftime(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"etftime"));
1473 if ((p_etftime.name !=
"None") && (p_etftime.data.size() == 0)) {
1474 B2DEBUG(10,
"Could not load Datafield: " << p_etftime.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1478 B2LDataField p_etfcc(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"etfcc"));
1479 if ((p_etfcc.name !=
"None") && (p_etfcc.data.size() == 0)) {
1480 B2DEBUG(10,
"Could not load Datafield: " << p_etfcc.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1484 B2LDataField p_etfqual(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"etfquality"));
1485 if ((p_etfqual.name !=
"None") && (p_etfqual.data.size() == 0)) {
1486 B2DEBUG(10,
"Could not load Datafield: " << p_etfqual.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1490 B2LDataField p_etfval(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"etfvalid"));
1491 if ((p_etfval.name !=
"None") && (p_etfval.data.size() == 0)) {
1492 B2DEBUG(10,
"Could not load Datafield: " << p_etfval.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1496 B2LDataField p_nntgdl(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"nntgdl"));
1497 if ((p_nntgdl.name !=
"None") && (p_nntgdl.data.size() == 0)) {
1498 B2DEBUG(10,
"Could not load Datafield: " << p_nntgdl.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1502 B2LDataField p_sttgdl(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"sttgdl"));
1503 if ((p_sttgdl.name !=
"None") && (p_sttgdl.data.size() == 0)) {
1504 B2DEBUG(10,
"Could not load Datafield: " << p_sttgdl.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1511 CDCTriggerTrack* track2D =
nullptr;
1515 B2DEBUG(21, padright(
" Stereos: ", 100));
1516 for (
auto stereolayer : {p_tsf1, p_tsf3, p_tsf5, p_tsf7}) {
1517 if (stereolayer.name ==
"None") {
1518 B2ERROR(
"Error in CDCTriggerNeuroConfig Payload, position of stereo tsf could not be found!");
1521 std::string tsstr =
" | ";
1522 for (
unsigned iHit = 0; iHit < 10; ++iHit) {
1523 tsOut ts = (sim13dt) ? decodeTSHit_sim(stereolayer.data.substr(iHit * lenTS, lenTS),
1524 p_2dcc.data) : decodeTSHit(stereolayer.data.substr(iHit * lenTS, lenTS));
1526 unsigned iTS = TSIDInSL(ts[0], sln * 2 + 1, iTracker);
1527 tsstr += std::to_string(iTS) +
", " + std::to_string(ts[1]) +
", " + std::to_string(ts[2]) +
", " + std::to_string(ts[3]) +
" | ";
1528 addTSHit(ts, sln * 2 + 1, iTracker, tsHitsAll, iclock);
1531 B2DEBUG(21, padright(
" SL" + std::to_string(sln * 2 + 1) + tsstr, 100));
1535 B2DEBUG(21, padright(
" 2DCC: " + std::to_string(std::stoi(p_2dcc.data, 0, 2)) +
", (" + p_2dcc.data +
")", 100));
1536 B2DEBUG(21, padright(
" ETFCC: " + std::to_string(std::stoi(p_etfcc.data, 0, 2)) +
", (" + p_etfcc.data +
")", 100));
1537 B2DEBUG(21, padright(
" ETFVAL: " + std::to_string(std::stoi(p_etfval.data, 0, 2)) +
", (" + p_etfval.data +
")", 100));
1538 B2DEBUG(21, padright(
" ETFT0: " + std::to_string(std::stoi(p_etftime.data, 0, 2)) +
", (" + p_etftime.data +
")", 100));
1539 B2DEBUG(21, padright(
" ETFQuality: " + std::to_string(std::stoi(p_etfqual.data, 0, 2)) +
", (" + p_etfqual.data +
")", 100));
1540 if (p_nnenable.data ==
"1") {
1541 bool hasETFTime =
false;
1542 if (p_etfval.data ==
"1") {
1543 storeETFTime->addBinnedEventT0(std::stoi(p_etftime.data, 0, 2), Const::CDC);
1546 std::vector<bool> foundoldtrack{
false};
1547 std::vector<bool> driftthreshold{
false};
1549 if (p_foundoldtrack.name !=
"None") {
1550 foundoldtrack = decodefoundoldtrack(p_foundoldtrack.data);
1552 if (p_driftthreshold.name !=
"None") {
1553 driftthreshold = decodedriftthreshold(p_driftthreshold.data);
1555 if (p_valstereobit.name !=
"None") {
1556 valstereobit = decodevalstereobit(p_valstereobit.data);
1559 if (std::all_of(p_phi.data.begin(), p_phi.data.end(), [](
char i) {return i == 0;})) {
1560 B2ERROR(
"Empty Phi Value found for 2DTrack, should not happen!");
1575 track2D = store2DTracks->appendNew(trk2D.phi0, trk2D.omega, 0., foundoldtrack, driftthreshold, valstereobit, iclock, iTracker);
1576 track2D->setRawOmega(trk2D.hwOmega);
1577 track2D->setRawPhi0(trk2D.hwPhi0);
1578 B2DEBUG(12, padright(
" 2DTrack: (phi=" + std::to_string(trk2D.phi0) +
", omega=" + std::to_string(
1579 trk2D.omega) +
", update=" + std::to_string(foundoldtrack[1]) +
")", 100));
1583 for (
unsigned iAx = 0; iAx < nAxialTSF; ++iAx) {
1584 const auto& ts = trk2D.ts[iAx];
1586 CDCTriggerSegmentHit* hit =
1587 addTSHit(ts, 2 * iAx, iTracker, tsHitsAll, iclock);
1588 unsigned iTS = TSIDInSL(ts[0], iAx * 2, iTracker);
1589 tsstr +=
"(SL" + std::to_string(iAx * 2) +
", " + std::to_string(iTS) +
", " + std::to_string(ts[1]) +
", " + std::to_string(
1590 ts[2]) +
", " + std::to_string(ts[3]) +
"),";
1591 track2D->addRelationTo(hit);
1594 B2DEBUG(16, padright(
" 2DTrack TS: " + tsstr, 100));
1599 trkNN = decodeNNTrack(p_mlpout_z.data,
1600 p_mlpout_theta.data,
1603 p_mlpin_drifttime.data,
1612 B2DEBUG(11, padright(
" NNTrack: (z=" + std::to_string(trkNN.z) +
", theta=" + std::to_string(trkNN.theta) +
")", 100));
1614 double phi0 = track2D->getPhi0();
1615 double omega = track2D->getOmega();
1617 std::vector<unsigned> tsvector(9, 0);
1618 std::vector<unsigned> tstimevector(9, 0);
1622 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
1623 tsvector[iSL] = trkNN.ts[iSL][3];
1624 tstimevector[iSL] = trkNN.ts[iSL][1];
1625 if (trkNN.ts[iSL][3] > 0) {
1626 unsigned iTS = TSIDInSL(trkNN.ts[iSL][0], iSL, iTracker);
1627 tsstr +=
"(SL" + std::to_string(iSL) +
", " + std::to_string(iTS) +
", " + std::to_string(trkNN.ts[iSL][1]) +
", " + std::to_string(
1628 trkNN.ts[iSL][2]) +
", " + std::to_string(trkNN.ts[iSL][3]) +
"),\n";
1631 if (!(trk2D.ts[iSL / 2][0] == trkNN.ts[iSL][0] &&
1633 trk2D.ts[iSL / 2][2] == trkNN.ts[iSL][2] &&
1634 trk2D.ts[iSL / 2][3] == trkNN.ts[iSL][3])) {
1640 tsstr +=
"( - ),\n";
1644 B2DEBUG(15, padright(
" NNTrack TS: " + tsstr, 100));
1646 CDCTriggerTrack* trackNN = storeNNTracks->appendNew(phi0, omega, 0.,
1647 trkNN.z, cos(trkNN.theta) / sin(trkNN.theta), 0., track2D->getFoundOldTrack(), track2D->getDriftThreshold(),
1648 track2D->getValidStereoBit(), trkNN.sector, tsvector, iclock, iTracker);
1649 trackNN->setHasETFTime(hasETFTime);
1650 track2D->setHasETFTime(hasETFTime);
1651 trackNN->setRawOmega(track2D->getRawOmega());
1652 trackNN->setRawPhi0(track2D->getRawPhi0());
1653 trackNN->setRawTheta(trkNN.hwTheta);
1654 trackNN->setRawZ(trkNN.hwZ);
1656 trackNN->setETF_unpacked(std::stoi(p_etftime.data, 0, 2));
1657 track2D->setETF_unpacked(std::stoi(p_etftime.data, 0, 2));
1659 trackNN->setETF_recalced(recalcETF(p_mlpin_drifttime.data, tstimevector, trackNN));
1660 track2D->setETF_recalced(recalcETF(p_mlpin_drifttime.data, tstimevector, trackNN));
1662 if (isin2d ==
false) {
1663 trackNN->setQualityVector(1);
1665 std::vector<float> inputVector(27, 0.);
1666 std::vector<int> rawinputVector(27, 0.);
1667 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
1668 inputVector[3 * iSL] = trkNN.inputID[iSL];
1669 inputVector[3 * iSL + 1] = trkNN.inputT[iSL];
1670 inputVector[3 * iSL + 2] = trkNN.inputAlpha[iSL];
1671 rawinputVector[3 * iSL] = trkNN.rawinputID[iSL];
1672 rawinputVector[3 * iSL + 1] = trkNN.rawinputT[iSL];
1673 rawinputVector[3 * iSL + 2] = trkNN.rawinputAlpha[iSL];
1675 trackNN->setRawInput(rawinputVector);
1677 CDCTriggerMLPInput* storeInput =
1678 storeNNInputs->appendNew(inputVector, trkNN.sector);
1679 trackNN->addRelationTo(storeInput);
1680 track2D->addRelationTo(trackNN);
1682 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
1683 if (trkNN.ts[iSL][3] > 0) {
1684 CDCTriggerSegmentHit* hit =
nullptr;
1714 hit = addTSHit(trkNN.ts[iSL], iSL, iTracker, tsHits, iclock);
1718 trackNN->addRelationTo(hit);
1720 track2D->addRelationTo(hit);
1724 if (p_nntgdl.name !=
"None") {
1725 bool dbool = decodebool(p_nntgdl.data);
1726 trackNN->setNNTToGDL(dbool);
1727 B2DEBUG(20,
"NNT to GDL Bit decision for this track is: " << dbool);
1729 if (p_sttgdl.name !=
"None") {
1730 bool dbool = decodebool(p_sttgdl.data);
1731 trackNN->setSTTToGDL(dbool);
1732 B2DEBUG(20,
"STT to GDL Bit decision for this track is: " << dbool);
1779 StoreArray<CDCTriggerUnpacker::DNNBitStream>* bitsNN,
1780 StoreArray<CDCTriggerTrack>* store2DTracks,
1781 StoreArray<CDCTriggerTrack>* storeNNTracks,
1782 StoreArray<CDCTriggerSegmentHit>* tsHits,
1783 StoreArray<CDCTriggerSegmentHit>* tsHitsAll,
1784 StoreArray<CDCTriggerMLPInput>* storeNNInputs,
1785 StoreObjPtr<BinnedEventT0> storeETFTime,
1786 const DBObjPtr<CDCTriggerNeuroConfig> neurodb,
1789 for (
unsigned iTracker = 0; iTracker < nTrackers; ++iTracker) {
1790 B2DEBUG(21,
"----------------------------------------------------------------------------------------------------");
1791 B2DEBUG(21, padright(
" Unpacking Tracker: " + std::to_string(iTracker), 100));
1794 for (
short iclock = 0; iclock < bitsNN->getEntries(); ++iclock) {
1798 B2LDataField_DNN p_nnenable(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"NNEnable"));
1799 if (p_nnenable.name ==
"None") {
1800 B2DEBUG(5,
"Neurotrigger: NNENable position unknown, skipping ... ");
1802 }
else if (p_nnenable.data ==
"1") {
1803 B2DEBUG(10, padright(
"Tracker: " + std::to_string(iTracker) +
", Clock: " + std::to_string(iclock) +
" : NNEnable set!", 100));
1805 B2DEBUG(21, padright(
" UnpackerClock: " + std::to_string(iclock), 100));
1809 CDCTriggerNeuroConfig::B2FormatLine nnall;
1813 nnall.name =
"nnall";
1815 B2DEBUG(22, padright(
" all bits: ", 100));
1816 B2DEBUG(22, padright(
" " + p_nnall.data, 100));
1818 B2LDataField_DNN p_driftthreshold(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"DriftThreshold"));
1819 if ((p_driftthreshold.name !=
"None") && (p_driftthreshold.data.size() == 0)) {
1820 B2DEBUG(10,
"Could not load Datafield: " << p_driftthreshold.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1825 B2LDataField_DNN p_valstereobit(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"ValStereoBit"));
1826 if ((p_valstereobit.name !=
"None") && (p_valstereobit.data.size() == 0)) {
1827 B2DEBUG(10,
"Could not load Datafield: " << p_valstereobit.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1831 B2LDataField_DNN p_foundoldtrack(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"FoundOldTrack"));
1832 if ((p_foundoldtrack.name !=
"None") && (p_foundoldtrack.data.size() == 0)) {
1833 B2DEBUG(10,
"Could not load Datafield: " << p_foundoldtrack.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1838 B2LDataField_DNN p_phi(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"Phi"));
1839 if ((p_phi.name !=
"None") && (p_phi.data.size() == 0)) {
1840 B2DEBUG(10,
"Could not load Datafield: " << p_phi.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1844 B2LDataField_DNN p_omega(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"Omega"));
1845 if ((p_omega.name !=
"None") && (p_omega.data.size() == 0)) {
1846 B2DEBUG(10,
"Could not load Datafield: " << p_omega.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1850 B2LDataField_DNN p_ts8(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TS8"));
1851 if ((p_ts8.name !=
"None") && (p_ts8.data.size() == 0)) {
1852 B2DEBUG(10,
"Could not load Datafield: " << p_ts8.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1856 B2LDataField_DNN p_ts6(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TS6"));
1857 if ((p_ts6.name !=
"None") && (p_ts6.data.size() == 0)) {
1858 B2DEBUG(10,
"Could not load Datafield: " << p_ts6.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1862 B2LDataField_DNN p_ts4(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TS4"));
1863 if ((p_ts4.name !=
"None") && (p_ts4.data.size() == 0)) {
1864 B2DEBUG(10,
"Could not load Datafield: " << p_ts4.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1868 B2LDataField_DNN p_ts2(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TS2"));
1869 if ((p_ts2.name !=
"None") && (p_ts2.data.size() == 0)) {
1870 B2DEBUG(10,
"Could not load Datafield: " << p_ts2.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1874 B2LDataField_DNN p_ts0(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TS0"));
1875 if ((p_ts0.name !=
"None") && (p_ts0.data.size() == 0)) {
1876 B2DEBUG(10,
"Could not load Datafield: " << p_ts0.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1880 B2LDataField_DNN p_tsf1(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TSF1"));
1881 if ((p_tsf1.name !=
"None") && (p_tsf1.data.size() == 0)) {
1882 B2DEBUG(10,
"Could not load Datafield: " << p_tsf1.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1886 B2LDataField_DNN p_tsf3(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TSF3"));
1887 if ((p_tsf3.name !=
"None") && (p_tsf3.data.size() == 0)) {
1888 B2DEBUG(10,
"Could not load Datafield: " << p_tsf3.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1892 B2LDataField_DNN p_tsf5(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TSF5"));
1893 if ((p_tsf5.name !=
"None") && (p_tsf5.data.size() == 0)) {
1894 B2DEBUG(10,
"Could not load Datafield: " << p_tsf5.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1898 B2LDataField_DNN p_tsf7(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TSF7"));
1899 if ((p_tsf7.name !=
"None") && (p_tsf7.data.size() == 0)) {
1900 B2DEBUG(10,
"Could not load Datafield: " << p_tsf7.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1904 B2LDataField_DNN p_tsfsel(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"TSFsel"));
1905 if ((p_tsfsel.name !=
"None") && (p_tsfsel.data.size() == 0)) {
1906 B2DEBUG(10,
"Could not load Datafield: " << p_tsfsel.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1910 B2LDataField_DNN p_mlpin_alpha(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPIn_alpha"));
1911 if ((p_mlpin_alpha.name !=
"None") && (p_mlpin_alpha.data.size() == 0)) {
1912 B2DEBUG(10,
"Could not load Datafield: " << p_mlpin_alpha.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1917 B2LDataField_DNN p_mlpin_drifttime(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPIn_driftt"));
1918 if ((p_mlpin_drifttime.name !=
"None") && (p_mlpin_drifttime.data.size() == 0)) {
1919 B2DEBUG(10,
"Could not load Datafield: " << p_mlpin_drifttime.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1924 B2LDataField_DNN p_mlpin_id(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPIn_id"));
1925 if ((p_mlpin_id.name !=
"None") && (p_mlpin_id.data.size() == 0)) {
1926 B2DEBUG(10,
"Could not load Datafield: " << p_mlpin_id.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1931 B2LDataField_DNN p_mlpin_extratime(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPIn_extrat"));
1932 if ((p_mlpin_id.name !=
"None") && (p_mlpin_id.data.size() == 0)) {
1933 B2DEBUG(10,
"Could not load Datafield: " << p_mlpin_id.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1938 B2LDataField_DNN p_netsel(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"Netsel"));
1939 if ((p_netsel.name !=
"None") && (p_netsel.data.size() == 0)) {
1940 B2DEBUG(10,
"Could not load Datafield: " << p_netsel.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1944 B2LDataField_DNN p_mlpout_z(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPOut_z"));
1945 if ((p_mlpout_z.name !=
"None") && (p_mlpout_z.data.size() == 0)) {
1946 B2DEBUG(10,
"Could not load Datafield: " << p_mlpout_z.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1951 B2LDataField_DNN p_mlpout_theta(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPOut_theta"));
1952 if ((p_mlpout_theta.name !=
"None") && (p_mlpout_theta.data.size() == 0)) {
1953 B2DEBUG(10,
"Could not load Datafield: " << p_mlpout_theta.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1958 B2LDataField_DNN p_mlpout_prob(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"MLPOut_p"));
1959 if ((p_mlpout_prob.name !=
"None") && (p_mlpout_prob.data.size() == 0)) {
1960 B2DEBUG(10,
"Could not load Datafield: " << p_mlpout_prob.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1964 B2LDataField_DNN p_2dcc(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"2dcc"));
1965 if ((p_2dcc.name !=
"None") && (p_2dcc.data.size() == 0)) {
1966 B2DEBUG(10,
"Could not load Datafield: " << p_2dcc.name <<
" from bitstream. Maybe offset was out of bounds? clock: " << iclock);
1970 B2LDataField_DNN p_extendedpts(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"extendedPriorityTimes"));
1971 if ((p_extendedpts.name !=
"None") && (p_extendedpts.data.size() == 0)) {
1972 B2DEBUG(10,
"Could not load Datafield: " << p_extendedpts.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1976 B2LDataField_DNN p_etftime(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"etftime"));
1977 if ((p_etftime.name !=
"None") && (p_etftime.data.size() == 0)) {
1978 B2DEBUG(10,
"Could not load Datafield: " << p_etftime.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1982 B2LDataField_DNN p_etfcc(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"etfcc"));
1983 if ((p_etfcc.name !=
"None") && (p_etfcc.data.size() == 0)) {
1984 B2DEBUG(10,
"Could not load Datafield: " << p_etfcc.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1988 B2LDataField_DNN p_etfqual(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"etfquality"));
1989 if ((p_etfqual.name !=
"None") && (p_etfqual.data.size() == 0)) {
1990 B2DEBUG(10,
"Could not load Datafield: " << p_etfqual.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
1994 B2LDataField_DNN p_etfval(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"etfvalid"));
1995 if ((p_etfval.name !=
"None") && (p_etfval.data.size() == 0)) {
1996 B2DEBUG(10,
"Could not load Datafield: " << p_etfval.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
2000 B2LDataField_DNN p_nntgdl(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"nntgdl"));
2001 if ((p_nntgdl.name !=
"None") && (p_nntgdl.data.size() == 0)) {
2002 B2DEBUG(10,
"Could not load Datafield: " << p_nntgdl.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
2006 B2LDataField_DNN p_sttgdl(bitsNN, iclock, iTracker, neurodb->getB2FormatLine(
"sttgdl"));
2007 if ((p_sttgdl.name !=
"None") && (p_sttgdl.data.size() == 0)) {
2008 B2DEBUG(10,
"Could not load Datafield: " << p_sttgdl.name <<
" from bitstream. Maybe offset was out of bounds? clock: " <<
2015 CDCTriggerTrack* track2D =
nullptr;
2019 B2DEBUG(21, padright(
" Stereos: ", 100));
2020 for (
auto stereolayer : {p_tsf1, p_tsf3, p_tsf5, p_tsf7}) {
2021 if (stereolayer.name ==
"None") {
2022 B2ERROR(
"Error in CDCTriggerNeuroConfig Payload, position of stereo tsf could not be found!");
2025 std::string tsstr =
" | ";
2026 for (
unsigned iHit = 0; iHit < 10; ++iHit) {
2027 tsOut ts = (sim13dt) ? decodeTSHit_sim(stereolayer.data.substr(iHit * lenTS, lenTS),
2028 p_2dcc.data) : decodeTSHit(stereolayer.data.substr(iHit * lenTS, lenTS));
2029 extraHitTimeOut exTime = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
2030 if (stereolayer.data.size() % 87 == 0) {
2031 exTime = (sim13dt) ? decodeTSHitExtra_sim(stereolayer.data.substr(iHit * lenTS, lenTS),
2032 p_2dcc.data) : decodeTSHitExtra(stereolayer.data.substr(iHit * lenTS, lenTS));
2035 unsigned iTS = TSIDInSL(ts[0], sln * 2 + 1, iTracker);
2036 tsstr += std::to_string(iTS) +
", " + std::to_string(ts[1]) +
", " + std::to_string(ts[2]) +
", " + std::to_string(ts[3]) +
" | ";
2037 addTSHit(ts, sln * 2 + 1, iTracker, tsHitsAll, iclock, exTime);
2040 B2DEBUG(21, padright(
" SL" + std::to_string(sln * 2 + 1) + tsstr, 100));
2044 B2DEBUG(21, padright(
" 2DCC: " + std::to_string(std::stoi(p_2dcc.data, 0, 2)) +
", (" + p_2dcc.data +
")", 100));
2045 B2DEBUG(21, padright(
" ETFCC: " + std::to_string(std::stoi(p_etfcc.data, 0, 2)) +
", (" + p_etfcc.data +
")", 100));
2046 B2DEBUG(21, padright(
" ETFVAL: " + std::to_string(std::stoi(p_etfval.data, 0, 2)) +
", (" + p_etfval.data +
")", 100));
2047 B2DEBUG(21, padright(
" ETFT0: " + std::to_string(std::stoi(p_etftime.data, 0, 2)) +
", (" + p_etftime.data +
")", 100));
2048 B2DEBUG(21, padright(
" ETFQuality: " + std::to_string(std::stoi(p_etfqual.data, 0, 2)) +
", (" + p_etfqual.data +
")", 100));
2049 if (p_nnenable.data ==
"1") {
2050 bool hasETFTime =
false;
2051 if (p_etfval.data ==
"1") {
2052 storeETFTime->addBinnedEventT0(std::stoi(p_etftime.data, 0, 2), Const::CDC);
2055 std::vector<bool> foundoldtrack{
false};
2056 std::vector<bool> driftthreshold{
false};
2058 if (p_foundoldtrack.name !=
"None") {
2059 foundoldtrack = decodefoundoldtrack(p_foundoldtrack.data);
2061 if (p_driftthreshold.name !=
"None") {
2062 driftthreshold = decodedriftthreshold(p_driftthreshold.data);
2064 if (p_valstereobit.name !=
"None") {
2065 valstereobit = decodevalstereobit(p_valstereobit.data);
2068 if (std::all_of(p_phi.data.begin(), p_phi.data.end(), [](
char i) {return i == 0;})) {
2069 B2ERROR(
"Empty Phi Value found for 2DTrack, should not happen!");
2084 track2D = store2DTracks->appendNew(trk2D.phi0, trk2D.omega, 0., foundoldtrack, driftthreshold, valstereobit, -1, iclock, iTracker);
2085 track2D->setRawOmega(trk2D.hwOmega);
2086 track2D->setRawPhi0(trk2D.hwPhi0);
2087 B2DEBUG(12, padright(
" 2DTrack: (phi=" + std::to_string(trk2D.phi0) +
", omega=" + std::to_string(
2088 trk2D.omega) +
", update=" + std::to_string(foundoldtrack[1]) +
")", 100));
2092 for (
unsigned iAx = 0; iAx < nAxialTSF; ++iAx) {
2093 const auto& ts = trk2D.ts[iAx];
2095 CDCTriggerSegmentHit* hit =
2096 addTSHit(ts, 2 * iAx, iTracker, tsHits, iclock);
2097 unsigned iTS = TSIDInSL(ts[0], iAx * 2, iTracker);
2098 tsstr +=
"(SL" + std::to_string(iAx * 2) +
", " + std::to_string(iTS) +
", " + std::to_string(ts[1]) +
", " + std::to_string(
2099 ts[2]) +
", " + std::to_string(ts[3]) +
"),";
2100 track2D->addRelationTo(hit);
2103 B2DEBUG(16, padright(
" 2DTrack TS: " + tsstr, 100));
2108 trkNN = decodeDNNTrack(p_mlpout_z.data,
2109 p_mlpout_theta.data,
2113 p_mlpin_drifttime.data,
2115 p_mlpin_extratime.data,
2123 B2DEBUG(11, padright(
" NNTrack: (z=" + std::to_string(trkNN.z) +
", theta=" + std::to_string(trkNN.theta) +
")", 100));
2125 double phi0 = track2D->getPhi0();
2126 double omega = track2D->getOmega();
2128 std::vector<unsigned> tsvector(9, 0);
2129 std::vector<unsigned> tstimevector(9, 0);
2133 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
2134 tsvector[iSL] = trkNN.ts[iSL][3];
2135 tstimevector[iSL] = trkNN.ts[iSL][1];
2136 if (trkNN.ts[iSL][3] > 0) {
2137 unsigned iTS = TSIDInSL(trkNN.ts[iSL][0], iSL, iTracker);
2138 tsstr +=
"(SL" + std::to_string(iSL) +
", " + std::to_string(iTS) +
", " + std::to_string(trkNN.ts[iSL][1]) +
", " + std::to_string(
2139 trkNN.ts[iSL][2]) +
", " + std::to_string(trkNN.ts[iSL][3]) +
"),\n";
2142 if (!(trk2D.ts[iSL / 2][0] == trkNN.ts[iSL][0] &&
2144 trk2D.ts[iSL / 2][2] == trkNN.ts[iSL][2] &&
2145 trk2D.ts[iSL / 2][3] == trkNN.ts[iSL][3])) {
2151 tsstr +=
"( - ),\n";
2155 B2DEBUG(15, padright(
" NNTrack TS: " + tsstr, 100));
2157 CDCTriggerTrack* trackNN = storeNNTracks->appendNew(phi0, omega, 0.,
2158 trkNN.z, cos(trkNN.theta) / sin(trkNN.theta), trkNN.prob, 0., track2D->getFoundOldTrack(), track2D->getDriftThreshold(),
2159 track2D->getValidStereoBit(), trkNN.sector, tsvector, iclock, iTracker);
2160 trackNN->setHasETFTime(hasETFTime);
2161 track2D->setHasETFTime(hasETFTime);
2162 trackNN->setRawOmega(track2D->getRawOmega());
2163 trackNN->setRawPhi0(track2D->getRawPhi0());
2164 trackNN->setRawTheta(trkNN.hwTheta);
2165 trackNN->setRawZ(trkNN.hwZ);
2167 trackNN->setETF_unpacked(std::stoi(p_etftime.data, 0, 2));
2168 track2D->setETF_unpacked(std::stoi(p_etftime.data, 0, 2));
2170 trackNN->setETF_recalced(recalcETF(p_mlpin_drifttime.data, tstimevector, trackNN));
2171 track2D->setETF_recalced(recalcETF(p_mlpin_drifttime.data, tstimevector, trackNN));
2173 if (isin2d ==
false) {
2174 trackNN->setQualityVector(1);
2176 std::vector<float> inputVector(71, 0.);
2177 std::vector<int> rawinputVector(71, 0.);
2179 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
2180 inputVector[3 * iSL + counts] = trkNN.inputID[iSL];
2181 inputVector[3 * iSL + 1 + counts] = trkNN.inputT[iSL];
2182 inputVector[3 * iSL + 2 + counts] = trkNN.inputAlpha[iSL];
2183 rawinputVector[3 * iSL + counts] = trkNN.rawinputID[iSL];
2184 rawinputVector[3 * iSL + 1 + counts] = trkNN.rawinputT[iSL];
2185 rawinputVector[3 * iSL + 2 + counts] = trkNN.rawinputAlpha[iSL];
2190 for (
unsigned iSL = 0; iSL < 4; ++iSL) {
2191 for (
unsigned iwire = 0; iwire < 11; ++iwire) {
2192 inputVector[(iSL * (11 + 6) + iwire + 6)] = trkNN.inputExtraT[iSL][iwire];
2193 rawinputVector[(iSL * (11 + 6) + iwire + 6)] = trkNN.rawinputExtraT[iSL][iwire];
2196 trackNN->setRawInput(rawinputVector);
2198 CDCTriggerMLPInput* storeInput =
2199 storeNNInputs->appendNew(inputVector, trkNN.sector);
2200 trackNN->addRelationTo(storeInput);
2201 track2D->addRelationTo(trackNN);
2203 for (
unsigned iSL = 0; iSL < 9; ++iSL) {
2204 if (trkNN.ts[iSL][3] > 0) {
2205 CDCTriggerSegmentHit* hit =
nullptr;
2235 hit = addTSHit(trkNN.ts[iSL], iSL, iTracker, tsHits, iclock, trkNN.TSExtraT[iSL]);
2239 trackNN->addRelationTo(hit);
2241 track2D->addRelationTo(hit);
2245 if (p_nntgdl.name !=
"None") {
2246 bool dbool = decodebool(p_nntgdl.data);
2247 trackNN->setNNTToGDL(dbool);
2248 B2DEBUG(20,
"NNT to GDL Bit decision for this track is: " << dbool);
2250 if (p_sttgdl.name !=
"None") {
2251 bool dbool = decodebool(p_sttgdl.data);
2252 trackNN->setSTTToGDL(dbool);
2253 B2DEBUG(20,
"STT to GDL Bit decision for this track is: " << dbool);
2276 void decodeNNIO_old(
2277 StoreArray<CDCTriggerUnpacker::NNBitStream>* bitsNN,
2278 StoreArray<CDCTriggerTrack>* store2DTracks,
2279 StoreArray<CDCTriggerTrack>* storeNNTracks,
2280 StoreArray<CDCTriggerSegmentHit>* tsHits,
2281 StoreArray<CDCTriggerMLPInput>* storeNNInputs)
2283 for (
short iclock = 0; iclock < bitsNN->getEntries(); ++iclock) {
2284 NNBitStream* bitsIn = (*bitsNN)[iclock];
2285 NNBitStream* bitsOutEnable = (*bitsNN)[iclock];
2286 for (
unsigned iTracker = 0; iTracker < nTrackers; ++iTracker) {
2287 const auto slvOutEnable = bitsOutEnable->signal()[iTracker];
2288 const auto slvIn = bitsIn->signal()[iTracker];
2289 std::string stringOutEnable = slv_to_bin_string(slvOutEnable);
2290 std::string stringIn = slv_to_bin_string(slvIn);
2291 if (stringOutEnable.c_str()[0] ==
'1') {
2292 CDCTriggerTrack* nntrack2D = decodeNNInput(iclock, iTracker, bitsIn, store2DTracks, tsHits);
2294 int foundTime = iclock;
2295 if (foundTime < bitsNN->getEntries()) {
2296 NNBitStream* bitsOut = (*bitsNN)[foundTime];
2297 NNBitStream* bitsSelectTS = (*bitsNN)[iclock];
2298 decodeNNOutput_old(iclock, iTracker, bitsOut, bitsSelectTS,
2299 storeNNTracks, tsHits, storeNNInputs,
const SignalBus & signal()
accessors
static const double speedOfLight
[cm/ns]
Accessor to arrays stored in the data store.
int getEntries() const
Get the number of objects in the array.
Abstract base class for different kinds of events.
tsOutArray ts
all TS of a 2D track
double omega
omega of a 2D track
int hwOmega
hw values of 2dtrack
double phi0
phi0 of a 2D track
int hwZ
raw output values of hw network
std::array< float, 9 > inputT
input T list of a NN track
std::array< float, 9 > inputAlpha
input Alpha list of a NN track
unsigned sector
sector of a NN track
std::array< std::array< float, 11 >, 4 > inputExtraT
input extra time list of a NN track
double prob
probability of background
std::array< float, 9 > inputID
input ID list of a NN track
std::array< tsOut, 9 > ts
input TS list of a NN track
double theta
theta of a NN track