ATLAS Offline Software
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Public Attributes | List of all members
EfexLatomeFibrePacker Class Reference

#include <EfexLatomeFibrePacker.h>

Inheritance diagram for EfexLatomeFibrePacker:
Collaboration diagram for EfexLatomeFibrePacker:

Public Types

enum class  InputDataFrameType { Normal , Alignement }
 type of input data frame More...
using myDataWord = uint32_t

Public Member Functions

 EfexLatomeFibrePacker ()
 Class implementing packing and unpacking data into LAr LATOME eFex format.
virtual ~EfexLatomeFibrePacker ()
virtual std::vector< myDataWord > getPackedData (const std::vector< myDataWord > &inFrame, myDataWord bcNumber, InputDataFrameType frameType) const override
 Function packing the data into the LATOME format, either standard or alignement frame.
virtual std::vector< myDataWord > getPackedControl (const std::vector< myDataWord > &inFrame, myDataWord bcNumber, InputDataFrameType frameType) const override
 Function returning control words.
virtual bool checkCRC (const std::vector< myDataWord > &encodedData, InputDataFrameType frameType) const override
virtual myDataWord getBcNumber (const std::vector< myDataWord > &encodedData, InputDataFrameType frameType) const override
virtual myDataWord getBcMask (InputDataFrameType frameType) const override
virtual std::vector< myDataWord > getUnpackedData (const std::vector< myDataWord > &encodedData, InputDataFrameType frameType) const override
 Function unpacking the data from LATOME format, either standard or alignement frame.
virtual myDataWord crc9full (const std::vector< myDataWord > &inwords, size_t num_bits) const
 Functions calculating CRC over input data.
virtual myDataWord crc9d32 (const std::vector< myDataWord > &inwords, size_t num_words, bool bit_reverse) const
virtual myDataWord crc9d23 (myDataWord inword, myDataWord in_crc, bool bit_reverse) const

Public Attributes

myDataWord K_28_5 = 0xbc
myDataWord K_28_1 = 0x3c
myDataWord K_28_0 = 0x1c

Detailed Description

Definition at line 10 of file EfexLatomeFibrePacker.h.

Member Typedef Documentation

◆ myDataWord

using FibrePackerBase::myDataWord = uint32_t
inherited

Definition at line 25 of file FibrePackerBase.h.

Member Enumeration Documentation

◆ InputDataFrameType

enum class FibrePackerBase::InputDataFrameType
stronginherited

type of input data frame

Enumerator
Normal 

Standard data frame.

Alignement 

Special mapping/alignement frame.

Definition at line 37 of file FibrePackerBase.h.

37 {
38 Normal,
39 Alignement
40 };

Constructor & Destructor Documentation

◆ EfexLatomeFibrePacker()

EfexLatomeFibrePacker::EfexLatomeFibrePacker ( )
inline

Class implementing packing and unpacking data into LAr LATOME eFex format.

The class does heavy lifting of packing and unpacking LATOME data packet. The format is taken from https://gitlab.cern.ch/atlas-lar-be-firmware/LATOME/LATOME/raw/master/LATOME/doc/LAr-LATOME-FW/LAr-LATOME-FW.pdf version from 29th of January 2020

Definition at line 21 of file EfexLatomeFibrePacker.h.

21{}

◆ ~EfexLatomeFibrePacker()

virtual EfexLatomeFibrePacker::~EfexLatomeFibrePacker ( )
inlinevirtual

Definition at line 22 of file EfexLatomeFibrePacker.h.

22{}

Member Function Documentation

◆ checkCRC()

bool EfexLatomeFibrePacker::checkCRC ( const std::vector< myDataWord > & encodedData,
InputDataFrameType frameType ) const
overridevirtual

Implements FibrePackerBase.

Definition at line 110 of file EfexLatomeFibrePacker.cxx.

