ATLAS Offline Software
Loading...
Searching...
No Matches
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
Hardware
@ Hardware
Definition BaseObject.h:11
BaseObject::BaseObject
BaseObject(ObjectType, const std::string &)
Definition BaseObject.cxx:7
RPCRODDecode::SectorID
ubit16 SectorID
Definition RPCRODDecode.h:48
RPCRODDecode::BunchXingID
RODword BunchXingID
Definition RPCRODDecode.h:39
RPCRODDecode::sourceIdentifier
RODword sourceIdentifier
Definition RPCRODDecode.h:37
RPCRODDecode::Level1Type
RODword Level1Type
Definition RPCRODDecode.h:40
RPCRODDecode::headerMarker
RODword headerMarker
Definition RPCRODDecode.h:34
RPCRODDecode::SourceSubDetectorID
ubit16 SourceSubDetectorID
Definition RPCRODDecode.h:44
RPCRODDecode::m_noRecord32
RODword m_noRecord32
Definition RPCRODDecode.h:74
RPCRODDecode::DetectorEventType
RODword DetectorEventType
Definition RPCRODDecode.h:41
RPCRODDecode::formatVersion
RODword formatVersion
Definition RPCRODDecode.h:36
RPCRODDecode::SourceReserved
ubit16 SourceReserved
Definition RPCRODDecode.h:42
RPCRODDecode::Level1ID
RODword Level1ID
Definition RPCRODDecode.h:38
RPCRODDecode::m_noRecord16
ubit16 m_noRecord16
Definition RPCRODDecode.h:73
RPCRODDecode::headerSize
RODword headerSize
Definition RPCRODDecode.h:35
RPCRODDecode::CMFragCheck
ubit16 CMFragCheck
Definition RPCRODDecode.h:51
RPCRODDecode::SourceModuleID
ubit16 SourceModuleID
Definition RPCRODDecode.h:45
RPCRODDecode::SourceModuleType
ubit16 SourceModuleType
Definition RPCRODDecode.h:43

◆ ~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; };
RPCRODDecode::CMRO
MatrixReadOut CMRO
Definition RPCRODDecode.h:57

◆ disablePrintOut()

void RPCRODDecode::disablePrintOut ( )

Definition at line 37 of file RPCRODDecode.cxx.

37{ m_enablePrintOut = false; } // dRPCRODDecode::disablePrintOut
RPCRODDecode::m_enablePrintOut
bool m_enablePrintOut
Definition RPCRODDecode.h:87

◆ 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; };
RPCRODDecode::m_CMFlag
ubit16 m_CMFlag
Definition RPCRODDecode.h:82

◆ 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
ubit16
unsigned short int ubit16
Definition RpcByteStreamEncoder.h:20
RPCRODDecode::CMROS
MatrixReadOutStructure CMROS
Definition RPCRODDecode.h:56

◆ gimePADFlag()

ubit16 RPCRODDecode::gimePADFlag ( )
inline

Definition at line 28 of file RPCRODDecode.h.

28{ return m_PADFlag; };
RPCRODDecode::m_PADFlag
ubit16 m_PADFlag
Definition RPCRODDecode.h:83

◆ gimeRODDataAddress()

sbit32 RPCRODDecode::gimeRODDataAddress ( )
inline

Definition at line 16 of file RPCRODDecode.h.

16{ return m_RODDataAddress; };
RPCRODDecode::m_RODDataAddress
sbit32 m_RODDataAddress
Definition RPCRODDecode.h:65

◆ gimeRXFlag()

ubit16 RPCRODDecode::gimeRXFlag ( )
inline

Definition at line 29 of file RPCRODDecode.h.

29{ return m_RXFlag; };
RPCRODDecode::m_RXFlag
ubit16 m_RXFlag
Definition RPCRODDecode.h:84

◆ name()

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

Definition at line 23 of file BaseObject.h.

23{ return m_name; }
BaseObject::m_name
std::string m_name
Definition BaseObject.h:16

◆ Print()

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

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

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}
RODword
uint32_t RODword
Definition Lvl1Def.h:18
RPCRODDecode::pushWord
int pushWord(const ubit16 inword, uint NOBXS)
Definition RPCRODDecode.cxx:55

◆ 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}
RPCRODDecode::m_reserved4
ubit16 m_reserved4
Definition RPCRODDecode.h:78
RPCRODDecode::SLROS
SectorLogicReadOutStructure SLROS
Definition RPCRODDecode.h:58
RPCRODDecode::RXROS
RXReadOutStructure RXROS
Definition RPCRODDecode.h:54
RPCRODDecode::SLRO
SectorLogicReadOut SLRO
Definition RPCRODDecode.h:59
RPCRODDecode::m_previousRecord
recType m_previousRecord
Definition RPCRODDecode.h:69
RPCRODDecode::PDROS
PadReadOutStructure PDROS
Definition RPCRODDecode.h:55

◆ 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
RPCRODDecode::RODHeader
void RODHeader(const RODword *ROBData)
Definition RPCRODDecode.cxx:753

◆ 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
RPCRODStructure::getSourceIDSubdetectorID
ubit16 getSourceIDSubdetectorID()
Definition RPCRODStructure.h:24
RPCRODStructure::getSourceIDRODID
ubit16 getSourceIDRODID()
Definition RPCRODStructure.h:25
RPCRODStructure::getSourceIDModuleType
ubit16 getSourceIDModuleType()
Definition RPCRODStructure.h:23
RPCRODStructure::decodeSourceID
void decodeSourceID(RODword sourceID)
Definition RPCRODStructure.cxx:49
RPCRODStructure::getSourceIDReserved
ubit16 getSourceIDReserved()
Definition RPCRODStructure.h:22

◆ 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; }
BaseObject::m_tag
ObjectType m_tag
Definition BaseObject.h:15

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.

82{};

◆ m_enablePrintOut

bool RPCRODDecode::m_enablePrintOut {}
private

Definition at line 87 of file RPCRODDecode.h.

87{};

◆ m_field

ubit16 RPCRODDecode::m_field {0xf000}
private

Definition at line 72 of file RPCRODDecode.h.

72{0xf000}; // field map of word identifier

◆ m_isSLBody

bool RPCRODDecode::m_isSLBody {}
private

Definition at line 62 of file RPCRODDecode.h.

62{};

◆ 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.

73{9999}; // no record content for 16bit words

◆ m_noRecord32

RODword RPCRODDecode::m_noRecord32 {0xdeadcafe}
private

Definition at line 74 of file RPCRODDecode.h.

74{0xdeadcafe}; // no record content for 32bit words

◆ m_PADFlag

ubit16 RPCRODDecode::m_PADFlag {}
private

Definition at line 83 of file RPCRODDecode.h.

83{};

◆ m_previousRecord

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

Definition at line 69 of file RPCRODDecode.h.

69{recType::Empty};

◆ m_reserved4

ubit16 RPCRODDecode::m_reserved4 {0xe000}
private

Definition at line 78 of file RPCRODDecode.h.

78{0xe000}; // reserved

◆ m_RODDataAddress

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

Definition at line 65 of file RPCRODDecode.h.

65{sbit32(0xdeadcafe)};// ROD Data Address
sbit32
int32_t sbit32
Definition Lvl1Def.h:19

◆ m_RXFlag

ubit16 RPCRODDecode::m_RXFlag {}
private

Definition at line 84 of file RPCRODDecode.h.

84{};

◆ 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:
Generated on for ATLAS Offline Software by doxygen 1.14.0