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

#include <RPCRXRODDecode.h>

Inheritance diagram for RPCRXRODDecode:
Collaboration diagram for RPCRXRODDecode:

Public Member Functions

 RPCRXRODDecode ()
 
 ~RPCRXRODDecode ()
 
sbit32 gimeRODDataAddress ()
 
void RODAddresses (const RODword *RODData, const sbit32 numberOfStatusElements, const sbit32 statusBlockPosition)
 
void RODHeader (const RODword *ROBData)
 
int pushWord (const ubit16 inword, uint NOBXS)
 
int pushWord (const RODword inword, ubit16 j, uint NOBXS)
 
MatrixReadOut * CMFragment ()
 
SectorLogicRXReadOut * SLFragment ()
 
void gimeCMROData ()
 
void RODHeaderDisplay ()
 
ubit16 gimeCMFlag ()
 
ubit16 gimePADFlag ()
 
ubit16 gimeRXFlag ()
 
void enablePrintOut ()
 
void disablePrintOut ()
 
void setSLFragmentFound (bool slFound)
 
ObjectType tag () const
 
std::string name () const
 
virtual void Print (std::ostream &, bool) const
 

Public Attributes

RODword headerMarker
 
RODword headerSize
 
RODword formatVersion
 
RODword sourceIdentifier
 
RODword Level1ID
 
RODword BunchXingID
 
RODword Level1Type
 
RODword DetectorEventType
 
ubit16 SourceReserved
 
ubit16 SourceModuleType
 
ubit16 SourceSubDetectorID
 
ubit16 SourceModuleID
 
ubit16 SectorID
 
ubit16 PadID
 
ubit16 CMID
 
ubit16 CMFragCheck
 
RXReadOutStructure RXROS
 
PadReadOutStructure PDROS
 
MatrixReadOutStructure CMROS
 
MatrixReadOut CMRO
 
SectorLogicRXReadOutStructure SLROS
 
SectorLogicRXReadOut SLRO
 

Private Types

enum  recType {
  Empty, CMHead, CMSub, CMBod,
  CMFoot, PadHead, PadSub, PadPre,
  PadFoot, SLHead, SLFoot, RXHead,
  RXFoot
}
 

Private Attributes

bool m_isSLBody
 
sbit32 m_RODDataAddress
 
recType m_previousRecord
 
ubit16 m_field
 
ubit16 m_noRecord16
 
RODword m_noRecord32
 
ubit16 m_reserved4
 
ubit16 m_CMFlag
 
ubit16 m_PADFlag
 
ubit16 m_RXFlag
 
bool m_enablePrintOut
 
bool m_slFound
 
ObjectType m_tag
 
std::string m_name
 

Detailed Description

Definition at line 13 of file RPCRXRODDecode.h.

Member Enumeration Documentation

◆ recType

enum RPCRXRODDecode::recType
private
Enumerator
Empty 
CMHead 
CMSub 
CMBod 
CMFoot 
PadHead 
PadSub 
PadPre 
PadFoot 
SLHead 
SLFoot 
RXHead 
RXFoot 

Definition at line 80 of file RPCRXRODDecode.h.

80 { Empty, CMHead, CMSub, CMBod, CMFoot, PadHead, PadSub, PadPre, PadFoot, SLHead, SLFoot, RXHead, RXFoot };

Constructor & Destructor Documentation

◆ RPCRXRODDecode()

RPCRXRODDecode::RPCRXRODDecode ( )

Definition at line 12 of file RPCRXRODDecode.cxx.

12  : BaseObject(Hardware, "RPCRXRODDecode") {
13  // std::cout<<" This is the constructor of RPCRXRODDecode "<<std::endl;
14  //
15  // define RPC data word indentifiers
16  //
17  m_field = 0xf000; // field map of word identifier
18  // reserved3 = 0xd000; // reserved
19  m_reserved4 = 0xe000; // reserved
20  // reserved5 = 0xf000; // reserved
21  //
22  // ROD Data Address
23  //
24  m_RODDataAddress = m_noRecord32;
25  //
26  m_noRecord16 = 9999; // no record content for 16bit words
27  m_noRecord32 = 0xdeadcafe; // no record content for 32bit words
28  //
29  // the ROD header
30  //
31  headerMarker = m_noRecord32;
32  headerSize = m_noRecord32;
33  formatVersion = m_noRecord32;
34  sourceIdentifier = m_noRecord32;
35  Level1ID = m_noRecord32;
36  BunchXingID = m_noRecord32;
37  Level1Type = m_noRecord32;
38  DetectorEventType = m_noRecord32;
39  SourceReserved = m_noRecord16;
40  SourceModuleType = m_noRecord16;
41  SourceSubDetectorID = m_noRecord16;
42  SourceModuleID = m_noRecord16;
43  //
44  // the RPC identifiers
45  //
46  SectorID = m_noRecord16;
47  PadID = m_noRecord16;
48  CMID = m_noRecord16;
49  //
50  // m_previousRecord initialization
51  //
52  m_previousRecord = Empty;
53  //
54  // the structure control flags
55  //
56  CMFragCheck = m_noRecord16;
57  m_CMFlag = 0;
58  m_PADFlag = 0;
59  m_RXFlag = 0;
60  m_isSLBody = false;
61  m_enablePrintOut = false;
62  m_slFound = false;
63 } // end-of-RPCRXRODDecode::RPCRXRODDecode

◆ ~RPCRXRODDecode()

RPCRXRODDecode::~RPCRXRODDecode ( )

Definition at line 65 of file RPCRXRODDecode.cxx.

65 {} // distructor

Member Function Documentation

◆ CMFragment()

MatrixReadOut* RPCRXRODDecode::CMFragment ( )
inline

Definition at line 22 of file RPCRXRODDecode.h.

22 { return &CMRO; };

◆ disablePrintOut()

void RPCRXRODDecode::disablePrintOut ( )

Definition at line 69 of file RPCRXRODDecode.cxx.

69 { m_enablePrintOut = false; } // dRPCRXRODDecode::disablePrintOut

◆ enablePrintOut()

void RPCRXRODDecode::enablePrintOut ( )

Definition at line 67 of file RPCRXRODDecode.cxx.

67 { m_enablePrintOut = true; } // RPCRXRODDecode::enablePrintOut

◆ gimeCMFlag()

ubit16 RPCRXRODDecode::gimeCMFlag ( )
inline

Definition at line 29 of file RPCRXRODDecode.h.

29 { return m_CMFlag; };

◆ gimeCMROData()

void RPCRXRODDecode::gimeCMROData ( )

