ATLAS Offline Software
Public Types | Public Member Functions | Public Attributes | List of all members
EfexTrexFibrePacker Class Reference

#include <EfexTrexFibrePacker.h>

Inheritance diagram for EfexTrexFibrePacker:
Collaboration diagram for EfexTrexFibrePacker:

Public Types

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

Public Member Functions

 EfexTrexFibrePacker ()
 Class implementing packing and unpacking data into TREX eFex format. More...
 
virtual ~EfexTrexFibrePacker ()
 
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. More...
 
virtual std::vector< myDataWord > getPackedControl (const std::vector< myDataWord > &inFrame, myDataWord bcNumber, InputDataFrameType frameType) const override
 Function returning control words. More...
 
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. More...
 
virtual myDataWord crc9full (const std::vector< myDataWord > &inwords, size_t num_bits) const
 Functions calculating CRC over input data. More...
 
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 EfexTrexFibrePacker.h.

Member Typedef Documentation

◆ myDataWord

using FibrePackerBase::myDataWord = uint32_t
inherited

Definition at line 25 of file FibrePackerBase.h.

Member Enumeration Documentation

◆ InputDataFrameType

enum 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

◆ EfexTrexFibrePacker()

EfexTrexFibrePacker::EfexTrexFibrePacker ( )
inline

Class implementing packing and unpacking data into TREX eFex format.

The class does heavy lifting of packing and unpacking TREX data packet. The format is similar to one used by LATOME and stored at https://gitlab.cern.ch/atlas-lar-be-firmware/LATOME/LATOME/raw/master/LATOME/doc/LAr-LATOME-FW/LAr-LATOME-FW.pdf but different in few important details! Most recent version is called TREX-FEX Real-Time Data Formats v3 14.10.2019

Definition at line 21 of file EfexTrexFibrePacker.h.

21 {}

◆ ~EfexTrexFibrePacker()

virtual EfexTrexFibrePacker::~EfexTrexFibrePacker ( )
inlinevirtual

Definition at line 22 of file EfexTrexFibrePacker.h.

22 {}

Member Function Documentation

◆ checkCRC()

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

Implements FibrePackerBase.

Definition at line 93 of file EfexTrexFibrePacker.cxx.

94  {
95 
96  auto inputData = encodedData;
97  myDataWord CRCCheck = 0;
98 
99  switch(frameType){
100 
101  case InputDataFrameType::Normal: // one K character in first data word
102  inputData.at(0) = inputData.at(0) & 0xffffff00;
103  CRCCheck = crc9d32(inputData,7l,true); // calculate CRC32 on first 6 words
104  break;
105 
106  case InputDataFrameType::Alignement: // two K characters in first data word, mask the first one
107  inputData.at(0) = inputData.at(0) & 0xffffff00;
108  CRCCheck = crc9d32(inputData,7l,true); // calculate CRC32 on first 6 words
109  break;
110 
111  }
112 
113  return (CRCCheck == 0);
114 }

◆ 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 108 of file FibrePackerBase.cxx.

108  {
109 
118  long int mask = 0x00000001;
119  long int crc_word = 0x000;
120 
121 
122  //d_in_s is a '23-bit input word'
123 
124  std::vector<long int> d_in_s(23,0);
125  std::vector<long int> crc_in_s(9,0);
126  std::vector<long int> crc_r(9,0);
127 
128  // crc calculation
129 
130  if (bit_reverse){
131 
132  for(int i=0; i!= 23; i++){
133  d_in_s[22-i] = inword & (mask << i);
134  d_in_s[22-i] = d_in_s[22-i] >> i;
135  }
136 
137  for(int i=0; i!= 9; i++){
138  crc_in_s[8-i] = in_crc & (mask << i);
139  crc_in_s[8-i] = crc_in_s[8-i] >> i;
140  }
141 
142  } else {
143 
144  for(int i=0; i!= 23; i++){
145  d_in_s[i] = inword & (mask << i);
146  d_in_s[i] = d_in_s[i] >> i;
147  }
148 
149  for(int i=0; i!= 9; i++){
150  crc_in_s[i] = in_crc & (mask << i);
151  crc_in_s[i] = crc_in_s[i] >> i;
152  }
153  }
154 
155  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];
156  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];
157  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];
158  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];
159  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];
160  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];
161  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];
162  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];
163  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];
164 
165 
166  if (bit_reverse){
167  for(int i=0; i!= 9; i++)
168  crc_word = crc_word | (crc_r[8-i] << i);
169  } else{
170  for(int i=0; i!= 9; i++)
171  crc_word = crc_word | (crc_r[i] << i);
172  }
173 
174  return (crc_word);
175 
176 }

◆ 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 37 of file FibrePackerBase.cxx.

