ATLAS Offline Software
Loading...
Searching...
No Matches
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 ()
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 ()
 ROD structure control flags.
ubit16 gimePADFlag ()
ubit16 gimeRXFlag ()
void enablePrintOut ()
void disablePrintOut ()
void setSLFragmentFound (bool slFound)
ObjectType tag () const
const std::string & name () const
virtual void Print (std::ostream &, bool) const

Public Attributes

RODword headerMarker {0xdeadcafe}
 ROD HEADER.
RODword headerSize {0xdeadcafe}
RODword formatVersion {0xdeadcafe}
RODword sourceIdentifier {0xdeadcafe}
RODword Level1ID {0xdeadcafe}
RODword BunchXingID {0xdeadcafe}
RODword Level1Type {0xdeadcafe}
RODword DetectorEventType {0xdeadcafe}
ubit16 SourceReserved {9999}
ubit16 SourceModuleType {9999}
ubit16 SourceSubDetectorID {9999}
ubit16 SourceModuleID {9999}
ubit16 SectorID {9999}
 Sector, Pad and Matrix identifiers.
ubit16 PadID {9999}
ubit16 CMID {9999}
ubit16 CMFragCheck {9999}
RXReadOutStructure RXROS {}
 service objects
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
}
 define "previous" type of 16-bit data record More...

Private Attributes

bool m_isSLBody {}
sbit32 m_RODDataAddress {}
 ROD Data address.
recType m_previousRecord {recType::Empty}
ubit16 m_field {0xf000}
 RPC data markers.
ubit16 m_reserved4 {0xe000}
ubit16 m_CMFlag {}
 data structure control flags
ubit16 m_PADFlag {}
ubit16 m_RXFlag {}
bool m_enablePrintOut {}
 enable printouts
bool m_slFound {}
 the SL fragment was found
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

define "previous" type of 16-bit data record

Enumerator
Empty 
CMHead 
CMSub 
CMBod 
CMFoot 
PadHead 
PadSub 
PadPre 
PadFoot 
SLHead 
SLFoot 
RXHead 
RXFoot 

Definition at line 75 of file RPCRXRODDecode.h.

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

Constructor & Destructor Documentation

◆ RPCRXRODDecode()

RPCRXRODDecode::RPCRXRODDecode ( )

Definition at line 11 of file RPCRXRODDecode.cxx.

11 : BaseObject(Hardware, "RPCRXRODDecode") {
12}
Hardware
@ Hardware
Definition BaseObject.h:11
BaseObject::BaseObject
BaseObject(ObjectType, const std::string &)
Definition BaseObject.cxx:7

Member Function Documentation

◆ CMFragment()

MatrixReadOut * RPCRXRODDecode::CMFragment ( )
inline

Definition at line 21 of file RPCRXRODDecode.h.

21{ return &CMRO; };
RPCRXRODDecode::CMRO
MatrixReadOut CMRO
Definition RPCRXRODDecode.h:64

◆ disablePrintOut()

void RPCRXRODDecode::disablePrintOut ( )

Definition at line 17 of file RPCRXRODDecode.cxx.

17{ m_enablePrintOut = false; } // dRPCRXRODDecode::disablePrintOut
RPCRXRODDecode::m_enablePrintOut
bool m_enablePrintOut
enable printouts
Definition RPCRXRODDecode.h:89

◆ enablePrintOut()

void RPCRXRODDecode::enablePrintOut ( )

Definition at line 15 of file RPCRXRODDecode.cxx.

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

◆ gimeCMFlag()

ubit16 RPCRXRODDecode::gimeCMFlag ( )
inline

ROD structure control flags.

Definition at line 27 of file RPCRXRODDecode.h.

27{ return m_CMFlag; };
RPCRXRODDecode::m_CMFlag
ubit16 m_CMFlag
data structure control flags
Definition RPCRXRODDecode.h:84

◆ gimeCMROData()

void RPCRXRODDecode::gimeCMROData ( )

Definition at line 704 of file RPCRXRODDecode.cxx.

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

◆ gimePADFlag()

ubit16 RPCRXRODDecode::gimePADFlag ( )
inline

Definition at line 28 of file RPCRXRODDecode.h.

28{ return m_PADFlag; };

◆ gimeRODDataAddress()

sbit32 RPCRXRODDecode::gimeRODDataAddress ( )
inline

Definition at line 16 of file RPCRXRODDecode.h.

16{ return m_RODDataAddress; };
RPCRXRODDecode::m_RODDataAddress
sbit32 m_RODDataAddress
ROD Data address.
Definition RPCRXRODDecode.h:72

◆ gimeRXFlag()

ubit16 RPCRXRODDecode::gimeRXFlag ( )
inline

Definition at line 29 of file RPCRXRODDecode.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; }
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 RPCRXRODDecode::pushWord ( const RODword inword,
ubit16 j,
uint NOBXS )

Definition at line 19 of file RPCRXRODDecode.cxx.