Definition at line 756 of file RPCRXRODDecode.cxx.

756  {
757  MatrixReadOutStructure CMROS;
758  ubit16 nCMROData = CMRO.numberOfBodyWords();
759 
760  if (m_enablePrintOut) {
761  std::cout << " number of Body Words in this CM Fragment " << nCMROData << std::endl;
762 
763  //
764  // get header data
765  //
766  CMROS = CMRO.getHeader();
767 
768  std::cout << " gimeCMROData, CMID: " << CMROS.cmid() << std::endl
769  << " gimeCMROData, FEL1ID: " << CMROS.fel1id() << std::endl
770  << " isLowPt = " << CMROS.isLowPt() << std::endl
771  << " isEtaProj= " << CMROS.isEtaProj() << std::endl
772  << " is0LocAdd= " << CMROS.is0LocAdd() << std::endl;
773 
774  //
775  // get subheader data
776  //
777  CMROS = CMRO.getSubHeader();
778 
779  std::cout << " gimeCMROData, FEBCID: " << CMROS.febcid() << std::endl;
780 
781  //
782  // get Body data
783  //
784  for (ubit16 i = 0; i < nCMROData; i++) {
785  CMROS = CMRO.getCMAHit(i);
786  ubit16 ijk = CMROS.ijk();
787  if (ijk < 6) {
788  std::cout << " gimeCMROData, hit chan: " << CMROS.channel() << " gimeCMROData, hit stri: " << CMROS.global_channel()
789  << " hit BCID: " << CMROS.bcid() << std::endl;
790  } else if (ijk == 6) {
791  std::cout << " gimeCMROData, trg chan: " << CMROS.channel() << " hit BCID: " << CMROS.bcid() << std::endl;
792  } else if (ijk == 7) {
793  std::cout << " gimeCMROData, trg thr: " << CMROS.threshold() << " trg ovl: " << CMROS.overlap() << std::endl;
794  } else {
795  std::cout << " this value of ijk=" << ijk << " is NOT ALLOWED " << std::endl;
796  } // end-of-if
797  std::cout << std::endl;
798  } // end-of-for
799  } // end-of-if(m_enablePrintOut
800 } // end-of-gimeCMROData

◆ gimePADFlag()

ubit16 RPCRXRODDecode::gimePADFlag ( )
inline

Definition at line 30 of file RPCRXRODDecode.h.

30 { return m_PADFlag; };

◆ gimeRODDataAddress()

sbit32 RPCRXRODDecode::gimeRODDataAddress ( )
inline

Definition at line 17 of file RPCRXRODDecode.h.

17 { return m_RODDataAddress; };

◆ gimeRXFlag()

ubit16 RPCRXRODDecode::gimeRXFlag ( )
inline

Definition at line 31 of file RPCRXRODDecode.h.

31 { return m_RXFlag; };

◆ name()

std::string BaseObject::name ( ) const
inlineinherited

Definition at line 23 of file BaseObject.h.

23 { return m_name; }

◆ Print()

virtual void BaseObject::Print ( std::ostream &  ,
bool   
) const
inlinevirtualinherited

Reimplemented in CMAparameters, RPC_CondCabling::CMApivotdata, RPC_CondCabling::CMAcablingdata, RPC_CondCabling::RPCchamberdata, RPC_CondCabling::WiredORdata, RPC_CondCabling::RPCchamber, CMApatterns, RPC_CondCabling::WiredOR, MuonSimuTrack, RPCdigit, CMAtrigger, PADpatterns, CMAdata, SLpatterns, SLdata, PADdata, RPCtrigDataObject, and bitPATTERN.

Definition at line 25 of file BaseObject.h.

25 {}

◆ pushWord() [1/2]

int RPCRXRODDecode::pushWord ( const RODword  inword,
ubit16  j,
uint  NOBXS 
)

Definition at line 71 of file RPCRXRODDecode.cxx.

71  {
72  //
73  // select the less significant 16 bits (j=0) or the
74  // highest significant 16 bits (j=1) of the 32 bits word inword
75  // and push this 16 bit word selected to the method pushWord
76  // for decoding
77  //
78  RODword mask1[2];
79  RODword shift[2];
80  mask1[0] = 0x0000ffff;
81  mask1[1] = 0xffff0000;
82  shift[0] = 0;
83  shift[1] = 16;
84  return pushWord((inword & mask1[j]) >> shift[j], NOBXS);
85 }

◆ pushWord() [2/2]

int RPCRXRODDecode::pushWord ( const ubit16  inword,
uint  NOBXS 
)

Definition at line 87 of file RPCRXRODDecode.cxx.