111 {
112
113 auto inputData = encodedData;
114 myDataWord CRCCheck = 0;
115
116 // Comment SJH: why do we need two cases here
117 // (may have been different originally, but not now?)
118 switch(frameType){
119
120 case InputDataFrameType::Normal: // one K character in first data word
121 inputData.at(0) = inputData.at(0) & 0xffffff00;
122 // old code
123 // CRCCheck = crc9d32(inputData,7l,true); // calculate CRC32 on first 6 words
124 // new code
125 CRCCheck = crc9full(inputData,224); // calculate CRC on 224 bits = 7*32 bit words
126 break;
127
128 case InputDataFrameType::Alignement: // two K characters in first data word, but zeroing only the first one
129 inputData.at(0) = inputData.at(0) & 0xffffff00;
130 // old code
131 // CRCCheck = crc9d32(inputData,7l,true); // calculate CRC32 on first 6 words
132 // new code
133 CRCCheck = crc9full(inputData,224); // calculate CRC on 224 bits = 7*32 bit words
134 break;
135
136 }
137
138 return (CRCCheck == 0);
139}
FibrePackerBase::crc9full
virtual myDataWord crc9full(const std::vector< myDataWord > &inwords, size_t num_bits) const
Functions calculating CRC over input data.
Definition FibrePackerBase.cxx:11
FibrePackerBase::InputDataFrameType::Alignement
@ Alignement
Special mapping/alignement frame.
Definition FibrePackerBase.h:39

◆ crc9d23()

FibrePackerBase::myDataWord FibrePackerBase::crc9d23 ( FibrePackerBase::myDataWord inword,
myDataWord in_crc,
bool bit_reverse ) const
virtualinherited

CRC9D23 as specified in LAr VHDL

Function does CRC9D23 calculation. Thanslated from LATOME VHDL to python by Ed Flaherty, then to c++ by jb

Definition at line 111 of file FibrePackerBase.cxx.