19 {
20 //
21 // select the less significant 16 bits (j=0) or the
22 // highest significant 16 bits (j=1) of the 32 bits word inword
23 // and push this 16 bit word selected to the method pushWord
24 // for decoding
25 //
26 RODword mask1[2];
27 RODword shift[2];
28 mask1[0] = 0x0000ffff;
29 mask1[1] = 0xffff0000;
30 shift[0] = 0;
31 shift[1] = 16;
32 return pushWord((inword & mask1[j]) >> shift[j], NOBXS);
33}
RODword
uint32_t RODword
Definition Lvl1Def.h:18
RPCRXRODDecode::pushWord
int pushWord(const ubit16 inword, uint NOBXS)
Definition RPCRXRODDecode.cxx:35

◆ pushWord() [2/2]

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

Definition at line 35 of file RPCRXRODDecode.cxx.

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

◆ RODAddresses()

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

Definition at line 801 of file RPCRXRODDecode.cxx.

801 {
802 RODHeader(RODData);
803 std::cout << " status block position " << statusBlockPosition << std::endl;
804 std::cout << " number of Status Elements " << numberOfStatusElements << std::endl;
805 if (statusBlockPosition) {
806 m_RODDataAddress = headerSize;
807 } else {
808 m_RODDataAddress = headerSize + numberOfStatusElements;
809 }
810} // end-of-RPCRXRODDecode::RODAddresses
RPCRXRODDecode::RODHeader
void RODHeader(const RODword *ROBData)
Definition RPCRXRODDecode.cxx:750

◆ RODHeader()

void RPCRXRODDecode::RODHeader ( const RODword * ROBData)

Definition at line 750 of file RPCRXRODDecode.cxx.

750 {
751 //
752 // decode the ROD header
753 //
754 headerSize = *(RODData + 1);
755 for (ubit16 i = 0; i < headerSize; i++) {
756 if (i == 0) {
757 headerMarker = *(RODData + i);
758 } else if (i == 2) {
759 formatVersion = *(RODData + i);
760 } else if (i == 3) {
761 sourceIdentifier = *(RODData + i);
762 RPCRODStructure RPCRODS;
763 RPCRODS.decodeSourceID(sourceIdentifier);
764 SourceModuleID = RPCRODS.getSourceIDRODID();
765 SourceSubDetectorID = RPCRODS.getSourceIDSubdetectorID();
766 SourceModuleType = RPCRODS.getSourceIDModuleType();
767 SourceReserved = RPCRODS.getSourceIDReserved();
768 } else if (i == 4) {
769 Level1ID = *(RODData + i);
770 } else if (i == 5) {
771 BunchXingID = *(RODData + i);
772 } else if (i == 6) {
773 Level1Type = *(RODData + i);
774 } else if (i == 7) {
775 DetectorEventType = *(RODData + i);
776 } // end-of-if
777 } // end-of-for
778} // 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
RPCRXRODDecode::formatVersion
RODword formatVersion
Definition RPCRXRODDecode.h:41
RPCRXRODDecode::sourceIdentifier
RODword sourceIdentifier
Definition RPCRXRODDecode.h:42
RPCRXRODDecode::SourceModuleType
ubit16 SourceModuleType
Definition RPCRXRODDecode.h:50
RPCRXRODDecode::headerMarker
RODword headerMarker
ROD HEADER.
Definition RPCRXRODDecode.h:39
RPCRXRODDecode::SourceSubDetectorID
ubit16 SourceSubDetectorID
Definition RPCRXRODDecode.h:51
RPCRXRODDecode::DetectorEventType
RODword DetectorEventType
Definition RPCRXRODDecode.h:46

◆ RODHeaderDisplay()

void RPCRXRODDecode::RODHeaderDisplay ( )

Definition at line 812 of file RPCRXRODDecode.cxx.

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

◆ setSLFragmentFound()

void RPCRXRODDecode::setSLFragmentFound ( bool slFound)
inline

Definition at line 34 of file RPCRXRODDecode.h.

34{ m_slFound = slFound; };

◆ SLFragment()

SectorLogicRXReadOut * RPCRXRODDecode::SLFragment ( )
inline

Definition at line 22 of file RPCRXRODDecode.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 RPCRXRODDecode::BunchXingID {0xdeadcafe}

Definition at line 44 of file RPCRXRODDecode.h.

44{0xdeadcafe};

◆ CMFragCheck

ubit16 RPCRXRODDecode::CMFragCheck {9999}

Definition at line 58 of file RPCRXRODDecode.h.

58{9999};

◆ CMID

ubit16 RPCRXRODDecode::CMID {9999}

Definition at line 57 of file RPCRXRODDecode.h.

57{9999};

◆ CMRO

MatrixReadOut RPCRXRODDecode::CMRO {}

Definition at line 64 of file RPCRXRODDecode.h.

64{};

◆ CMROS

MatrixReadOutStructure RPCRXRODDecode::CMROS {}

Definition at line 63 of file RPCRXRODDecode.h.

63{};

◆ DetectorEventType

RODword RPCRXRODDecode::DetectorEventType {0xdeadcafe}