37  {
45  long int mask = 0x00000001;
46  long int crc_word = 0x000;
47 
48 
49  //d_in_s is a '23-bit input word'
50 
51  std::vector<long int> d_in(32,0);
52  std::vector<long int> crc_s(9,1);
53  std::vector<long int> crc_r(9,1);
54 
55  for(size_t k=0; k != num_words; k++){
56 
57  // 32-bit word crc calculation
58 
59  if (bit_reverse){
60  for(int i=0; i!= 32; i++){
61  d_in [31-i] = inwords.at(k) & (mask << i);
62  d_in[31-i] = d_in[31-i] >> i;
63  }
64  } else {
65  for(int i=0; i!= 32; i++){
66  d_in [i] = inwords.at(k) & (mask << i);
67  d_in[i] = d_in[i] >> i;
68  }
69  }
70 
71  // in the first iteration CRC_S must be set to all 1's: note CRC_R is set to 1's above
72  // then CRC_S must equal the previous CRC_R
73 
74  for(int j=0; j!= 9; j++)
75  crc_s[j] = crc_r[j];
76 
77 
78  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];
79  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];
80  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];
81  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];
82  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];
83  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];
84  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];
85  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];
86  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];
87 
88  crc_word = 0x000;
89 
90  if (bit_reverse){
91 
92  for(int i=0; i!= 9; i++)
93  crc_word = crc_word | (crc_r[8-i] << i);
94 
95  } else {
96 
97  for(int i=0; i!= 9; i++)
98  crc_word = crc_word | (crc_r[i] << i);
99 
100  }
101 
102  }
103 
104  return (crc_word);
105 
106 }

◆ 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 8 of file FibrePackerBase.cxx.

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

◆ getBcMask()

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

Implements FibrePackerBase.

Definition at line 122 of file EfexTrexFibrePacker.cxx.

122  {
123  // BC number is the full 12 bits from any frame.
124  return 0xfff;
125 }

◆ getBcNumber()

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

Implements FibrePackerBase.

Definition at line 116 of file EfexTrexFibrePacker.cxx.

117  {
118  myDataWord BcNumber = encodedData.at(6) & 0xfff;
119  return BcNumber;
120 }

◆ getPackedControl()

std::vector< FibrePackerBase::myDataWord > EfexTrexFibrePacker::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 72 of file EfexTrexFibrePacker.cxx.

74  {
75 
76  std::vector<myDataWord> controlWords(FexDefs::num32BitWordsPerFibre(),0);
77 
78  switch(frameType){
79 
80  case InputDataFrameType::Normal: // one K character in first data word
81  controlWords.at(0) = 0x1;
82  break;
83 
84  case InputDataFrameType::Alignement: // two K characters in first data word
85  controlWords.at(0) = 0x3;
86  break;
87 
88  }
89 
90  return controlWords;
91 }

◆ getPackedData()

std::vector< FibrePackerBase::myDataWord > EfexTrexFibrePacker::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 the function doesn't need any additional data.

Implements FibrePackerBase.

Definition at line 9 of file EfexTrexFibrePacker.cxx.

11  {
12 
13  std::vector<myDataWord> dataToLoad(FexDefs::num32BitWordsPerFibre(),0);
14  auto supercells = inFrame;
15 
16  switch(frameType){
17 
18  case InputDataFrameType::Normal: // Standard data pattern
19  {
20  for(auto& icell:supercells)
21  icell = icell & 0x3ff; // truncate to 10 bits
22 
23  myDataWord bcId = bcNumber & 0x7f ; // 7 bits from BCID
24  myDataWord bcIdFull = bcNumber & 0xfff; // full 12 bit BCID
25  myDataWord bcId02 = bcId & 0x7;
26  myDataWord bcId34 = (bcId >> 3) & 0x3;
27  myDataWord bcId56 = (bcId >> 5) & 0x3;
28 
29  dataToLoad.at(0) = (bcId56 << 8) | ((supercells.at(0)&0xff) <<10) |
30  ((supercells.at(1)&0xff) << 20) | (bcId34 << 30);
31  dataToLoad.at(1) = (supercells.at(2)&0xff) | ((supercells.at(3)&0xff) << 10) |
32  ((supercells.at(4)&0xff) << 20);
33  dataToLoad.at(2) = (supercells.at(5)&0xff) | ((supercells.at(6)&0xff) << 10) |
34  ((supercells.at(7)&0xff) << 20);
35  dataToLoad.at(3) = (supercells.at(8)&0xff) | ((supercells.at(9)&0xff) << 10) |
36  ((supercells.at(10)&0xff) << 20);
37  dataToLoad.at(4) = (supercells.at(11)&0xff) | ((supercells.at(12)&0xff) << 10) |
38  ((supercells.at(13)&0xff) << 20);
39  dataToLoad.at(5) = (supercells.at(14)&0xff) | ((supercells.at(15)&0xff) << 10) ;
40  dataToLoad.at(6) = bcIdFull | bcId02 << 20;
41 
42  myDataWord tempCRC = crc9d32(dataToLoad,6l,true); // calculate CRC32 on first 6 words
43  myDataWord myCRCReminder = crc9d23(dataToLoad[6],tempCRC,true); // CRC23 on the last word
44 
45  dataToLoad.at(0) = K_28_5 | dataToLoad.at(0) ; // add K-character
46  dataToLoad[6] = dataToLoad[6] | ( myCRCReminder << 23) ; // add CRC check
47 
48  break;
49  }
50  case InputDataFrameType::Alignement: // Special pattern, LATOME alignement/mapping frame
51  {
52 
53  myDataWord bcId = bcNumber & 0xfff ; // 12 bits of BCID
54 
55  dataToLoad.at(6) = bcId;
56  dataToLoad.at(0) = (K_28_0 << 8) | dataToLoad.at(0) ; // add K_28_0 -character, used for CRC calculation
57 
58  myDataWord tempCRC = crc9d32(dataToLoad,6l,true); // calculate CRC32 on first 6 words
59  myDataWord myCRCReminder = crc9d23(dataToLoad[6],tempCRC,true); // CRC23 on the last word
60 
61  dataToLoad.at(0) = K_28_5 | dataToLoad.at(0) ; // add K-character
62  dataToLoad[6] = dataToLoad[6] | ( myCRCReminder << 23) ; // add CRC check to the famous last word
63 
64  break;
65  }
66  }
67 
68  return dataToLoad;
69 
70 }