111 {
112
119
120
121 long int mask = 0x00000001;
122 long int crc_word = 0x000;
123
124
125 //d_in_s is a '23-bit input word'
126
127 std::vector<long int> d_in_s(23,0);
128 std::vector<long int> crc_in_s(9,0);
129 std::vector<long int> crc_r(9,0);
130
131 // crc calculation
132
133 if (bit_reverse){
134
135 for(int i=0; i!= 23; i++){
136 d_in_s[22-i] = inword & (mask << i);
137 d_in_s[22-i] = d_in_s[22-i] >> i;
138 }
139
140 for(int i=0; i!= 9; i++){
141 crc_in_s[8-i] = in_crc & (mask << i);
142 crc_in_s[8-i] = crc_in_s[8-i] >> i;
143 }
144
145 } else {
146
147 for(int i=0; i!= 23; i++){
148 d_in_s[i] = inword & (mask << i);
149 d_in_s[i] = d_in_s[i] >> i;
150 }
151
152 for(int i=0; i!= 9; i++){
153 crc_in_s[i] = in_crc & (mask << i);
154 crc_in_s[i] = crc_in_s[i] >> i;
155 }
156 }
157
158 crc_r[0] = crc_in_s[1] ^ crc_in_s[4] ^ crc_in_s[5] ^ crc_in_s[6] ^ crc_in_s[7] ^ crc_in_s[8] ^ d_in_s[0] ^ d_in_s[2] ^ d_in_s[3] ^ d_in_s[5] ^ d_in_s[6] ^ d_in_s[7] ^ d_in_s[8] ^ d_in_s[9] ^ d_in_s[10] ^ d_in_s[11] ^ d_in_s[15] ^ d_in_s[18] ^ d_in_s[19] ^ d_in_s[20] ^ d_in_s[21] ^ d_in_s[22];
159 crc_r[1] = crc_in_s[1] ^ crc_in_s[2] ^ crc_in_s[4] ^ d_in_s[0] ^ d_in_s[1] ^ d_in_s[2] ^ d_in_s[4] ^ d_in_s[5] ^ d_in_s[12] ^ d_in_s[15] ^ d_in_s[16] ^ d_in_s[18];
160 crc_r[2] = crc_in_s[2] ^ crc_in_s[3] ^ crc_in_s[5] ^ d_in_s[1] ^ d_in_s[2] ^ d_in_s[3] ^ d_in_s[5] ^ d_in_s[6] ^ d_in_s[13] ^ d_in_s[16] ^ d_in_s[17] ^ d_in_s[19];
161 crc_r[3] = crc_in_s[0] ^ crc_in_s[1] ^ crc_in_s[3] ^ crc_in_s[5] ^ crc_in_s[7] ^ crc_in_s[8] ^ d_in_s[0] ^ d_in_s[4] ^ d_in_s[5] ^ d_in_s[8] ^ d_in_s[9] ^ d_in_s[10] ^ d_in_s[11] ^ d_in_s[14] ^ d_in_s[15] ^ d_in_s[17] ^ d_in_s[19] ^ d_in_s[21] ^ d_in_s[22];
162 crc_r[4] = crc_in_s[2] ^ crc_in_s[5] ^ crc_in_s[7] ^ d_in_s[0] ^ d_in_s[1] ^ d_in_s[2] ^ d_in_s[3] ^ d_in_s[7] ^ d_in_s[8] ^ d_in_s[12] ^ d_in_s[16] ^ d_in_s[19] ^ d_in_s[21];
163 crc_r[5] = crc_in_s[1] ^ crc_in_s[3] ^ crc_in_s[4] ^ crc_in_s[5] ^ crc_in_s[7] ^ d_in_s[0] ^ d_in_s[1] ^ d_in_s[4] ^ d_in_s[5] ^ d_in_s[6] ^ d_in_s[7] ^ d_in_s[10] ^ d_in_s[11] ^ d_in_s[13] ^ d_in_s[15] ^ d_in_s[17] ^ d_in_s[18] ^ d_in_s[19] ^ d_in_s[21];
164 crc_r[6] = crc_in_s[0] ^ crc_in_s[1] ^ crc_in_s[2] ^ crc_in_s[7] ^ d_in_s[0] ^ d_in_s[1] ^ d_in_s[3] ^ d_in_s[9] ^ d_in_s[10] ^ d_in_s[12] ^ d_in_s[14] ^ d_in_s[15] ^ d_in_s[16] ^ d_in_s[21];
165 crc_r[7] = crc_in_s[2] ^ crc_in_s[3] ^ crc_in_s[4] ^ crc_in_s[5] ^ crc_in_s[6] ^ crc_in_s[7] ^ d_in_s[0] ^ d_in_s[1] ^ d_in_s[3] ^ d_in_s[4] ^ d_in_s[5] ^ d_in_s[6] ^ d_in_s[7] ^ d_in_s[8] ^ d_in_s[9] ^ d_in_s[13] ^ d_in_s[16] ^ d_in_s[17] ^ d_in_s[18] ^ d_in_s[19] ^ d_in_s[20] ^ d_in_s[21];
166 crc_r[8] = crc_in_s[0] ^ crc_in_s[3] ^ crc_in_s[4] ^ crc_in_s[5] ^ crc_in_s[6] ^ crc_in_s[7] ^ crc_in_s[8] ^ d_in_s[1] ^ d_in_s[2] ^ d_in_s[4] ^ d_in_s[5] ^ d_in_s[6] ^ d_in_s[7] ^ d_in_s[8] ^ d_in_s[9] ^ d_in_s[10] ^ d_in_s[14] ^ d_in_s[17] ^ d_in_s[18] ^ d_in_s[19] ^ d_in_s[20] ^ d_in_s[21] ^ d_in_s[22];
167
168
169 if (bit_reverse){
170 for(int i=0; i!= 9; i++)
171 crc_word = crc_word | (crc_r[8-i] << i);
172 } else{
173 for(int i=0; i!= 9; i++)
174 crc_word = crc_word | (crc_r[i] << i);
175 }
176
177 return (crc_word);
178
179}

◆ crc9d32()