87  {
88  //
89  // analyze the current inword ReadOutDriver (ROD) data word:
90  // 1st) identify the type of word and
91  // 2nd) fill the MatrixReadOut object when CM hits are present;
92  // 3rd) close the MatrixReadOut fragment when the CM footer is ecountered;
93  // 4th) at this point the MatrixReadOut object can deliver the RPC hits
94  //
95  //
96  //
97  // analysis of patological cases and related actions:
98  //
99  // store in a flag, typePrevRec, the type of record of previous dataword:
100  //
101  // 0 == no CMA Record; "0"
102  // 1 == CMA Header; "H"
103  // 2 == CMA SubHeader; "S"
104  // 3 == CMA Body; "B"
105  // 3 == CMA Footer; "F"
106  //
107  //
108  // all cases should be accompained by error messages, except cases reported as
109  // "regular sequence: no problem at all"
110  //
111  // -Current record-|-Previous record-----------------Action---------------------
112  // type type
113  //
114  // 0 H close "CMRO": CMRO.writeRecord(inword,true);
115  // 0 S close "CMRO": CMRO.writeRecord(inword,true);
116  // 0 B close "CMRO": CMRO.writeRecord(inword,true);
117  // 0 F no action needed
118  //
119  // H 0 no action; no error message
120  // H H header overwriting;
121  // H S no action
122  // H B close "CMRO": CMRO.writeRecord(inword,true);
123  // H F no action needed
124  //
125  // S 0 no action
126  // S H regular sequence: no problem at all
127  // S S subheader overwriting;
128  // S B close "CMRO": CMRO.writeRecord(inword,true);
129  // S F no action needed
130  //
131  // B 0 no action
132  // B H no action needed;
133  // B S regular sequence: no problem at all
134  // B B regular sequence: no problem at all
135  // B F no action needed
136  //
137  // F 0 no action
138  // F H no action needed
139  // F S no action needed
140  // F B regular sequence: no problem at all
141  // F F no action needed
142  //
143  //
144  bool thereIsACM = false; // true if the data word is a CM footer
145  // that closes the CM fragment.
146  bool thereIsASL = false; // true if the data word is a SL footer
147  // that closes the SL fragment.
148  char recField; // record field
149  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode; inword= " << std::hex << inword << std::dec << std::endl; }
150  //
151  // recognize first the current word
152  //
153  CMROS.decodeFragment(inword, recField);
154  PDROS.decodeFragment(inword, recField);
155  RXROS.decodeFragment(inword, recField);
156  SLROS.decodeFragment(inword, recField);
157  //
158  // Identify the current 16bit word and check it...
159  //
160 
161  if (SLROS.isHeader()) {
162  //
163  // SL Header
164  //
165  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: SectorLogic Header " << std::endl; }
166  m_isSLBody = false;
167  SLRO.reset();
168  SLRO.writeRecord(inword, false);
169  thereIsASL = false;
170  m_slFound = true;
171 
172  } else if (SLROS.isSubHeader() && m_slFound) {
173  //
174  // SL Header
175  //
176  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: SectorLogic SubHeader " << std::endl; }
177  m_isSLBody = true;
178  SLRO.writeRecord(inword, false);
179 
180  } else if (SLROS.isFooter() && m_slFound) {
181  //
182  // SL Footer
183  //
184  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: SectorLogic Footer " << std::endl; }
185  m_isSLBody = false;
186  thereIsASL = true;
187  SLRO.writeRecord(inword, true);
188 
189  m_slFound = false;
190 
191  } else if (m_isSLBody && m_slFound) {
192  //
193  // SL Body
194  //
195  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: SectorLogic Body " << std::endl; }
196  SLRO.writeRecord(inword, false);
197  thereIsASL = false;
198 
199  } else if (RXROS.isHeader()) {
200  //
201  // RX header
202  //
203  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: RX Header " << std::endl; }
204  m_RXFlag++;
205  RXROS.decodeFragment(inword, recField);
206  if (recField == 'H') { SectorID = RXROS.RXid(); }
207  thereIsACM = false;
208  if (m_enablePrintOut) { std::cout << " Sector ID = " << SectorID << std::endl; }
209 
210  switch (m_previousRecord) {
211  case Empty: break;
212  case CMHead:
213  if (m_enablePrintOut) {
214  std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and RX Header found" << std::endl;
215  }
216  thereIsACM = true; // close this matrix fragment
217  CMRO.writeRecord(inword, true);
218  // gimeCMROData();
219  break;
220  case CMSub:
221  if (m_enablePrintOut) {
222  std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and and RX Header found" << std::endl;
223  }
224  thereIsACM = true; // close this matrix fragment
225  CMRO.writeRecord(inword, true);
226  // gimeCMROData();
227  break;
228  case CMBod:
229  if (m_enablePrintOut) {
230  std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and RX Header found" << std::endl;
231  }
232  thereIsACM = true; // close this matrix fragment
233  CMRO.writeRecord(inword, true);
234  // gimeCMROData();
235  break;
236  case CMFoot:
237  if (m_enablePrintOut) {
238  std::cout << " RPCRXRODDecode Fragment problem: CM Header or Pad Footer expected and RX Header found" << std::endl;
239  }
240  break;
241  case PadHead:
242  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
243  break;
244  case PadPre:
245  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
246  break;
247  case PadSub:
248  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
249  break;
250  case PadFoot:
251  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
252  break;
253  default:
254  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
255  } // end-of-switch
256  m_previousRecord = Empty;
257 
258  } else if (RXROS.isFooter()) {
259  //
260  // RX footer
261  //
262  if (m_enablePrintOut) { std::cout << " RX footer " << std::endl; }
263  m_RXFlag--;
264  RXROS.decodeFragment(inword, recField);
265  if (recField == 'F') {}
266  thereIsACM = false;
267  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: Footer of Sector with ID = " << SectorID << std::endl; }
268 
269  switch (m_previousRecord) {
270  case Empty: break;
271  case CMHead:
272  if (m_enablePrintOut) {
273  std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and RX Footer found" << std::endl;
274  }
275  thereIsACM = true; // close this matrix fragment
276  CMRO.writeRecord(inword, true);
277  // gimeCMROData();
278  break;
279  case CMSub:
280  if (m_enablePrintOut) {
281  std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and RX Footer found" << std::endl;
282  }
283  thereIsACM = true; // close this matrix fragment
284  CMRO.writeRecord(inword, true);
285  // gimeCMROData();
286  break;
287  case CMBod:
288  if (m_enablePrintOut) {
289  std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and and RX Footer found" << std::endl;
290  }
291  thereIsACM = true; // close this matrix fragment
292  CMRO.writeRecord(inword, true);
293  // gimeCMROData();
294  break;
295  case CMFoot:
296  if (m_enablePrintOut) {
297  std::cout << " RPCRXRODDecode Fragment problem: CM Header or Pad Footer expected and RX Footer found" << std::endl;
298  }
299  break;
300  case PadHead:
301  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
302  break;
303  case PadPre:
304  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
305  break;
306  case PadSub:
307  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
308  break;
309  case PadFoot:
310  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
311  break;
312  default:
313  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
314  } // end-of-switch
315  m_previousRecord = Empty;
316 
317  } else if (PDROS.isHeader()) {
318  //
319  // Pad header
320  //
321  if (m_enablePrintOut) { std::cout << " PAD Header " << std::hex << inword << std::dec << std::endl; }
322  m_PADFlag++;
323  PDROS.decodeFragment(inword, recField);
324  if (recField == 'H') { PadID = PDROS.padid(); }
325  thereIsACM = false;
326  if (m_enablePrintOut) {
327  std::cout << " PAD " << PadID << " LVL1 " << std::hex << ((inword & 0x0e00) >> 8) << std::dec << std::endl;
328  }
329 
330  switch (m_previousRecord) {
331  case Empty: break;
332  case CMHead:
333  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and not found" << std::endl; }
334  thereIsACM = true; // close this matrix fragment
335  CMRO.writeRecord(inword, true);
336  // gimeCMROData();
337  break;
338  case CMSub:
339  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and not found" << std::endl; }
340  thereIsACM = true; // close this matrix fragment
341  CMRO.writeRecord(inword, true);
342  // gimeCMROData();
343  break;
344  case CMBod:
345  if (m_enablePrintOut) {
346  std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and not found" << std::endl;
347  }
348  thereIsACM = true; // close this matrix fragment
349  CMRO.writeRecord(inword, true);
350  // gimeCMROData();
351  break;
352  case CMFoot: break;
353  case PadHead:
354  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
355  break;
356  case PadPre:
357  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
358  break;
359  case PadSub:
360  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
361  break;
362  case PadFoot:
363  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
364  break;
365  default:
366  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
367  } // end-of-switch
368  m_previousRecord = Empty;
369 
370  } else if (PDROS.isSubHeader()) {
371  //
372  // Pad Subheader
373  //
374  if (m_enablePrintOut) { std::cout << " BCID " << std::hex << (inword & 0x0fff) << std::dec << std::endl; }
375  switch (m_previousRecord) {
376  case Empty: break;
377  case CMHead:
378  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and not found" << std::endl; }
379  thereIsACM = true; // close this matrix fragment
380  CMRO.writeRecord(inword, true);
381  // gimeCMROData();
382  break;
383  case CMSub:
384  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and not found" << std::endl; }
385  thereIsACM = true; // close this matrix fragment
386  CMRO.writeRecord(inword, true);
387  // gimeCMROData();
388  break;
389  case CMBod:
390  if (m_enablePrintOut) {
391  std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and not found" << std::endl;
392  }
393  thereIsACM = true; // close this matrix fragment
394  CMRO.writeRecord(inword, true);
395  // gimeCMROData();
396  break;
397  case CMFoot:
398  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad Header expected and not found" << std::endl; }
399  break;
400  case PadHead:
401  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
402  break;
403  case PadPre:
404  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
405  break;
406  case PadSub:
407  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
408  break;
409  case PadFoot:
410  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
411  break;
412  default:
413  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
414  } // end-of-switch
415  m_previousRecord = Empty;
416 
417  } else if (PDROS.isPreFooter()) {
418  //
419  // Pad PreFooter
420  //
421  if (m_enablePrintOut) { std::cout << " STATUS ERROR " << std::hex << (inword & 0x000f) << std::dec << std::endl; }
422  switch (m_previousRecord) {
423  case Empty: break;
424  case CMHead:
425  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and not found" << std::endl; }
426  thereIsACM = true; // close this matrix fragment
427  CMRO.writeRecord(inword, true);
428  // gimeCMROData();
429  break;
430  case CMSub:
431  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and not found" << std::endl; }
432  thereIsACM = true; // close this matrix fragment
433  CMRO.writeRecord(inword, true);
434  // gimeCMROData();
435  break;
436  case CMBod:
437  if (m_enablePrintOut) {
438  std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and not found" << std::endl;
439  }
440  thereIsACM = true; // close this matrix fragment
441  CMRO.writeRecord(inword, true);
442  // gimeCMROData();
443  break;
444  case CMFoot: break;
445  case PadHead:
446  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
447  break;
448  case PadPre:
449  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
450  break;
451  case PadSub:
452  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
453  break;
454  case PadFoot:
455  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
456  break;
457  default:
458  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
459  } // end-of-switch
460  m_previousRecord = PadPre;
461 
462  } else if (PDROS.isFooter()) {
463  //
464  // Pad footer
465  //
466  if (m_enablePrintOut) {
467  std::cout << " PAD Footer " << std::hex << inword << std::dec << " ERROR FLAG " << std::hex << (inword & 0x0fff) << std::dec
468  << std::endl;
469  }
470  m_PADFlag--;
471  PDROS.decodeFragment(inword, recField);
472  if (recField == 'F') {}
473  thereIsACM = false;
474  if (m_enablePrintOut) { std::cout << " Footer of Pad with ID = " << PadID << std::endl; }
475 
476  switch (m_previousRecord) {
477  case Empty: break;
478  case CMHead:
479  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and not found" << std::endl; }
480  thereIsACM = true; // close this matrix fragment
481  CMRO.writeRecord(inword, true);
482  // gimeCMROData();
483  break;
484  case CMSub:
485  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and not found" << std::endl; }
486  thereIsACM = true; // close this matrix fragment
487  CMRO.writeRecord(inword, true);
488  // gimeCMROData();
489  break;
490  case CMBod:
491  if (m_enablePrintOut) {
492  std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and not found" << std::endl;
493  }
494  thereIsACM = true; // close this matrix fragment
495  CMRO.writeRecord(inword, true);
496  // gimeCMROData();
497  break;
498  case CMFoot:
499  if (m_enablePrintOut) {
500  std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected and not found" << std::endl;
501  }
502  break;
503  case PadHead:
504  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
505  break;
506  case PadPre: break;
507  case PadSub:
508  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
509  break;
510  case PadFoot:
511  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
512  break;
513  default:
514  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
515  } // end-of-switch
516  m_previousRecord = Empty;
517 
518  } else if (CMROS.isHeader()) {
519  //
520  // CM Header: reset MatrixReadOut and load the word
521  //
522  m_CMFlag++;
523  CMRO.reset(NOBXS);
524  CMRO.writeRecord(inword, false);
525  thereIsACM = false;
526 
527  switch (m_previousRecord) {
528  case Empty: break;
529  case CMHead:
530  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode warning: CM SubHeader expected and CM Header found" << std::endl; }
531  break;
532  case CMSub: break;
533  case CMBod:
534  if (m_enablePrintOut) {
535  std::cout << " RPCRXRODDecode warning: CM Body or CM Footer expected and CM Header found" << std::endl;
536  }
537  break;
538  case CMFoot: break;
539  case PadHead:
540  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
541  break;
542  case PadPre:
543  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
544  break;
545  case PadSub:
546  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
547  break;
548  case PadFoot:
549  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
550  break;
551  default:
552  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
553  } // end-of-switch
554  m_previousRecord = CMHead;
555 
556  } else if (CMROS.isSubHeader()) {
557  //
558  // CM Subheader
559  //
560  m_CMFlag++;
561  CMRO.writeRecord(inword, false);
562  thereIsACM = false;
563 
564  switch (m_previousRecord) {
565  case Empty:
566  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode warning: previous record was not a CM Header" << std::endl; }
567  break;
568  case CMHead: break;
569  case CMSub:
570  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode warning: CM Body expected and CM SubHeader found" << std::endl; }
571  break;
572  case CMBod:
573  if (m_enablePrintOut) {
574  std::cout << " RPCRXRODDecode warning: CM Body or CM Footer expected; CM SubHeader found" << std::endl;
575  }
576  break;
577  case CMFoot:
578  if (m_enablePrintOut) {
579  std::cout << " RPCRXRODDecode warning: CM Header or Pad Footer expected; CM SubHeader found" << std::endl;
580  }
581  break;
582  case PadHead:
583  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
584  break;
585  case PadPre:
586  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
587  break;
588  case PadSub:
589  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
590  break;
591  case PadFoot:
592  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
593  break;
594  default:
595  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
596  } // end-of-switch
597  m_previousRecord = CMSub;
598 
599  } else if (CMROS.isBody()) {
600  //
601  // CM hit
602  //
603  if (m_CMFlag) CMRO.writeRecord(inword, false);
604  thereIsACM = false;
605 
606  switch (m_previousRecord) {
607  case Empty:
608  if (m_enablePrintOut) {
609  std::cout << " RPCRXRODDecode (CMBody1) warning: previous record was not a CM subHeader"
610  << " or CM Body Record " << std::endl;
611  }
612  break;
613  case CMHead:
614  if (m_enablePrintOut) {
615  std::cout << " RPCRXRODDecode (CMBody2) warning: previous record was not a CM subHeader"
616  << " or CM Body Record " << std::endl;
617  }
618  break;
619  case CMSub: break;
620  case CMBod: break;
621  case CMFoot:
622  if (m_enablePrintOut) {
623  std::cout << " RPCRXRODDecode (CMBody3) warning: previous record was not a CM subHeader"
624  << " or CM Body Record " << std::endl;
625  }
626  break;
627  case PadHead:
628  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
629  break;
630  case PadPre:
631  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
632  break;
633  case PadSub:
634  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
635  break;
636  case PadFoot:
637  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
638  break;
639  default:
640  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord=" << std::endl; }
641  } // end-of-switch
642  m_previousRecord = CMBod;
643 
644  } else if (CMROS.isFooter()) {
645  //
646  // CM footer
647  //
648  thereIsACM = true;
649  m_CMFlag--;
650  m_CMFlag--;
651  CMRO.writeRecord(inword, true);
652  CMFragCheck = CMRO.checkFragment();
653 
654  switch (m_previousRecord) {
655  case Empty:
656  if (m_enablePrintOut) {
657  std::cout << " RPCRXRODDecode (CMFooter1) warning: previous record was not a Body record " << std::endl;
658  }
659  break;
660  case CMHead:
661  if (m_enablePrintOut) {
662  std::cout << " RPCRXRODDecode (CMFooter2) warning: previous record was not a Body record" << std::endl;
663  }
664  break;
665  case CMSub:
666  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode warning: previous record was not a Body record" << std::endl; }
667  break;
668  case CMBod: break;
669  case CMFoot:
670  if (m_enablePrintOut) {
671  std::cout << " RPCRXRODDecode (CMFooter3) warning: previous record was not a Body record" << std::endl;
672  }
673  break;
674  case PadHead:
675  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
676  break;
677  case PadPre:
678  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
679  break;
680  case PadSub:
681  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
682  break;
683  case PadFoot:
684  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
685  break;
686  default:
687  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord" << std::endl; }
688  } // end-of-switch
689  m_previousRecord = CMFoot;
690 
691  // gimeCMROData();
692 
693  //} else if(((inword & m_field)==reserved3) || ((inword & m_field)==m_reserved4)) {
694  } else if ((inword & m_field) == m_reserved4) {
695  //
696  // reserved word
697  //
698  thereIsACM = false;
699  if (m_enablePrintOut) { std::cout << " (reserved) " << std::endl; }
700 
701  switch (m_previousRecord) {
702  case Empty: break;
703  case CMHead:
704  if (m_enablePrintOut) {
705  std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and (reserved) found" << std::endl;
706  }
707  thereIsACM = true; // close this matrix fragment
708  CMRO.writeRecord(inword, true);
709  // gimeCMROData();
710  break;
711  case CMSub:
712  if (m_enablePrintOut) {
713  std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and (reserved) found" << std::endl;
714  }
715  thereIsACM = true; // close this matrix fragment
716  CMRO.writeRecord(inword, true);
717  // gimeCMROData();
718  break;
719  case CMBod:
720  if (m_enablePrintOut) {
721  std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and (reserved) found" << std::endl;
722  }
723  thereIsACM = true; // close this matrix fragment
724  CMRO.writeRecord(inword, true);
725  // gimeCMROData();
726  break;
727  case CMFoot:
728  if (m_enablePrintOut) {
729  std::cout << " RPCRXRODDecode Fragment problem: CM Header or Pad Footer expected and (reserved) found" << std::endl;
730  }
731  break;
732  case PadHead:
733  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
734  break;
735  case PadPre:
736  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
737  break;
738  case PadSub:
739  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
740  break;
741  case PadFoot:
742  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
743  break;
744  default:
745  if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
746  } // end-of-switch
747  m_previousRecord = Empty;
748 
749  } // end-of-if
750  int answer = 0;
751  if (thereIsACM) answer = 1;
752  if (thereIsASL) answer = 2;
753  return answer;
754 }

