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#include <math.h>
8
9#include <iostream>
10
11//----------------------------------------------------------------------------//
12RPCRXRODDecode::RPCRXRODDecode() : BaseObject(Hardware, "RPCRXRODDecode") {
13 // std::cout<<" This is the constructor of RPCRXRODDecode "<<std::endl;
14 //
15 // define RPC data word indentifiers
16 //
17 m_field = 0xf000; // field map of word identifier
18 // reserved3 = 0xd000; // reserved
19 m_reserved4 = 0xe000; // reserved
20 // reserved5 = 0xf000; // reserved
21 //
22 // ROD Data Address
23 //
24 m_RODDataAddress = m_noRecord32;
25 //
26 m_noRecord16 = 9999; // no record content for 16bit words
27 m_noRecord32 = 0xdeadcafe; // no record content for 32bit words
28 //
29 // the ROD header
30 //
31 headerMarker = m_noRecord32;
32 headerSize = m_noRecord32;
33 formatVersion = m_noRecord32;
34 sourceIdentifier = m_noRecord32;
35 Level1ID = m_noRecord32;
36 BunchXingID = m_noRecord32;
37 Level1Type = m_noRecord32;
38 DetectorEventType = m_noRecord32;
39 SourceReserved = m_noRecord16;
40 SourceModuleType = m_noRecord16;
41 SourceSubDetectorID = m_noRecord16;
42 SourceModuleID = m_noRecord16;
43 //
44 // the RPC identifiers
45 //
46 SectorID = m_noRecord16;
47 PadID = m_noRecord16;
48 CMID = m_noRecord16;
49 //
50 // m_previousRecord initialization
51 //
52 m_previousRecord = Empty;
53 //
54 // the structure control flags
55 //
56 CMFragCheck = m_noRecord16;
57 m_CMFlag = 0;
58 m_PADFlag = 0;
59 m_RXFlag = 0;
60 m_isSLBody = false;
61 m_enablePrintOut = false;
62 m_slFound = false;
63} // end-of-RPCRXRODDecode::RPCRXRODDecode
64//----------------------------------------------------------------------------//
65RPCRXRODDecode::~RPCRXRODDecode() {} // distructor
66//----------------------------------------------------------------------------//
67void RPCRXRODDecode::enablePrintOut() { m_enablePrintOut = true; } // RPCRXRODDecode::enablePrintOut
68//----------------------------------------------------------------------------//
69void RPCRXRODDecode::disablePrintOut() { m_enablePrintOut = false; } // dRPCRXRODDecode::disablePrintOut
70//----------------------------------------------------------------------------//
71int RPCRXRODDecode::pushWord(const RODword inword, ubit16 j, uint NOBXS) {
72 //
73 // select the less significant 16 bits (j=0) or the
74 // highest significant 16 bits (j=1) of the 32 bits word inword
75 // and push this 16 bit word selected to the method pushWord
76 // for decoding
77 //
78 RODword mask1[2];
79 RODword shift[2];
80 mask1[0] = 0x0000ffff;
81 mask1[1] = 0xffff0000;
82 shift[0] = 0;
83 shift[1] = 16;
84 return pushWord((inword & mask1[j]) >> shift[j], NOBXS);
85}
86//----------------------------------------------------------------------------//
87int RPCRXRODDecode::pushWord(const ubit16 inword, uint NOBXS) {
88 //
89 // analyze the current inword ReadOutDriver (ROD) data word:
90 // 1st) identify the type of word and
91 // 2nd) fill the MatrixReadOut object when CM hits are present;
92 // 3rd) close the MatrixReadOut fragment when the CM footer is ecountered;
93 // 4th) at this point the MatrixReadOut object can deliver the RPC hits
94 //
95 //
96 //
97 // analysis of patological cases and related actions:
98 //
99 // store in a flag, typePrevRec, the type of record of previous dataword:
100 //
101 // 0 == no CMA Record; "0"
102 // 1 == CMA Header; "H"
103 // 2 == CMA SubHeader; "S"
104 // 3 == CMA Body; "B"
105 // 3 == CMA Footer; "F"
106 //
107 //
108 // all cases should be accompained by error messages, except cases reported as
109 // "regular sequence: no problem at all"
110 //
111 // -Current record-|-Previous record-----------------Action---------------------
112 // type type
113 //
114 // 0 H close "CMRO": CMRO.writeRecord(inword,true);
115 // 0 S close "CMRO": CMRO.writeRecord(inword,true);
116 // 0 B close "CMRO": CMRO.writeRecord(inword,true);
117 // 0 F no action needed
118 //
119 // H 0 no action; no error message
120 // H H header overwriting;
121 // H S no action
122 // H B close "CMRO": CMRO.writeRecord(inword,true);
123 // H F no action needed
124 //
125 // S 0 no action
126 // S H regular sequence: no problem at all
127 // S S subheader overwriting;
128 // S B close "CMRO": CMRO.writeRecord(inword,true);
129 // S F no action needed
130 //
131 // B 0 no action
132 // B H no action needed;
133 // B S regular sequence: no problem at all
134 // B B regular sequence: no problem at all
135 // B F no action needed
136 //
137 // F 0 no action
138 // F H no action needed
139 // F S no action needed
140 // F B regular sequence: no problem at all
141 // F F no action needed
142 //
143 //
144 bool thereIsACM = false; // true if the data word is a CM footer
145 // that closes the CM fragment.
146 bool thereIsASL = false; // true if the data word is a SL footer
147 // that closes the SL fragment.
148 char recField; // record field
149 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode; inword= " << std::hex << inword << std::dec << std::endl; }
150 //
151 // recognize first the current word
152 //
153 CMROS.decodeFragment(inword, recField);
154 PDROS.decodeFragment(inword, recField);
155 RXROS.decodeFragment(inword, recField);
156 SLROS.decodeFragment(inword, recField);
157 //
158 // Identify the current 16bit word and check it...
159 //
160
161 if (SLROS.isHeader()) {
162 //
163 // SL Header
164 //
165 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: SectorLogic Header " << std::endl; }
166 m_isSLBody = false;
167 SLRO.reset();
168 SLRO.writeRecord(inword, false);
169 thereIsASL = false;
170 m_slFound = true;
171
172 } else if (SLROS.isSubHeader() && m_slFound) {
173 //
174 // SL Header
175 //
176 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: SectorLogic SubHeader " << std::endl; }
177 m_isSLBody = true;
178 SLRO.writeRecord(inword, false);
179
180 } else if (SLROS.isFooter() && m_slFound) {
181 //
182 // SL Footer
183 //
184 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: SectorLogic Footer " << std::endl; }
185 m_isSLBody = false;
186 thereIsASL = true;
187 SLRO.writeRecord(inword, true);
188
189 m_slFound = false;
190
191 } else if (m_isSLBody && m_slFound) {
192 //
193 // SL Body
194 //
195 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: SectorLogic Body " << std::endl; }
196 SLRO.writeRecord(inword, false);
197 thereIsASL = false;
198
199 } else if (RXROS.isHeader()) {
200 //
201 // RX header
202 //
203 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: RX Header " << std::endl; }
204 m_RXFlag++;
205 RXROS.decodeFragment(inword, recField);
206 if (recField == 'H') { SectorID = RXROS.RXid(); }
207 thereIsACM = false;
208 if (m_enablePrintOut) { std::cout << " Sector ID = " << SectorID << std::endl; }
209
210 switch (m_previousRecord) {
211 case Empty: break;
212 case CMHead:
213 if (m_enablePrintOut) {
214 std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and RX Header found" << std::endl;
215 }
216 thereIsACM = true; // close this matrix fragment
217 CMRO.writeRecord(inword, true);
218 // gimeCMROData();
219 break;
220 case CMSub:
221 if (m_enablePrintOut) {
222 std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and and RX Header found" << std::endl;
223 }
224 thereIsACM = true; // close this matrix fragment
225 CMRO.writeRecord(inword, true);
226 // gimeCMROData();
227 break;
228 case CMBod:
229 if (m_enablePrintOut) {
230 std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and RX Header found" << std::endl;
231 }
232 thereIsACM = true; // close this matrix fragment
233 CMRO.writeRecord(inword, true);
234 // gimeCMROData();
235 break;
236 case CMFoot:
237 if (m_enablePrintOut) {
238 std::cout << " RPCRXRODDecode Fragment problem: CM Header or Pad Footer expected and RX Header found" << std::endl;
239 }
240 break;
241 case PadHead:
242 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
243 break;
244 case PadPre:
245 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
246 break;
247 case PadSub:
248 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
249 break;
250 case PadFoot:
251 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
252 break;
253 default:
254 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
255 } // end-of-switch
256 m_previousRecord = Empty;
257
258 } else if (RXROS.isFooter()) {
259 //
260 // RX footer
261 //
262 if (m_enablePrintOut) { std::cout << " RX footer " << std::endl; }
263 m_RXFlag--;
264 RXROS.decodeFragment(inword, recField);
265 if (recField == 'F') {}
266 thereIsACM = false;
267 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode: Footer of Sector with ID = " << SectorID << std::endl; }
268
269 switch (m_previousRecord) {
270 case Empty: break;
271 case CMHead:
272 if (m_enablePrintOut) {
273 std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and RX Footer found" << std::endl;
274 }
275 thereIsACM = true; // close this matrix fragment
276 CMRO.writeRecord(inword, true);
277 // gimeCMROData();
278 break;
279 case CMSub:
280 if (m_enablePrintOut) {
281 std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and RX Footer found" << std::endl;
282 }
283 thereIsACM = true; // close this matrix fragment
284 CMRO.writeRecord(inword, true);
285 // gimeCMROData();
286 break;
287 case CMBod:
288 if (m_enablePrintOut) {
289 std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and and RX Footer found" << std::endl;
290 }
291 thereIsACM = true; // close this matrix fragment
292 CMRO.writeRecord(inword, true);
293 // gimeCMROData();
294 break;
295 case CMFoot:
296 if (m_enablePrintOut) {
297 std::cout << " RPCRXRODDecode Fragment problem: CM Header or Pad Footer expected and RX Footer found" << std::endl;
298 }
299 break;
300 case PadHead:
301 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
302 break;
303 case PadPre:
304 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
305 break;
306 case PadSub:
307 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
308 break;
309 case PadFoot:
310 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
311 break;
312 default:
313 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
314 } // end-of-switch
315 m_previousRecord = Empty;
316
317 } else if (PDROS.isHeader()) {
318 //
319 // Pad header
320 //
321 if (m_enablePrintOut) { std::cout << " PAD Header " << std::hex << inword << std::dec << std::endl; }
322 m_PADFlag++;
323 PDROS.decodeFragment(inword, recField);
324 if (recField == 'H') { PadID = PDROS.padid(); }
325 thereIsACM = false;
326 if (m_enablePrintOut) {
327 std::cout << " PAD " << PadID << " LVL1 " << std::hex << ((inword & 0x0e00) >> 8) << std::dec << std::endl;
328 }
329
330 switch (m_previousRecord) {
331 case Empty: break;
332 case CMHead:
333 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode 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 << " RPCRXRODDecode 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 << " RPCRXRODDecode 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: break;
353 case PadHead:
354 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
355 break;
356 case PadPre:
357 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
358 break;
359 case PadSub:
360 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
361 break;
362 case PadFoot:
363 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
364 break;
365 default:
366 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
367 } // end-of-switch
368 m_previousRecord = Empty;
369
370 } else if (PDROS.isSubHeader()) {
371 //
372 // Pad Subheader
373 //
374 if (m_enablePrintOut) { std::cout << " BCID " << std::hex << (inword & 0x0fff) << std::dec << std::endl; }
375 switch (m_previousRecord) {
376 case Empty: break;
377 case CMHead:
378 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and not found" << std::endl; }
379 thereIsACM = true; // close this matrix fragment
380 CMRO.writeRecord(inword, true);
381 // gimeCMROData();
382 break;
383 case CMSub:
384 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and not found" << std::endl; }
385 thereIsACM = true; // close this matrix fragment
386 CMRO.writeRecord(inword, true);
387 // gimeCMROData();
388 break;
389 case CMBod:
390 if (m_enablePrintOut) {
391 std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and not found" << std::endl;
392 }
393 thereIsACM = true; // close this matrix fragment
394 CMRO.writeRecord(inword, true);
395 // gimeCMROData();
396 break;
397 case CMFoot:
398 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad Header expected and not found" << std::endl; }
399 break;
400 case PadHead:
401 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
402 break;
403 case PadPre:
404 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
405 break;
406 case PadSub:
407 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
408 break;
409 case PadFoot:
410 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
411 break;
412 default:
413 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
414 } // end-of-switch
415 m_previousRecord = Empty;
416
417 } else if (PDROS.isPreFooter()) {
418 //
419 // Pad PreFooter
420 //
421 if (m_enablePrintOut) { std::cout << " STATUS ERROR " << std::hex << (inword & 0x000f) << std::dec << std::endl; }
422 switch (m_previousRecord) {
423 case Empty: break;
424 case CMHead:
425 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and not found" << std::endl; }
426 thereIsACM = true; // close this matrix fragment
427 CMRO.writeRecord(inword, true);
428 // gimeCMROData();
429 break;
430 case CMSub:
431 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and not found" << std::endl; }
432 thereIsACM = true; // close this matrix fragment
433 CMRO.writeRecord(inword, true);
434 // gimeCMROData();
435 break;
436 case CMBod:
437 if (m_enablePrintOut) {
438 std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and not found" << std::endl;
439 }
440 thereIsACM = true; // close this matrix fragment
441 CMRO.writeRecord(inword, true);
442 // gimeCMROData();
443 break;
444 case CMFoot: break;
445 case PadHead:
446 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
447 break;
448 case PadPre:
449 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
450 break;
451 case PadSub:
452 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
453 break;
454 case PadFoot:
455 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
456 break;
457 default:
458 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
459 } // end-of-switch
460 m_previousRecord = PadPre;
461
462 } else if (PDROS.isFooter()) {
463 //
464 // Pad footer
465 //
466 if (m_enablePrintOut) {
467 std::cout << " PAD Footer " << std::hex << inword << std::dec << " ERROR FLAG " << std::hex << (inword & 0x0fff) << std::dec
468 << std::endl;
469 }
470 m_PADFlag--;
471 PDROS.decodeFragment(inword, recField);
472 if (recField == 'F') {}
473 thereIsACM = false;
474 if (m_enablePrintOut) { std::cout << " Footer of Pad with ID = " << PadID << std::endl; }
475
476 switch (m_previousRecord) {
477 case Empty: break;
478 case CMHead:
479 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and not found" << std::endl; }
480 thereIsACM = true; // close this matrix fragment
481 CMRO.writeRecord(inword, true);
482 // gimeCMROData();
483 break;
484 case CMSub:
485 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and not found" << std::endl; }
486 thereIsACM = true; // close this matrix fragment
487 CMRO.writeRecord(inword, true);
488 // gimeCMROData();
489 break;
490 case CMBod:
491 if (m_enablePrintOut) {
492 std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and not found" << std::endl;
493 }
494 thereIsACM = true; // close this matrix fragment
495 CMRO.writeRecord(inword, true);
496 // gimeCMROData();
497 break;
498 case CMFoot:
499 if (m_enablePrintOut) {
500 std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected and not found" << std::endl;
501 }
502 break;
503 case PadHead:
504 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
505 break;
506 case PadPre: break;
507 case PadSub:
508 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
509 break;
510 case PadFoot:
511 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
512 break;
513 default:
514 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
515 } // end-of-switch
516 m_previousRecord = Empty;
517
518 } else if (CMROS.isHeader()) {
519 //
520 // CM Header: reset MatrixReadOut and load the word
521 //
522 m_CMFlag++;
523 CMRO.reset(NOBXS);
524 CMRO.writeRecord(inword, false);
525 thereIsACM = false;
526
527 switch (m_previousRecord) {
528 case Empty: break;
529 case CMHead:
530 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode warning: CM SubHeader expected and CM Header found" << std::endl; }
531 break;
532 case CMSub: break;
533 case CMBod:
534 if (m_enablePrintOut) {
535 std::cout << " RPCRXRODDecode warning: CM Body or CM Footer expected and CM Header found" << std::endl;
536 }
537 break;
538 case CMFoot: break;
539 case PadHead:
540 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
541 break;
542 case PadPre:
543 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
544 break;
545 case PadSub:
546 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
547 break;
548 case PadFoot:
549 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
550 break;
551 default:
552 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
553 } // end-of-switch
554 m_previousRecord = CMHead;
555
556 } else if (CMROS.isSubHeader()) {
557 //
558 // CM Subheader
559 //
560 m_CMFlag++;
561 CMRO.writeRecord(inword, false);
562 thereIsACM = false;
563
564 switch (m_previousRecord) {
565 case Empty:
566 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode warning: previous record was not a CM Header" << std::endl; }
567 break;
568 case CMHead: break;
569 case CMSub:
570 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode warning: CM Body expected and CM SubHeader found" << std::endl; }
571 break;
572 case CMBod:
573 if (m_enablePrintOut) {
574 std::cout << " RPCRXRODDecode warning: CM Body or CM Footer expected; CM SubHeader found" << std::endl;
575 }
576 break;
577 case CMFoot:
578 if (m_enablePrintOut) {
579 std::cout << " RPCRXRODDecode warning: CM Header or Pad Footer expected; CM SubHeader found" << std::endl;
580 }
581 break;
582 case PadHead:
583 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
584 break;
585 case PadPre:
586 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
587 break;
588 case PadSub:
589 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
590 break;
591 case PadFoot:
592 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
593 break;
594 default:
595 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
596 } // end-of-switch
597 m_previousRecord = CMSub;
598
599 } else if (CMROS.isBody()) {
600 //
601 // CM hit
602 //
603 if (m_CMFlag) CMRO.writeRecord(inword, false);
604 thereIsACM = false;
605
606 switch (m_previousRecord) {
607 case Empty:
608 if (m_enablePrintOut) {
609 std::cout << " RPCRXRODDecode (CMBody1) warning: previous record was not a CM subHeader"
610 << " or CM Body Record " << std::endl;
611 }
612 break;
613 case CMHead:
614 if (m_enablePrintOut) {
615 std::cout << " RPCRXRODDecode (CMBody2) warning: previous record was not a CM subHeader"
616 << " or CM Body Record " << std::endl;
617 }
618 break;
619 case CMSub: break;
620 case CMBod: break;
621 case CMFoot:
622 if (m_enablePrintOut) {
623 std::cout << " RPCRXRODDecode (CMBody3) warning: previous record was not a CM subHeader"
624 << " or CM Body Record " << std::endl;
625 }
626 break;
627 case PadHead:
628 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
629 break;
630 case PadPre:
631 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
632 break;
633 case PadSub:
634 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
635 break;
636 case PadFoot:
637 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
638 break;
639 default:
640 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord=" << std::endl; }
641 } // end-of-switch
642 m_previousRecord = CMBod;
643
644 } else if (CMROS.isFooter()) {
645 //
646 // CM footer
647 //
648 thereIsACM = true;
649 m_CMFlag--;
650 m_CMFlag--;
651 CMRO.writeRecord(inword, true);
652 CMFragCheck = CMRO.checkFragment();
653
654 switch (m_previousRecord) {
655 case Empty:
656 if (m_enablePrintOut) {
657 std::cout << " RPCRXRODDecode (CMFooter1) warning: previous record was not a Body record " << std::endl;
658 }
659 break;
660 case CMHead:
661 if (m_enablePrintOut) {
662 std::cout << " RPCRXRODDecode (CMFooter2) warning: previous record was not a Body record" << std::endl;
663 }
664 break;
665 case CMSub:
666 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode warning: previous record was not a Body record" << std::endl; }
667 break;
668 case CMBod: break;
669 case CMFoot:
670 if (m_enablePrintOut) {
671 std::cout << " RPCRXRODDecode (CMFooter3) warning: previous record was not a Body record" << std::endl;
672 }
673 break;
674 case PadHead:
675 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
676 break;
677 case PadPre:
678 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
679 break;
680 case PadSub:
681 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
682 break;
683 case PadFoot:
684 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
685 break;
686 default:
687 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord" << std::endl; }
688 } // end-of-switch
689 m_previousRecord = CMFoot;
690
691 // gimeCMROData();
692
693 //} else if(((inword & m_field)==reserved3) || ((inword & m_field)==m_reserved4)) {
694 } else if ((inword & m_field) == m_reserved4) {
695 //
696 // reserved word
697 //
698 thereIsACM = false;
699 if (m_enablePrintOut) { std::cout << " (reserved) " << std::endl; }
700
701 switch (m_previousRecord) {
702 case Empty: break;
703 case CMHead:
704 if (m_enablePrintOut) {
705 std::cout << " RPCRXRODDecode Fragment problem: CM SubHeader expected and (reserved) found" << std::endl;
706 }
707 thereIsACM = true; // close this matrix fragment
708 CMRO.writeRecord(inword, true);
709 // gimeCMROData();
710 break;
711 case CMSub:
712 if (m_enablePrintOut) {
713 std::cout << " RPCRXRODDecode Fragment problem: CM Body expected and (reserved) found" << std::endl;
714 }
715 thereIsACM = true; // close this matrix fragment
716 CMRO.writeRecord(inword, true);
717 // gimeCMROData();
718 break;
719 case CMBod:
720 if (m_enablePrintOut) {
721 std::cout << " RPCRXRODDecode Fragment problem: CM Body or Footer expected and (reserved) found" << std::endl;
722 }
723 thereIsACM = true; // close this matrix fragment
724 CMRO.writeRecord(inword, true);
725 // gimeCMROData();
726 break;
727 case CMFoot:
728 if (m_enablePrintOut) {
729 std::cout << " RPCRXRODDecode Fragment problem: CM Header or Pad Footer expected and (reserved) found" << std::endl;
730 }
731 break;
732 case PadHead:
733 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: PadSubHeader expected" << std::endl; }
734 break;
735 case PadPre:
736 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA fragment expected" << std::endl; }
737 break;
738 case PadSub:
739 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: CMA Footer expected" << std::endl; }
740 break;
741 case PadFoot:
742 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode Fragment problem: Pad PreFooter expected" << std::endl; }
743 break;
744 default:
745 if (m_enablePrintOut) { std::cout << " RPCRXRODDecode ERROR in previousRecord " << std::endl; }
746 } // end-of-switch
747 m_previousRecord = Empty;
748
749 } // end-of-if
750 int answer = 0;
751 if (thereIsACM) answer = 1;
752 if (thereIsASL) answer = 2;
753 return answer;
754}
755//----------------------------------------------------------------------------//
756void RPCRXRODDecode::gimeCMROData() {
757 MatrixReadOutStructure CMROS;
758 ubit16 nCMROData = CMRO.numberOfBodyWords();
759
760 if (m_enablePrintOut) {
761 std::cout << " number of Body Words in this CM Fragment " << nCMROData << std::endl;
762
763 //
764 // get header data
765 //
766 CMROS = CMRO.getHeader();
767
768 std::cout << " gimeCMROData, CMID: " << CMROS.cmid() << std::endl
769 << " gimeCMROData, FEL1ID: " << CMROS.fel1id() << std::endl
770 << " isLowPt = " << CMROS.isLowPt() << std::endl
771 << " isEtaProj= " << CMROS.isEtaProj() << std::endl
772 << " is0LocAdd= " << CMROS.is0LocAdd() << std::endl;
773
774 //
775 // get subheader data
776 //
777 CMROS = CMRO.getSubHeader();
778
779 std::cout << " gimeCMROData, FEBCID: " << CMROS.febcid() << std::endl;
780
781 //
782 // get Body data
783 //
784 for (ubit16 i = 0; i < nCMROData; i++) {
785 CMROS = CMRO.getCMAHit(i);
786 ubit16 ijk = CMROS.ijk();
787 if (ijk < 6) {
788 std::cout << " gimeCMROData, hit chan: " << CMROS.channel() << " gimeCMROData, hit stri: " << CMROS.global_channel()
789 << " hit BCID: " << CMROS.bcid() << std::endl;
790 } else if (ijk == 6) {
791 std::cout << " gimeCMROData, trg chan: " << CMROS.channel() << " hit BCID: " << CMROS.bcid() << std::endl;
792 } else if (ijk == 7) {
793 std::cout << " gimeCMROData, trg thr: " << CMROS.threshold() << " trg ovl: " << CMROS.overlap() << std::endl;
794 } else {
795 std::cout << " this value of ijk=" << ijk << " is NOT ALLOWED " << std::endl;
796 } // end-of-if
797 std::cout << std::endl;
798 } // end-of-for
799 } // end-of-if(m_enablePrintOut
800} // end-of-gimeCMROData
801//---------------------------------------------------------------------------//
802void RPCRXRODDecode::RODHeader(const RODword *RODData) {
803 //
804 // decode the ROD header
805 //
806 headerSize = *(RODData + 1);
807 for (ubit16 i = 0; i < headerSize; i++) {
808 if (i == 0) {
809 headerMarker = *(RODData + i);
810 } else if (i == 2) {
811 formatVersion = *(RODData + i);
812 } else if (i == 3) {
813 sourceIdentifier = *(RODData + i);
814 RPCRODStructure RPCRODS;
815 RPCRODS.decodeSourceID(sourceIdentifier);
816 SourceModuleID = RPCRODS.getSourceIDRODID();
817 SourceSubDetectorID = RPCRODS.getSourceIDSubdetectorID();
818 SourceModuleType = RPCRODS.getSourceIDModuleType();
819 SourceReserved = RPCRODS.getSourceIDReserved();
820 } else if (i == 4) {
821 Level1ID = *(RODData + i);
822 } else if (i == 5) {
823 BunchXingID = *(RODData + i);
824 } else if (i == 6) {
825 Level1Type = *(RODData + i);
826 } else if (i == 7) {
827 DetectorEventType = *(RODData + i);
828 } // end-of-if
829 } // end-of-for
830} // end-of-RODHeader
831//----------------------------------------------------------------------------//
832// void RPCRXRODDecode::ROBAddresses(const RODword *ROBData) {
836// ROBTotalSize = *(ROBData + locROBTotalFragSize-1);
837// RODDataSize = *(ROBData + ROBTotalSize-1 + locRODNumberOfDataElements);
838// RODStatusSize = *(ROBData + ROBTotalSize-1 + locRODNumberOfStatusElements);
839// RODStatusPosition = *(ROBData + ROBTotalSize-1 + locRODStatusBlockPosition);
840// RODBlockSize = RODDataSize + RODStatusSize;
841// if(RODStatusPosition) {
842// m_RODDataAddress = ROBTotalSize-(RODBlockSize+RODTrailerSize-1);
843//} else {
844// m_RODDataAddress = ROBTotalSize-(RODDataSize+RODTrailerSize-1);
845//}
846//
847// cout<<" Object ROB Total Size "<<ROBTotalSize<<endl;
848// cout<<" Object ROD Data Size "<<RODDataSize<<endl;
849// cout<<" Object ROD Status Size "<<RODStatusSize<<endl;
850// cout<<" Object ROD Data Address "<<m_RODDataAddress<<endl;
851//}//end-of-ROBAddresses
852//----------------------------------------------------------------------------//
853void RPCRXRODDecode::RODAddresses(const RODword *RODData, const sbit32 numberOfStatusElements, const sbit32 statusBlockPosition) {
854 RODHeader(RODData);
855 std::cout << " status block position " << statusBlockPosition << std::endl;
856 std::cout << " number of Status Elements " << numberOfStatusElements << std::endl;
857 if (statusBlockPosition) {
858 m_RODDataAddress = headerSize;
859 } else {
860 m_RODDataAddress = headerSize + numberOfStatusElements;
861 }
862} // end-of-RPCRXRODDecode::RODAddresses
863//----------------------------------------------------------------------------//
864void RPCRXRODDecode::RODHeaderDisplay() {
865 if (m_enablePrintOut) {
866 std::cout << "*****************************************************" << std::endl
867 << "****** R O D H E A D E R *******" << std::endl
868 << "*****************************************************" << std::endl
869 << " ROD Header marker: " << std::hex << headerMarker << std::dec << std::endl
870 << " ROD Header size: " << headerSize << std::endl
871 << " ROD Format version number: " << formatVersion << std::endl
872 << " ROD Source Identifier: " << sourceIdentifier << std::endl
873 << " ROD Source Module ID: " << SourceModuleID << std::endl
874 << " ROD Source SubDectID: " << SourceSubDetectorID << std::endl
875 << " ROD Source Module Ty: " << SourceModuleType << std::endl
876 << " ROD Source Reserved : " << SourceReserved << std::endl
877 << " ROD Level1 ID: " << Level1ID << std::endl
878 << " ROD BuncgXingID: " << BunchXingID << std::endl
879 << " ROD Level1 Type: " << Level1Type << std::endl
880 << " ROD Detector Ev. Type: " << DetectorEventType << std::endl
881 << "*****************************************************" << std::endl;
882 } // end-of-if(m_enablePrintOut
883} // 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::CMRO
MatrixReadOut CMRO
Definition RPCRXRODDecode.h:67
RPCRXRODDecode::SLROS
SectorLogicRXReadOutStructure SLROS
Definition RPCRXRODDecode.h:68
RPCRXRODDecode::formatVersion
RODword formatVersion
Definition RPCRXRODDecode.h:44
RPCRXRODDecode::m_previousRecord
recType m_previousRecord
Definition RPCRXRODDecode.h:81
RPCRXRODDecode::SLRO
SectorLogicRXReadOut SLRO
Definition RPCRXRODDecode.h:69
RPCRXRODDecode::sourceIdentifier
RODword sourceIdentifier
Definition RPCRXRODDecode.h:45
RPCRXRODDecode::SourceModuleType
ubit16 SourceModuleType
Definition RPCRXRODDecode.h:51
RPCRXRODDecode::CMROS
MatrixReadOutStructure CMROS
Definition RPCRXRODDecode.h:66
RPCRXRODDecode::PDROS
PadReadOutStructure PDROS
Definition RPCRXRODDecode.h:65
RPCRXRODDecode::pushWord
int pushWord(const ubit16 inword, uint NOBXS)
Definition RPCRXRODDecode.cxx:87
RPCRXRODDecode::RODAddresses
void RODAddresses(const RODword *RODData, const sbit32 numberOfStatusElements, const sbit32 statusBlockPosition)
Definition RPCRXRODDecode.cxx:853
RPCRXRODDecode::RXROS
RXReadOutStructure RXROS
Definition RPCRXRODDecode.h:64
RPCRXRODDecode::SourceSubDetectorID
ubit16 SourceSubDetectorID
Definition RPCRXRODDecode.h:52
RPCRXRODDecode::RODHeader
void RODHeader(const RODword *ROBData)
Definition RPCRXRODDecode.cxx:802
RPCRXRODDecode::m_RODDataAddress
sbit32 m_RODDataAddress
Definition RPCRXRODDecode.h:76
RPCRXRODDecode::DetectorEventType
RODword DetectorEventType
Definition RPCRXRODDecode.h:49
Generated on for ATLAS Offline Software by doxygen 1.14.0