ATLAS Offline Software
Loading...
Searching...
No Matches
RPCRODDecode.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3*/
4
5#include "TrigT1RPChardware/RPCRODDecode.h"
6#include <iostream>
7
8//----------------------------------------------------------------------------//
9RPCRODDecode::RPCRODDecode() : 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
32//----------------------------------------------------------------------------//
33RPCRODDecode::~RPCRODDecode() {} // destructor
34//----------------------------------------------------------------------------//
35void RPCRODDecode::enablePrintOut() { m_enablePrintOut = true; } // RPCRODDecode::enablePrintOut
36//----------------------------------------------------------------------------//
37void RPCRODDecode::disablePrintOut() { m_enablePrintOut = false; } // dRPCRODDecode::disablePrintOut
38//----------------------------------------------------------------------------//
39int RPCRODDecode::pushWord(const RODword inword, ubit16 j, uint NOBXS) {
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}
54//----------------------------------------------------------------------------//
55int RPCRODDecode::pushWord(const ubit16 inword, uint NOBXS) {
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}
706//----------------------------------------------------------------------------//
707void RPCRODDecode::gimeCMROData() {
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
752//---------------------------------------------------------------------------//
753void RPCRODDecode::RODHeader(const RODword *RODData) {
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
782//----------------------------------------------------------------------------//
783// void RPCRODDecode::ROBAddresses(const RODword *ROBData) {
787// ROBTotalSize = *(ROBData + locROBTotalFragSize-1);
788// RODDataSize = *(ROBData + ROBTotalSize-1 + locRODNumberOfDataElements);
789// RODStatusSize = *(ROBData + ROBTotalSize-1 + locRODNumberOfStatusElements);
790// RODStatusPosition = *(ROBData + ROBTotalSize-1 + locRODStatusBlockPosition);
791// RODBlockSize = RODDataSize + RODStatusSize;
792// if(RODStatusPosition) {
793// m_RODDataAddress = ROBTotalSize-(RODBlockSize+RODTrailerSize-1);
794//} else {
795// m_RODDataAddress = ROBTotalSize-(RODDataSize+RODTrailerSize-1);
796//}
797//
798// cout<<" Object ROB Total Size "<<ROBTotalSize<<endl;
799// cout<<" Object ROD Data Size "<<RODDataSize<<endl;
800// cout<<" Object ROD Status Size "<<RODStatusSize<<endl;
801// cout<<" Object ROD Data Address "<<m_RODDataAddress<<endl;
802//}//end-of-ROBAddresses
803//----------------------------------------------------------------------------//
804void RPCRODDecode::RODAddresses(const RODword *RODData, const sbit32 numberOfStatusElements, const sbit32 statusBlockPosition) {
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
814//----------------------------------------------------------------------------//
815void RPCRODDecode::RODHeaderDisplay() {
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
Hardware
@ Hardware
Definition BaseObject.h:11
uint
unsigned int uint
Definition LArOFPhaseFill.cxx:20
RODword
uint32_t RODword
Definition Lvl1Def.h:18
sbit32
int32_t sbit32
Definition Lvl1Def.h:19
ubit16
unsigned short int ubit16
Definition RpcByteStreamEncoder.h:20
BaseObject::BaseObject
BaseObject(ObjectType, const std::string &)
Definition BaseObject.cxx:7
RPCRODDecode::m_reserved4
ubit16 m_reserved4
Definition RPCRODDecode.h:78
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::m_enablePrintOut
bool m_enablePrintOut
Definition RPCRODDecode.h:87
RPCRODDecode::RODHeader
void RODHeader(const RODword *ROBData)
Definition RPCRODDecode.cxx:753
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::SLROS
SectorLogicReadOutStructure SLROS
Definition RPCRODDecode.h:58
RPCRODDecode::RXROS
RXReadOutStructure RXROS
Definition RPCRODDecode.h:54
RPCRODDecode::m_CMFlag
ubit16 m_CMFlag
Definition RPCRODDecode.h:82
RPCRODDecode::disablePrintOut
void disablePrintOut()
Definition RPCRODDecode.cxx:37
RPCRODDecode::formatVersion
RODword formatVersion
Definition RPCRODDecode.h:36
RPCRODDecode::m_RXFlag
ubit16 m_RXFlag
Definition RPCRODDecode.h:84
RPCRODDecode::m_PADFlag
ubit16 m_PADFlag
Definition RPCRODDecode.h:83
RPCRODDecode::m_RODDataAddress
sbit32 m_RODDataAddress
Definition RPCRODDecode.h:65
RPCRODDecode::SLRO
SectorLogicReadOut SLRO
Definition RPCRODDecode.h:59
RPCRODDecode::RODAddresses
void RODAddresses(const RODword *RODData, const sbit32 numberOfStatusElements, const sbit32 statusBlockPosition)
Definition RPCRODDecode.cxx:804
RPCRODDecode::SourceReserved
ubit16 SourceReserved
Definition RPCRODDecode.h:42
RPCRODDecode::Level1ID
RODword Level1ID
Definition RPCRODDecode.h:38
RPCRODDecode::m_previousRecord
recType m_previousRecord
Definition RPCRODDecode.h:69
RPCRODDecode::m_noRecord16
ubit16 m_noRecord16
Definition RPCRODDecode.h:73
RPCRODDecode::CMRO
MatrixReadOut CMRO
Definition RPCRODDecode.h:57
RPCRODDecode::pushWord
int pushWord(const ubit16 inword, uint NOBXS)
Definition RPCRODDecode.cxx:55
RPCRODDecode::enablePrintOut
void enablePrintOut()
Definition RPCRODDecode.cxx:35
RPCRODDecode::headerSize
RODword headerSize
Definition RPCRODDecode.h:35
RPCRODDecode::RODHeaderDisplay
void RODHeaderDisplay()
Definition RPCRODDecode.cxx:815
RPCRODDecode::CMFragCheck
ubit16 CMFragCheck
Definition RPCRODDecode.h:51
RPCRODDecode::SourceModuleID
ubit16 SourceModuleID
Definition RPCRODDecode.h:45
RPCRODDecode::CMROS
MatrixReadOutStructure CMROS
Definition RPCRODDecode.h:56
RPCRODDecode::SourceModuleType
ubit16 SourceModuleType
Definition RPCRODDecode.h:43
RPCRODDecode::PDROS
PadReadOutStructure PDROS
Definition RPCRODDecode.h:55
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
Generated on for ATLAS Offline Software by doxygen 1.14.0