◆ RODAddresses()

void RPCRXRODDecode::RODAddresses ( const RODword *  RODData,
const sbit32  numberOfStatusElements,
const sbit32  statusBlockPosition 
)

Definition at line 853 of file RPCRXRODDecode.cxx.

853  {
854  RODHeader(RODData);
855  std::cout << " status block position " << statusBlockPosition << std::endl;
856  std::cout << " number of Status Elements " << numberOfStatusElements << std::endl;
857  if (statusBlockPosition) {
858  m_RODDataAddress = headerSize;
859  } else {
860  m_RODDataAddress = headerSize + numberOfStatusElements;
861  }
862 } // end-of-RPCRXRODDecode::RODAddresses

◆ RODHeader()

void RPCRXRODDecode::RODHeader ( const RODword *  ROBData)

Definition at line 802 of file RPCRXRODDecode.cxx.

802  {
803  //
804  // decode the ROD header
805  //
806  headerSize = *(RODData + 1);
807  for (ubit16 i = 0; i < headerSize; i++) {
808  if (i == 0) {
809  headerMarker = *(RODData + i);
810  } else if (i == 2) {
811  formatVersion = *(RODData + i);
812  } else if (i == 3) {
813  sourceIdentifier = *(RODData + i);
814  RPCRODStructure RPCRODS;
815  RPCRODS.decodeSourceID(sourceIdentifier);
816  SourceModuleID = RPCRODS.getSourceIDRODID();
817  SourceSubDetectorID = RPCRODS.getSourceIDSubdetectorID();
818  SourceModuleType = RPCRODS.getSourceIDModuleType();
819  SourceReserved = RPCRODS.getSourceIDReserved();
820  } else if (i == 4) {
821  Level1ID = *(RODData + i);
822  } else if (i == 5) {
823  BunchXingID = *(RODData + i);
824  } else if (i == 6) {
825  Level1Type = *(RODData + i);
826  } else if (i == 7) {
827  DetectorEventType = *(RODData + i);
828  } // end-of-if
829  } // end-of-for
830 } // end-of-RODHeader