FibrePackerBase::myDataWord FibrePackerBase::crc9d32 ( const std::vector< myDataWord > & inwords,
size_t num_words,
bool bit_reverse = true ) const
virtualinherited

CRC9D32 as specified in LAr VHDL

Function does CRC9D32 calculation. Thanslated from LATOME VHDL to python by Ed Flaherty, then to c++ by jb

Definition at line 40 of file FibrePackerBase.cxx.

40 {
47
48 long int mask = 0x00000001;
49 long int crc_word = 0x000;
50
51
52 //d_in_s is a '23-bit input word'
53
54 std::vector<long int> d_in(32,0);
55 std::vector<long int> crc_s(9,1);
56 std::vector<long int> crc_r(9,1);
57
58 for(size_t k=0; k != num_words; k++){
59
60 // 32-bit word crc calculation
61
62 if (bit_reverse){
63 for(int i=0; i!= 32; i++){
64 d_in [31-i] = inwords.at(k) & (mask << i);
65 d_in[31-i] = d_in[31-i] >> i;
66 }
67 } else {
68 for(int i=0; i!= 32; i++){
69 d_in [i] = inwords.at(k) & (mask << i);
70 d_in[i] = d_in[i] >> i;
71 }
72 }
73
74 // in the first iteration CRC_S must be set to all 1's: note CRC_R is set to 1's above
75 // then CRC_S must equal the previous CRC_R
76
77 for(int j=0; j!= 9; j++)
78 crc_s[j] = crc_r[j];
79
80
81 crc_r[0]= crc_s[0] ^ crc_s[2] ^ crc_s[3] ^ crc_s[6] ^ crc_s[8] ^ d_in[0] ^ d_in[2] ^ d_in[3] ^ d_in[5] ^ d_in[6] ^ d_in[7] ^ d_in[8] ^ d_in[9] ^ d_in[10] ^ d_in[11] ^ d_in[15] ^ d_in[18] ^ d_in[19] ^ d_in[20] ^ d_in[21] ^ d_in[22] ^ d_in[23] ^ d_in[25] ^ d_in[26] ^ d_in[29] ^ d_in[31];
82 crc_r[1]= crc_s[1] ^ crc_s[2] ^ crc_s[4] ^ crc_s[6] ^ crc_s[7] ^ crc_s[8] ^ d_in[0] ^ d_in[1] ^ d_in[2] ^ d_in[4] ^ d_in[5] ^ d_in[12] ^ d_in[15] ^ d_in[16] ^ d_in[18] ^ d_in[24] ^ d_in[25] ^ d_in[27] ^ d_in[29] ^ d_in[30] ^ d_in[31];
83 crc_r[2]= crc_s[2] ^ crc_s[3] ^ crc_s[5] ^ crc_s[7] ^ crc_s[8] ^ d_in[1] ^ d_in[2] ^ d_in[3] ^ d_in[5] ^ d_in[6] ^ d_in[13] ^ d_in[16] ^ d_in[17] ^ d_in[19] ^ d_in[25] ^ d_in[26] ^ d_in[28] ^ d_in[30] ^ d_in[31];
84 crc_r[3]= crc_s[0] ^ crc_s[2] ^ crc_s[4] ^ d_in[0] ^ d_in[4] ^ d_in[5] ^ d_in[8] ^ d_in[9] ^ d_in[10] ^ d_in[11] ^ d_in[14] ^ d_in[15] ^ d_in[17] ^ d_in[19] ^ d_in[21] ^ d_in[22] ^ d_in[23] ^ d_in[25] ^ d_in[27];
85 crc_r[4]= crc_s[1] ^ crc_s[2] ^ crc_s[5] ^ crc_s[6] ^ crc_s[8] ^ d_in[0] ^ d_in[1] ^ d_in[2] ^ d_in[3] ^ d_in[7] ^ d_in[8] ^ d_in[12] ^ d_in[16] ^ d_in[19] ^ d_in[21] ^ d_in[24] ^ d_in[25] ^ d_in[28] ^ d_in[29] ^ d_in[31];
86 crc_r[5]= crc_s[0] ^ crc_s[7] ^ crc_s[8] ^ d_in[0] ^ d_in[1] ^ d_in[4] ^ d_in[5] ^ d_in[6] ^ d_in[7] ^ d_in[10] ^ d_in[11] ^ d_in[13] ^ d_in[15] ^ d_in[17] ^ d_in[18] ^ d_in[19] ^ d_in[21] ^ d_in[23] ^ d_in[30] ^ d_in[31];
87 crc_r[6]= crc_s[0] ^ crc_s[1] ^ crc_s[2] ^ crc_s[3] ^ crc_s[6] ^ d_in[0] ^ d_in[1] ^ d_in[3] ^ d_in[9] ^ d_in[10] ^ d_in[12] ^ d_in[14] ^ d_in[15] ^ d_in[16] ^ d_in[21] ^ d_in[23] ^ d_in[24] ^ d_in[25] ^ d_in[26] ^ d_in[29];
88 crc_r[7]= crc_s[0] ^ crc_s[1] ^ crc_s[4] ^ crc_s[6] ^ crc_s[7] ^ crc_s[8] ^ d_in[0] ^ d_in[1] ^ d_in[3] ^ d_in[4] ^ d_in[5] ^ d_in[6] ^ d_in[7] ^ d_in[8] ^ d_in[9] ^ d_in[13] ^ d_in[16] ^ d_in[17] ^ d_in[18] ^ d_in[19] ^ d_in[20] ^ d_in[21] ^ d_in[23] ^ d_in[24] ^ d_in[27] ^ d_in[29] ^ d_in[30] ^ d_in[31];
89 crc_r[8]= crc_s[1] ^ crc_s[2] ^ crc_s[5] ^ crc_s[7] ^ crc_s[8] ^ d_in[1] ^ d_in[2] ^ d_in[4] ^ d_in[5] ^ d_in[6] ^ d_in[7] ^ d_in[8] ^ d_in[9] ^ d_in[10] ^ d_in[14] ^ d_in[17] ^ d_in[18] ^ d_in[19] ^ d_in[20] ^ d_in[21] ^ d_in[22] ^ d_in[24] ^ d_in[25] ^ d_in[28] ^ d_in[30] ^ d_in[31];
90
91 crc_word = 0x000;
92
93 if (bit_reverse){
94
95 for(int i=0; i!= 9; i++)
96 crc_word = crc_word | (crc_r[8-i] << i);
97
98 } else {
99
100 for(int i=0; i!= 9; i++)
101 crc_word = crc_word | (crc_r[i] << i);
102
103 }
104
105 }
106
107 return (crc_word);
108
109}

