1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////////
20 // This class provides access to ZDC digits in raw data. //
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. //
27 ///////////////////////////////////////////////////////////////////////////////
30 #include "AliZDCRawStream.h"
31 #include "AliRawReader.h"
32 #include "AliRawDataHeader.h"
33 #include "AliRawEventHeaderBase.h"
36 ClassImp(AliZDCRawStream)
39 //_____________________________________________________________________________
40 AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
41 fRawReader(rawReader),
47 fIsDARCHeader(kFALSE),
48 fIsHeaderMapping(kFALSE),
50 fIsADCDataWord(kFALSE),
70 fIsScEventGood(kTRUE),
71 fIsScHeaderRead(kFALSE),
76 fIsTriggerScaler(kFALSE),
80 fSCentralTrigInput(0),
88 fIsTriggerHistory(kFALSE),
102 fIsADCEventGood(kTRUE),
104 fIsPileUpEvent(kFALSE)
106 // Create an object to read ZDC raw digits
108 fRawReader->Select("ZDC");
111 for(Int_t i=0; i<kNch; i++){
112 for(Int_t j=0; j<5; j++){
114 if(i<32) fScalerMap[i][j]=-1;
118 for(Int_t k=0; k<4; k++) fCPTInput[k] = 0;
122 //_____________________________________________________________________________
123 AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
125 fRawReader(stream.fRawReader),
126 fBuffer(stream.GetRawBuffer()),
127 fReadOutCard(stream.GetReadOutCard()),
128 fEvType(stream.fEvType),
129 fPosition(stream.fPosition),
130 fIsCalib(stream.fIsCalib),
131 fIsDARCHeader(stream.fIsDARCHeader),
132 fIsHeaderMapping(stream.fIsHeaderMapping),
133 fIsChMapping(stream.fIsChMapping),
134 fIsADCDataWord(stream.fIsADCDataWord),
135 fIsADCHeader(stream.fIsADCHeader),
136 fIsADCEOB(stream.fIsADCEOB),
137 fSODReading(stream.fSODReading),
138 fIsMapRead(stream.fIsMapRead),
139 fDeadfaceOffset(stream.GetDeadfaceOffset()),
140 fDeadbeefOffset(stream.GetDeadbeefOffset()),
141 fDataOffset(stream.GetDataOffset()),
142 fModType(stream.GetModType()),
143 fADCModule(stream.GetADCModule()),
144 fADCNChannels(stream.GetADCNChannels()),
145 fADCChannel(stream.GetADCChannel()),
146 fADCValue(stream.GetADCValue()),
147 fADCGain(stream.GetADCGain()),
148 fIsUnderflow(stream.fIsUnderflow),
149 fIsOverflow(stream.fIsOverflow),
150 fScGeo(stream.GetScGeo()),
151 fScNWords(stream.GetScNWords()),
152 fScTriggerSource(stream.GetScTriggerSource()),
153 fScTriggerNumber(stream.fScTriggerNumber),
154 fIsScEventGood(stream.fIsScEventGood),
155 fIsScHeaderRead(stream.fIsScHeaderRead),
156 fScStartCounter(stream.fScStartCounter),
157 fScEvCounter(stream.fScEvCounter),
158 fDetPattern(stream.fDetPattern),
159 fTrigCountNWords(stream.fTrigCountNWords),
160 fIsTriggerScaler(stream.fIsTriggerScaler),
161 fTrigCountStart(stream.fTrigCountStart),
162 fMBTrigInput(stream.fMBTrigInput),
163 fCentralTrigInput(stream.fCentralTrigInput),
164 fSCentralTrigInput(stream.fSCentralTrigInput),
165 fEMDTrigInput(stream.fEMDTrigInput),
166 fL0Received(stream.fL0Received),
167 fMBtrig2CTP(stream.fMBtrig2CTP),
168 fCentralTrig2CTP(stream.fCentralTrig2CTP),
169 fSCentralTrig2CTP(stream.fSCentralTrig2CTP),
170 fEMDTrig2CTP(stream.fEMDTrig2CTP),
171 fTrigHistNWords(stream.fTrigHistNWords),
172 fIsTriggerHistory(stream.fIsTriggerHistory),
173 fTrigHistStart(stream.fTrigHistStart),
174 fPileUpBit1stWord(stream.fPileUpBit1stWord),
175 fL0Bit1stWord(stream.fL0Bit1stWord),
176 fCentralTrigHist(stream.fCentralTrigHist),
177 fMBTrigHist(stream.fMBTrigHist),
178 fPileUpBit2ndWord(stream.fPileUpBit2ndWord),
179 fL0Bit2ndWord(stream.fL0Bit2ndWord),
180 fSCentralTrigHist(stream.fSCentralTrigHist),
181 fEMDTrigHist(stream.fEMDTrigHist),
182 fNChannelsOn(stream.fNChannelsOn),
183 fCurrentCh(stream.fCurrentCh),
184 fCabledSignal(stream.GetCabledSignal()),
185 fCurrScCh(stream.fCurrScCh),
186 fIsADCEventGood(stream.fIsADCEventGood),
187 fIsL0BitSet(stream.fIsL0BitSet),
188 fIsPileUpEvent(stream.fIsPileUpEvent)
193 for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j);
194 for(Int_t i=0; i<kNch; i++){
195 for(Int_t j=0; j<5; j++){
196 fMapADC[i][j] = stream.fMapADC[i][j];
197 if(i<32) fScalerMap[i][j] = stream.fMapADC[i][j];
201 for(Int_t k=0; k<4; k++) fCPTInput[k] = stream.fCPTInput[k];
204 //_____________________________________________________________________________
205 AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream&
208 // Assignment operator
209 Fatal("operator =", "assignment operator not implemented");
213 //_____________________________________________________________________________
214 AliZDCRawStream::~AliZDCRawStream()
220 //_____________________________________________________________________________
221 void AliZDCRawStream::ReadChMap()
223 // Reading channel map
225 AliDebug(2,"\t Reading ZDC ADC mapping from OCDB\n");
226 AliZDCChMap * chMap = GetChMap();
228 for(Int_t i=0; i<kNch; i++){
229 fMapADC[i][0] = chMap->GetADCModule(i);
230 fMapADC[i][1] = chMap->GetADCChannel(i);
232 fMapADC[i][3] = chMap->GetDetector(i);
233 fMapADC[i][4] = chMap->GetSector(i);
238 //_____________________________________________________________________________
239 void AliZDCRawStream::ReadCDHHeader()
242 const AliRawDataHeader* header = fRawReader->GetDataHeader();
244 AliError(" No CDH in raw data streaming");
245 fRawReader->AddMajorErrorLog(kCDHError);
249 //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
251 UChar_t message = header->GetAttributes();
252 //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
254 if((message & 0x0) == 0x0){ // PHYSICS RUN
255 //printf("\t PHYSICS RUN raw data found\n");
257 else if((message & 0x10) == 0x10){ // COSMIC RUN
258 //printf("\t STANDALONE_COSMIC RUN raw data found\n");
260 else if((message & 0x20) == 0x20){ // PEDESTAL RUN
261 //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
263 else if((message & 0x30) == 0x30){ // LASER RUN
264 //printf("\t STANDALONE_LASER RUN raw data found\n");
266 else if((message & 0x40) == 0x40){ // CALIBRATION_CENTRAL RUN
267 //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
269 else if((message & 0x50) == 0x50){ // CALIBRATION_SEMICENTRAL
270 //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
272 else if((message & 0x60) == 0x60){ // CALIBRATION_MB
273 //printf("\t CALIBRATION_MB RUN raw data found\n");
275 else if((message & 0x70) == 0x70){ // CALIBRATION_EMD
276 //printf("\t CALIBRATION_EMD RUN raw data found\n");
278 // *** Checking the bit indicating the used readout card
279 // (the payload is different in the 2 cases!)
280 if((message & 0x08) == 0){ // ** DARC card
282 fIsDARCHeader = kTRUE;
283 AliInfo("\t ZDC readout card used: DARC");
285 else if((message & 0x08) == 0x08){ // ** ZRC card
287 AliInfo("\t ZDC readout card used: ZRC");
290 if(header->GetL1TriggerMessage() & 0x1){ // Calibration bit set in CDH
293 //printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
294 //printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);
296 UInt_t status = header->GetStatus();
297 //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status);
298 if((status & 0x000f) == 0x0001){
299 AliDebug(2,"CDH -> DARC trg0 overlap error");
300 fRawReader->AddMajorErrorLog(kDARCError);
302 if((status & 0x000f) == 0x0002){
303 AliDebug(2,"CDH -> DARC trg0 missing error");
304 fRawReader->AddMajorErrorLog(kDARCError);
306 if((status & 0x000f) == 0x0004){
307 AliDebug(2,"CDH -> DARC data parity error");
308 fRawReader->AddMajorErrorLog(kDARCError);
310 if((status & 0x000f) == 0x0008){
311 AliDebug(2,"CDH -> DARC ctrl parity error");
312 fRawReader->AddMajorErrorLog(kDARCError);
315 if((status & 0x00f0) == 0x0010){
316 AliDebug(2,"CDH -> DARC trg unavailable");
317 fRawReader->AddMajorErrorLog(kDARCError);
319 if((status & 0x00f0) == 0x0020){
320 AliDebug(2,"CDH -> DARC FEE error");
321 fRawReader->AddMajorErrorLog(kDARCError);
324 if((status & 0x0f00) == 0x0200){
325 AliDebug(2,"CDH -> DARC L1 time violation");
326 fRawReader->AddMajorErrorLog(kDARCError);
328 if((status & 0x0f00) == 0x0400){
329 AliDebug(2,"CDH -> DARC L2 time-out");
330 fRawReader->AddMajorErrorLog(kDARCError);
332 if((status & 0x0f00) == 0x0800){
333 AliDebug(2,"CDH -> DARC prepulse time violation");
334 fRawReader->AddMajorErrorLog(kDARCError);
337 if((status & 0xf000) == 0x1000){
338 AliDebug(2,"CDH -> DARC other error");
339 fRawReader->AddMajorErrorLog(kDARCError);
345 //_____________________________________________________________________________
346 Bool_t AliZDCRawStream::Next()
348 // Read the next raw digit
349 // Returns kFALSE if there is no digit left
351 if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
353 Int_t kFirstADCGeo=0, kLastADCGeo=3, kScalerGeo=8, kPUGeo=29, kTrigScales=30, kTrigHistory=31;
354 fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE;
355 fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
356 fIsUnderflow = kFALSE; fIsOverflow = kFALSE;
357 fSector[0] = fSector[1] = -1;
358 // fTrigCountNWords = 9; fTrigHistNWords = 2;
359 for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
361 fEvType = fRawReader->GetType();
363 //if(fEvType==7 || fEvType ==8){ //Physics or calibration event
366 fCurrentCh=0; fCurrScCh=0; fNChannelsOn=0;
368 //printf("\n AliZDCRawStream::Next() - ev. type %d",fEvType);
372 //printf("\n AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
374 // *** End of ZDC event
375 if(fBuffer == 0xcafefade){
376 //printf("\n AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
380 // -------------------------------------------
382 // -------------------------------------------
383 // If the CDH has been read then
384 // the DARC header must follow
385 if(fReadOutCard==0 && fIsDARCHeader){
386 //printf("\t ---- DARC header ----\n");
389 fDeadbeefOffset = 25;
395 fDataOffset = 1+fDeadbeefOffset;
396 fIsDARCHeader = kFALSE;
399 // ---------------------------------------------
400 // --- Start of data event (SOD) ---
401 // --- decoding mapping of connected ADC ch. ---
402 // ---------------------------------------------
403 // In the SOD event ADC ch. mapping is written
407 if(fPosition>=fDataOffset){
408 if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
409 // DARC 1st datum @ fDataOffset+1 \ ZRC 1st valid datum fDataOffset=0
410 if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){
411 printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
412 fCurrentCh=0; fCurrScCh=0;
415 printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
416 fSODReading = kFALSE;
420 else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
422 return kFALSE; // !!!!!!!!!!!!!!!!!!!!! For the moment thresholds are not read
424 else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
425 fIsHeaderMapping = kTRUE;
426 fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
427 fModType = ((fBuffer & 0x7ff00)>>8);
428 fADCNChannels = (fBuffer & 0xff); // # of channels following the header
430 printf(" ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
432 else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
433 fADCChannel = ((fBuffer & 0x3fff0000)>>16);
434 fCabledSignal = (fBuffer&0xffff);
436 if(fModType == kV965){ // ******** ADCs ********************************
438 if((fBuffer&0x40000000)>>30==0){ // high range chain ADC
439 fIsChMapping = kTRUE;
440 fMapADC[fCurrentCh][0] = fADCModule;
441 fMapADC[fCurrentCh][1] = fADCChannel;
442 fMapADC[fCurrentCh][2] = fCabledSignal;
443 // - No. of channels on
446 // Determining detector and sector
447 // -----------------------------------------
448 // For the decoding of the following lines
449 // look the enum in AliZDCRawStream.h file
450 // -----------------------------------------
451 if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
452 || fCabledSignal==24 || fCabledSignal==48){
453 fMapADC[fCurrentCh][3] = 4; //ZNA
455 if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot) fMapADC[fCurrentCh][4]=0;
456 else if(fCabledSignal==3 || fCabledSignal==27) fMapADC[fCurrentCh][4]=1;
457 else if(fCabledSignal==4 || fCabledSignal==28) fMapADC[fCurrentCh][4]=2;
458 else if(fCabledSignal==5 || fCabledSignal==29) fMapADC[fCurrentCh][4]=3;
459 else if(fCabledSignal==6 || fCabledSignal==30) fMapADC[fCurrentCh][4]=4;
460 else if(fCabledSignal==24 || fCabledSignal==48) fMapADC[fCurrentCh][4]=5; //Reference PTM
462 else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
463 fMapADC[fCurrentCh][3] = 5; //ZPA
465 if(fCabledSignal==7 || fCabledSignal==31) fMapADC[fCurrentCh][4]=0;
466 else if(fCabledSignal==8 || fCabledSignal==32) fMapADC[fCurrentCh][4]=1;
467 else if(fCabledSignal==9 || fCabledSignal==33) fMapADC[fCurrentCh][4]=2;
468 else if(fCabledSignal==10 || fCabledSignal==34) fMapADC[fCurrentCh][4]=3;
469 else if(fCabledSignal==11 || fCabledSignal==35) fMapADC[fCurrentCh][4]=4;
471 else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
472 || fCabledSignal==25 || fCabledSignal==49){
473 fMapADC[fCurrentCh][3] = 1; //ZNC
475 if(fCabledSignal==12 || fCabledSignal==36) fMapADC[fCurrentCh][4]=0;
476 else if(fCabledSignal==13 || fCabledSignal==37) fMapADC[fCurrentCh][4]=1;
477 else if(fCabledSignal==14 || fCabledSignal==38) fMapADC[fCurrentCh][4]=2;
478 else if(fCabledSignal==15 || fCabledSignal==39) fMapADC[fCurrentCh][4]=3;
479 else if(fCabledSignal==16 || fCabledSignal==40) fMapADC[fCurrentCh][4]=4;
480 else if(fCabledSignal==25 || fCabledSignal==49) fMapADC[fCurrentCh][4]=5; //Reference PTM
482 else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
483 fMapADC[fCurrentCh][3] = 2; //ZPC
485 if(fCabledSignal==17 || fCabledSignal==41) fMapADC[fCurrentCh][4]=0;
486 else if(fCabledSignal==18 || fCabledSignal==42) fMapADC[fCurrentCh][4]=1;
487 else if(fCabledSignal==19 || fCabledSignal==43) fMapADC[fCurrentCh][4]=2;
488 else if(fCabledSignal==20 || fCabledSignal==44) fMapADC[fCurrentCh][4]=3;
489 else if(fCabledSignal==21 || fCabledSignal==45) fMapADC[fCurrentCh][4]=4;
491 else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
492 fMapADC[fCurrentCh][3] = 3; // ZEM
494 if(fCabledSignal==22 || fCabledSignal==46) fMapADC[fCurrentCh][4]=1;
495 else if(fCabledSignal==23 || fCabledSignal==47) fMapADC[fCurrentCh][4]=2;
498 //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
499 //printf(" det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
503 } // high range channels
504 }// ModType=1 (ADC mapping)
505 else if(fModType == kV830){ // ******** VME scaler **************************
506 fIsChMapping = kTRUE;
507 fScalerMap[fCurrScCh][0] = fADCModule;
508 fScalerMap[fCurrScCh][1] = fADCChannel;
509 fScalerMap[fCurrScCh][2] = fCabledSignal;
511 // Determining detector and sector
512 // -----------------------------------------
513 // For the decoding of the following lines
514 // look the enum in AliZDCRawStream.h file
515 // -----------------------------------------
516 // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
517 if(fCabledSignal>=2 && fCabledSignal<=6){
518 fScalerMap[fCurrScCh][3] = 4; //ZNA
520 if(fCabledSignal==2 ) fScalerMap[fCurrScCh][4]=0;
521 else if(fCabledSignal==3) fScalerMap[fCurrScCh][4]=1;
522 else if(fCabledSignal==4) fScalerMap[fCurrScCh][4]=2;
523 else if(fCabledSignal==5) fScalerMap[fCurrScCh][4]=3;
524 else if(fCabledSignal==6) fScalerMap[fCurrScCh][4]=4;
526 else if(fCabledSignal>=7 && fCabledSignal<=11){
527 fScalerMap[fCurrScCh][3] = 5; //ZPA
529 if(fCabledSignal==7 ) fScalerMap[fCurrScCh][4]=0;
530 else if(fCabledSignal==8) fScalerMap[fCurrScCh][4]=1;
531 else if(fCabledSignal==9) fScalerMap[fCurrScCh][4]=2;
532 else if(fCabledSignal==10) fScalerMap[fCurrScCh][4]=3;
533 else if(fCabledSignal==11) fScalerMap[fCurrScCh][4]=4;
535 else if(fCabledSignal>=12 && fCabledSignal<=16){
536 fScalerMap[fCurrScCh][3] = 1; //ZNC
538 if(fCabledSignal==12) fScalerMap[fCurrScCh][4]=0;
539 else if(fCabledSignal==13) fScalerMap[fCurrScCh][4]=1;
540 else if(fCabledSignal==14) fScalerMap[fCurrScCh][4]=2;
541 else if(fCabledSignal==15) fScalerMap[fCurrScCh][4]=3;
542 else if(fCabledSignal==16) fScalerMap[fCurrScCh][4]=4;
544 else if(fCabledSignal>=17 && fCabledSignal<=21){
545 fScalerMap[fCurrScCh][3] = 2; //ZPC
547 if(fCabledSignal==17) fScalerMap[fCurrScCh][4]=0;
548 else if(fCabledSignal==18) fScalerMap[fCurrScCh][4]=1;
549 else if(fCabledSignal==19) fScalerMap[fCurrScCh][4]=2;
550 else if(fCabledSignal==20) fScalerMap[fCurrScCh][4]=3;
551 else if(fCabledSignal==21) fScalerMap[fCurrScCh][4]=4;
553 else if(fCabledSignal==22 || fCabledSignal==23){
554 fScalerMap[fCurrScCh][3] = 3; // ZEM
556 if(fCabledSignal==22 ) fScalerMap[fCurrScCh][4]=1;
557 else if(fCabledSignal==23) fScalerMap[fCurrScCh][4]=2;
560 //printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
561 //if(fCabledSignal!=0 && fCabledSignal!=1) printf(" det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
562 //else printf(" Signal void/not connected\n");
566 /*else if(fModType == kTRG){ // **** scalers from trigger card
567 //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
569 else if(fModType == kTRGI){ // **** trigger history from trigger card
570 //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
572 else if(fModType == kPU){ // **** pattern unit
573 //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
575 }//reading channel mapping
580 } // ------------------------------- SOD event
582 // -------------------------------------------
584 // -------------------------------------------
585 if(fPosition<fDeadfaceOffset && fReadOutCard==0){
589 else if(fPosition==fDeadfaceOffset && fReadOutCard==0){
590 if(fBuffer != 0xdeadface){
591 AliWarning(" NO deadface after DARC data");
592 fRawReader->AddMajorErrorLog(kDARCError);
599 else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){
603 else if(fPosition==fDeadbeefOffset && fReadOutCard==0){
604 if(fBuffer != 0xdeadbeef){
605 AliWarning(" NO deadbeef after DARC global data");
606 fRawReader->AddMajorErrorLog(kDARCError);
614 } // ------------------------------- End of DARC data
616 // ---------------------------------------------
618 // --- ADCs + VME scaler + trigger card + P.U.
619 // ---------------------------------------------
620 else if(fPosition>=fDataOffset){
622 //printf("AliZDCRawStream: fSODReading = %d\n", fSODReading);
623 if(!fSODReading && !fIsMapRead) ReadChMap();
625 // !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!!
626 // Not valid datum before the event
627 // there MUST be a NOT valid datum before the event!!!
629 if(fPosition==fDataOffset){
630 //printf("\t **** ZDC data begin ****\n");
631 if((fBuffer & 0x07000000) != 0x06000000){
632 fRawReader->AddMajorErrorLog(kZDCDataError);
634 else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
635 fIsADCEventGood = kFALSE;
639 // If the not valid datum isn't followed by the 1st ADC header
640 // the event is corrupted (i.e., 2 gates arrived before trigger)
641 else if(fPosition==fDataOffset+1){
642 if((fBuffer & 0x07000000) != 0x02000000){
643 AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
644 fRawReader->AddMajorErrorLog(kZDCDataError);
645 fIsADCEventGood = kFALSE;
652 // Get geo address of current word
653 // - ADC GEO = 0, 1, 2, 3
654 // - VME scaler GEO = 8
656 // - Trigger card scales GEO = 30
657 // - Trigger card history GEO = 31
658 fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
660 // ************************************ ADC MODULES ************************************
661 if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo){
663 if((fBuffer & 0x07000000) == 0x02000000){
664 fIsADCHeader = kTRUE;
665 fADCNChannels = ((fBuffer & 0x00003f00)>>8);
666 //printf(" AliZDCRawStream -> ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
669 else if((fBuffer & 0x07000000) == 0x00000000){
670 fIsADCDataWord = kTRUE;
671 fADCChannel = ((fBuffer & 0x1e0000) >> 17);
672 fADCGain = ((fBuffer & 0x10000) >> 16);
673 fADCValue = (fBuffer & 0xfff);
675 //printf(" AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n",
676 // fADCModule,fADCChannel,fADCGain,fADCValue);
678 // Checking if the channel map for the ADCs has been provided/read
679 if(fMapADC[0][0]==-1){
680 printf("\t ATTENTION!!! No ADC mapping has been found/provided!!!\n");
684 /*for(Int_t ci=0; ci<kNch; ci++){
685 printf(" %d mod %d ch %d det %d sec %d\n",ci,fMapADC[ci][0],
686 fMapADC[ci][1], fMapADC[ci][3], fMapADC[ci][4]);
689 // Scan of the map to assign the correct volumes
690 Int_t foundMapEntry = kFALSE;
691 for(Int_t k=0; k<kNch; k++){
692 if(fADCModule==fMapADC[k][0] && fADCChannel==fMapADC[k][1]){
693 fSector[0] = fMapADC[k][3];
694 fSector[1] = fMapADC[k][4];
695 foundMapEntry = kTRUE;
699 if(foundMapEntry==kFALSE){
700 AliWarning(Form(" No valid entry in ADC mapping for raw data %d ADCmod. %d ch. %d\n",
701 fPosition,fADCModule,fADCChannel));
704 //printf("AliZDCRawStream -> ADCmod. %d ch. %d -> det %d sec %d\n",
705 // fADCModule,fADCChannel,fSector[0],fSector[1]);
708 if(foundMapEntry==kTRUE){
709 if(fSector[0]<1 || fSector[0]>5){
710 AliWarning(Form(" No valid detector assignment: %d",fSector[0]));
711 fRawReader->AddMajorErrorLog(kInvalidSector);
714 if(fSector[1]<0 || fSector[1]>5){
715 AliWarning(Form(" No valid sector assignment: %d",fSector[1]));
716 fRawReader->AddMajorErrorLog(kInvalidSector);
719 if(fADCModule<0 || fADCModule>3){
720 AliError(Form(" No valid ADC module: %d",fADCModule));
721 fRawReader->AddMajorErrorLog(kInvalidADCModule);
725 // Checking the underflow and overflow bits
726 if(fBuffer & 0x1000) fIsUnderflow = kTRUE;
727 else if (fBuffer & 0x2000) fIsOverflow = kTRUE;
731 else if((fBuffer & 0x07000000) == 0x04000000){
733 //printf(" AliZDCRawStream -> EOB --------------------------\n");
736 // ********************************* VME SCALER HEADER *********************************
737 else if(fADCModule == kScalerGeo){
738 if(fBuffer & 0x04000000 && fIsScHeaderRead==kFALSE){ // *** Scaler header
739 fScGeo = (fBuffer & 0xf8000000)>>27;
740 fScNWords = (fBuffer & 0x00fc0000)>>18;
741 fScTriggerSource = (fBuffer & 0x00030000)>>16;
742 fScTriggerNumber = (fBuffer & 0x0000ffff);
743 fIsScHeaderRead = kTRUE;
744 fScStartCounter = fPosition;
746 //printf(" AliZDCRawStream -> VME SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n",
747 // fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber);
749 else if(!(fBuffer & 0x04000000)){
750 fIsScEventGood = kFALSE;
753 // *********************************** PATTERN UNIT ***********************************
754 else if(fADCModule == kPUGeo){
755 // still to be implemented!!! Not yet in data!!!
756 fDetPattern = (fBuffer & 0x0000003f);
758 //printf(" AliZDCRawStream -> Pattern Unit\n");
761 // ******************************** TRIGGER CARD COUNTS ********************************
762 else if(fADCModule == kTrigScales){
763 if(fIsTriggerScaler == kFALSE){
764 fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
765 fTrigCountStart = fPosition;
766 fIsTriggerScaler = kTRUE;
769 //printf(" AliZDCRawStream -> Trigger Scaler header\n");
771 // ********************************** TRIGGER HISTORY **********************************
772 else if(fADCModule == kTrigHistory){
773 if(fIsTriggerHistory == kFALSE){
774 fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
775 fTrigHistStart = fPosition;
776 fIsTriggerHistory = kTRUE;
779 //printf(" AliZDCRawStream -> Trigger History header\n");
782 // ********************************** VME SCALER DATA **********************************
783 // Reading VME scaler data
784 if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
785 fADCModule = kScalerGeo;
786 fScEvCounter = fBuffer;
787 Int_t nWords = (Int_t) (fScNWords);
788 if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
790 //printf(" AliZDCRawStream -> scaler datum %d", fScEvCounter);
792 // ******************************** TRIGGER SCALER DATA ********************************
793 // Reading trigger scaler data
794 if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
795 fADCModule = kTrigScales;
796 if(fPosition == fTrigCountStart+1) fMBTrigInput = fBuffer;
797 else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;
798 else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
799 else if(fPosition == fTrigCountStart+4) fEMDTrigInput = fBuffer;
800 else if(fPosition == fTrigCountStart+5) fL0Received = fBuffer;
801 else if(fPosition == fTrigCountStart+6) fMBtrig2CTP = fBuffer;
802 else if(fPosition == fTrigCountStart+7) fCentralTrig2CTP = fBuffer;
803 else if(fPosition == fTrigCountStart+8) fSCentralTrig2CTP = fBuffer;
804 else if(fPosition == fTrigCountStart+9){
805 fEMDTrig2CTP = fBuffer;
806 fIsTriggerScaler = kFALSE;
809 //printf(" AliZDCRawStream -> Trigger Scaler datum %d\n", fPosition-fTrigCountStart);
811 // ******************************* TRIGGER HISTORY WORDS ******************************
812 // Reading trigger history
813 if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
814 fADCModule = kTrigHistory;
815 if(fPosition == fTrigHistStart+1){
816 fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
817 fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;
818 fCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
819 fMBTrigHist = (fBuffer & 0x00007fff);
821 fCPTInput[0] = (fBuffer & 0x00000080) >> 6; // MB bit
822 fCPTInput[1] = (fBuffer & 0x00400000) >> 21; // CENTRAL bit
825 else if(fPosition == fTrigHistStart+fTrigHistNWords){
826 fPileUpBit2ndWord = (fBuffer & 0x80000000) >> 31;
827 fL0Bit2ndWord = (fBuffer & 0x40000000) >> 30;
828 fSCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
829 fEMDTrigHist = (fBuffer & 0x00007fff);
831 fCPTInput[2] = (fBuffer & 0x00000080) >> 6; // SEMICENTRAL bit
832 fCPTInput[3] = (fBuffer & 0x00400000) >> 21; // EMD bit
834 fIsTriggerHistory = kFALSE;
836 // Checking if the event is good
837 // (1) both history word pile up bits must be = 0
838 if(fPileUpBit1stWord==0 && fPileUpBit2ndWord==0) fIsPileUpEvent = kFALSE;
840 fIsPileUpEvent = kTRUE;
841 printf(" AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
842 fPileUpBit1stWord, fPileUpBit2ndWord);
844 // (2) both history word L0 bits must be = 1
845 if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
847 fIsL0BitSet = kFALSE;
848 printf(" AliZDCRawStream -> L0 wrongly set: bitL0word0 %d bitL0word1 %d\n",
849 fL0Bit1stWord, fL0Bit2ndWord);
853 //printf(" AliZDCRawStream -> Trigger history word %d\n", fPosition-fTrigHistStart);
863 //_____________________________________________________________________________
864 AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri)
866 // Setting the storage
868 AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri);
874 //_____________________________________________________________________________
875 AliZDCChMap* AliZDCRawStream::GetChMap() const
878 // Getting calibration object for ZDC
880 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
881 if(!entry) AliFatal("No calibration data loaded!");
883 AliZDCChMap *calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
884 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");