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

#include <RPCRODDecode.h>

Inheritance diagram for RPCRODDecode:
Collaboration diagram for RPCRODDecode:

Public Member Functions

 RPCRODDecode ()
 
 ~RPCRODDecode ()
 
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 ()
 
SectorLogicReadOut * SLFragment ()
 
void gimeCMROData ()
 
void RODHeaderDisplay ()
 
ubit16 gimeCMFlag ()
 
ubit16 gimePADFlag ()
 
ubit16 gimeRXFlag ()
 
void enablePrintOut ()
 
void disablePrintOut ()
 
ObjectType tag () const
 
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
 
SectorLogicReadOutStructure SLROS
 
SectorLogicReadOut 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 {sbit32(0xdeadcafe)}
 
recType m_previousRecord {recType::Empty}
 
ubit16 m_field {0xf000}
 
ubit16 m_noRecord16 {9999}
 
RODword m_noRecord32 {0xdeadcafe}
 
ubit16 m_reserved4 {0xe000}
 
ubit16 m_CMFlag {}
 
ubit16 m_PADFlag {}
 
ubit16 m_RXFlag {}
 
bool m_enablePrintOut {}
 
ObjectType m_tag
 
std::string m_name
 

Detailed Description

Definition at line 12 of file RPCRODDecode.h.

Member Enumeration Documentation

◆ recType

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

Definition at line 68 of file RPCRODDecode.h.

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

Constructor & Destructor Documentation

◆ RPCRODDecode()

RPCRODDecode::RPCRODDecode ( )

Definition at line 9 of file RPCRODDecode.cxx.

9  : BaseObject(Hardware, "RPCRODDecode") {
10  // the ROD header
11  headerMarker = m_noRecord32;
12  headerSize = m_noRecord32;
13  formatVersion = m_noRecord32;
14  sourceIdentifier = m_noRecord32;
15  Level1ID = m_noRecord32;
16  BunchXingID = m_noRecord32;
17  Level1Type = m_noRecord32;
18  DetectorEventType = m_noRecord32;
19  SourceReserved = m_noRecord16;
20  SourceModuleType = m_noRecord16;
21  SourceSubDetectorID = m_noRecord16;
22  SourceModuleID = m_noRecord16;
23  //
24  // the RPC identifiers
25  SectorID = m_noRecord16;
26  PadID = m_noRecord16;
27  CMID = m_noRecord16;
28  //
29  // the structure control flags
30  CMFragCheck = m_noRecord16;
31 } // end-of-RPCRODDecode::RPCRODDecode

◆ ~RPCRODDecode()

RPCRODDecode::~RPCRODDecode ( )

Definition at line 33 of file RPCRODDecode.cxx.

33 {} // destructor

Member Function Documentation

◆ CMFragment()

MatrixReadOut* RPCRODDecode::CMFragment ( )
inline

Definition at line 21 of file RPCRODDecode.h.

21 { return &CMRO; };

◆ disablePrintOut()

void RPCRODDecode::disablePrintOut ( )

Definition at line 37 of file RPCRODDecode.cxx.

37 { m_enablePrintOut = false; } // dRPCRODDecode::disablePrintOut

◆ enablePrintOut()

void RPCRODDecode::enablePrintOut ( )

Definition at line 35 of file RPCRODDecode.cxx.

35 { m_enablePrintOut = true; } // RPCRODDecode::enablePrintOut

◆ gimeCMFlag()

ubit16 RPCRODDecode::gimeCMFlag ( )
inline

Definition at line 27 of file RPCRODDecode.h.

27 { return m_CMFlag; };

◆ gimeCMROData()

void RPCRODDecode::gimeCMROData ( )

Definition at line 707 of file RPCRODDecode.cxx.