◆ RODHeaderDisplay()

void RPCRXRODDecode::RODHeaderDisplay ( )

Definition at line 864 of file RPCRXRODDecode.cxx.

864  {
865  if (m_enablePrintOut) {
866  std::cout << "*****************************************************" << std::endl
867  << "****** R O D H E A D E R *******" << std::endl
868  << "*****************************************************" << std::endl
869  << " ROD Header marker: " << std::hex << headerMarker << std::dec << std::endl
870  << " ROD Header size: " << headerSize << std::endl
871  << " ROD Format version number: " << formatVersion << std::endl
872  << " ROD Source Identifier: " << sourceIdentifier << std::endl
873  << " ROD Source Module ID: " << SourceModuleID << std::endl
874  << " ROD Source SubDectID: " << SourceSubDetectorID << std::endl
875  << " ROD Source Module Ty: " << SourceModuleType << std::endl
876  << " ROD Source Reserved : " << SourceReserved << std::endl
877  << " ROD Level1 ID: " << Level1ID << std::endl
878  << " ROD BuncgXingID: " << BunchXingID << std::endl
879  << " ROD Level1 Type: " << Level1Type << std::endl
880  << " ROD Detector Ev. Type: " << DetectorEventType << std::endl
881  << "*****************************************************" << std::endl;
882  } // end-of-if(m_enablePrintOut
883 } // end-of-RODHeaderDisplay

