typo corrected
[u/mrichter/AliRoot.git] / ZDC / AliZDCRawStream.cxx
... / ...
CommitLineData
1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
18///////////////////////////////////////////////////////////////////////////////
19// //
20// This class provides access to ZDC digits in raw data. //
21// //
22// It loops over all ZDC digits in the raw data given by the AliRawReader. //
23// The Next method goes to the next digit. If there are no digits left //
24// it returns kFALSE. //
25// Getters provide information about the current digit. //
26// //
27///////////////////////////////////////////////////////////////////////////////
28
29#include <TSystem.h>
30#include "AliZDCRawStream.h"
31#include "AliRawReader.h"
32#include "AliRawDataHeader.h"
33#include "AliRawEventHeaderBase.h"
34#include "AliLog.h"
35
36ClassImp(AliZDCRawStream)
37
38
39//_____________________________________________________________________________
40AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
41 fRawReader(rawReader),
42 fBuffer(0),
43 fReadOutCard(-1),
44 fEvType(0),
45 fPosition(0),
46 fIsCalib(kFALSE),
47 fIsDARCHeader(kFALSE),
48 fIsHeaderMapping(kFALSE),
49 fIsChMapping(kFALSE),
50 fIsADCDataWord(kFALSE),
51 fIsADCHeader(kFALSE),
52 fIsADCEOB(kFALSE),
53 fSODReading(kFALSE),
54 fIsMapRead(kFALSE),
55 fReadCDH(kFALSE),
56 fDeadfaceOffset(-1),
57 fDeadbeefOffset(-1),
58 fDataOffset(0),
59 fModType(-1),
60 fADCModule(-1),
61 fADCNChannels(-1),
62 fADCChannel(-1),
63 fADCValue(-1),
64 fADCGain(-1),
65 fIsUnderflow(kFALSE),
66 fIsOverflow(kFALSE),
67 fScGeo(0),
68 fScNWords(0),
69 fScTriggerSource(0),
70 fScTriggerNumber(0),
71 fIsScEventGood(kTRUE),
72 fIsScHeaderRead(kFALSE),
73 fScStartCounter(0),
74 fScEvCounter(0),
75 fIsScalerWord(kFALSE),
76 fDetPattern(0),
77 fTrigCountNWords(0),
78 fIsTriggerScaler(kFALSE),
79 fTrigCountStart(0),
80 fMBTrigInput(0),
81 fCentralTrigInput(0),
82 fSCentralTrigInput(0),
83 fEMDTrigInput(0),
84 fL0Received(0),
85 fMBtrig2CTP(0),
86 fCentralTrig2CTP(0),
87 fSCentralTrig2CTP(0),
88 fEMDTrig2CTP(0),
89 fTrigHistNWords(0),
90 fIsTriggerHistory(kFALSE),
91 fTrigHistStart(0),
92 fPileUpBit1stWord(0),
93 fL0Bit1stWord(0),
94 fCentralTrigHist(0),
95 fMBTrigHist(0),
96 fPileUpBit2ndWord(0),
97 fL0Bit2ndWord(0),
98 fSCentralTrigHist(0),
99 fEMDTrigHist(0),
100 fNChannelsOn(0),
101 fCurrentCh(-1),
102 fCabledSignal(-1),
103 fCurrScCh(-1),
104 fCurrTDCCh(-1),
105 fIsADCEventGood(kTRUE),
106 fIsL0BitSet(kTRUE),
107 fIsPileUpEvent(kFALSE),
108 fIsADDChannel(kFALSE),
109 fADDADCdatum(0),
110 fIsTDCHeaderRead(kFALSE),
111 fTDCStartCounter(0),
112 fIsZDCTDCHeader(kFALSE),
113 fIsZDCTDCdatum(kFALSE),
114 fZDCTDCdatum(0),
115 fIsADDTDCHeader(kFALSE),
116 fIsADDTDCdatum(kFALSE),
117 fADDTDCdatum(0)
118{
119 // Create an object to read ZDC raw digits
120 fRawReader->Reset();
121 fRawReader->Select("ZDC");
122 //
123 const int kNch = 48;
124 for(Int_t i=0; i<kNch; i++){
125 for(Int_t j=0; j<5; j++){
126 fMapADC[i][j]=-1;
127 if(i<32){
128 fScalerMap[i][j]=-1;
129 if(j<3) fTDCMap[i][j]=-1;
130 }
131 }
132 }
133
134 for(Int_t k=0; k<4; k++) fCPTInput[k] = 0;
135
136}
137
138//_____________________________________________________________________________
139AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
140 TObject(stream),
141 fRawReader(stream.fRawReader),
142 fBuffer(stream.GetRawBuffer()),
143 fReadOutCard(stream.GetReadOutCard()),
144 fEvType(stream.fEvType),
145 fPosition(stream.fPosition),
146 fIsCalib(stream.fIsCalib),
147 fIsDARCHeader(stream.fIsDARCHeader),
148 fIsHeaderMapping(stream.fIsHeaderMapping),
149 fIsChMapping(stream.fIsChMapping),
150 fIsADCDataWord(stream.fIsADCDataWord),
151 fIsADCHeader(stream.fIsADCHeader),
152 fIsADCEOB(stream.fIsADCEOB),
153 fSODReading(stream.fSODReading),
154 fIsMapRead(stream.fIsMapRead),
155 fReadCDH(stream.fReadCDH),
156 fDeadfaceOffset(stream.GetDeadfaceOffset()),
157 fDeadbeefOffset(stream.GetDeadbeefOffset()),
158 fDataOffset(stream.GetDataOffset()),
159 fModType(stream.GetModType()),
160 fADCModule(stream.GetADCModule()),
161 fADCNChannels(stream.GetADCNChannels()),
162 fADCChannel(stream.GetADCChannel()),
163 fADCValue(stream.GetADCValue()),
164 fADCGain(stream.GetADCGain()),
165 fIsUnderflow(stream.fIsUnderflow),
166 fIsOverflow(stream.fIsOverflow),
167 fScGeo(stream.GetScGeo()),
168 fScNWords(stream.GetScNWords()),
169 fScTriggerSource(stream.GetScTriggerSource()),
170 fScTriggerNumber(stream.fScTriggerNumber),
171 fIsScEventGood(stream.fIsScEventGood),
172 fIsScHeaderRead(stream.fIsScHeaderRead),
173 fScStartCounter(stream.fScStartCounter),
174 fScEvCounter(stream.fScEvCounter),
175 fIsScalerWord(stream.fIsScalerWord),
176 fDetPattern(stream.fDetPattern),
177 fTrigCountNWords(stream.fTrigCountNWords),
178 fIsTriggerScaler(stream.fIsTriggerScaler),
179 fTrigCountStart(stream.fTrigCountStart),
180 fMBTrigInput(stream.fMBTrigInput),
181 fCentralTrigInput(stream.fCentralTrigInput),
182 fSCentralTrigInput(stream.fSCentralTrigInput),
183 fEMDTrigInput(stream.fEMDTrigInput),
184 fL0Received(stream.fL0Received),
185 fMBtrig2CTP(stream.fMBtrig2CTP),
186 fCentralTrig2CTP(stream.fCentralTrig2CTP),
187 fSCentralTrig2CTP(stream.fSCentralTrig2CTP),
188 fEMDTrig2CTP(stream.fEMDTrig2CTP),
189 fTrigHistNWords(stream.fTrigHistNWords),
190 fIsTriggerHistory(stream.fIsTriggerHistory),
191 fTrigHistStart(stream.fTrigHistStart),
192 fPileUpBit1stWord(stream.fPileUpBit1stWord),
193 fL0Bit1stWord(stream.fL0Bit1stWord),
194 fCentralTrigHist(stream.fCentralTrigHist),
195 fMBTrigHist(stream.fMBTrigHist),
196 fPileUpBit2ndWord(stream.fPileUpBit2ndWord),
197 fL0Bit2ndWord(stream.fL0Bit2ndWord),
198 fSCentralTrigHist(stream.fSCentralTrigHist),
199 fEMDTrigHist(stream.fEMDTrigHist),
200 fNChannelsOn(stream.fNChannelsOn),
201 fCurrentCh(stream.fCurrentCh),
202 fCabledSignal(stream.GetCabledSignal()),
203 fCurrScCh(stream.fCurrScCh),
204 fCurrTDCCh(stream.fCurrTDCCh),
205 fIsADCEventGood(stream.fIsADCEventGood),
206 fIsL0BitSet(stream.fIsL0BitSet),
207 fIsPileUpEvent(stream.fIsPileUpEvent),
208 fIsADDChannel(stream.fIsADDChannel),
209 fADDADCdatum(stream.fADDADCdatum),
210 fIsTDCHeaderRead(stream.fIsTDCHeaderRead),
211 fTDCStartCounter(stream.fTDCStartCounter),
212 fIsZDCTDCHeader(stream.fIsZDCTDCHeader),
213 fIsZDCTDCdatum(stream.fIsZDCTDCdatum),
214 fZDCTDCdatum(stream.fZDCTDCdatum),
215 fIsADDTDCHeader(stream.fIsADDTDCHeader),
216 fIsADDTDCdatum(stream.fIsADDTDCdatum),
217 fADDTDCdatum(stream.fADDTDCdatum)
218{
219 // Copy constructor
220 const int kNch = 48;
221 for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j);
222 for(Int_t i=0; i<kNch; i++){
223 for(Int_t j=0; j<5; j++){
224 fMapADC[i][j] = stream.fMapADC[i][j];
225 if(i<32) fScalerMap[i][j] = stream.fMapADC[i][j];
226 }
227 }
228
229 for(Int_t k=0; k<4; k++) fCPTInput[k] = stream.fCPTInput[k];
230}
231
232//_____________________________________________________________________________
233AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream&
234 /* stream */)
235{
236 // Assignment operator
237 Fatal("operator =", "assignment operator not implemented");
238 return *this;
239}
240
241//_____________________________________________________________________________
242AliZDCRawStream::~AliZDCRawStream()
243{
244// Destructor
245
246}
247
248//_____________________________________________________________________________
249void AliZDCRawStream::ReadChMap()
250{
251 // Reading channel map
252 const int kNch = 48;
253 AliDebug(2,"\t Reading ZDC ADC mapping from OCDB\n");
254 AliZDCChMap * chMap = GetChMap();
255 //chMap->Print("");
256 for(Int_t i=0; i<kNch; i++){
257 fMapADC[i][0] = chMap->GetADCModule(i);
258 fMapADC[i][1] = chMap->GetADCChannel(i);
259 fMapADC[i][2] = chMap->GetADCSignalCode(i);
260 fMapADC[i][3] = chMap->GetDetector(i);
261 fMapADC[i][4] = chMap->GetSector(i);
262 }
263 fIsMapRead = kTRUE;
264}
265
266//_____________________________________________________________________________
267void AliZDCRawStream::ReadCDHHeader()
268{
269 // Reading CDH
270 const AliRawDataHeader* header = fRawReader->GetDataHeader();
271 const AliRawDataHeaderV3* headerV3 = fRawReader->GetDataHeaderV3();
272 if(!header && !headerV3) {
273 AliError(" No CDH in raw data streaming");
274 fRawReader->AddMajorErrorLog(kCDHError);
275 return;
276 }
277
278 //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
279
280 UChar_t message = header ? header->GetAttributes() : headerV3->GetAttributes();
281 //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
282
283 if((message & 0xf0) == 0x0){ // PHYSICS RUN
284 //printf("\t PHYSICS RUN raw data found\n");
285 }
286 else if((message & 0xf0) == 0x10){ // COSMIC RUN
287 //printf("\t STANDALONE_COSMIC RUN raw data found\n");
288 }
289 else if((message & 0xf0) == 0x20){ // PEDESTAL RUN
290 //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
291 }
292 else if((message & 0xf0) == 0x30){ // LASER RUN
293 //printf("\t STANDALONE_LASER RUN raw data found\n");
294 }
295 else if((message & 0xf0) == 0x40){ // CALIBRATION_CENTRAL RUN
296 //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
297 }
298 else if((message & 0xf0) == 0x50){ // CALIBRATION_SEMICENTRAL
299 //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
300 }
301 else if((message & 0xf0) == 0x60){ // CALIBRATION_MB
302 //printf("\t CALIBRATION_MB RUN raw data found\n");
303 }
304 else if((message & 0xf0) == 0x70){ // CALIBRATION_EMD
305 //printf("\t CALIBRATION_EMD RUN raw data found\n");
306 }
307 // *** Checking the bit indicating the used readout card
308 // (the payload is different in the 2 cases!)
309 if((message & 0x08) == 0){ // ** DARC card
310 fReadOutCard = 0;
311 fIsDARCHeader = kTRUE;
312 //AliInfo("\t ZDC readout card used: DARC");
313 }
314 else if((message & 0x08) == 0x08){ // ** ZRC card
315 fReadOutCard = 1;
316 //AliInfo("\t ZDC readout card used: ZRC");
317 }
318
319 fIsCalib = (header ? header->GetL1TriggerMessage() : headerV3->GetL1TriggerMessage()) & 0x1;
320
321 //printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
322 //printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);
323
324/* UInt_t status = header->GetStatus();
325 //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status);
326 if((status & 0x000f) == 0x0001){
327 AliDebug(2,"CDH -> DARC trg0 overlap error");
328 fRawReader->AddMajorErrorLog(kDARCError);
329 }
330 if((status & 0x000f) == 0x0002){
331 AliDebug(2,"CDH -> DARC trg0 missing error");
332 fRawReader->AddMajorErrorLog(kDARCError);
333 }
334 if((status & 0x000f) == 0x0004){
335 AliDebug(2,"CDH -> DARC data parity error");
336 fRawReader->AddMajorErrorLog(kDARCError);
337 }
338 if((status & 0x000f) == 0x0008){
339 AliDebug(2,"CDH -> DARC ctrl parity error");
340 fRawReader->AddMajorErrorLog(kDARCError);
341 }
342 //
343 if((status & 0x00f0) == 0x0010){
344 AliDebug(2,"CDH -> DARC trg unavailable");
345 fRawReader->AddMajorErrorLog(kDARCError);
346 }
347 if((status & 0x00f0) == 0x0020){
348 AliDebug(2,"CDH -> DARC FEE error");
349 fRawReader->AddMajorErrorLog(kDARCError);
350 }
351 //
352 if((status & 0x0f00) == 0x0200){
353 AliDebug(2,"CDH -> DARC L1 time violation");
354 fRawReader->AddMajorErrorLog(kDARCError);
355 }
356 if((status & 0x0f00) == 0x0400){
357 AliDebug(2,"CDH -> DARC L2 time-out");
358 fRawReader->AddMajorErrorLog(kDARCError);
359 }
360 if((status & 0x0f00) == 0x0800){
361 AliDebug(2,"CDH -> DARC prepulse time violation");
362 fRawReader->AddMajorErrorLog(kDARCError);
363 }
364 //
365 if((status & 0xf000) == 0x1000){
366 AliDebug(2,"CDH -> DARC other error");
367 fRawReader->AddMajorErrorLog(kDARCError);
368 }
369 */
370
371}
372
373//_____________________________________________________________________________
374Bool_t AliZDCRawStream::Next()
375{
376 // Read the next raw digit
377 // Returns kFALSE if there is no digit left
378
379 if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
380 const int kNch = 48;
381 //
382 fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE;
383 fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
384 fIsZDCTDCdatum = kFALSE; fIsADDChannel = kFALSE; fIsADDTDCdatum=kFALSE;
385 fIsUnderflow = kFALSE; fIsOverflow = kFALSE; fIsScalerWord = kFALSE;
386 fSector[0] = fSector[1] = -1;
387 for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
388
389 fEvType = fRawReader->GetType();
390 if(fPosition==0){
391 ReadCDHHeader();
392 // Needed to read simulated raw data (temporary solution?)
393 if(!fReadCDH) fReadOutCard=1;
394 fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;fNChannelsOn=0;
395 // Ch. debug
396 //printf("\n AliZDCRawStream::Next() - ev. type %d",fEvType);
397 }
398 // Ch. debug
399 //printf("\n AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
400
401 // *** End of ZDC event
402 if(fBuffer == 0xcafefade){
403 //printf("\n AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
404 return kFALSE;
405 }
406
407 // -------------------------------------------
408 // --- DARC header
409 // -------------------------------------------
410 // If the CDH has been read then
411 // the DARC header must follow
412 if(fReadOutCard==0 && fIsDARCHeader){
413 //printf("\t ---- DARC header ----\n");
414 if(fIsCalib){
415 fDeadfaceOffset = 9;
416 fDeadbeefOffset = 25;
417 }
418 else{
419 fDeadfaceOffset = 1;
420 fDeadbeefOffset = 7;
421 }
422 fDataOffset = 1+fDeadbeefOffset;
423 fIsDARCHeader = kFALSE;
424 }
425
426 // ---------------------------------------------
427 // --- Start of data event (SOD) ---
428 // --- decoding mapping of connected ADC ch. ---
429 // ---------------------------------------------
430 // In the SOD event ADC ch. mapping is written
431 if(fEvType==10){
432 if(fSODReading){
433
434 if(fPosition>=fDataOffset){
435 if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
436 // DARC 1st datum @ fDataOffset+1 \ ZRC 1st valid datum @ fDataOffset=0
437 if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){
438 printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
439 fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;
440 }
441 else{
442 printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
443 fSODReading = kFALSE;
444 return kFALSE;
445 }
446 }
447 else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
448 fPosition++;
449 return kFALSE; // !!!!!!!!!!!!!!!!!!!!! For the moment thresholds are not read
450 }
451 else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
452 fIsHeaderMapping = kTRUE;
453 fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
454 fModType = ((fBuffer & 0x7ff00)>>8);
455 fADCNChannels = (fBuffer & 0xff); // # of channels following the header
456 //
457 printf(" ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
458 }
459 else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
460 fADCChannel = ((fBuffer & 0x3fff0000)>>16);
461 fCabledSignal = (fBuffer&0xffff);
462 //
463 if(fModType == kV965){ // ******** ADCs ********************************
464 // Channel signal
465 if((fBuffer&0x40000000)>>30==0 && fADCModule<=kLastADCGeo){ // *ZDC* high range chain ADC
466 fIsChMapping = kTRUE;
467 fMapADC[fCurrentCh][0] = fADCModule;
468 fMapADC[fCurrentCh][1] = fADCChannel;
469 fMapADC[fCurrentCh][2] = fCabledSignal;
470 // - No. of channels on
471 fNChannelsOn++;
472 //
473 // Determining detector and sector
474 // -----------------------------------------
475 // For the decoding of the following lines
476 // look the enum in AliZDCRawStream.h file
477 // -----------------------------------------
478 if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
479 || fCabledSignal==24 || fCabledSignal==48){
480 fMapADC[fCurrentCh][3] = 4; //ZNA
481 //
482 if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot) fMapADC[fCurrentCh][4]=0;
483 else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1oot) fMapADC[fCurrentCh][4]=1;
484 else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2oot) fMapADC[fCurrentCh][4]=2;
485 else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3oot) fMapADC[fCurrentCh][4]=3;
486 else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4oot) fMapADC[fCurrentCh][4]=4;
487 else if(fCabledSignal==kZDCAMon || fCabledSignal==kZDCAMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
488 }
489 else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
490 fMapADC[fCurrentCh][3] = 5; //ZPA
491 //
492 if(fCabledSignal==kZPAC || fCabledSignal==kZPACoot) fMapADC[fCurrentCh][4]=0;
493 else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1oot) fMapADC[fCurrentCh][4]=1;
494 else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2oot) fMapADC[fCurrentCh][4]=2;
495 else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3oot) fMapADC[fCurrentCh][4]=3;
496 else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4oot) fMapADC[fCurrentCh][4]=4;
497 }
498 else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
499 || fCabledSignal==25 || fCabledSignal==49){
500 fMapADC[fCurrentCh][3] = 1; //ZNC
501 //
502 if(fCabledSignal==kZNCC || fCabledSignal==kZNCCoot) fMapADC[fCurrentCh][4]=0;
503 else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1oot) fMapADC[fCurrentCh][4]=1;
504 else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2oot) fMapADC[fCurrentCh][4]=2;
505 else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3oot) fMapADC[fCurrentCh][4]=3;
506 else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4oot) fMapADC[fCurrentCh][4]=4;
507 else if(fCabledSignal==kZDCCMon || fCabledSignal==kZDCCMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
508 }
509 else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
510 fMapADC[fCurrentCh][3] = 2; //ZPC
511 //
512 if(fCabledSignal==kZPCC || fCabledSignal==kZPCCoot) fMapADC[fCurrentCh][4]=0;
513 else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1oot) fMapADC[fCurrentCh][4]=1;
514 else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2oot) fMapADC[fCurrentCh][4]=2;
515 else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3oot) fMapADC[fCurrentCh][4]=3;
516 else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4oot) fMapADC[fCurrentCh][4]=4;
517 }
518 else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
519 fMapADC[fCurrentCh][3] = 3; // ZEM
520 //
521 if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1oot) fMapADC[fCurrentCh][4]=1;
522 else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2oot) fMapADC[fCurrentCh][4]=2;
523 }
524 //Ch. debug
525 //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
526 //printf(" det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
527 //
528 fCurrentCh++;
529 //
530 } // high range channels
531 }// ModType=1 (ADC mapping)
532 else if(fModType == kV830){ // ******** VME scaler **************************
533 fIsChMapping = kTRUE;
534 fScalerMap[fCurrScCh][0] = fADCModule;
535 fScalerMap[fCurrScCh][1] = fADCChannel;
536 fScalerMap[fCurrScCh][2] = fCabledSignal;
537 //
538 // Determining detector and sector
539 // -----------------------------------------
540 // For the decoding of the following lines
541 // look the enum in AliZDCRawStream.h file
542 // -----------------------------------------
543 // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
544 if((fCabledSignal>=2 && fCabledSignal<=6) ||
545 (fCabledSignal>=61 && fCabledSignal<=65)){
546 fScalerMap[fCurrScCh][3] = 4; //ZNA
547 //
548 if(fCabledSignal==kZNAC || fCabledSignal==kZNACD) fScalerMap[fCurrScCh][4]=0;
549 else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1D) fScalerMap[fCurrScCh][4]=1;
550 else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2D) fScalerMap[fCurrScCh][4]=2;
551 else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3D) fScalerMap[fCurrScCh][4]=3;
552 else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4D) fScalerMap[fCurrScCh][4]=4;
553 }
554 else if((fCabledSignal>=7 && fCabledSignal<=11) ||
555 (fCabledSignal>=66 && fCabledSignal<=70)){
556 fScalerMap[fCurrScCh][3] = 5; //ZPA
557 //
558 if(fCabledSignal==kZPAC || fCabledSignal==kZPACD) fScalerMap[fCurrScCh][4]=0;
559 else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1D) fScalerMap[fCurrScCh][4]=1;
560 else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2D) fScalerMap[fCurrScCh][4]=2;
561 else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3D) fScalerMap[fCurrScCh][4]=3;
562 else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4D) fScalerMap[fCurrScCh][4]=4;
563 }
564 else if((fCabledSignal>=12 && fCabledSignal<=16) ||
565 (fCabledSignal>=71 && fCabledSignal<=75)){
566 fScalerMap[fCurrScCh][3] = 1; //ZNC
567 //
568 if(fCabledSignal==kZNCC || fCabledSignal==kZNCCD) fScalerMap[fCurrScCh][4]=0;
569 else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1D) fScalerMap[fCurrScCh][4]=1;
570 else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2D) fScalerMap[fCurrScCh][4]=2;
571 else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3D) fScalerMap[fCurrScCh][4]=3;
572 else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4D) fScalerMap[fCurrScCh][4]=4;
573 }
574 else if((fCabledSignal>=17 && fCabledSignal<=21) ||
575 (fCabledSignal>=76 && fCabledSignal<=80)){
576 fScalerMap[fCurrScCh][3] = 2; //ZPC
577 //
578 if(fCabledSignal==kZPCC || fCabledSignal==kZPCCD) fScalerMap[fCurrScCh][4]=0;
579 else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1D) fScalerMap[fCurrScCh][4]=1;
580 else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2D) fScalerMap[fCurrScCh][4]=2;
581 else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3D) fScalerMap[fCurrScCh][4]=3;
582 else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4D) fScalerMap[fCurrScCh][4]=4;
583 }
584 else if(fCabledSignal==22 || fCabledSignal==23 ||
585 fCabledSignal==81 || fCabledSignal==82){
586 fScalerMap[fCurrScCh][3] = 3; // ZEM
587 //
588 if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1D) fScalerMap[fCurrScCh][4]=1;
589 else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2D) fScalerMap[fCurrScCh][4]=2;
590 }
591 // Ch debug.
592 /*printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
593 if(fCabledSignal!=0 && fCabledSignal!=1) printf(" det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
594 else printf(" Signal void/not connected\n");*/
595
596 fCurrScCh++;
597 }
598 else if(fModType==KV1290 && fADCModule==kZDCTDCGeo){ // ******** ZDC TDC **************************
599 fIsChMapping = kTRUE;
600 fTDCMap[fCurrTDCCh][0] = fADCModule;
601 fTDCMap[fCurrTDCCh][1] = fADCChannel;
602 fTDCMap[fCurrTDCCh][2] = fCabledSignal;
603
604 fCurrTDCCh++;
605
606 // Ch debug.
607 //printf("\tZDC TDC: mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
608 }
609 /*else if(fModType == kTRG){ // **** scalers from trigger card
610 //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
611 }
612 else if(fModType == kTRGI){ // **** trigger history from trigger card
613 //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
614 }
615 else if(fModType == kPU){ // **** pattern unit
616 //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
617 }*/
618 }//reading channel mapping
619 }
620 } // if fSODREading
621 fPosition++;
622 return kTRUE;
623 } // ------------------------------- SOD event
624
625 // -------------------------------------------
626 // --- DARC data
627 // -------------------------------------------
628 if(fPosition<fDeadfaceOffset && fReadOutCard==0){
629 fPosition++;
630 return kTRUE;
631 }
632 else if(fPosition==fDeadfaceOffset && fReadOutCard==0){
633 if(fBuffer != 0xdeadface){
634 //AliWarning(" NO deadface after DARC data");
635 fRawReader->AddMajorErrorLog(kDARCError);
636 }
637 else{
638 fPosition++;
639 return kTRUE;
640 }
641 }
642 else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){
643 fPosition++;
644 return kTRUE;
645 }
646 else if(fPosition==fDeadbeefOffset && fReadOutCard==0){
647 if(fBuffer != 0xdeadbeef){
648 //AliWarning(" NO deadbeef after DARC global data");
649 fRawReader->AddMajorErrorLog(kDARCError);
650 fPosition++;
651 return kFALSE;
652 }
653 else{
654 fPosition++;
655 return kTRUE;
656 }
657 } // ------------------------------- End of DARC data
658
659 // ---------------------------------------------
660 // --- ZDC data
661 // --- ADCs + VME scaler + trigger card + P.U.
662 // ---------------------------------------------
663 else if(fPosition>=fDataOffset){
664
665 if(!fSODReading && !fIsMapRead) ReadChMap();
666
667 // !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!!
668 // Not valid datum before the event
669 // there MUST be a NOT valid datum before the event!!!
670 if(fReadOutCard==0){
671 if(fPosition==fDataOffset){
672 //printf("\t **** ZDC data begin ****\n");
673 if((fBuffer & 0x07000000) != 0x06000000){
674 fRawReader->AddMajorErrorLog(kZDCDataError);
675 }
676 //else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
677 // fIsADCEventGood = kFALSE;
678 //}
679 }
680
681 // If the not valid datum isn't followed by the 1st ADC header
682 // the event is corrupted (i.e., 2 gates arrived before trigger)
683 else if(fPosition==fDataOffset+1){
684 if((fBuffer & 0x07000000) != 0x02000000){
685 AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
686 fRawReader->AddMajorErrorLog(kZDCDataError);
687 fIsADCEventGood = kFALSE;
688 fPosition++;
689 return kFALSE;
690 }
691 }
692 }
693
694 // Get geo address of current word
695 if(fIsTDCHeaderRead && fIsZDCTDCHeader) fADCModule = kZDCTDCGeo;
696 else if(fIsTDCHeaderRead && fIsADDTDCHeader) fADCModule = kADDTDCGeo;
697 else fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
698
699 // ************************************ ADC MODULES ************************************
700 if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo &&
701 !fIsTriggerHistory && !fIsScHeaderRead && !fIsTriggerScaler){
702 // *** ADC header
703 if((fBuffer & 0x07000000) == 0x02000000){
704 fIsADCHeader = kTRUE;
705 fADCNChannels = ((fBuffer & 0x00003f00)>>8);
706 //printf(" AliZDCRawStream -> ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
707 }
708 // *** ADC data word
709 else if((fBuffer & 0x07000000) == 0x00000000){
710 fIsADCDataWord = kTRUE;
711 fADCChannel = ((fBuffer & 0x1e0000) >> 17);
712 fADCGain = ((fBuffer & 0x10000) >> 16);
713 fADCValue = (fBuffer & 0xfff);
714 //
715 //printf(" AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n",
716 //fADCModule,fADCChannel,fADCGain,fADCValue);
717
718 // Checking if the channel map for the ADCs has been provided/read
719 if(fMapADC[0][0]==-1){
720 printf("\t ATTENTION!!! No ADC mapping has been found/provided!!!\n");
721 return kFALSE;
722 }
723 //
724 /*for(Int_t ci=0; ci<kNch; ci++){
725 printf(" %d mod %d ch %d det %d sec %d\n",ci,fMapADC[ci][0],
726 fMapADC[ci][1], fMapADC[ci][3], fMapADC[ci][4]);
727 }*/
728
729 // Scan of the map to assign the correct volumes
730 Int_t foundMapEntry = kFALSE;
731 for(Int_t k=0; k<kNch; k++){
732 if(fADCModule==fMapADC[k][0] && fADCChannel==fMapADC[k][1]){
733 fSector[0] = fMapADC[k][3];
734 fSector[1] = fMapADC[k][4];
735 foundMapEntry = kTRUE;
736 break;
737 }
738 }
739 if(foundMapEntry==kFALSE && fEvType==7){
740 AliWarning(Form(" No valid entry in ADC mapping for raw data %d ADCmod. %d ch. %d\n",
741 fPosition,fADCModule,fADCChannel));
742 }
743
744 // Final checks
745 if(foundMapEntry==kTRUE && fEvType==7){
746 if(fSector[0]<1 || fSector[0]>5){
747 AliWarning(Form(" No valid detector assignment: %d",fSector[0]));
748 fRawReader->AddMajorErrorLog(kInvalidSector);
749 }
750 //
751 if(fSector[1]<0 || fSector[1]>5){
752 AliWarning(Form(" No valid sector assignment: %d",fSector[1]));
753 fRawReader->AddMajorErrorLog(kInvalidSector);
754 }
755 //
756 if(fADCModule<0 || fADCModule>3){
757 AliError(Form(" No valid ADC module: %d",fADCModule));
758 fRawReader->AddMajorErrorLog(kInvalidADCModule);
759 }
760 }
761
762 // Checking the underflow and overflow bits
763 if(fBuffer & 0x1000) fIsUnderflow = kTRUE;
764 else if (fBuffer & 0x2000) fIsOverflow = kTRUE;
765
766 }//ADC data word
767 // *** ADC EOB
768 else if((fBuffer & 0x07000000) == 0x04000000){
769 fIsADCEOB = kTRUE;
770 //printf(" AliZDCRawStream -> ADC EOB --------------------------\n");
771 }
772 }//ADC module
773 // ********************************* ADD ADC *********************************
774 else if(fADCModule == kADDADCGeo){
775 // *** ADC header
776 if((fBuffer & 0x07000000) == 0x02000000){
777 fIsADCHeader = kTRUE;
778 fADCNChannels = ((fBuffer & 0x00003f00)>>8);
779 //printf(" AliZDCRawStream -> ADD ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
780 }
781 // *** ADC data word
782 else if((fBuffer & 0x07000000) == 0x00000000){
783 fIsADDChannel = kTRUE;
784 fADCChannel = ((fBuffer & 0x1e0000) >> 17);
785 fADCGain = ((fBuffer & 0x10000) >> 16);
786 fADCValue = (fBuffer & 0xfff);
787 //
788 //printf(" ADD ADC DATUM -> mod. %d ch. %d gain %d value %d\n",
789 // fADCModule,fADCChannel,fADCGain,fADCValue);
790 }
791 // *** ADC EOB
792 else if((fBuffer & 0x07000000) == 0x04000000){
793 fIsADCEOB = kTRUE;
794 //printf(" AliZDCRawStream -> ADD ADC EOB --------------------------\n");
795 }
796 }
797 // ********************************* TDC *********************************
798 else if(fADCModule==kTDCFakeGeo && fIsTDCHeaderRead==kFALSE){
799 // *** TDC header
800 fIsTDCHeaderRead = kTRUE;
801 fTDCStartCounter = fPosition;
802 // GEO address from TDC header
803 fADCModule = (Int_t) (fBuffer & 0x1f);
804 if(fADCModule==kZDCTDCGeo){ // *** ZDC TDC
805 fIsZDCTDCHeader = kTRUE;
806 //Ch. debug
807 //printf(" AliZDCRawStream -> ZDC TDC header: mod.%d\n",fADCModule);
808 }
809 else if(fADCModule==kADDTDCGeo){ // *** ADD TDC
810 fIsADDTDCHeader = kTRUE;
811 //Ch. debug
812 //printf(" AliZDCRawStream -> ADD TDC: mod.%d\n",fADCModule);
813 }
814 }
815 // ********************************* VME SCALER HEADER *********************************
816 else if(fADCModule == kScalerGeo){
817 if(fBuffer & 0x04000000 && fIsScHeaderRead==kFALSE){ // *** Scaler header
818 fScGeo = (fBuffer & 0xf8000000)>>27;
819 fScNWords = (fBuffer & 0x00fc0000)>>18;
820 fScTriggerSource = (fBuffer & 0x00030000)>>16;
821 fScTriggerNumber = (fBuffer & 0x0000ffff);
822 fIsScHeaderRead = kTRUE;
823 fScStartCounter = fPosition;
824 //Ch. debug
825 //printf(" AliZDCRawStream -> VME SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n",
826 // fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber);
827 }
828 // Commented by C.O. & M.G. (23/09/2011)
829 //else if(!(fBuffer & 0x04000000) && fIsScHeaderRead==kFALSE){
830 // fIsScEventGood = kFALSE;
831 //}
832 }
833 // *********************************** PATTERN UNIT ***********************************
834 else if(fADCModule == kPUGeo){
835 // still to be implemented!!! Not yet in data!!!
836 fDetPattern = (fBuffer & 0x0000003f);
837 // Ch. debug
838 //printf(" AliZDCRawStream -> Pattern Unit\n");
839
840 }
841 // ******************************** TRIGGER CARD COUNTS ********************************
842 else if(fADCModule == kTrigScales){
843 if(fIsTriggerScaler == kFALSE){
844 fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
845 fTrigCountStart = fPosition;
846 fIsTriggerScaler = kTRUE;
847 }
848 // Ch. debug
849 //printf(" AliZDCRawStream -> Trigger Scaler header\n");
850 }
851 // ********************************** TRIGGER HISTORY **********************************
852 else if(fADCModule == kTrigHistory){
853 if(fIsTriggerHistory == kFALSE){
854 fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
855 fTrigHistStart = fPosition;
856 fIsTriggerHistory = kTRUE;
857 }
858 // Ch. debug
859 //printf(" AliZDCRawStream -> Trigger History header\n");
860
861 }
862 // ********************************** VME SCALER DATA **********************************
863 // Reading VME scaler data
864 if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
865 fADCModule=kScalerGeo;
866 fIsADCDataWord=kFALSE;
867 fIsScalerWord=kTRUE;
868 fScEvCounter = fBuffer;
869 Int_t nWords = (Int_t) (fScNWords);
870 if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
871 //Ch. debug
872 //printf(" AliZDCRawStream -> scaler datum %x \n", fScEvCounter);
873 }
874 // ********************************** ZDC TDC DATA **********************************
875 // ZDC TDC data
876 if(fIsTDCHeaderRead && fIsZDCTDCHeader && fPosition>=fTDCStartCounter+1){
877 fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
878 if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
879 fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
880 fIsZDCTDCdatum = kTRUE;
881 fZDCTDCdatum = (Int_t) (fBuffer & 0x1fffff);
882 // Ch. debug
883 //printf(" AliZDCRawStream -> ZDC TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fZDCTDCdatum);
884 }
885 if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
886 // Trailer
887 fIsTDCHeaderRead = kFALSE;
888 // Ch. debug
889 //printf(" AliZDCRawStream -> ZDC TDC global trailer\n");
890 }
891 }
892 // ********************************** ADD TDC DATA **********************************
893 // ADD TDC data
894 if(fIsTDCHeaderRead && fIsADDTDCHeader && fPosition>=fTDCStartCounter+1){
895 fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
896 if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
897 fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
898 fIsADDTDCdatum = kTRUE;
899 fADDTDCdatum = (Int_t) (fBuffer & 0x1fffff);
900 // Ch. debug
901 //printf(" AliZDCRawStream -> ADD TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fADDTDCdatum);
902 }
903 if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
904 // Trailer
905 fIsTDCHeaderRead = kFALSE;
906 // Ch. debug
907 //printf(" AliZDCRawStream -> ADD TDC global trailer\n");
908 }
909 }
910 // ******************************** TRIGGER SCALER DATA ********************************
911 // Reading trigger scaler data
912 if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
913 fADCModule = kTrigScales; fIsADCDataWord = kFALSE;
914 if(fPosition == fTrigCountStart+1) fMBTrigInput = fBuffer;
915 else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;
916 else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
917 else if(fPosition == fTrigCountStart+4) fEMDTrigInput = fBuffer;
918 else if(fPosition == fTrigCountStart+5) fL0Received = fBuffer;
919 else if(fPosition == fTrigCountStart+6) fMBtrig2CTP = fBuffer;
920 else if(fPosition == fTrigCountStart+7) fCentralTrig2CTP = fBuffer;
921 else if(fPosition == fTrigCountStart+8) fSCentralTrig2CTP = fBuffer;
922 else if(fPosition == fTrigCountStart+9){
923 fEMDTrig2CTP = fBuffer;
924 fIsTriggerScaler = kFALSE;
925 }
926 // Ch. debug
927 //printf(" AliZDCRawStream -> Trigger Scaler datum %d\n", fPosition-fTrigCountStart);
928 }
929 // ******************************* TRIGGER HISTORY WORDS ******************************
930 // Reading trigger history
931 if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
932 fADCModule = kTrigHistory; fIsADCDataWord = kFALSE;
933 if(fPosition == fTrigHistStart+1){
934 fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
935 fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;
936 fCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
937 fMBTrigHist = (fBuffer & 0x00007fff);
938 //
939 fCPTInput[0] = (fBuffer & 0x00000080) >> 6; // MB bit
940 fCPTInput[1] = (fBuffer & 0x00400000) >> 21; // CENTRAL bit
941 }
942
943 else if(fPosition == fTrigHistStart+fTrigHistNWords){
944 fPileUpBit2ndWord = (fBuffer & 0x80000000) >> 31;
945 fL0Bit2ndWord = (fBuffer & 0x40000000) >> 30;
946 fSCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
947 fEMDTrigHist = (fBuffer & 0x00007fff);
948 //
949 fCPTInput[2] = (fBuffer & 0x00000080) >> 6; // SEMICENTRAL bit
950 fCPTInput[3] = (fBuffer & 0x00400000) >> 21; // EMD bit
951 //
952 fIsTriggerHistory = kFALSE;
953
954 // Checking if the event is good
955 // (1) both history word pile up bits must be = 0
956 if(fPileUpBit1stWord==0 && fPileUpBit2ndWord==0) fIsPileUpEvent = kFALSE;
957 else{
958 fIsPileUpEvent = kTRUE;
959 printf(" AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
960 fPileUpBit1stWord, fPileUpBit2ndWord);
961 }
962 // (2) both history word L0 bits must be = 1
963 if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
964 else{
965 fIsL0BitSet = kFALSE;
966 printf(" AliZDCRawStream -> L0 wrongly set: bitL0word0 %d bitL0word1 %d\n",
967 fL0Bit1stWord, fL0Bit2ndWord);
968 }
969 }
970 // Ch. debug
971 //printf(" AliZDCRawStream -> Trigger history word[%d] %x\n", fPosition, fBuffer);
972 }
973
974 }
975
976 fPosition++;
977
978 return kTRUE;
979}
980
981//_____________________________________________________________________________
982AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri)
983{
984 // Setting the storage
985
986 AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri);
987
988 return storage;
989}
990
991
992//_____________________________________________________________________________
993AliZDCChMap* AliZDCRawStream::GetChMap() const
994{
995
996 // Getting calibration object for ZDC
997
998 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
999 if(!entry) AliFatal("No calibration data loaded!");
1000
1001 AliZDCChMap *calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
1002 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");
1003
1004 return calibdata;
1005}