◆ getUnpackedData()

std::vector< FibrePackerBase::myDataWord > EfexTrexFibrePacker::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 empty vector.

Implements FibrePackerBase.

Definition at line 127 of file EfexTrexFibrePacker.cxx.

128  {
129  std::vector<myDataWord> unpackedData;
130 
131  switch(frameType){
132 
133  case InputDataFrameType::Normal:
134  {
135  std::vector<myDataWord> supercells(EfexDefs::maxSuperCellsPerFibre(),0);
136 
137  supercells.at(0) = (encodedData.at(0) >> 10) & 0x3ff;
138  supercells.at(1) = (encodedData.at(0) >> 20) & 0x3ff;
139  supercells.at(2) = (encodedData.at(1) ) & 0x3ff;
140  supercells.at(3) = (encodedData.at(1) >> 10) & 0x3ff;
141  supercells.at(4) = (encodedData.at(1) >> 20) & 0x3ff;
142  supercells.at(5) = (encodedData.at(2) ) & 0x3ff;
143  supercells.at(6) = (encodedData.at(2) >> 10) & 0x3ff;
144  supercells.at(7) = (encodedData.at(2) >> 20) & 0x3ff;
145  supercells.at(8) = (encodedData.at(3) ) & 0x3ff;
146  supercells.at(9) = (encodedData.at(3) >> 10) & 0x3ff;
147  supercells.at(10) = (encodedData.at(3) >> 20) & 0x3ff;
148  supercells.at(11) = (encodedData.at(4) ) & 0x3ff;
149  supercells.at(12) = (encodedData.at(4) >> 10) & 0x3ff;
150  supercells.at(13) = (encodedData.at(4) >> 20) & 0x3ff;
151  supercells.at(14) = (encodedData.at(5) ) & 0x3ff;
152  supercells.at(15) = (encodedData.at(5) >> 10) & 0x3ff;
153 
154  unpackedData=supercells;
155  break;
156  }
157  case InputDataFrameType::Alignement:
158  {
159  break; // no hyper data in the frame
160  }
161  }
162 
163  return unpackedData;
164 
165 }

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:
FexDefs::num32BitWordsPerFibre
static int num32BitWordsPerFibre()
Definition: FexDefs.h:17
WriteCellNoiseToCool.icell
icell
Definition: WriteCellNoiseToCool.py:339
FibrePackerBase::K_28_5
myDataWord K_28_5
Definition: FibrePackerBase.h:30
ORAlgo::Normal
@ Normal
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:460
EfexDefs::maxSuperCellsPerFibre
static int maxSuperCellsPerFibre()
Definition: EfexDefs.h:27
FibrePackerBase::K_28_0
myDataWord K_28_0
Definition: FibrePackerBase.h:32
lumiFormat.i
int i
Definition: lumiFormat.py:85
FibrePackerBase::crc9d32
virtual myDataWord crc9d32(const std::vector< myDataWord > &inwords, size_t num_words, bool bit_reverse) const
Definition: FibrePackerBase.cxx:37
bcId
uint16_t bcId(uint32_t data)
Definition: TgcByteStreamData.h:329
FibrePackerBase::InputDataFrameType::Alignement
@ Alignement
Special mapping/alignement frame.
FibrePackerBase::myDataWord
uint32_t myDataWord
Definition: FibrePackerBase.h:25
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
FibrePackerBase::crc9d23
virtual myDataWord crc9d23(myDataWord inword, myDataWord in_crc, bool bit_reverse) const
Definition: FibrePackerBase.cxx:108
FibrePackerBase::InputDataFrameType::Normal
@ Normal
Standard data frame.
fitman.k
k
Definition: fitman.py:528
Generated on Fri Oct 4 2024 21:43:20 for ATLAS Offline Software by   doxygen 1.8.18