ATLAS Offline Software
Loading...
Searching...
No Matches
RPCRXRODDecode.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3*/
4
5#include "TrigT1RPChardware/RPCRXRODDecode.h"
6
7
8#include <iostream>
9#include <ios> // for std::hex
10//----------------------------------------------------------------------------//
13
14//----------------------------------------------------------------------------//
15void RPCRXRODDecode::enablePrintOut() { m_enablePrintOut = true; } // RPCRXRODDecode::enablePrintOut
16//----------------------------------------------------------------------------//
17void RPCRXRODDecode::disablePrintOut() { m_enablePrintOut = false; } // dRPCRXRODDecode::disablePrintOut
18//----------------------------------------------------------------------------//
19int RPCRXRODDecode::pushWord(const RODword inword, ubit16 j, uint NOBXS) {
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}
34//----------------------------------------------------------------------------//
35int RPCRXRODDecode::pushWord(const ubit16 inword, uint NOBXS) {
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}
703//----------------------------------------------------------------------------//
704void RPCRXRODDecode::gimeCMROData() {
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
749//---------------------------------------------------------------------------//
750void RPCRXRODDecode::RODHeader(const RODword *RODData) {
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
779//----------------------------------------------------------------------------//
780// void RPCRXRODDecode::ROBAddresses(const RODword *ROBData) {
784// ROBTotalSize = *(ROBData + locROBTotalFragSize-1);
785// RODDataSize = *(ROBData + ROBTotalSize-1 + locRODNumberOfDataElements);
786// RODStatusSize = *(ROBData + ROBTotalSize-1 + locRODNumberOfStatusElements);
787// RODStatusPosition = *(ROBData + ROBTotalSize-1 + locRODStatusBlockPosition);
788// RODBlockSize = RODDataSize + RODStatusSize;
789// if(RODStatusPosition) {
790// m_RODDataAddress = ROBTotalSize-(RODBlockSize+RODTrailerSize-1);
791//} else {
792// m_RODDataAddress = ROBTotalSize-(RODDataSize+RODTrailerSize-1);
793//}
794//
795// cout<<" Object ROB Total Size "<<ROBTotalSize<<endl;
796// cout<<" Object ROD Data Size "<<RODDataSize<<endl;
797// cout<<" Object ROD Status Size "<<RODStatusSize<<endl;
798// cout<<" Object ROD Data Address "<<m_RODDataAddress<<endl;
799//}//end-of-ROBAddresses
800//----------------------------------------------------------------------------//
801void RPCRXRODDecode::RODAddresses(const RODword *RODData, const sbit32 numberOfStatusElements, const sbit32 statusBlockPosition) {
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
811//----------------------------------------------------------------------------//
812void RPCRXRODDecode::RODHeaderDisplay() {
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
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
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::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::CMRO
MatrixReadOut CMRO
Definition RPCRXRODDecode.h:64
RPCRXRODDecode::SLROS
SectorLogicRXReadOutStructure SLROS
Definition RPCRXRODDecode.h:65
RPCRXRODDecode::formatVersion
RODword formatVersion
Definition RPCRXRODDecode.h:41
RPCRXRODDecode::m_previousRecord
recType m_previousRecord
Definition RPCRXRODDecode.h:76
RPCRXRODDecode::SLRO
SectorLogicRXReadOut SLRO
Definition RPCRXRODDecode.h:66
RPCRXRODDecode::sourceIdentifier
RODword sourceIdentifier
Definition RPCRXRODDecode.h:42
RPCRXRODDecode::SourceModuleType
ubit16 SourceModuleType
Definition RPCRXRODDecode.h:50
RPCRXRODDecode::m_CMFlag
ubit16 m_CMFlag
data structure control flags
Definition RPCRXRODDecode.h:84
RPCRXRODDecode::CMROS
MatrixReadOutStructure CMROS
Definition RPCRXRODDecode.h:63
RPCRXRODDecode::PDROS
PadReadOutStructure PDROS
Definition RPCRXRODDecode.h:62
RPCRXRODDecode::pushWord
int pushWord(const ubit16 inword, uint NOBXS)
Definition RPCRXRODDecode.cxx:35
RPCRXRODDecode::headerMarker
RODword headerMarker
ROD HEADER.
Definition RPCRXRODDecode.h:39
RPCRXRODDecode::RODAddresses
void RODAddresses(const RODword *RODData, const sbit32 numberOfStatusElements, const sbit32 statusBlockPosition)
Definition RPCRXRODDecode.cxx:801
RPCRXRODDecode::RXROS
RXReadOutStructure RXROS
service objects
Definition RPCRXRODDecode.h:61
RPCRXRODDecode::m_enablePrintOut
bool m_enablePrintOut
enable printouts
Definition RPCRXRODDecode.h:89
RPCRXRODDecode::SourceSubDetectorID
ubit16 SourceSubDetectorID
Definition RPCRXRODDecode.h:51
RPCRXRODDecode::RODHeader
void RODHeader(const RODword *ROBData)
Definition RPCRXRODDecode.cxx:750
RPCRXRODDecode::m_RODDataAddress
sbit32 m_RODDataAddress
ROD Data address.
Definition RPCRXRODDecode.h:72
RPCRXRODDecode::m_field
ubit16 m_field
RPC data markers.
Definition RPCRXRODDecode.h:79
RPCRXRODDecode::DetectorEventType
RODword DetectorEventType
Definition RPCRXRODDecode.h:46
Generated on for ATLAS Offline Software by doxygen 1.14.0