◆ setSLFragmentFound()

void RPCRXRODDecode::setSLFragmentFound ( bool  slFound)
inline

Definition at line 37 of file RPCRXRODDecode.h.

37 { m_slFound = slFound; };

◆ SLFragment()

SectorLogicRXReadOut* RPCRXRODDecode::SLFragment ( )
inline

Definition at line 23 of file RPCRXRODDecode.h.

23 { return &SLRO; };

◆ tag()

ObjectType BaseObject::tag ( ) const
inlineinherited

Definition at line 22 of file BaseObject.h.

22 { return m_tag; }

Member Data Documentation

◆ BunchXingID

RODword RPCRXRODDecode::BunchXingID

Definition at line 47 of file RPCRXRODDecode.h.

◆ CMFragCheck

ubit16 RPCRXRODDecode::CMFragCheck

Definition at line 60 of file RPCRXRODDecode.h.

◆ CMID

ubit16 RPCRXRODDecode::CMID

Definition at line 59 of file RPCRXRODDecode.h.

◆ CMRO

MatrixReadOut RPCRXRODDecode::CMRO

Definition at line 67 of file RPCRXRODDecode.h.

◆ CMROS

MatrixReadOutStructure RPCRXRODDecode::CMROS

Definition at line 66 of file RPCRXRODDecode.h.

◆ DetectorEventType

RODword RPCRXRODDecode::DetectorEventType

Definition at line 49 of file RPCRXRODDecode.h.

◆ formatVersion

RODword RPCRXRODDecode::formatVersion

Definition at line 44 of file RPCRXRODDecode.h.

◆ headerMarker

RODword RPCRXRODDecode::headerMarker

Definition at line 42 of file RPCRXRODDecode.h.

◆ headerSize

RODword RPCRXRODDecode::headerSize

Definition at line 43 of file RPCRXRODDecode.h.

◆ Level1ID

RODword RPCRXRODDecode::Level1ID

Definition at line 46 of file RPCRXRODDecode.h.

◆ Level1Type

RODword RPCRXRODDecode::Level1Type

Definition at line 48 of file RPCRXRODDecode.h.

◆ m_CMFlag

ubit16 RPCRXRODDecode::m_CMFlag
private

Definition at line 96 of file RPCRXRODDecode.h.

◆ m_enablePrintOut

bool RPCRXRODDecode::m_enablePrintOut
private

Definition at line 102 of file RPCRXRODDecode.h.

◆ m_field

ubit16 RPCRXRODDecode::m_field
private

Definition at line 85 of file RPCRXRODDecode.h.

◆ m_isSLBody

bool RPCRXRODDecode::m_isSLBody
private

Definition at line 72 of file RPCRXRODDecode.h.

◆ m_name

std::string BaseObject::m_name
privateinherited

Definition at line 16 of file BaseObject.h.

◆ m_noRecord16

ubit16 RPCRXRODDecode::m_noRecord16
private

Definition at line 86 of file RPCRXRODDecode.h.

◆ m_noRecord32

RODword RPCRXRODDecode::m_noRecord32
private

Definition at line 87 of file RPCRXRODDecode.h.

◆ m_PADFlag

ubit16 RPCRXRODDecode::m_PADFlag
private

Definition at line 97 of file RPCRXRODDecode.h.

◆ m_previousRecord

recType RPCRXRODDecode::m_previousRecord
private

Definition at line 81 of file RPCRXRODDecode.h.

◆ m_reserved4

ubit16 RPCRXRODDecode::m_reserved4
private

Definition at line 91 of file RPCRXRODDecode.h.

◆ m_RODDataAddress

sbit32 RPCRXRODDecode::m_RODDataAddress
private

Definition at line 76 of file RPCRXRODDecode.h.

◆ m_RXFlag

ubit16 RPCRXRODDecode::m_RXFlag
private

Definition at line 98 of file RPCRXRODDecode.h.

◆ m_slFound

bool RPCRXRODDecode::m_slFound
private

Definition at line 105 of file RPCRXRODDecode.h.

◆ m_tag

ObjectType BaseObject::m_tag
privateinherited

Definition at line 15 of file BaseObject.h.

◆ PadID

ubit16 RPCRXRODDecode::PadID

Definition at line 58 of file RPCRXRODDecode.h.

◆ PDROS

PadReadOutStructure RPCRXRODDecode::PDROS

Definition at line 65 of file RPCRXRODDecode.h.

◆ RXROS

RXReadOutStructure RPCRXRODDecode::RXROS

Definition at line 64 of file RPCRXRODDecode.h.

◆ SectorID

ubit16 RPCRXRODDecode::SectorID

Definition at line 57 of file RPCRXRODDecode.h.

◆ SLRO

SectorLogicRXReadOut RPCRXRODDecode::SLRO

Definition at line 69 of file RPCRXRODDecode.h.

◆ SLROS

SectorLogicRXReadOutStructure RPCRXRODDecode::SLROS

Definition at line 68 of file RPCRXRODDecode.h.