◆ crc9full()

FibrePackerBase::myDataWord FibrePackerBase::crc9full ( const std::vector< myDataWord > & inwords,
size_t num_bits ) const
virtualinherited

Functions calculating CRC over input data.

CRC9 with polynomial 1011111011 over num_bits bits

Uses a more succinct CRC calculation and flexible in terms of digits, checked versus old code but only supports bit reversal = true

Definition at line 11 of file FibrePackerBase.cxx.

12{
20
21 size_t num_words = inwords.size();
22 if ( (num_bits+31)/32 > num_words )
23 {
24 std::cout << "ERROR: not enough words (" << num_words << ") for " << num_bits << "-bit CRC calculation." << std::endl;
25 return 0;
26 }
27 long int val = 0x1ff;
28 for ( size_t i = 0 ; i < num_bits ; ++i )
29 {
30 if ( (inwords.at(i/32)>>(i%32)) & 1 )
31 val ^= 1;
32 if ( val&1 )
33 val ^= 0x37d; // 1101111101 = polynomial reversed
34 val >>= 1;
35 }
36 return val;
37}
Pythia8_RapidityOrderMPI.val
val
Definition Pythia8_RapidityOrderMPI.py:14

◆ getBcMask()

FibrePackerBase::myDataWord EfexLatomeFibrePacker::getBcMask ( InputDataFrameType frameType) const
overridevirtual

