Loading [MathJax]/jax/input/TeX/config.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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  InputDataFrameType { InputDataFrameType::Normal, InputDataFrameType::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. More...
 
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. 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 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 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 106 of file EfexLatomeFibrePacker.cxx.

107  {
108 
109  auto inputData = encodedData;
110  myDataWord CRCCheck = 0;
111 
112  // Comment SJH: why do we need two cases here
113  // (may have been different originally, but not now?)
114  switch(frameType){
115 
116  case InputDataFrameType::Normal: // one K character in first data word
117  inputData.at(0) = inputData.at(0) & 0xffffff00;
118  // old code
119  // CRCCheck = crc9d32(inputData,7l,true); // calculate CRC32 on first 6 words
120  // new code
121  CRCCheck = crc9full(inputData,224); // calculate CRC on 224 bits = 7*32 bit words
122  break;
123 
124  case InputDataFrameType::Alignement: // two K characters in first data word, but zeroing only the first one
125  inputData.at(0) = inputData.at(0) & 0xffffff00;
126  // old code
127  // CRCCheck = crc9d32(inputData,7l,true); // calculate CRC32 on first 6 words
128  // new code
129  CRCCheck = crc9full(inputData,224); // calculate CRC on 224 bits = 7*32 bit words
130  break;
131 
132  }
133 
134  return (CRCCheck == 0);
135 }

◆ 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 EfexLatomeFibrePacker::getBcMask ( InputDataFrameType  frameType) const
overridevirtual

Implements FibrePackerBase.

Definition at line 162 of file EfexLatomeFibrePacker.cxx.

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

◆ getBcNumber()

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

Implements FibrePackerBase.

Definition at line 137 of file EfexLatomeFibrePacker.cxx.

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

◆ 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 85 of file EfexLatomeFibrePacker.cxx.

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

◆ 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 9 of file EfexLatomeFibrePacker.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 
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) <<10) |
30  (supercells.at(1) << 20) | (bcId34 << 30);
31  dataToLoad.at(1) = supercells.at(2) | (supercells.at(3) << 10) |
32  (supercells.at(4) << 20) | (((supercells.at(19) >>8) & 0x3) << 30);
33  dataToLoad.at(2) = supercells.at(5) | (supercells.at(6) << 10) |
34  (supercells.at(7) << 20) | (((supercells.at(19) >>6) & 0x3) << 30);
35  dataToLoad.at(3) = supercells.at(8) | (supercells.at(9) << 10) |
36  (supercells.at(10) << 20) | (((supercells.at(19) >>4) & 0x3) << 30);
37  dataToLoad.at(4) = supercells.at(11) | (supercells.at(12) << 10) |
38  (supercells.at(13) << 20) | (((supercells.at(19) >>2) & 0x3) << 30);
39  dataToLoad.at(5) = supercells.at(14) | (supercells.at(15) << 10) |
40  (supercells.at(16) << 20) | (((supercells.at(19) ) & 0x3) << 30);
41  dataToLoad.at(6) = supercells.at(17) | (supercells.at(18) << 10)| bcId02 << 20;
42 
43  // original code
44  // myDataWord tempCRC = crc9d32(dataToLoad,6l,true); // calculate CRC32 on first 6 words
45  // myDataWord myCRCReminder = crc9d23(dataToLoad[6],tempCRC,true); // CRC23 on the last word
46  // new code
47  myDataWord myCRCReminder = crc9full(dataToLoad,215); // 215 = 32*6+23
48 
49  dataToLoad.at(0) = K_28_5 | dataToLoad.at(0) ; // add K-character
50  dataToLoad[6] = dataToLoad[6] | ( myCRCReminder << 23) ; // add CRC check
51 
52  break;
53  }
54  case InputDataFrameType::Alignement: // Special pattern, LATOME alignement/mapping frame
55  {
56 
57  myDataWord latome_id = supercells.at(0) & 0xff; // 8b
58  myDataWord latome_src_id = supercells.at(1) & 0xffffffff; // 32b
59  myDataWord fiber_id = supercells.at(2) & 0x3f; // 6b
60  myDataWord bcId = bcNumber & 0xfff ; // 12 bits of BCID
61 
62  dataToLoad.at(0) = (fiber_id << 16) | (latome_id << 24);
63  dataToLoad.at(1) = latome_src_id;
64  dataToLoad.at(6) = bcId;
65 
66  dataToLoad.at(0) = (K_28_0 << 8) | dataToLoad.at(0) ; // add K_28_0, this is used for CRC calculation
67 
68  // original code
69  // myDataWord tempCRC = crc9d32(dataToLoad,6l,true); // calculate CRC32 on first 6 words
70  //myDataWord myCRCReminder = crc9d23(dataToLoad[6],tempCRC,true); // CRC23 on the last word
71  // new code
72  myDataWord myCRCReminder = crc9full(dataToLoad,215); // 215 = 32*6+23
73 
74  dataToLoad.at(0) = K_28_5 | dataToLoad.at(0) ; // add K_28_5, this is not used for CRC calculation
75  dataToLoad[6] = dataToLoad[6] | ( myCRCReminder << 23) ; // add CRC check to the famous last word
76 
77  break;
78  }
79  }
80 
81  return dataToLoad;
82 
83 }

◆ 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 168 of file EfexLatomeFibrePacker.cxx.

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

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
ORAlgo::Normal
@ Normal
FibrePackerBase::K_28_5
myDataWord K_28_5
Definition: FibrePackerBase.h:30
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:460
EfexDefs::maxSuperCellsPerFibre
static int maxSuperCellsPerFibre()
Definition: EfexDefs.h:27
FibrePackerBase::crc9full
virtual myDataWord crc9full(const std::vector< myDataWord > &inwords, size_t num_bits) const
Functions calculating CRC over input data.
Definition: FibrePackerBase.cxx:8
FibrePackerBase::K_28_0
myDataWord K_28_0
Definition: FibrePackerBase.h:32
lumiFormat.i
int i
Definition: lumiFormat.py:85
bcId
uint16_t bcId(uint32_t data)
Definition: TgcByteStreamData.h:326
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::InputDataFrameType::Normal
@ Normal
Standard data frame.
fitman.k
k
Definition: fitman.py:528
Generated on Fri Apr 11 2025 21:32:39 for ATLAS Offline Software by   doxygen 1.8.18