◆ sourceIdentifier

RODword RPCRXRODDecode::sourceIdentifier

Definition at line 45 of file RPCRXRODDecode.h.

◆ SourceModuleID

ubit16 RPCRXRODDecode::SourceModuleID

Definition at line 53 of file RPCRXRODDecode.h.

◆ SourceModuleType

ubit16 RPCRXRODDecode::SourceModuleType

Definition at line 51 of file RPCRXRODDecode.h.

◆ SourceReserved

ubit16 RPCRXRODDecode::SourceReserved

Definition at line 50 of file RPCRXRODDecode.h.

◆ SourceSubDetectorID

ubit16 RPCRXRODDecode::SourceSubDetectorID

Definition at line 52 of file RPCRXRODDecode.h.

The documentation for this class was generated from the following files:
MatrixReadOut::reset
void reset(uint NOBXS)
Definition: MatrixReadOut.cxx:240
MatrixReadOutStructure::febcid
ubit16 febcid()
Definition: MatrixReadOutStructure.h:32
RPCRXRODDecode::headerSize
RODword headerSize
Definition: RPCRXRODDecode.h:43
MatrixReadOutStructure::channel
ubit16 channel()
Definition: MatrixReadOutStructure.h:36
MatrixReadOutStructure::ijk
ubit16 ijk()
Definition: MatrixReadOutStructure.h:35
SectorLogicRXReadOutStructure::isFooter
bool isFooter()
Definition: SectorLogicRXReadOutStructure.cxx:154
MatrixReadOutStructure::decodeFragment
ubit16 decodeFragment(ubit16 inputWord, char &field)
Definition: MatrixReadOutStructure.cxx:111
RPCRXRODDecode::PadID
ubit16 PadID
Definition: RPCRXRODDecode.h:58
RPCRXRODDecode::m_enablePrintOut
bool m_enablePrintOut
Definition: RPCRXRODDecode.h:102
MatrixReadOutStructure::isBody
bool isBody()
Definition: MatrixReadOutStructure.cxx:180
RPCRXRODDecode::PadFoot
@ PadFoot
Definition: RPCRXRODDecode.h:80
BaseObject::m_name
std::string m_name
Definition: BaseObject.h:16
MatrixReadOutStructure::global_channel
ubit16 global_channel()
Definition: MatrixReadOutStructure.cxx:198
SectorLogicRXReadOut::reset
void reset()
Definition: SectorLogicRXReadOut.cxx:66
RPCRXRODDecode::m_field
ubit16 m_field
Definition: RPCRXRODDecode.h:85
RPCRXRODDecode::Empty
@ Empty
Definition: RPCRXRODDecode.h:80
RODword
uint32_t RODword
Definition: Lvl1Def.h:18
SectorLogicRXReadOutStructure::isHeader
bool isHeader()
Definition: SectorLogicRXReadOutStructure.cxx:110
RPCRXRODDecode::SLROS
SectorLogicRXReadOutStructure SLROS
Definition: RPCRXRODDecode.h:68
RPCRXRODDecode::SLFoot
@ SLFoot
Definition: RPCRXRODDecode.h:80
MatrixReadOut::getHeader
MatrixReadOutStructure getHeader()
Definition: MatrixReadOut.cxx:948
MatrixReadOutStructure::isEtaProj
bool isEtaProj()
Definition: MatrixReadOutStructure.cxx:226
RPCRXRODDecode::SLHead
@ SLHead
Definition: RPCRXRODDecode.h:80
RPCRXRODDecode::CMFragCheck
ubit16 CMFragCheck
Definition: RPCRXRODDecode.h:60
SectorLogicRXReadOutStructure::isSubHeader
bool isSubHeader()
Definition: SectorLogicRXReadOutStructure.cxx:117
RPCRXRODDecode::sourceIdentifier
RODword sourceIdentifier
Definition: RPCRXRODDecode.h:45
RPCRXRODDecode::RXFoot
@ RXFoot
Definition: RPCRXRODDecode.h:80
PadReadOutStructure::isPreFooter
bool isPreFooter()
Definition: PadReadOutStructure.cxx:182
MatrixReadOutStructure::isHeader
bool isHeader()
Definition: MatrixReadOutStructure.cxx:166
MatrixReadOut::getSubHeader
MatrixReadOutStructure getSubHeader()
Definition: MatrixReadOut.cxx:953
MatrixReadOutStructure::overlap
ubit16 overlap()
Definition: MatrixReadOutStructure.h:38
RPCRXRODDecode::Level1ID
RODword Level1ID
Definition: RPCRXRODDecode.h:46
RPCRXRODDecode::CMRO
MatrixReadOut CMRO
Definition: RPCRXRODDecode.h:67
RPCRXRODDecode::DetectorEventType
RODword DetectorEventType
Definition: RPCRXRODDecode.h:49
MatrixReadOutStructure::fel1id
ubit16 fel1id()
Definition: MatrixReadOutStructure.h:31
MatrixReadOutStructure::cmid
ubit16 cmid()
Definition: MatrixReadOutStructure.h:30
RPCRXRODDecode::CMBod
@ CMBod
Definition: RPCRXRODDecode.h:80
MatrixReadOutStructure::is0LocAdd
bool is0LocAdd()
Definition: MatrixReadOutStructure.cxx:234
MatrixReadOut::checkFragment
ubit16 checkFragment()
Definition: MatrixReadOut.cxx:807
RPCRXRODDecode::CMSub
@ CMSub
Definition: RPCRXRODDecode.h:80
RPCRXRODDecode::PadPre
@ PadPre
Definition: RPCRXRODDecode.h:80
SectorLogicRXReadOut::writeRecord
void writeRecord(ubit16 thisRecord, bool last)
Definition: SectorLogicRXReadOut.cxx:76
RPCRXRODDecode::RXROS
RXReadOutStructure RXROS
Definition: RPCRXRODDecode.h:64
RPCRXRODDecode::CMFoot
@ CMFoot
Definition: RPCRXRODDecode.h:80
RPCRODStructure::getSourceIDSubdetectorID
ubit16 getSourceIDSubdetectorID()
Definition: RPCRODStructure.h:24
RPCRXRODDecode::BunchXingID
RODword BunchXingID
Definition: RPCRXRODDecode.h:47
PadReadOutStructure::decodeFragment
ubit16 decodeFragment(ubit16 inputWord, char &field)
Definition: PadReadOutStructure.cxx:118
lumiFormat.i
int i
Definition: lumiFormat.py:92
RPCRXRODDecode::Level1Type
RODword Level1Type
Definition: RPCRXRODDecode.h:48
MatrixReadOutStructure::isFooter
bool isFooter()
Definition: MatrixReadOutStructure.cxx:187
RPCRXRODDecode::m_CMFlag
ubit16 m_CMFlag
Definition: RPCRXRODDecode.h:96
PadReadOutStructure::isHeader
bool isHeader()
Definition: PadReadOutStructure.cxx:166
RPCRXRODDecode::CMID
ubit16 CMID
Definition: RPCRXRODDecode.h:59
RPCRXRODDecode::SLRO
SectorLogicRXReadOut SLRO
Definition: RPCRXRODDecode.h:69
RPCRXRODDecode::SourceReserved
ubit16 SourceReserved
Definition: RPCRXRODDecode.h:50
RPCRODStructure::getSourceIDReserved
ubit16 getSourceIDReserved()
Definition: RPCRODStructure.h:22
RPCRXRODDecode::m_previousRecord
recType m_previousRecord
Definition: RPCRXRODDecode.h:81
RXReadOutStructure::decodeFragment
ubit16 decodeFragment(ubit16 inputWord, char &field)
Definition: RXReadOutStructure.cxx:78
RPCRXRODDecode::m_RODDataAddress
sbit32 m_RODDataAddress
Definition: RPCRXRODDecode.h:76
RPCRODStructure
Definition: RPCRODStructure.h:16
Hardware
@ Hardware
Definition: BaseObject.h:11
RPCRXRODDecode::RODHeader
void RODHeader(const RODword *ROBData)
Definition: RPCRXRODDecode.cxx:802
RPCRXRODDecode::m_reserved4
ubit16 m_reserved4
Definition: RPCRXRODDecode.h:91
MatrixReadOut::getCMAHit
MatrixReadOutStructure getCMAHit(int index)
Definition: MatrixReadOut.cxx:699
MatrixReadOutStructure
Definition: MatrixReadOutStructure.h:13
RPCRXRODDecode::RXHead
@ RXHead
Definition: RPCRXRODDecode.h:80
RPCRXRODDecode::SourceSubDetectorID
ubit16 SourceSubDetectorID
Definition: RPCRXRODDecode.h:52
BaseObject::BaseObject
BaseObject(ObjectType, const std::string &)
Definition: BaseObject.cxx:7
MatrixReadOut::numberOfBodyWords
ubit16 numberOfBodyWords()
Definition: MatrixReadOut.h:49
RPCRODStructure::getSourceIDModuleType
ubit16 getSourceIDModuleType()
Definition: RPCRODStructure.h:23
MatrixReadOutStructure::isSubHeader
bool isSubHeader()
Definition: MatrixReadOutStructure.cxx:173
RPCRXRODDecode::m_RXFlag
ubit16 m_RXFlag
Definition: RPCRXRODDecode.h:98
RPCRXRODDecode::CMROS
MatrixReadOutStructure CMROS
Definition: RPCRXRODDecode.h:66
RPCRODStructure::getSourceIDRODID
ubit16 getSourceIDRODID()
Definition: RPCRODStructure.h:25
RPCRXRODDecode::m_noRecord16
ubit16 m_noRecord16
Definition: RPCRXRODDecode.h:86
RPCRXRODDecode::PadHead
@ PadHead
Definition: RPCRXRODDecode.h:80
MatrixReadOutStructure::isLowPt
bool isLowPt()
Definition: MatrixReadOutStructure.cxx:218
RPCRXRODDecode::formatVersion
RODword formatVersion
Definition: RPCRXRODDecode.h:44
BaseObject::m_tag
ObjectType m_tag
Definition: BaseObject.h:15
PadReadOutStructure::padid
ubit16 padid() const
Definition: PadReadOutStructure.h:32
PadReadOutStructure::isSubHeader
bool isSubHeader()
Definition: PadReadOutStructure.cxx:174
RPCRXRODDecode::pushWord
int pushWord(const ubit16 inword, uint NOBXS)
Definition: RPCRXRODDecode.cxx:87
RPCRODStructure::decodeSourceID
void decodeSourceID(RODword sourceID)
Definition: RPCRODStructure.cxx:49
RPCRXRODDecode::headerMarker
RODword headerMarker
Definition: RPCRXRODDecode.h:37
RXReadOutStructure::isFooter
bool isFooter()
Definition: RXReadOutStructure.cxx:71
MatrixReadOut::writeRecord
void writeRecord(ubit16 thisRecord, bool last)
Definition: MatrixReadOut.cxx:183
MatrixReadOutStructure::threshold
ubit16 threshold()
Definition: MatrixReadOutStructure.h:37
SectorLogicRXReadOutStructure::decodeFragment
ubit16 decodeFragment(ubit16 inputWord, char &field)
Definition: SectorLogicRXReadOutStructure.cxx:39
RXReadOutStructure::RXid
ubit16 RXid()
Definition: RXReadOutStructure.h:33
PadReadOutStructure::isFooter
bool isFooter()
Definition: PadReadOutStructure.cxx:190
RPCRXRODDecode::SourceModuleType
ubit16 SourceModuleType
Definition: RPCRXRODDecode.h:51
RPCRXRODDecode::CMHead
@ CMHead
Definition: RPCRXRODDecode.h:80
ubit16
unsigned short int ubit16
Definition: RpcByteStreamEncoder.h:20
RPCRXRODDecode::PadSub
@ PadSub
Definition: RPCRXRODDecode.h:80
RPCRXRODDecode::m_slFound
bool m_slFound
Definition: RPCRXRODDecode.h:105
RPCRXRODDecode::m_noRecord32
RODword m_noRecord32
Definition: RPCRXRODDecode.h:87
RPCRXRODDecode::m_isSLBody
bool m_isSLBody
Definition: RPCRXRODDecode.h:72
RPCRXRODDecode::m_PADFlag
ubit16 m_PADFlag
Definition: RPCRXRODDecode.h:97
RPCRXRODDecode::SectorID
ubit16 SectorID
Definition: RPCRXRODDecode.h:57
RPCRXRODDecode::SourceModuleID
ubit16 SourceModuleID
Definition: RPCRXRODDecode.h:53
MatrixReadOutStructure::bcid
ubit16 bcid()
Definition: MatrixReadOutStructure.h:33
RXReadOutStructure::isHeader
bool isHeader()
Definition: RXReadOutStructure.cxx:64
RPCRXRODDecode::PDROS
PadReadOutStructure PDROS
Definition: RPCRXRODDecode.h:65
Generated on Sun Jun 30 2024 21:57:00 for ATLAS Offline Software by   doxygen 1.8.18