Implements FibrePackerBase.

Definition at line 166 of file EfexLatomeFibrePacker.cxx.

166 {
167 // BC number is just 7 bits for normal frames
168 // but the full 12 bits from align frames.
169 return (frameType == InputDataFrameType::Alignement) ? 0xfff : 0x07f;
170}

◆ getBcNumber()

FibrePackerBase::myDataWord EfexLatomeFibrePacker::getBcNumber ( const std::vector< myDataWord > & encodedData,
InputDataFrameType frameType ) const
overridevirtual

Implements FibrePackerBase.

Definition at line 141 of file EfexLatomeFibrePacker.cxx.

142 {
143 myDataWord BcNumber =0;
144
145 switch(frameType){
146
147 case InputDataFrameType::Normal:
148 {
149 myDataWord bcId02 = (encodedData.at(6) >> 20 ) & 0x7;
150 myDataWord bcId34 = (encodedData.at(0) >> 30 ) & 0x3;
151 myDataWord bcId56 = (encodedData.at(0) >> 8 ) & 0x3;
152
153 BcNumber = bcId02 | (bcId34 << 3) | (bcId56 << 5);
154 break;
155 }
156 case InputDataFrameType::Alignement:
157 {
158 BcNumber = encodedData.at(6) & 0xfff;
159 break;
160 }
161 }
162
163 return BcNumber;
164}

◆ getPackedControl()

std::vector< FibrePackerBase::myDataWord > EfexLatomeFibrePacker::getPackedControl ( const std::vector< myDataWord > & inFrame,
myDataWord bcNumber,
InputDataFrameType frameType ) const
overridevirtual

Function returning control words.

The control words are used to distinguish between standard data and K characters. Each K character is 8 bit long and can be at one of four positions in 32 bit word. Control words encode location of K characters in 32 bit words, for example 0x1 means K character in the lowest byte, 0x3 means two K-characters in two lowest bytes

Implements FibrePackerBase.

Definition at line 89 of file EfexLatomeFibrePacker.cxx.

91 {
92
93 std::vector<myDataWord> controlWords(FexDefs::num32BitWordsPerFibre(),0);
94
95 switch(frameType){
96
97 case InputDataFrameType::Normal: // one K character in first data word
98 controlWords.at(0) = 0x1;
99 break;
100
101 case InputDataFrameType::Alignement: // two K characters in first data word
102 controlWords.at(0) = 0x3;
103 break;
104
105 }
106
107 return controlWords;
108}
FexDefs::num32BitWordsPerFibre
static int num32BitWordsPerFibre()
Definition FexDefs.h:17

◆ getPackedData()

std::vector< FibrePackerBase::myDataWord > EfexLatomeFibrePacker::getPackedData ( const std::vector< myDataWord > & inFrame,
myDataWord bcNumber,
InputDataFrameType frameType ) const
overridevirtual

Function packing the data into the LATOME format, either standard or alignement frame.

The function expects input data in vector inFrame. For normal frame, this is a vector of supercell energies. For alignement frame this function expects LATOME meta information in following format: inFrame[0] ... latome_id inFrame[1] ... latome_src_id inFrame[2] ... fiber_id

FEX_ID is always set to zero because it's eFex

Implements FibrePackerBase.

Definition at line 13 of file EfexLatomeFibrePacker.cxx.