707  {
708  MatrixReadOutStructure CMROS;
709  ubit16 nCMROData = CMRO.numberOfBodyWords();
710 
711  if (m_enablePrintOut) {
712  std::cout << " number of Body Words in this CM Fragment " << nCMROData << std::endl;
713 
714  //
715  // get header data
716  //
717  CMROS = CMRO.getHeader();
718 
719  std::cout << " gimeCMROData, CMID: " << CMROS.cmid() << std::endl
720  << " gimeCMROData, FEL1ID: " << CMROS.fel1id() << std::endl
721  << " isLowPt = " << CMROS.isLowPt() << std::endl
722  << " isEtaProj= " << CMROS.isEtaProj() << std::endl
723  << " is0LocAdd= " << CMROS.is0LocAdd() << std::endl;
724 
725  //
726  // get subheader data
727  //
728  CMROS = CMRO.getSubHeader();
729 
730  std::cout << " gimeCMROData, FEBCID: " << CMROS.febcid() << std::endl;
731 
732  //
733  // get Body data
734  //
735  for (ubit16 i = 0; i < nCMROData; i++) {
736  CMROS = CMRO.getCMAHit(i);
737  ubit16 ijk = CMROS.ijk();
738  if (ijk < 6) {
739  std::cout << " gimeCMROData, hit chan: " << CMROS.channel() << " gimeCMROData, hit stri: " << CMROS.global_channel()
740  << " hit BCID: " << CMROS.bcid() << std::endl;
741  } else if (ijk == 6) {
742  std::cout << " gimeCMROData, trg chan: " << CMROS.channel() << " hit BCID: " << CMROS.bcid() << std::endl;
743  } else if (ijk == 7) {
744  std::cout << " gimeCMROData, trg thr: " << CMROS.threshold() << " trg ovl: " << CMROS.overlap() << std::endl;
745  } else {
746  std::cout << " this value of ijk=" << ijk << " is NOT ALLOWED " << std::endl;
747  } // end-of-if
748  std::cout << std::endl;
749  } // end-of-for
750  } // end-of-if(m_enablePrintOut
751 } // end-of-gimeCMROData

◆ gimePADFlag()

ubit16 RPCRODDecode::gimePADFlag ( )
inline

Definition at line 28 of file RPCRODDecode.h.

28 { return m_PADFlag; };

◆ gimeRODDataAddress()

sbit32 RPCRODDecode::gimeRODDataAddress ( )
inline

Definition at line 16 of file RPCRODDecode.h.

16 { return m_RODDataAddress; };

◆ gimeRXFlag()

ubit16 RPCRODDecode::gimeRXFlag ( )
inline

Definition at line 29 of file RPCRODDecode.h.

29 { return m_RXFlag; };

◆ name()

const 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 RPCRODDecode::pushWord ( const RODword  inword,
ubit16  j,
uint  NOBXS 
)

Definition at line 39 of file RPCRODDecode.cxx.

39  {
40  //
41  // select the less significant 16 bits (j=0) or the
42  // highest significant 16 bits (j=1) of the 32 bits word inword
43  // and push this 16 bit word selected to the method pushWord
44  // for decoding
45  //
46  RODword mask1[2];
47  RODword shift[2];
48  mask1[0] = 0x0000ffff;
49  mask1[1] = 0xffff0000;
50  shift[0] = 0;
51  shift[1] = 16;
52  return pushWord((inword & mask1[j]) >> shift[j], NOBXS);
53 }

◆ pushWord() [2/2]

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

Definition at line 55 of file RPCRODDecode.cxx.

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

◆ RODAddresses()

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

Definition at line 804 of file RPCRODDecode.cxx.

804  {
805  RODHeader(RODData);
806  std::cout << " status block position " << statusBlockPosition << std::endl;
807  std::cout << " number of Status Elements " << numberOfStatusElements << std::endl;
808  if (statusBlockPosition) {
809  m_RODDataAddress = headerSize;
810  } else {
811  m_RODDataAddress = headerSize + numberOfStatusElements;
812  }
813 } // end-of-RPCRODDecode::RODAddresses

◆ RODHeader()

void RPCRODDecode::RODHeader ( const RODword *  ROBData)

Definition at line 753 of file RPCRODDecode.cxx.

753  {
754  //
755  // decode the ROD header
756  //
757  headerSize = *(RODData + 1);
758  for (ubit16 i = 0; i < headerSize; i++) {
759  if (i == 0) {
760  headerMarker = *(RODData + i);
761  } else if (i == 2) {
762  formatVersion = *(RODData + i);
763  } else if (i == 3) {
764  sourceIdentifier = *(RODData + i);
765  RPCRODStructure RPCRODS;
766  RPCRODS.decodeSourceID(sourceIdentifier);
767  SourceModuleID = RPCRODS.getSourceIDRODID();
768  SourceSubDetectorID = RPCRODS.getSourceIDSubdetectorID();
769  SourceModuleType = RPCRODS.getSourceIDModuleType();
770  SourceReserved = RPCRODS.getSourceIDReserved();
771  } else if (i == 4) {
772  Level1ID = *(RODData + i);
773  } else if (i == 5) {
774  BunchXingID = *(RODData + i);
775  } else if (i == 6) {
776  Level1Type = *(RODData + i);
777  } else if (i == 7) {
778  DetectorEventType = *(RODData + i);
779  } // end-of-if
780  } // end-of-for
781 } // end-of-RODHeader

