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),
74 fIsScalerWord(kFALSE),
77 fIsTriggerScaler(kFALSE),
81 fSCentralTrigInput(0),
89 fIsTriggerHistory(kFALSE),
103 fIsADCEventGood(kTRUE),
105 fIsPileUpEvent(kFALSE)
107 // Create an object to read ZDC raw digits
109 fRawReader->Select("ZDC");
112 for(Int_t i=0; i<kNch; i++){
113 for(Int_t j=0; j<5; j++){
115 if(i<32) fScalerMap[i][j]=-1;
119 for(Int_t k=0; k<4; k++) fCPTInput[k] = 0;
123 //_____________________________________________________________________________
124 AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
126 fRawReader(stream.fRawReader),
127 fBuffer(stream.GetRawBuffer()),
128 fReadOutCard(stream.GetReadOutCard()),
129 fEvType(stream.fEvType),
130 fPosition(stream.fPosition),
131 fIsCalib(stream.fIsCalib),
132 fIsDARCHeader(stream.fIsDARCHeader),
133 fIsHeaderMapping(stream.fIsHeaderMapping),
134 fIsChMapping(stream.fIsChMapping),
135 fIsADCDataWord(stream.fIsADCDataWord),
136 fIsADCHeader(stream.fIsADCHeader),
137 fIsADCEOB(stream.fIsADCEOB),
138 fSODReading(stream.fSODReading),
139 fIsMapRead(stream.fIsMapRead),
140 fDeadfaceOffset(stream.GetDeadfaceOffset()),
141 fDeadbeefOffset(stream.GetDeadbeefOffset()),
142 fDataOffset(stream.GetDataOffset()),
143 fModType(stream.GetModType()),
144 fADCModule(stream.GetADCModule()),
145 fADCNChannels(stream.GetADCNChannels()),
146 fADCChannel(stream.GetADCChannel()),
147 fADCValue(stream.GetADCValue()),
148 fADCGain(stream.GetADCGain()),
149 fIsUnderflow(stream.fIsUnderflow),
150 fIsOverflow(stream.fIsOverflow),
151 fScGeo(stream.GetScGeo()),
152 fScNWords(stream.GetScNWords()),
153 fScTriggerSource(stream.GetScTriggerSource()),
154 fScTriggerNumber(stream.fScTriggerNumber),
155 fIsScEventGood(stream.fIsScEventGood),
156 fIsScHeaderRead(stream.fIsScHeaderRead),
157 fScStartCounter(stream.fScStartCounter),
158 fScEvCounter(stream.fScEvCounter),
159 fIsScalerWord(stream.fIsScalerWord),
160 fDetPattern(stream.fDetPattern),
161 fTrigCountNWords(stream.fTrigCountNWords),
162 fIsTriggerScaler(stream.fIsTriggerScaler),
163 fTrigCountStart(stream.fTrigCountStart),
164 fMBTrigInput(stream.fMBTrigInput),
165 fCentralTrigInput(stream.fCentralTrigInput),
166 fSCentralTrigInput(stream.fSCentralTrigInput),
167 fEMDTrigInput(stream.fEMDTrigInput),
168 fL0Received(stream.fL0Received),
169 fMBtrig2CTP(stream.fMBtrig2CTP),
170 fCentralTrig2CTP(stream.fCentralTrig2CTP),
171 fSCentralTrig2CTP(stream.fSCentralTrig2CTP),
172 fEMDTrig2CTP(stream.fEMDTrig2CTP),
173 fTrigHistNWords(stream.fTrigHistNWords),
174 fIsTriggerHistory(stream.fIsTriggerHistory),
175 fTrigHistStart(stream.fTrigHistStart),
176 fPileUpBit1stWord(stream.fPileUpBit1stWord),
177 fL0Bit1stWord(stream.fL0Bit1stWord),
178 fCentralTrigHist(stream.fCentralTrigHist),
179 fMBTrigHist(stream.fMBTrigHist),
180 fPileUpBit2ndWord(stream.fPileUpBit2ndWord),
181 fL0Bit2ndWord(stream.fL0Bit2ndWord),
182 fSCentralTrigHist(stream.fSCentralTrigHist),
183 fEMDTrigHist(stream.fEMDTrigHist),
184 fNChannelsOn(stream.fNChannelsOn),
185 fCurrentCh(stream.fCurrentCh),
186 fCabledSignal(stream.GetCabledSignal()),
187 fCurrScCh(stream.fCurrScCh),
188 fIsADCEventGood(stream.fIsADCEventGood),
189 fIsL0BitSet(stream.fIsL0BitSet),
190 fIsPileUpEvent(stream.fIsPileUpEvent)
195 for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j);
196 for(Int_t i=0; i<kNch; i++){
197 for(Int_t j=0; j<5; j++){
198 fMapADC[i][j] = stream.fMapADC[i][j];
199 if(i<32) fScalerMap[i][j] = stream.fMapADC[i][j];
203 for(Int_t k=0; k<4; k++) fCPTInput[k] = stream.fCPTInput[k];
206 //_____________________________________________________________________________
207 AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream&
210 // Assignment operator
211 Fatal("operator =", "assignment operator not implemented");
215 //_____________________________________________________________________________
216 AliZDCRawStream::~AliZDCRawStream()
222 //_____________________________________________________________________________
223 void AliZDCRawStream::ReadChMap()
225 // Reading channel map
227 AliDebug(2,"\t Reading ZDC ADC mapping from OCDB\n");
228 AliZDCChMap * chMap = GetChMap();
230 for(Int_t i=0; i<kNch; i++){
231 fMapADC[i][0] = chMap->GetADCModule(i);
232 fMapADC[i][1] = chMap->GetADCChannel(i);
234 fMapADC[i][3] = chMap->GetDetector(i);
235 fMapADC[i][4] = chMap->GetSector(i);
240 //_____________________________________________________________________________
241 void AliZDCRawStream::ReadCDHHeader()
244 const AliRawDataHeader* header = fRawReader->GetDataHeader();
246 AliError(" No CDH in raw data streaming");
247 fRawReader->AddMajorErrorLog(kCDHError);
251 //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
253 UChar_t message = header->GetAttributes();
254 //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
256 if((message & 0xf0) == 0x0){ // PHYSICS RUN
257 //printf("\t PHYSICS RUN raw data found\n");
259 else if((message & 0xf0) == 0x10){ // COSMIC RUN
260 //printf("\t STANDALONE_COSMIC RUN raw data found\n");
262 else if((message & 0xf0) == 0x20){ // PEDESTAL RUN
263 //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
265 else if((message & 0xf0) == 0x30){ // LASER RUN
266 //printf("\t STANDALONE_LASER RUN raw data found\n");
268 else if((message & 0xf0) == 0x40){ // CALIBRATION_CENTRAL RUN
269 //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
271 else if((message & 0xf0) == 0x50){ // CALIBRATION_SEMICENTRAL
272 //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
274 else if((message & 0xf0) == 0x60){ // CALIBRATION_MB
275 //printf("\t CALIBRATION_MB RUN raw data found\n");
277 else if((message & 0xf0) == 0x70){ // CALIBRATION_EMD
278 //printf("\t CALIBRATION_EMD RUN raw data found\n");
280 // *** Checking the bit indicating the used readout card
281 // (the payload is different in the 2 cases!)
282 if((message & 0x08) == 0){ // ** DARC card
284 fIsDARCHeader = kTRUE;
285 AliInfo("\t ZDC readout card used: DARC");
287 else if((message & 0x08) == 0x08){ // ** ZRC card
289 AliInfo("\t ZDC readout card used: ZRC");
292 if(header->GetL1TriggerMessage() & 0x1){ // Calibration bit set in CDH
295 //printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
296 //printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);
298 UInt_t status = header->GetStatus();
299 //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status);
300 if((status & 0x000f) == 0x0001){
301 AliDebug(2,"CDH -> DARC trg0 overlap error");
302 fRawReader->AddMajorErrorLog(kDARCError);
304 if((status & 0x000f) == 0x0002){
305 AliDebug(2,"CDH -> DARC trg0 missing error");
306 fRawReader->AddMajorErrorLog(kDARCError);
308 if((status & 0x000f) == 0x0004){
309 AliDebug(2,"CDH -> DARC data parity error");
310 fRawReader->AddMajorErrorLog(kDARCError);
312 if((status & 0x000f) == 0x0008){
313 AliDebug(2,"CDH -> DARC ctrl parity error");
314 fRawReader->AddMajorErrorLog(kDARCError);
317 if((status & 0x00f0) == 0x0010){
318 AliDebug(2,"CDH -> DARC trg unavailable");
319 fRawReader->AddMajorErrorLog(kDARCError);
321 if((status & 0x00f0) == 0x0020){
322 AliDebug(2,"CDH -> DARC FEE error");
323 fRawReader->AddMajorErrorLog(kDARCError);
326 if((status & 0x0f00) == 0x0200){
327 AliDebug(2,"CDH -> DARC L1 time violation");
328 fRawReader->AddMajorErrorLog(kDARCError);
330 if((status & 0x0f00) == 0x0400){
331 AliDebug(2,"CDH -> DARC L2 time-out");
332 fRawReader->AddMajorErrorLog(kDARCError);
334 if((status & 0x0f00) == 0x0800){
335 AliDebug(2,"CDH -> DARC prepulse time violation");
336 fRawReader->AddMajorErrorLog(kDARCError);
339 if((status & 0xf000) == 0x1000){
340 AliDebug(2,"CDH -> DARC other error");
341 fRawReader->AddMajorErrorLog(kDARCError);
347 //_____________________________________________________________________________
348 Bool_t AliZDCRawStream::Next()
350 // Read the next raw digit
351 // Returns kFALSE if there is no digit left
353 if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
355 Int_t kFirstADCGeo=0, kLastADCGeo=3, kScalerGeo=8, kPUGeo=29, kTrigScales=30, kTrigHistory=31;
356 fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE;
357 fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
358 fIsUnderflow = kFALSE; fIsOverflow = kFALSE; fIsScalerWord = kFALSE;
359 fSector[0] = fSector[1] = -1;
360 // fTrigCountNWords = 9; fTrigHistNWords = 2;
361 for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
363 fEvType = fRawReader->GetType();
365 //if(fEvType==7 || fEvType ==8){ //Physics or calibration event
368 fCurrentCh=0; fCurrScCh=0; fNChannelsOn=0;
370 //printf("\n AliZDCRawStream::Next() - ev. type %d",fEvType);
374 //printf("\n AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
376 // *** End of ZDC event
377 if(fBuffer == 0xcafefade){
378 //printf("\n AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
382 // -------------------------------------------
384 // -------------------------------------------
385 // If the CDH has been read then
386 // the DARC header must follow
387 if(fReadOutCard==0 && fIsDARCHeader){
388 //printf("\t ---- DARC header ----\n");
391 fDeadbeefOffset = 25;
397 fDataOffset = 1+fDeadbeefOffset;
398 fIsDARCHeader = kFALSE;
401 // ---------------------------------------------
402 // --- Start of data event (SOD) ---
403 // --- decoding mapping of connected ADC ch. ---
404 // ---------------------------------------------
405 // In the SOD event ADC ch. mapping is written
409 if(fPosition>=fDataOffset){
410 if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
411 // DARC 1st datum @ fDataOffset+1 \ ZRC 1st valid datum @ fDataOffset=0
412 if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){
413 printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
414 fCurrentCh=0; fCurrScCh=0;
417 printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
418 fSODReading = kFALSE;
422 else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
424 return kFALSE; // !!!!!!!!!!!!!!!!!!!!! For the moment thresholds are not read
426 else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
427 fIsHeaderMapping = kTRUE;
428 fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
429 fModType = ((fBuffer & 0x7ff00)>>8);
430 fADCNChannels = (fBuffer & 0xff); // # of channels following the header
432 printf(" ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
434 else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
435 fADCChannel = ((fBuffer & 0x3fff0000)>>16);
436 fCabledSignal = (fBuffer&0xffff);
438 if(fModType == kV965){ // ******** ADCs ********************************
440 if((fBuffer&0x40000000)>>30==0){ // high range chain ADC
441 fIsChMapping = kTRUE;
442 fMapADC[fCurrentCh][0] = fADCModule;
443 fMapADC[fCurrentCh][1] = fADCChannel;
444 fMapADC[fCurrentCh][2] = fCabledSignal;
445 // - No. of channels on
448 // Determining detector and sector
449 // -----------------------------------------
450 // For the decoding of the following lines
451 // look the enum in AliZDCRawStream.h file
452 // -----------------------------------------
453 if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
454 || fCabledSignal==24 || fCabledSignal==48){
455 fMapADC[fCurrentCh][3] = 4; //ZNA
457 if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot) fMapADC[fCurrentCh][4]=0;
458 else if(fCabledSignal==3 || fCabledSignal==27) fMapADC[fCurrentCh][4]=1;
459 else if(fCabledSignal==4 || fCabledSignal==28) fMapADC[fCurrentCh][4]=2;
460 else if(fCabledSignal==5 || fCabledSignal==29) fMapADC[fCurrentCh][4]=3;
461 else if(fCabledSignal==6 || fCabledSignal==30) fMapADC[fCurrentCh][4]=4;
462 else if(fCabledSignal==24 || fCabledSignal==48) fMapADC[fCurrentCh][4]=5; //Reference PTM
464 else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
465 fMapADC[fCurrentCh][3] = 5; //ZPA
467 if(fCabledSignal==7 || fCabledSignal==31) fMapADC[fCurrentCh][4]=0;
468 else if(fCabledSignal==8 || fCabledSignal==32) fMapADC[fCurrentCh][4]=1;
469 else if(fCabledSignal==9 || fCabledSignal==33) fMapADC[fCurrentCh][4]=2;
470 else if(fCabledSignal==10 || fCabledSignal==34) fMapADC[fCurrentCh][4]=3;
471 else if(fCabledSignal==11 || fCabledSignal==35) fMapADC[fCurrentCh][4]=4;
473 else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
474 || fCabledSignal==25 || fCabledSignal==49){
475 fMapADC[fCurrentCh][3] = 1; //ZNC
477 if(fCabledSignal==12 || fCabledSignal==36) fMapADC[fCurrentCh][4]=0;
478 else if(fCabledSignal==13 || fCabledSignal==37) fMapADC[fCurrentCh][4]=1;
479 else if(fCabledSignal==14 || fCabledSignal==38) fMapADC[fCurrentCh][4]=2;
480 else if(fCabledSignal==15 || fCabledSignal==39) fMapADC[fCurrentCh][4]=3;
481 else if(fCabledSignal==16 || fCabledSignal==40) fMapADC[fCurrentCh][4]=4;
482 else if(fCabledSignal==25 || fCabledSignal==49) fMapADC[fCurrentCh][4]=5; //Reference PTM
484 else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
485 fMapADC[fCurrentCh][3] = 2; //ZPC
487 if(fCabledSignal==17 || fCabledSignal==41) fMapADC[fCurrentCh][4]=0;
488 else if(fCabledSignal==18 || fCabledSignal==42) fMapADC[fCurrentCh][4]=1;
489 else if(fCabledSignal==19 || fCabledSignal==43) fMapADC[fCurrentCh][4]=2;
490 else if(fCabledSignal==20 || fCabledSignal==44) fMapADC[fCurrentCh][4]=3;
491 else if(fCabledSignal==21 || fCabledSignal==45) fMapADC[fCurrentCh][4]=4;
493 else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
494 fMapADC[fCurrentCh][3] = 3; // ZEM
496 if(fCabledSignal==22 || fCabledSignal==46) fMapADC[fCurrentCh][4]=1;
497 else if(fCabledSignal==23 || fCabledSignal==47) fMapADC[fCurrentCh][4]=2;
500 //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
501 //printf(" det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
505 } // high range channels
506 }// ModType=1 (ADC mapping)
507 else if(fModType == kV830){ // ******** VME scaler **************************
508 fIsChMapping = kTRUE;
509 fScalerMap[fCurrScCh][0] = fADCModule;
510 fScalerMap[fCurrScCh][1] = fADCChannel;
511 fScalerMap[fCurrScCh][2] = fCabledSignal;
513 // Determining detector and sector
514 // -----------------------------------------
515 // For the decoding of the following lines
516 // look the enum in AliZDCRawStream.h file
517 // -----------------------------------------
518 // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
519 if(fCabledSignal>=2 && fCabledSignal<=6){
520 fScalerMap[fCurrScCh][3] = 4; //ZNA
522 if(fCabledSignal==2 ) fScalerMap[fCurrScCh][4]=0;
523 else if(fCabledSignal==3) fScalerMap[fCurrScCh][4]=1;
524 else if(fCabledSignal==4) fScalerMap[fCurrScCh][4]=2;
525 else if(fCabledSignal==5) fScalerMap[fCurrScCh][4]=3;
526 else if(fCabledSignal==6) fScalerMap[fCurrScCh][4]=4;
528 else if(fCabledSignal>=7 && fCabledSignal<=11){
529 fScalerMap[fCurrScCh][3] = 5; //ZPA
531 if(fCabledSignal==7 ) fScalerMap[fCurrScCh][4]=0;
532 else if(fCabledSignal==8) fScalerMap[fCurrScCh][4]=1;
533 else if(fCabledSignal==9) fScalerMap[fCurrScCh][4]=2;
534 else if(fCabledSignal==10) fScalerMap[fCurrScCh][4]=3;
535 else if(fCabledSignal==11) fScalerMap[fCurrScCh][4]=4;
537 else if(fCabledSignal>=12 && fCabledSignal<=16){
538 fScalerMap[fCurrScCh][3] = 1; //ZNC
540 if(fCabledSignal==12) fScalerMap[fCurrScCh][4]=0;
541 else if(fCabledSignal==13) fScalerMap[fCurrScCh][4]=1;
542 else if(fCabledSignal==14) fScalerMap[fCurrScCh][4]=2;
543 else if(fCabledSignal==15) fScalerMap[fCurrScCh][4]=3;
544 else if(fCabledSignal==16) fScalerMap[fCurrScCh][4]=4;
546 else if(fCabledSignal>=17 && fCabledSignal<=21){
547 fScalerMap[fCurrScCh][3] = 2; //ZPC
549 if(fCabledSignal==17) fScalerMap[fCurrScCh][4]=0;
550 else if(fCabledSignal==18) fScalerMap[fCurrScCh][4]=1;
551 else if(fCabledSignal==19) fScalerMap[fCurrScCh][4]=2;
552 else if(fCabledSignal==20) fScalerMap[fCurrScCh][4]=3;
553 else if(fCabledSignal==21) fScalerMap[fCurrScCh][4]=4;
555 else if(fCabledSignal==22 || fCabledSignal==23){
556 fScalerMap[fCurrScCh][3] = 3; // ZEM
558 if(fCabledSignal==22 ) fScalerMap[fCurrScCh][4]=1;
559 else if(fCabledSignal==23) fScalerMap[fCurrScCh][4]=2;
562 //printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
563 //if(fCabledSignal!=0 && fCabledSignal!=1) printf(" det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
564 //else printf(" Signal void/not connected\n");
568 /*else if(fModType == kTRG){ // **** scalers from trigger card
569 //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
571 else if(fModType == kTRGI){ // **** trigger history from trigger card
572 //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
574 else if(fModType == kPU){ // **** pattern unit
575 //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
577 }//reading channel mapping
582 } // ------------------------------- SOD event
584 // -------------------------------------------
586 // -------------------------------------------
587 if(fPosition<fDeadfaceOffset && fReadOutCard==0){
591 else if(fPosition==fDeadfaceOffset && fReadOutCard==0){
592 if(fBuffer != 0xdeadface){
593 //AliWarning(" NO deadface after DARC data");
594 fRawReader->AddMajorErrorLog(kDARCError);
601 else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){
605 else if(fPosition==fDeadbeefOffset && fReadOutCard==0){
606 if(fBuffer != 0xdeadbeef){
607 //AliWarning(" NO deadbeef after DARC global data");
608 fRawReader->AddMajorErrorLog(kDARCError);
616 } // ------------------------------- End of DARC data
618 // ---------------------------------------------
620 // --- ADCs + VME scaler + trigger card + P.U.
621 // ---------------------------------------------
622 else if(fPosition>=fDataOffset){
624 //printf("AliZDCRawStream: fSODReading = %d\n", fSODReading);
625 if(!fSODReading && !fIsMapRead) ReadChMap();
627 // !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!!
628 // Not valid datum before the event
629 // there MUST be a NOT valid datum before the event!!!
631 if(fPosition==fDataOffset){
632 //printf("\t **** ZDC data begin ****\n");
633 if((fBuffer & 0x07000000) != 0x06000000){
634 fRawReader->AddMajorErrorLog(kZDCDataError);
636 else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
637 fIsADCEventGood = kFALSE;
641 // If the not valid datum isn't followed by the 1st ADC header
642 // the event is corrupted (i.e., 2 gates arrived before trigger)
643 else if(fPosition==fDataOffset+1){
644 if((fBuffer & 0x07000000) != 0x02000000){
645 AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
646 fRawReader->AddMajorErrorLog(kZDCDataError);
647 fIsADCEventGood = kFALSE;
654 // Get geo address of current word
655 // - ADC GEO = 0, 1, 2, 3
656 // - VME scaler GEO = 8
658 // - Trigger card scales GEO = 30
659 // - Trigger card history GEO = 31
660 fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
662 // ************************************ ADC MODULES ************************************
663 if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo){
665 if((fBuffer & 0x07000000) == 0x02000000){
666 fIsADCHeader = kTRUE;
667 fADCNChannels = ((fBuffer & 0x00003f00)>>8);
668 //printf(" AliZDCRawStream -> ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
671 else if((fBuffer & 0x07000000) == 0x00000000){
672 fIsADCDataWord = kTRUE;
673 fADCChannel = ((fBuffer & 0x1e0000) >> 17);
674 fADCGain = ((fBuffer & 0x10000) >> 16);
675 fADCValue = (fBuffer & 0xfff);
677 //printf(" AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n",
678 // fADCModule,fADCChannel,fADCGain,fADCValue);
680 // Checking if the channel map for the ADCs has been provided/read
681 if(fMapADC[0][0]==-1){
682 printf("\t ATTENTION!!! No ADC mapping has been found/provided!!!\n");
686 /*for(Int_t ci=0; ci<kNch; ci++){
687 printf(" %d mod %d ch %d det %d sec %d\n",ci,fMapADC[ci][0],
688 fMapADC[ci][1], fMapADC[ci][3], fMapADC[ci][4]);
691 // Scan of the map to assign the correct volumes
692 Int_t foundMapEntry = kFALSE;
693 for(Int_t k=0; k<kNch; k++){
694 if(fADCModule==fMapADC[k][0] && fADCChannel==fMapADC[k][1]){
695 fSector[0] = fMapADC[k][3];
696 fSector[1] = fMapADC[k][4];
697 foundMapEntry = kTRUE;
701 if(foundMapEntry==kFALSE){
702 AliWarning(Form(" No valid entry in ADC mapping for raw data %d ADCmod. %d ch. %d\n",
703 fPosition,fADCModule,fADCChannel));
706 //printf("AliZDCRawStream -> ADCmod. %d ch. %d -> det %d sec %d\n",
707 // fADCModule,fADCChannel,fSector[0],fSector[1]);
710 if(foundMapEntry==kTRUE){
711 if(fSector[0]<1 || fSector[0]>5){
712 AliWarning(Form(" No valid detector assignment: %d",fSector[0]));
713 fRawReader->AddMajorErrorLog(kInvalidSector);
716 if(fSector[1]<0 || fSector[1]>5){
717 AliWarning(Form(" No valid sector assignment: %d",fSector[1]));
718 fRawReader->AddMajorErrorLog(kInvalidSector);
721 if(fADCModule<0 || fADCModule>3){
722 AliError(Form(" No valid ADC module: %d",fADCModule));
723 fRawReader->AddMajorErrorLog(kInvalidADCModule);
727 // Checking the underflow and overflow bits
728 if(fBuffer & 0x1000) fIsUnderflow = kTRUE;
729 else if (fBuffer & 0x2000) fIsOverflow = kTRUE;
733 else if((fBuffer & 0x07000000) == 0x04000000){
735 //printf(" AliZDCRawStream -> EOB --------------------------\n");
738 // ********************************* VME SCALER HEADER *********************************
739 else if(fADCModule == kScalerGeo){
740 if(fBuffer & 0x04000000 && fIsScHeaderRead==kFALSE){ // *** Scaler header
741 fScGeo = (fBuffer & 0xf8000000)>>27;
742 fScNWords = (fBuffer & 0x00fc0000)>>18;
743 fScTriggerSource = (fBuffer & 0x00030000)>>16;
744 fScTriggerNumber = (fBuffer & 0x0000ffff);
745 fIsScHeaderRead = kTRUE;
746 fScStartCounter = fPosition;
748 //printf(" AliZDCRawStream -> VME SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n",
749 // fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber);
751 else if(!(fBuffer & 0x04000000)){
752 fIsScEventGood = kFALSE;
755 // *********************************** PATTERN UNIT ***********************************
756 else if(fADCModule == kPUGeo){
757 // still to be implemented!!! Not yet in data!!!
758 fDetPattern = (fBuffer & 0x0000003f);
760 //printf(" AliZDCRawStream -> Pattern Unit\n");
763 // ******************************** TRIGGER CARD COUNTS ********************************
764 else if(fADCModule == kTrigScales){
765 if(fIsTriggerScaler == kFALSE){
766 fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
767 fTrigCountStart = fPosition;
768 fIsTriggerScaler = kTRUE;
771 //printf(" AliZDCRawStream -> Trigger Scaler header\n");
773 // ********************************** TRIGGER HISTORY **********************************
774 else if(fADCModule == kTrigHistory){
775 if(fIsTriggerHistory == kFALSE){
776 fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
777 fTrigHistStart = fPosition;
778 fIsTriggerHistory = kTRUE;
781 //printf(" AliZDCRawStream -> Trigger History header\n");
784 // ********************************** VME SCALER DATA **********************************
785 // Reading VME scaler data
786 if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
787 fADCModule=kScalerGeo; fIsADCDataWord=kFALSE; fIsScalerWord=kTRUE;
788 fScEvCounter = fBuffer;
789 Int_t nWords = (Int_t) (fScNWords);
790 if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
792 //printf(" AliZDCRawStream -> scaler datum %d", fScEvCounter);
794 // ******************************** TRIGGER SCALER DATA ********************************
795 // Reading trigger scaler data
796 if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
797 fADCModule = kTrigScales; fIsADCDataWord = kFALSE;
798 if(fPosition == fTrigCountStart+1) fMBTrigInput = fBuffer;
799 else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;
800 else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
801 else if(fPosition == fTrigCountStart+4) fEMDTrigInput = fBuffer;
802 else if(fPosition == fTrigCountStart+5) fL0Received = fBuffer;
803 else if(fPosition == fTrigCountStart+6) fMBtrig2CTP = fBuffer;
804 else if(fPosition == fTrigCountStart+7) fCentralTrig2CTP = fBuffer;
805 else if(fPosition == fTrigCountStart+8) fSCentralTrig2CTP = fBuffer;
806 else if(fPosition == fTrigCountStart+9){
807 fEMDTrig2CTP = fBuffer;
808 fIsTriggerScaler = kFALSE;
811 //printf(" AliZDCRawStream -> Trigger Scaler datum %d\n", fPosition-fTrigCountStart);
813 // ******************************* TRIGGER HISTORY WORDS ******************************
814 // Reading trigger history
815 if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
816 fADCModule = kTrigHistory; fIsADCDataWord = kFALSE;
817 if(fPosition == fTrigHistStart+1){
818 fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
819 fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;
820 fCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
821 fMBTrigHist = (fBuffer & 0x00007fff);
823 fCPTInput[0] = (fBuffer & 0x00000080) >> 6; // MB bit
824 fCPTInput[1] = (fBuffer & 0x00400000) >> 21; // CENTRAL bit
827 else if(fPosition == fTrigHistStart+fTrigHistNWords){
828 fPileUpBit2ndWord = (fBuffer & 0x80000000) >> 31;
829 fL0Bit2ndWord = (fBuffer & 0x40000000) >> 30;
830 fSCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
831 fEMDTrigHist = (fBuffer & 0x00007fff);
833 fCPTInput[2] = (fBuffer & 0x00000080) >> 6; // SEMICENTRAL bit
834 fCPTInput[3] = (fBuffer & 0x00400000) >> 21; // EMD bit
836 fIsTriggerHistory = kFALSE;
838 // Checking if the event is good
839 // (1) both history word pile up bits must be = 0
840 if(fPileUpBit1stWord==0 && fPileUpBit2ndWord==0) fIsPileUpEvent = kFALSE;
842 fIsPileUpEvent = kTRUE;
843 printf(" AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
844 fPileUpBit1stWord, fPileUpBit2ndWord);
846 // (2) both history word L0 bits must be = 1
847 if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
849 fIsL0BitSet = kFALSE;
850 printf(" AliZDCRawStream -> L0 wrongly set: bitL0word0 %d bitL0word1 %d\n",
851 fL0Bit1stWord, fL0Bit2ndWord);
855 //printf(" AliZDCRawStream -> Trigger history word %d\n", fPosition-fTrigHistStart);
865 //_____________________________________________________________________________
866 AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri)
868 // Setting the storage
870 AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri);
876 //_____________________________________________________________________________
877 AliZDCChMap* AliZDCRawStream::GetChMap() const
880 // Getting calibration object for ZDC
882 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
883 if(!entry) AliFatal("No calibration data loaded!");
885 AliZDCChMap *calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
886 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");