15 {
16
17 std::vector<myDataWord> dataToLoad(FexDefs::num32BitWordsPerFibre(),0);
18 auto supercells = inFrame;
19
20 switch(frameType){
21
22 case InputDataFrameType::Normal: // Standard data pattern
23 {
24 for(auto& icell:supercells)
25 icell = icell & 0x3ff; // truncate to 10 bits
26
27 myDataWord bcId = bcNumber & 0x7f ; // 7 bits from BCID
28
29 myDataWord bcId02 = bcId & 0x7;
30 myDataWord bcId34 = (bcId >> 3) & 0x3;
31 myDataWord bcId56 = (bcId >> 5) & 0x3;
32
33 dataToLoad.at(0) = (bcId56 << 8) | (supercells.at(0) <<10) |
34 (supercells.at(1) << 20) | (bcId34 << 30);
35 dataToLoad.at(1) = supercells.at(2) | (supercells.at(3) << 10) |
36 (supercells.at(4) << 20) | (((supercells.at(19) >>8) & 0x3) << 30);
37 dataToLoad.at(2) = supercells.at(5) | (supercells.at(6) << 10) |
38 (supercells.at(7) << 20) | (((supercells.at(19) >>6) & 0x3) << 30);
39 dataToLoad.at(3) = supercells.at(8) | (supercells.at(9) << 10) |
40 (supercells.at(10) << 20) | (((supercells.at(19) >>4) & 0x3) << 30);
41 dataToLoad.at(4) = supercells.at(11) | (supercells.at(12) << 10) |
42 (supercells.at(13) << 20) | (((supercells.at(19) >>2) & 0x3) << 30);
43 dataToLoad.at(5) = supercells.at(14) | (supercells.at(15) << 10) |
44 (supercells.at(16) << 20) | (((supercells.at(19) ) & 0x3) << 30);
45 dataToLoad.at(6) = supercells.at(17) | (supercells.at(18) << 10)| bcId02 << 20;
46
47 // original code
48 // myDataWord tempCRC = crc9d32(dataToLoad,6l,true); // calculate CRC32 on first 6 words
49 // myDataWord myCRCReminder = crc9d23(dataToLoad[6],tempCRC,true); // CRC23 on the last word
50 // new code
51 myDataWord myCRCReminder = crc9full(dataToLoad,215); // 215 = 32*6+23
52
53 dataToLoad.at(0) = K_28_5 | dataToLoad.at(0) ; // add K-character
54 dataToLoad[6] = dataToLoad[6] | ( myCRCReminder << 23) ; // add CRC check
55
56 break;
57 }
58 case InputDataFrameType::Alignement: // Special pattern, LATOME alignement/mapping frame
59 {
60
61 myDataWord latome_id = supercells.at(0) & 0xff; // 8b
62 myDataWord latome_src_id = supercells.at(1) & 0xffffffff; // 32b
63 myDataWord fiber_id = supercells.at(2) & 0x3f; // 6b
64 myDataWord bcId = bcNumber & 0xfff ; // 12 bits of BCID
65
66 dataToLoad.at(0) = (fiber_id << 16) | (latome_id << 24);
67 dataToLoad.at(1) = latome_src_id;
68 dataToLoad.at(6) = bcId;
69
70 dataToLoad.at(0) = (K_28_0 << 8) | dataToLoad.at(0) ; // add K_28_0, this is used for CRC calculation
71
72 // original code
73 // myDataWord tempCRC = crc9d32(dataToLoad,6l,true); // calculate CRC32 on first 6 words
74 //myDataWord myCRCReminder = crc9d23(dataToLoad[6],tempCRC,true); // CRC23 on the last word
75 // new code
76 myDataWord myCRCReminder = crc9full(dataToLoad,215); // 215 = 32*6+23
77
78 dataToLoad.at(0) = K_28_5 | dataToLoad.at(0) ; // add K_28_5, this is not used for CRC calculation
79 dataToLoad[6] = dataToLoad[6] | ( myCRCReminder << 23) ; // add CRC check to the famous last word
80
81 break;
82 }
83 }
84
85 return dataToLoad;
86
87}
bcId
uint16_t bcId(uint32_t data)
Definition TgcByteStreamData.h:326

◆ getUnpackedData()

std::vector< FibrePackerBase::myDataWord > EfexLatomeFibrePacker::getUnpackedData ( const std::vector< myDataWord > & encodedData,
InputDataFrameType frameType ) const
overridevirtual

Function unpacking the data from LATOME format, either standard or alignement frame.