Definition at line 46 of file RPCRXRODDecode.h.

46{0xdeadcafe};

◆ formatVersion

RODword RPCRXRODDecode::formatVersion {0xdeadcafe}

Definition at line 41 of file RPCRXRODDecode.h.

41{0xdeadcafe};

◆ headerMarker

RODword RPCRXRODDecode::headerMarker {0xdeadcafe}

ROD HEADER.

Definition at line 39 of file RPCRXRODDecode.h.

39{0xdeadcafe};

◆ headerSize

RODword RPCRXRODDecode::headerSize {0xdeadcafe}

Definition at line 40 of file RPCRXRODDecode.h.

40{0xdeadcafe};

◆ Level1ID

RODword RPCRXRODDecode::Level1ID {0xdeadcafe}

Definition at line 43 of file RPCRXRODDecode.h.

43{0xdeadcafe};

◆ Level1Type

RODword RPCRXRODDecode::Level1Type {0xdeadcafe}

Definition at line 45 of file RPCRXRODDecode.h.

45{0xdeadcafe};

◆ m_CMFlag

ubit16 RPCRXRODDecode::m_CMFlag {}
private

data structure control flags

Definition at line 84 of file RPCRXRODDecode.h.

84{};

◆ m_enablePrintOut

bool RPCRXRODDecode::m_enablePrintOut {}
private

enable printouts

Definition at line 89 of file RPCRXRODDecode.h.

89{};

◆ m_field

ubit16 RPCRXRODDecode::m_field {0xf000}
private

RPC data markers.

field map of word identifier

Definition at line 79 of file RPCRXRODDecode.h.

79{0xf000};

◆ m_isSLBody

bool RPCRXRODDecode::m_isSLBody {}
private

Definition at line 69 of file RPCRXRODDecode.h.

69{};

◆ m_name

std::string BaseObject::m_name
privateinherited

Definition at line 16 of file BaseObject.h.

◆ m_PADFlag

ubit16 RPCRXRODDecode::m_PADFlag {}
private

Definition at line 85 of file RPCRXRODDecode.h.

85{};

◆ m_previousRecord

recType RPCRXRODDecode::m_previousRecord {recType::Empty}
private

Definition at line 76 of file RPCRXRODDecode.h.

76{recType::Empty};

◆ m_reserved4

ubit16 RPCRXRODDecode::m_reserved4 {0xe000}
private

Definition at line 81 of file RPCRXRODDecode.h.

81{0xe000};

◆ m_RODDataAddress

sbit32 RPCRXRODDecode::m_RODDataAddress {}
private

ROD Data address.

Definition at line 72 of file RPCRXRODDecode.h.

72{};

◆ m_RXFlag

ubit16 RPCRXRODDecode::m_RXFlag {}
private

Definition at line 86 of file RPCRXRODDecode.h.

86{};

◆ m_slFound

bool RPCRXRODDecode::m_slFound {}
private

the SL fragment was found

Definition at line 92 of file RPCRXRODDecode.h.

92{};

◆ m_tag

ObjectType BaseObject::m_tag
privateinherited

Definition at line 15 of file BaseObject.h.

◆ PadID

ubit16 RPCRXRODDecode::PadID {9999}

Definition at line 56 of file RPCRXRODDecode.h.

56{9999};

◆ PDROS

PadReadOutStructure RPCRXRODDecode::PDROS {}

Definition at line 62 of file RPCRXRODDecode.h.

62{};

◆ RXROS

RXReadOutStructure RPCRXRODDecode::RXROS {}

service objects

Definition at line 61 of file RPCRXRODDecode.h.

61{};

◆ SectorID

ubit16 RPCRXRODDecode::SectorID {9999}

Sector, Pad and Matrix identifiers.

Definition at line 55 of file RPCRXRODDecode.h.

55{9999};

◆ SLRO

SectorLogicRXReadOut RPCRXRODDecode::SLRO {}

Definition at line 66 of file RPCRXRODDecode.h.

66{};

◆ SLROS

SectorLogicRXReadOutStructure RPCRXRODDecode::SLROS {}

Definition at line 65 of file RPCRXRODDecode.h.

65{};

◆ sourceIdentifier

RODword RPCRXRODDecode::sourceIdentifier {0xdeadcafe}

Definition at line 42 of file RPCRXRODDecode.h.

42{0xdeadcafe};

◆ SourceModuleID

ubit16 RPCRXRODDecode::SourceModuleID {9999}

Definition at line 52 of file RPCRXRODDecode.h.

52{9999};

◆ SourceModuleType

ubit16 RPCRXRODDecode::SourceModuleType {9999}

Definition at line 50 of file RPCRXRODDecode.h.

50{9999};

◆ SourceReserved

ubit16 RPCRXRODDecode::SourceReserved {9999}

Definition at line 49 of file RPCRXRODDecode.h.

49{9999};

◆ SourceSubDetectorID

ubit16 RPCRXRODDecode::SourceSubDetectorID {9999}

Definition at line 51 of file RPCRXRODDecode.h.

51{9999};
The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0