◆ RODHeaderDisplay()

void RPCRODDecode::RODHeaderDisplay ( )

Definition at line 815 of file RPCRODDecode.cxx.

815  {
816  if (m_enablePrintOut) {
817  std::cout << "*****************************************************" << std::endl
818  << "****** R O D H E A D E R *******" << std::endl
819  << "*****************************************************" << std::endl
820  << " ROD Header marker: " << std::hex << headerMarker << std::dec << std::endl
821  << " ROD Header size: " << headerSize << std::endl
822  << " ROD Format version number: " << formatVersion << std::endl
823  << " ROD Source Identifier: " << sourceIdentifier << std::endl
824  << " ROD Source Module ID: " << SourceModuleID << std::endl
825  << " ROD Source SubDectID: " << SourceSubDetectorID << std::endl
826  << " ROD Source Module Ty: " << SourceModuleType << std::endl
827  << " ROD Source Reserved : " << SourceReserved << std::endl
828  << " ROD Level1 ID: " << Level1ID << std::endl
829  << " ROD BuncgXingID: " << BunchXingID << std::endl
830  << " ROD Level1 Type: " << Level1Type << std::endl
831  << " ROD Detector Ev. Type: " << DetectorEventType << std::endl
832  << "*****************************************************" << std::endl;
833  } // end-of-if(m_enablePrintOut
834 } // end-of-RODHeaderDisplay

◆ SLFragment()

SectorLogicReadOut* RPCRODDecode::SLFragment ( )
inline

Definition at line 22 of file RPCRODDecode.h.