For normal frame, the function returns a vector of supercell energies. For alignement frame the function returns LATOME meta information in following format: inFrame[0] ... latome_id inFrame[1] ... latome_src_id inFrame[2] ... fiber_id

Implements FibrePackerBase.

Definition at line 172 of file EfexLatomeFibrePacker.cxx.

173 {
174 std::vector<myDataWord> unpackedData;
175
176 switch(frameType){
177
178 case InputDataFrameType::Normal:
179 {
180 std::vector<myDataWord> supercells(EfexDefs::maxSuperCellsPerFibre(),0);
181
182 // see: https://gitlab.cern.ch/atlas-l1calo-online/infraL1Calo/-/commit/1dc82d1ce21c14ca56d90e1af7d1af9bdb7990df#note_5865270
183 // 20 10-bit counts encoded in 7 32-bit words
184 // word 0 has 2, word 1-5 have 3 each (so 15 in total),
185 // word 6 has 2 more, and the last count is spread over the extra
186 // 2 bits in words 1-5
187
188 supercells[0] = (encodedData[0] >> 10) & 0x3ff;
189 supercells[1] = (encodedData[0] >> 20) & 0x3ff;
190 supercells[2] = (encodedData[1] ) & 0x3ff;
191 supercells[3] = (encodedData[1] >> 10) & 0x3ff;
192 supercells[4] = (encodedData[1] >> 20) & 0x3ff;
193 supercells[5] = (encodedData[2] ) & 0x3ff;
194 supercells[6] = (encodedData[2] >> 10) & 0x3ff;
195 supercells[7] = (encodedData[2] >> 20) & 0x3ff;
196 supercells[8] = (encodedData[3] ) & 0x3ff;
197 supercells[9] = (encodedData[3] >> 10) & 0x3ff;
198 supercells[10] = (encodedData[3] >> 20) & 0x3ff;
199 supercells[11] = (encodedData[4] ) & 0x3ff;
200 supercells[12] = (encodedData[4] >> 10) & 0x3ff;
201 supercells[13] = (encodedData[4] >> 20) & 0x3ff;
202 supercells[14] = (encodedData[5] ) & 0x3ff;
203 supercells[15] = (encodedData[5] >> 10) & 0x3ff;
204 supercells[16] = (encodedData[5] >> 20) & 0x3ff;
205 supercells[17] = (encodedData.at(6) ) & 0x3ff;
206 supercells[18] = (encodedData[6] >> 10) & 0x3ff;
207 supercells.at(19) = ((encodedData[5] >> 30) & 0x3) |
208 ((encodedData[4] >> 30) & 0x3) << 2 |
209 ((encodedData[3] >> 30) & 0x3) << 4 |
210 ((encodedData[2] >> 30) & 0x3) << 6 |
211 ((encodedData[1] >> 30) & 0x3) << 8 ;
212 unpackedData=std::move(supercells);
213 break;
214 }
215 case InputDataFrameType::Alignement:
216 {
217 myDataWord latome_id = (encodedData.at(0) >> 24) & 0xff; // 8b
218 myDataWord latome_src_id = encodedData.at(1) & 0xffffffff; // 32b
219 myDataWord fiber_id = (encodedData.at(0) >> 16) & 0x3f; // 6b
220
221 unpackedData.push_back(latome_id);
222 unpackedData.push_back(latome_src_id);
223 unpackedData.push_back(fiber_id);
224 break;
225 }
226 }
227
228
229 return unpackedData;
230
231}
EfexDefs::maxSuperCellsPerFibre
static int maxSuperCellsPerFibre()
Definition EfexDefs.h:27

Member Data Documentation

◆ K_28_0

myDataWord FibrePackerBase::K_28_0 = 0x1c
inherited

Definition at line 32 of file FibrePackerBase.h.

◆ K_28_1

myDataWord FibrePackerBase::K_28_1 = 0x3c
inherited

Definition at line 31 of file FibrePackerBase.h.

◆ K_28_5

myDataWord FibrePackerBase::K_28_5 = 0xbc
inherited

Definition at line 30 of file FibrePackerBase.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0