22 { 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 RPCRODDecode::BunchXingID

Definition at line 39 of file RPCRODDecode.h.

◆ CMFragCheck

ubit16 RPCRODDecode::CMFragCheck

Definition at line 51 of file RPCRODDecode.h.

◆ CMID

ubit16 RPCRODDecode::CMID

Definition at line 50 of file RPCRODDecode.h.

◆ CMRO

MatrixReadOut RPCRODDecode::CMRO

Definition at line 57 of file RPCRODDecode.h.

◆ CMROS

MatrixReadOutStructure RPCRODDecode::CMROS

Definition at line 56 of file RPCRODDecode.h.

◆ DetectorEventType

RODword RPCRODDecode::DetectorEventType

Definition at line 41 of file RPCRODDecode.h.

◆ formatVersion

RODword RPCRODDecode::formatVersion

Definition at line 36 of file RPCRODDecode.h.

◆ headerMarker

RODword RPCRODDecode::headerMarker

Definition at line 34 of file RPCRODDecode.h.

◆ headerSize

RODword RPCRODDecode::headerSize

Definition at line 35 of file RPCRODDecode.h.

◆ Level1ID

RODword RPCRODDecode::Level1ID

Definition at line 38 of file RPCRODDecode.h.

◆ Level1Type

RODword RPCRODDecode::Level1Type

Definition at line 40 of file RPCRODDecode.h.

◆ m_CMFlag

ubit16 RPCRODDecode::m_CMFlag {}
private

Definition at line 82 of file RPCRODDecode.h.

◆ m_enablePrintOut

bool RPCRODDecode::m_enablePrintOut {}
private

Definition at line 87 of file RPCRODDecode.h.

◆ m_field

ubit16 RPCRODDecode::m_field {0xf000}
private

Definition at line 72 of file RPCRODDecode.h.

◆ m_isSLBody

bool RPCRODDecode::m_isSLBody {}
private

Definition at line 62 of file RPCRODDecode.h.

◆ m_name

std::string BaseObject::m_name
privateinherited

Definition at line 16 of file BaseObject.h.

◆ m_noRecord16

ubit16 RPCRODDecode::m_noRecord16 {9999}
private

Definition at line 73 of file RPCRODDecode.h.

◆ m_noRecord32

RODword RPCRODDecode::m_noRecord32 {0xdeadcafe}
private

Definition at line 74 of file RPCRODDecode.h.

◆ m_PADFlag

ubit16 RPCRODDecode::m_PADFlag {}
private

Definition at line 83 of file RPCRODDecode.h.

◆ m_previousRecord

recType RPCRODDecode::m_previousRecord {recType::Empty}
private

Definition at line 69 of file RPCRODDecode.h.

◆ m_reserved4

ubit16 RPCRODDecode::m_reserved4 {0xe000}
private

Definition at line 78 of file RPCRODDecode.h.

◆ m_RODDataAddress

sbit32 RPCRODDecode::m_RODDataAddress {sbit32(0xdeadcafe)}
private

Definition at line 65 of file RPCRODDecode.h.

◆ m_RXFlag

ubit16 RPCRODDecode::m_RXFlag {}
private

Definition at line 84 of file RPCRODDecode.h.

◆ m_tag

ObjectType BaseObject::m_tag
privateinherited

Definition at line 15 of file BaseObject.h.

◆ PadID

ubit16 RPCRODDecode::PadID

Definition at line 49 of file RPCRODDecode.h.

◆ PDROS

PadReadOutStructure RPCRODDecode::PDROS

Definition at line 55 of file RPCRODDecode.h.

◆ RXROS

RXReadOutStructure RPCRODDecode::RXROS

Definition at line 54 of file RPCRODDecode.h.

◆ SectorID

ubit16 RPCRODDecode::SectorID

Definition at line 48 of file RPCRODDecode.h.

◆ SLRO

SectorLogicReadOut RPCRODDecode::SLRO

Definition at line 59 of file RPCRODDecode.h.

◆ SLROS

SectorLogicReadOutStructure RPCRODDecode::SLROS

Definition at line 58 of file RPCRODDecode.h.

◆ sourceIdentifier

RODword RPCRODDecode::sourceIdentifier

Definition at line 37 of file RPCRODDecode.h.

◆ SourceModuleID

ubit16 RPCRODDecode::SourceModuleID

Definition at line 45 of file RPCRODDecode.h.

◆ SourceModuleType

ubit16 RPCRODDecode::SourceModuleType

Definition at line 43 of file RPCRODDecode.h.

◆ SourceReserved

ubit16 RPCRODDecode::SourceReserved

Definition at line 42 of file RPCRODDecode.h.

◆ SourceSubDetectorID

ubit16 RPCRODDecode::SourceSubDetectorID

Definition at line 44 of file RPCRODDecode.h.

The documentation for this class was generated from the following files:
MatrixReadOut::reset
void reset(uint NOBXS)
Definition: MatrixReadOut.cxx:240
RPCRODDecode::sourceIdentifier
RODword sourceIdentifier
Definition: RPCRODDecode.h:37
MatrixReadOutStructure::febcid
ubit16 febcid()
Definition: MatrixReadOutStructure.h:32
SectorLogicReadOutStructure::decodeFragment
ubit16 decodeFragment(ubit16 inputWord, char &field)
Definition: SectorLogicReadOutStructure.cxx:39
RPCRODDecode::m_previousRecord
recType m_previousRecord
Definition: RPCRODDecode.h:69
MatrixReadOutStructure::channel
ubit16 channel()
Definition: MatrixReadOutStructure.h:36
RPCRODDecode::SourceModuleType
ubit16 SourceModuleType
Definition: RPCRODDecode.h:43
MatrixReadOutStructure::ijk
ubit16 ijk()
Definition: MatrixReadOutStructure.h:35
MatrixReadOutStructure::decodeFragment
ubit16 decodeFragment(ubit16 inputWord, char &field)
Definition: MatrixReadOutStructure.cxx:111
RPCRODDecode::CMSub
@ CMSub
Definition: RPCRODDecode.h:68
RPCRODDecode::CMROS
MatrixReadOutStructure CMROS
Definition: RPCRODDecode.h:56
RPCRODDecode::RXFoot
@ RXFoot
Definition: RPCRODDecode.h:68
MatrixReadOutStructure::isBody
bool isBody()
Definition: MatrixReadOutStructure.cxx:180
RPCRODDecode::m_noRecord32
RODword m_noRecord32
Definition: RPCRODDecode.h:74
BaseObject::m_name
std::string m_name
Definition: BaseObject.h:16
MatrixReadOutStructure::global_channel
ubit16 global_channel()
Definition: MatrixReadOutStructure.cxx:198
RPCRODDecode::RXROS
RXReadOutStructure RXROS
Definition: RPCRODDecode.h:54
RPCRODDecode::CMHead
@ CMHead
Definition: RPCRODDecode.h:68
RPCRODDecode::formatVersion
RODword formatVersion
Definition: RPCRODDecode.h:36
RPCRODDecode::Level1Type
RODword Level1Type
Definition: RPCRODDecode.h:40
RODword
uint32_t RODword
Definition: Lvl1Def.h:18
RPCRODDecode::PadHead
@ PadHead
Definition: RPCRODDecode.h:68
MatrixReadOut::getHeader
MatrixReadOutStructure getHeader()
Definition: MatrixReadOut.cxx:948
MatrixReadOutStructure::isEtaProj
bool isEtaProj()
Definition: MatrixReadOutStructure.cxx:226
RPCRODDecode::Level1ID
RODword Level1ID
Definition: RPCRODDecode.h:38
RPCRODDecode::CMBod
@ CMBod
Definition: RPCRODDecode.h:68
RPCRODDecode::Empty
@ Empty
Definition: RPCRODDecode.h:68
PadReadOutStructure::isPreFooter
bool isPreFooter()
Definition: PadReadOutStructure.cxx:182
RPCRODDecode::m_RODDataAddress
sbit32 m_RODDataAddress
Definition: RPCRODDecode.h:65
MatrixReadOutStructure::isHeader
bool isHeader()
Definition: MatrixReadOutStructure.cxx:166
MatrixReadOut::getSubHeader
MatrixReadOutStructure getSubHeader()
Definition: MatrixReadOut.cxx:953
MatrixReadOutStructure::overlap
ubit16 overlap()
Definition: MatrixReadOutStructure.h:38
MatrixReadOutStructure::fel1id
ubit16 fel1id()
Definition: MatrixReadOutStructure.h:31
MatrixReadOutStructure::cmid
ubit16 cmid()
Definition: MatrixReadOutStructure.h:30
MatrixReadOutStructure::is0LocAdd
bool is0LocAdd()
Definition: MatrixReadOutStructure.cxx:234
MatrixReadOut::checkFragment
ubit16 checkFragment()
Definition: MatrixReadOut.cxx:807
RPCRODDecode::BunchXingID
RODword BunchXingID
Definition: RPCRODDecode.h:39
RPCRODDecode::SourceSubDetectorID
ubit16 SourceSubDetectorID
Definition: RPCRODDecode.h:44
RPCRODDecode::m_PADFlag
ubit16 m_PADFlag
Definition: RPCRODDecode.h:83
RPCRODDecode::PadID
ubit16 PadID
Definition: RPCRODDecode.h:49
SectorLogicReadOutStructure::isFooter
bool isFooter()
Definition: SectorLogicReadOutStructure.cxx:74
RPCRODDecode::SLHead
@ SLHead
Definition: RPCRODDecode.h:68
RPCRODDecode::RXHead
@ RXHead
Definition: RPCRODDecode.h:68
RPCRODDecode::m_enablePrintOut
bool m_enablePrintOut
Definition: RPCRODDecode.h:87
RPCRODDecode::PadPre
@ PadPre
Definition: RPCRODDecode.h:68
RPCRODDecode::CMID
ubit16 CMID
Definition: RPCRODDecode.h:50
RPCRODDecode::PadSub
@ PadSub
Definition: RPCRODDecode.h:68
RPCRODDecode::RODHeader
void RODHeader(const RODword *ROBData)
Definition: RPCRODDecode.cxx:753
RPCRODDecode::DetectorEventType
RODword DetectorEventType
Definition: RPCRODDecode.h:41
RPCRODDecode::SLFoot
@ SLFoot
Definition: RPCRODDecode.h:68
RPCRODDecode::m_field
ubit16 m_field
Definition: RPCRODDecode.h:72
SectorLogicReadOutStructure::isHeader
bool isHeader()
Definition: SectorLogicReadOutStructure.cxx:66
RPCRODStructure::getSourceIDSubdetectorID
ubit16 getSourceIDSubdetectorID()
Definition: RPCRODStructure.h:24
RPCRODDecode::SLRO
SectorLogicReadOut SLRO
Definition: RPCRODDecode.h:59
PadReadOutStructure::decodeFragment
ubit16 decodeFragment(ubit16 inputWord, char &field)
Definition: PadReadOutStructure.cxx:118
lumiFormat.i
int i
Definition: lumiFormat.py:85
RPCRODDecode::m_CMFlag
ubit16 m_CMFlag
Definition: RPCRODDecode.h:82
MatrixReadOutStructure::isFooter
bool isFooter()
Definition: MatrixReadOutStructure.cxx:187
PadReadOutStructure::isHeader
bool isHeader()
Definition: PadReadOutStructure.cxx:166
RPCRODDecode::CMFragCheck
ubit16 CMFragCheck
Definition: RPCRODDecode.h:51
RPCRODStructure::getSourceIDReserved
ubit16 getSourceIDReserved()
Definition: RPCRODStructure.h:22
RPCRODDecode::CMFoot
@ CMFoot
Definition: RPCRODDecode.h:68
SectorLogicReadOut::writeRecord
void writeRecord(ubit16 newHit, bool last)
Definition: SectorLogicReadOut.cxx:102
RXReadOutStructure::decodeFragment
ubit16 decodeFragment(ubit16 inputWord, char &field)
Definition: RXReadOutStructure.cxx:78
RPCRODStructure
Definition: RPCRODStructure.h:16
RPCRODDecode::m_RXFlag
ubit16 m_RXFlag
Definition: RPCRODDecode.h:84
RPCRODDecode::PDROS
PadReadOutStructure PDROS
Definition: RPCRODDecode.h:55
RPCRODDecode::CMRO
MatrixReadOut CMRO
Definition: RPCRODDecode.h:57
RPCRODDecode::headerSize
RODword headerSize
Definition: RPCRODDecode.h:35
Hardware
@ Hardware
Definition: BaseObject.h:11
MatrixReadOut::getCMAHit
MatrixReadOutStructure getCMAHit(int index)
Definition: MatrixReadOut.cxx:699
RPCRODDecode::m_isSLBody
bool m_isSLBody
Definition: RPCRODDecode.h:62
MatrixReadOutStructure
Definition: MatrixReadOutStructure.h:13
SectorLogicReadOut::reset
void reset()
Definition: SectorLogicReadOut.cxx:93
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
RPCRODStructure::getSourceIDRODID
ubit16 getSourceIDRODID()
Definition: RPCRODStructure.h:25
RPCRODDecode::SectorID
ubit16 SectorID
Definition: RPCRODDecode.h:48
RPCRODDecode::SLROS
SectorLogicReadOutStructure SLROS
Definition: RPCRODDecode.h:58
MatrixReadOutStructure::isLowPt
bool isLowPt()
Definition: MatrixReadOutStructure.cxx:218
BaseObject::m_tag
ObjectType m_tag
Definition: BaseObject.h:15
PadReadOutStructure::padid
ubit16 padid() const
Definition: PadReadOutStructure.h:32
RPCRODDecode::pushWord
int pushWord(const ubit16 inword, uint NOBXS)
Definition: RPCRODDecode.cxx:55
PadReadOutStructure::isSubHeader
bool isSubHeader()
Definition: PadReadOutStructure.cxx:174
RPCRODDecode::headerMarker
RODword headerMarker
Definition: RPCRODDecode.h:34
RPCRODStructure::decodeSourceID
void decodeSourceID(RODword sourceID)
Definition: RPCRODStructure.cxx:49
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
RXReadOutStructure::RXid
ubit16 RXid()
Definition: RXReadOutStructure.h:33
PadReadOutStructure::isFooter
bool isFooter()
Definition: PadReadOutStructure.cxx:190
ubit16
unsigned short int ubit16
Definition: RpcByteStreamEncoder.h:20
RPCRODDecode::SourceModuleID
ubit16 SourceModuleID
Definition: RPCRODDecode.h:45
RPCRODDecode::PadFoot
@ PadFoot
Definition: RPCRODDecode.h:68
RPCRODDecode::SourceReserved
ubit16 SourceReserved
Definition: RPCRODDecode.h:42
RPCRODDecode::m_noRecord16
ubit16 m_noRecord16
Definition: RPCRODDecode.h:73
MatrixReadOutStructure::bcid
ubit16 bcid()
Definition: MatrixReadOutStructure.h:33
RXReadOutStructure::isHeader
bool isHeader()
Definition: RXReadOutStructure.cxx:64
RPCRODDecode::m_reserved4
ubit16 m_reserved4
Definition: RPCRODDecode.h:78
Generated on Sun Aug 31 2025 21:44:37 for ATLAS Offline Software by   doxygen 1.8.18