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),
106 fIsZDCTDCHeader(kFALSE),
107 fIsTDCHeaderRead(kFALSE),
109 fIsADDChannel(kFALSE),
110 fIsADDTDCHeader(kFALSE),
111 fIsADDTDCdatum(kFALSE)
113 // Create an object to read ZDC raw digits
115 fRawReader->Select("ZDC");
118 for(Int_t i=0; i<kNch; i++){
119 for(Int_t j=0; j<5; j++){
121 if(i<32) fScalerMap[i][j]=-1;
125 for(Int_t k=0; k<4; k++) fCPTInput[k] = 0;
129 //_____________________________________________________________________________
130 AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
132 fRawReader(stream.fRawReader),
133 fBuffer(stream.GetRawBuffer()),
134 fReadOutCard(stream.GetReadOutCard()),
135 fEvType(stream.fEvType),
136 fPosition(stream.fPosition),
137 fIsCalib(stream.fIsCalib),
138 fIsDARCHeader(stream.fIsDARCHeader),
139 fIsHeaderMapping(stream.fIsHeaderMapping),
140 fIsChMapping(stream.fIsChMapping),
141 fIsADCDataWord(stream.fIsADCDataWord),
142 fIsADCHeader(stream.fIsADCHeader),
143 fIsADCEOB(stream.fIsADCEOB),
144 fSODReading(stream.fSODReading),
145 fIsMapRead(stream.fIsMapRead),
146 fDeadfaceOffset(stream.GetDeadfaceOffset()),
147 fDeadbeefOffset(stream.GetDeadbeefOffset()),
148 fDataOffset(stream.GetDataOffset()),
149 fModType(stream.GetModType()),
150 fADCModule(stream.GetADCModule()),
151 fADCNChannels(stream.GetADCNChannels()),
152 fADCChannel(stream.GetADCChannel()),
153 fADCValue(stream.GetADCValue()),
154 fADCGain(stream.GetADCGain()),
155 fIsUnderflow(stream.fIsUnderflow),
156 fIsOverflow(stream.fIsOverflow),
157 fScGeo(stream.GetScGeo()),
158 fScNWords(stream.GetScNWords()),
159 fScTriggerSource(stream.GetScTriggerSource()),
160 fScTriggerNumber(stream.fScTriggerNumber),
161 fIsScEventGood(stream.fIsScEventGood),
162 fIsScHeaderRead(stream.fIsScHeaderRead),
163 fScStartCounter(stream.fScStartCounter),
164 fScEvCounter(stream.fScEvCounter),
165 fIsScalerWord(stream.fIsScalerWord),
166 fDetPattern(stream.fDetPattern),
167 fTrigCountNWords(stream.fTrigCountNWords),
168 fIsTriggerScaler(stream.fIsTriggerScaler),
169 fTrigCountStart(stream.fTrigCountStart),
170 fMBTrigInput(stream.fMBTrigInput),
171 fCentralTrigInput(stream.fCentralTrigInput),
172 fSCentralTrigInput(stream.fSCentralTrigInput),
173 fEMDTrigInput(stream.fEMDTrigInput),
174 fL0Received(stream.fL0Received),
175 fMBtrig2CTP(stream.fMBtrig2CTP),
176 fCentralTrig2CTP(stream.fCentralTrig2CTP),
177 fSCentralTrig2CTP(stream.fSCentralTrig2CTP),
178 fEMDTrig2CTP(stream.fEMDTrig2CTP),
179 fTrigHistNWords(stream.fTrigHistNWords),
180 fIsTriggerHistory(stream.fIsTriggerHistory),
181 fTrigHistStart(stream.fTrigHistStart),
182 fPileUpBit1stWord(stream.fPileUpBit1stWord),
183 fL0Bit1stWord(stream.fL0Bit1stWord),
184 fCentralTrigHist(stream.fCentralTrigHist),
185 fMBTrigHist(stream.fMBTrigHist),
186 fPileUpBit2ndWord(stream.fPileUpBit2ndWord),
187 fL0Bit2ndWord(stream.fL0Bit2ndWord),
188 fSCentralTrigHist(stream.fSCentralTrigHist),
189 fEMDTrigHist(stream.fEMDTrigHist),
190 fNChannelsOn(stream.fNChannelsOn),
191 fCurrentCh(stream.fCurrentCh),
192 fCabledSignal(stream.GetCabledSignal()),
193 fCurrScCh(stream.fCurrScCh),
194 fIsADCEventGood(stream.fIsADCEventGood),
195 fIsL0BitSet(stream.fIsL0BitSet),
196 fIsPileUpEvent(stream.fIsPileUpEvent),
197 fIsZDCTDCHeader(stream.fIsZDCTDCHeader),
198 fIsTDCHeaderRead(stream.fIsTDCHeaderRead),
199 fTDCStartCounter(stream.fTDCStartCounter),
200 fIsADDChannel(stream.fIsADDChannel),
201 fIsADDTDCHeader(stream.fIsADDTDCHeader),
202 fIsADDTDCdatum(stream.fIsADDTDCdatum)
207 for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j);
208 for(Int_t i=0; i<kNch; i++){
209 for(Int_t j=0; j<5; j++){
210 fMapADC[i][j] = stream.fMapADC[i][j];
211 if(i<32) fScalerMap[i][j] = stream.fMapADC[i][j];
215 for(Int_t k=0; k<4; k++) fCPTInput[k] = stream.fCPTInput[k];
218 //_____________________________________________________________________________
219 AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream&
222 // Assignment operator
223 Fatal("operator =", "assignment operator not implemented");
227 //_____________________________________________________________________________
228 AliZDCRawStream::~AliZDCRawStream()
234 //_____________________________________________________________________________
235 void AliZDCRawStream::ReadChMap()
237 // Reading channel map
239 AliDebug(2,"\t Reading ZDC ADC mapping from OCDB\n");
240 AliZDCChMap * chMap = GetChMap();
242 for(Int_t i=0; i<kNch; i++){
243 fMapADC[i][0] = chMap->GetADCModule(i);
244 fMapADC[i][1] = chMap->GetADCChannel(i);
246 fMapADC[i][3] = chMap->GetDetector(i);
247 fMapADC[i][4] = chMap->GetSector(i);
252 //_____________________________________________________________________________
253 void AliZDCRawStream::ReadCDHHeader()
256 const AliRawDataHeader* header = fRawReader->GetDataHeader();
258 AliError(" No CDH in raw data streaming");
259 fRawReader->AddMajorErrorLog(kCDHError);
263 //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
265 UChar_t message = header->GetAttributes();
266 //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
268 if((message & 0xf0) == 0x0){ // PHYSICS RUN
269 //printf("\t PHYSICS RUN raw data found\n");
271 else if((message & 0xf0) == 0x10){ // COSMIC RUN
272 //printf("\t STANDALONE_COSMIC RUN raw data found\n");
274 else if((message & 0xf0) == 0x20){ // PEDESTAL RUN
275 //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
277 else if((message & 0xf0) == 0x30){ // LASER RUN
278 //printf("\t STANDALONE_LASER RUN raw data found\n");
280 else if((message & 0xf0) == 0x40){ // CALIBRATION_CENTRAL RUN
281 //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
283 else if((message & 0xf0) == 0x50){ // CALIBRATION_SEMICENTRAL
284 //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
286 else if((message & 0xf0) == 0x60){ // CALIBRATION_MB
287 //printf("\t CALIBRATION_MB RUN raw data found\n");
289 else if((message & 0xf0) == 0x70){ // CALIBRATION_EMD
290 //printf("\t CALIBRATION_EMD RUN raw data found\n");
292 // *** Checking the bit indicating the used readout card
293 // (the payload is different in the 2 cases!)
294 if((message & 0x08) == 0){ // ** DARC card
296 fIsDARCHeader = kTRUE;
297 //AliInfo("\t ZDC readout card used: DARC");
299 else if((message & 0x08) == 0x08){ // ** ZRC card
301 //AliInfo("\t ZDC readout card used: ZRC");
304 if(header->GetL1TriggerMessage() & 0x1){ // Calibration bit set in CDH
307 //printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
308 //printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);
310 /* UInt_t status = header->GetStatus();
311 //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status);
312 if((status & 0x000f) == 0x0001){
313 AliDebug(2,"CDH -> DARC trg0 overlap error");
314 fRawReader->AddMajorErrorLog(kDARCError);
316 if((status & 0x000f) == 0x0002){
317 AliDebug(2,"CDH -> DARC trg0 missing error");
318 fRawReader->AddMajorErrorLog(kDARCError);
320 if((status & 0x000f) == 0x0004){
321 AliDebug(2,"CDH -> DARC data parity error");
322 fRawReader->AddMajorErrorLog(kDARCError);
324 if((status & 0x000f) == 0x0008){
325 AliDebug(2,"CDH -> DARC ctrl parity error");
326 fRawReader->AddMajorErrorLog(kDARCError);
329 if((status & 0x00f0) == 0x0010){
330 AliDebug(2,"CDH -> DARC trg unavailable");
331 fRawReader->AddMajorErrorLog(kDARCError);
333 if((status & 0x00f0) == 0x0020){
334 AliDebug(2,"CDH -> DARC FEE error");
335 fRawReader->AddMajorErrorLog(kDARCError);
338 if((status & 0x0f00) == 0x0200){
339 AliDebug(2,"CDH -> DARC L1 time violation");
340 fRawReader->AddMajorErrorLog(kDARCError);
342 if((status & 0x0f00) == 0x0400){
343 AliDebug(2,"CDH -> DARC L2 time-out");
344 fRawReader->AddMajorErrorLog(kDARCError);
346 if((status & 0x0f00) == 0x0800){
347 AliDebug(2,"CDH -> DARC prepulse time violation");
348 fRawReader->AddMajorErrorLog(kDARCError);
351 if((status & 0xf000) == 0x1000){
352 AliDebug(2,"CDH -> DARC other error");
353 fRawReader->AddMajorErrorLog(kDARCError);
360 //_____________________________________________________________________________
361 Bool_t AliZDCRawStream::Next()
363 // Read the next raw digit
364 // Returns kFALSE if there is no digit left
366 if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
368 Int_t kFirstADCGeo=0, kLastADCGeo=3;
369 Int_t kADDADCGeo=5, kADDTDCGeo=6;
370 Int_t kZDCTDCGeo=8, kScalerGeo=16;
371 Int_t kPUGeo=29, kTrigScales=30, kTrigHistory=31;
373 fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE;
374 fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
375 fIsADDChannel = kFALSE; fIsADDTDCHeader= kFALSE; fIsADDTDCdatum=kFALSE;
376 fIsUnderflow = kFALSE; fIsOverflow = kFALSE; fIsScalerWord = kFALSE;
377 fSector[0] = fSector[1] = -1;
378 for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
380 fEvType = fRawReader->GetType();
382 //if(fEvType==7 || fEvType ==8){ //Physics or calibration event
385 fCurrentCh=0; fCurrScCh=0; fNChannelsOn=0;
387 //printf("\n AliZDCRawStream::Next() - ev. type %d",fEvType);
391 //printf("\n AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
393 // *** End of ZDC event
394 if(fBuffer == 0xcafefade){
395 //printf("\n AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
399 // -------------------------------------------
401 // -------------------------------------------
402 // If the CDH has been read then
403 // the DARC header must follow
404 if(fReadOutCard==0 && fIsDARCHeader){
405 //printf("\t ---- DARC header ----\n");
408 fDeadbeefOffset = 25;
414 fDataOffset = 1+fDeadbeefOffset;
415 fIsDARCHeader = kFALSE;
418 // ---------------------------------------------
419 // --- Start of data event (SOD) ---
420 // --- decoding mapping of connected ADC ch. ---
421 // ---------------------------------------------
422 // In the SOD event ADC ch. mapping is written
426 if(fPosition>=fDataOffset){
427 if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
428 // DARC 1st datum @ fDataOffset+1 \ ZRC 1st valid datum @ fDataOffset=0
429 if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){
430 printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
431 fCurrentCh=0; fCurrScCh=0;
434 printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
435 fSODReading = kFALSE;
439 else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
441 return kFALSE; // !!!!!!!!!!!!!!!!!!!!! For the moment thresholds are not read
443 else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
444 fIsHeaderMapping = kTRUE;
445 fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
446 fModType = ((fBuffer & 0x7ff00)>>8);
447 fADCNChannels = (fBuffer & 0xff); // # of channels following the header
449 printf(" ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
451 else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
452 fADCChannel = ((fBuffer & 0x3fff0000)>>16);
453 fCabledSignal = (fBuffer&0xffff);
455 if(fModType == kV965){ // ******** ADCs ********************************
457 if((fBuffer&0x40000000)>>30==0 && fADCModule<=kLastADCGeo){ // *ZDC* high range chain ADC
458 fIsChMapping = kTRUE;
459 fMapADC[fCurrentCh][0] = fADCModule;
460 fMapADC[fCurrentCh][1] = fADCChannel;
461 fMapADC[fCurrentCh][2] = fCabledSignal;
462 // - No. of channels on
465 // Determining detector and sector
466 // -----------------------------------------
467 // For the decoding of the following lines
468 // look the enum in AliZDCRawStream.h file
469 // -----------------------------------------
470 if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
471 || fCabledSignal==24 || fCabledSignal==48){
472 fMapADC[fCurrentCh][3] = 4; //ZNA
474 if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot) fMapADC[fCurrentCh][4]=0;
475 else if(fCabledSignal==3 || fCabledSignal==27) fMapADC[fCurrentCh][4]=1;
476 else if(fCabledSignal==4 || fCabledSignal==28) fMapADC[fCurrentCh][4]=2;
477 else if(fCabledSignal==5 || fCabledSignal==29) fMapADC[fCurrentCh][4]=3;
478 else if(fCabledSignal==6 || fCabledSignal==30) fMapADC[fCurrentCh][4]=4;
479 else if(fCabledSignal==24 || fCabledSignal==48) fMapADC[fCurrentCh][4]=5; //Reference PTM
481 else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
482 fMapADC[fCurrentCh][3] = 5; //ZPA
484 if(fCabledSignal==7 || fCabledSignal==31) fMapADC[fCurrentCh][4]=0;
485 else if(fCabledSignal==8 || fCabledSignal==32) fMapADC[fCurrentCh][4]=1;
486 else if(fCabledSignal==9 || fCabledSignal==33) fMapADC[fCurrentCh][4]=2;
487 else if(fCabledSignal==10 || fCabledSignal==34) fMapADC[fCurrentCh][4]=3;
488 else if(fCabledSignal==11 || fCabledSignal==35) fMapADC[fCurrentCh][4]=4;
490 else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
491 || fCabledSignal==25 || fCabledSignal==49){
492 fMapADC[fCurrentCh][3] = 1; //ZNC
494 if(fCabledSignal==12 || fCabledSignal==36) fMapADC[fCurrentCh][4]=0;
495 else if(fCabledSignal==13 || fCabledSignal==37) fMapADC[fCurrentCh][4]=1;
496 else if(fCabledSignal==14 || fCabledSignal==38) fMapADC[fCurrentCh][4]=2;
497 else if(fCabledSignal==15 || fCabledSignal==39) fMapADC[fCurrentCh][4]=3;
498 else if(fCabledSignal==16 || fCabledSignal==40) fMapADC[fCurrentCh][4]=4;
499 else if(fCabledSignal==25 || fCabledSignal==49) fMapADC[fCurrentCh][4]=5; //Reference PTM
501 else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
502 fMapADC[fCurrentCh][3] = 2; //ZPC
504 if(fCabledSignal==17 || fCabledSignal==41) fMapADC[fCurrentCh][4]=0;
505 else if(fCabledSignal==18 || fCabledSignal==42) fMapADC[fCurrentCh][4]=1;
506 else if(fCabledSignal==19 || fCabledSignal==43) fMapADC[fCurrentCh][4]=2;
507 else if(fCabledSignal==20 || fCabledSignal==44) fMapADC[fCurrentCh][4]=3;
508 else if(fCabledSignal==21 || fCabledSignal==45) fMapADC[fCurrentCh][4]=4;
510 else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
511 fMapADC[fCurrentCh][3] = 3; // ZEM
513 if(fCabledSignal==22 || fCabledSignal==46) fMapADC[fCurrentCh][4]=1;
514 else if(fCabledSignal==23 || fCabledSignal==47) fMapADC[fCurrentCh][4]=2;
517 //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
518 //printf(" det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
522 } // high range channels
523 }// ModType=1 (ADC mapping)
524 else if(fModType == kV830){ // ******** VME scaler **************************
525 fIsChMapping = kTRUE;
526 fScalerMap[fCurrScCh][0] = fADCModule;
527 fScalerMap[fCurrScCh][1] = fADCChannel;
528 fScalerMap[fCurrScCh][2] = fCabledSignal;
530 // Determining detector and sector
531 // -----------------------------------------
532 // For the decoding of the following lines
533 // look the enum in AliZDCRawStream.h file
534 // -----------------------------------------
535 // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
536 if((fCabledSignal>=2 && fCabledSignal<=6) ||
537 (fCabledSignal>=61 && fCabledSignal<=65)){
538 fScalerMap[fCurrScCh][3] = 4; //ZNA
540 if(fCabledSignal==2 || fCabledSignal==61) fScalerMap[fCurrScCh][4]=0;
541 else if(fCabledSignal==3 || fCabledSignal==62) fScalerMap[fCurrScCh][4]=1;
542 else if(fCabledSignal==4 || fCabledSignal==63) fScalerMap[fCurrScCh][4]=2;
543 else if(fCabledSignal==5 || fCabledSignal==64) fScalerMap[fCurrScCh][4]=3;
544 else if(fCabledSignal==6 || fCabledSignal==65) fScalerMap[fCurrScCh][4]=4;
546 else if((fCabledSignal>=7 && fCabledSignal<=11) ||
547 (fCabledSignal>=66 && fCabledSignal<=70)){
548 fScalerMap[fCurrScCh][3] = 5; //ZPA
550 if(fCabledSignal==7 || fCabledSignal==66) fScalerMap[fCurrScCh][4]=0;
551 else if(fCabledSignal==8 || fCabledSignal==67) fScalerMap[fCurrScCh][4]=1;
552 else if(fCabledSignal==9 || fCabledSignal==68) fScalerMap[fCurrScCh][4]=2;
553 else if(fCabledSignal==10 || fCabledSignal==69) fScalerMap[fCurrScCh][4]=3;
554 else if(fCabledSignal==11 || fCabledSignal==70) fScalerMap[fCurrScCh][4]=4;
556 else if((fCabledSignal>=12 && fCabledSignal<=16) ||
557 (fCabledSignal>=71 && fCabledSignal<=75)){
558 fScalerMap[fCurrScCh][3] = 1; //ZNC
560 if(fCabledSignal==12 || fCabledSignal==71) fScalerMap[fCurrScCh][4]=0;
561 else if(fCabledSignal==13 || fCabledSignal==72) fScalerMap[fCurrScCh][4]=1;
562 else if(fCabledSignal==14 || fCabledSignal==73) fScalerMap[fCurrScCh][4]=2;
563 else if(fCabledSignal==15 || fCabledSignal==74) fScalerMap[fCurrScCh][4]=3;
564 else if(fCabledSignal==16 || fCabledSignal==75) fScalerMap[fCurrScCh][4]=4;
566 else if((fCabledSignal>=17 && fCabledSignal<=21) ||
567 (fCabledSignal>=76 && fCabledSignal<=80)){
568 fScalerMap[fCurrScCh][3] = 2; //ZPC
570 if(fCabledSignal==17 || fCabledSignal==76) fScalerMap[fCurrScCh][4]=0;
571 else if(fCabledSignal==18 || fCabledSignal==77) fScalerMap[fCurrScCh][4]=1;
572 else if(fCabledSignal==19 || fCabledSignal==78) fScalerMap[fCurrScCh][4]=2;
573 else if(fCabledSignal==20 || fCabledSignal==79) fScalerMap[fCurrScCh][4]=3;
574 else if(fCabledSignal==21 || fCabledSignal==80) fScalerMap[fCurrScCh][4]=4;
576 else if(fCabledSignal==22 || fCabledSignal==23 ||
577 fCabledSignal==81 || fCabledSignal==82){
578 fScalerMap[fCurrScCh][3] = 3; // ZEM
580 if(fCabledSignal==22 || fCabledSignal==81) fScalerMap[fCurrScCh][4]=1;
581 else if(fCabledSignal==23 || fCabledSignal==82) fScalerMap[fCurrScCh][4]=2;
584 //printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
585 //if(fCabledSignal!=0 && fCabledSignal!=1) printf(" det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
586 //else printf(" Signal void/not connected\n");
590 /*else if(fModType == kTRG){ // **** scalers from trigger card
591 //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
593 else if(fModType == kTRGI){ // **** trigger history from trigger card
594 //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
596 else if(fModType == kPU){ // **** pattern unit
597 //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
599 }//reading channel mapping
604 } // ------------------------------- SOD event
606 // -------------------------------------------
608 // -------------------------------------------
609 if(fPosition<fDeadfaceOffset && fReadOutCard==0){
613 else if(fPosition==fDeadfaceOffset && fReadOutCard==0){
614 if(fBuffer != 0xdeadface){
615 //AliWarning(" NO deadface after DARC data");
616 fRawReader->AddMajorErrorLog(kDARCError);
623 else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){
627 else if(fPosition==fDeadbeefOffset && fReadOutCard==0){
628 if(fBuffer != 0xdeadbeef){
629 //AliWarning(" NO deadbeef after DARC global data");
630 fRawReader->AddMajorErrorLog(kDARCError);
638 } // ------------------------------- End of DARC data
640 // ---------------------------------------------
642 // --- ADCs + VME scaler + trigger card + P.U.
643 // ---------------------------------------------
644 else if(fPosition>=fDataOffset){
646 //printf("AliZDCRawStream: fSODReading = %d\n", fSODReading);
647 if(!fSODReading && !fIsMapRead) ReadChMap();
649 // !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!!
650 // Not valid datum before the event
651 // there MUST be a NOT valid datum before the event!!!
653 if(fPosition==fDataOffset){
654 //printf("\t **** ZDC data begin ****\n");
655 if((fBuffer & 0x07000000) != 0x06000000){
656 fRawReader->AddMajorErrorLog(kZDCDataError);
658 else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
659 fIsADCEventGood = kFALSE;
663 // If the not valid datum isn't followed by the 1st ADC header
664 // the event is corrupted (i.e., 2 gates arrived before trigger)
665 else if(fPosition==fDataOffset+1){
666 if((fBuffer & 0x07000000) != 0x02000000){
667 AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
668 fRawReader->AddMajorErrorLog(kZDCDataError);
669 fIsADCEventGood = kFALSE;
676 // Get geo address of current word
677 fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
678 if(fIsTDCHeaderRead)fADCModule = kZDCTDCGeo;
680 // ************************************ ADC MODULES ************************************
681 if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo){
683 if((fBuffer & 0x07000000) == 0x02000000){
684 fIsADCHeader = kTRUE;
685 fADCNChannels = ((fBuffer & 0x00003f00)>>8);
686 //printf(" AliZDCRawStream -> ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
689 else if((fBuffer & 0x07000000) == 0x00000000){
690 fIsADCDataWord = kTRUE;
691 fADCChannel = ((fBuffer & 0x1e0000) >> 17);
692 fADCGain = ((fBuffer & 0x10000) >> 16);
693 fADCValue = (fBuffer & 0xfff);
695 //printf(" AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n",
696 // fADCModule,fADCChannel,fADCGain,fADCValue);
698 // Checking if the channel map for the ADCs has been provided/read
699 if(fMapADC[0][0]==-1){
700 printf("\t ATTENTION!!! No ADC mapping has been found/provided!!!\n");
704 /*for(Int_t ci=0; ci<kNch; ci++){
705 printf(" %d mod %d ch %d det %d sec %d\n",ci,fMapADC[ci][0],
706 fMapADC[ci][1], fMapADC[ci][3], fMapADC[ci][4]);
709 // Scan of the map to assign the correct volumes
710 Int_t foundMapEntry = kFALSE;
711 for(Int_t k=0; k<kNch; k++){
712 if(fADCModule==fMapADC[k][0] && fADCChannel==fMapADC[k][1]){
713 fSector[0] = fMapADC[k][3];
714 fSector[1] = fMapADC[k][4];
715 foundMapEntry = kTRUE;
719 if(foundMapEntry==kFALSE){
720 AliWarning(Form(" No valid entry in ADC mapping for raw data %d ADCmod. %d ch. %d\n",
721 fPosition,fADCModule,fADCChannel));
724 //printf("AliZDCRawStream -> ADCmod. %d ch. %d -> det %d sec %d\n",
725 // fADCModule,fADCChannel,fSector[0],fSector[1]);
728 if(foundMapEntry==kTRUE){
729 if(fSector[0]<1 || fSector[0]>5){
730 AliWarning(Form(" No valid detector assignment: %d",fSector[0]));
731 fRawReader->AddMajorErrorLog(kInvalidSector);
734 if(fSector[1]<0 || fSector[1]>5){
735 AliWarning(Form(" No valid sector assignment: %d",fSector[1]));
736 fRawReader->AddMajorErrorLog(kInvalidSector);
739 if(fADCModule<0 || fADCModule>3){
740 AliError(Form(" No valid ADC module: %d",fADCModule));
741 fRawReader->AddMajorErrorLog(kInvalidADCModule);
745 // Checking the underflow and overflow bits
746 if(fBuffer & 0x1000) fIsUnderflow = kTRUE;
747 else if (fBuffer & 0x2000) fIsOverflow = kTRUE;
751 else if((fBuffer & 0x07000000) == 0x04000000){
753 //printf(" AliZDCRawStream -> EOB --------------------------\n");
756 // ********************************* ADD ADC *********************************
757 else if(fADCModule == kADDADCGeo){
759 if((fBuffer & 0x07000000) == 0x02000000){
760 fIsADCHeader = kTRUE;
761 fADCNChannels = ((fBuffer & 0x00003f00)>>8);
762 //printf(" AliZDCRawStream -> ADD ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
765 else if((fBuffer & 0x07000000) == 0x00000000){
766 fIsADDChannel = kTRUE;
767 fADCChannel = ((fBuffer & 0x1e0000) >> 17);
768 fADCGain = ((fBuffer & 0x10000) >> 16);
769 fADCValue = (fBuffer & 0xfff);
771 //printf(" ADD ADC DATUM -> mod. %d ch. %d gain %d value %d\n",
772 // fADCModule,fADCChannel,fADCGain,fADCValue);
775 else if((fBuffer & 0x07000000) == 0x04000000){
777 //printf(" AliZDCRawStream -> EOB --------------------------\n");
780 // ********************************* ZDC TDC *********************************
781 else if(fADCModule==kZDCTDCGeo && fIsTDCHeaderRead==kFALSE){
782 fIsZDCTDCHeader = kTRUE;
783 fIsTDCHeaderRead = kTRUE;
784 fTDCStartCounter = fPosition;
786 //printf(" AliZDCRawStream -> ZDC TDC: mod.%d\n",fADCModule);
788 // ********************************* ADD TDC *********************************
789 else if(fADCModule == kADDTDCGeo){
791 if((fBuffer & 0x07000000) == 0x02000000){
792 fIsADDTDCHeader = kTRUE;
793 fADCNChannels = ((fBuffer & 0x00003f00)>>8);
794 //printf(" AliZDCRawStream -> ADD TDC: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
797 else if((fBuffer & 0x07000000) == 0x00000000){
798 fIsADDTDCdatum = kTRUE;
801 if((fBuffer & 0x07000000) == 0x04000000){
803 //printf(" AliZDCRawStream -> ADD TDC EOB\n");
806 // ********************************* VME SCALER HEADER *********************************
807 else if(fADCModule == kScalerGeo){
808 if(fBuffer & 0x04000000 && fIsScHeaderRead==kFALSE){ // *** Scaler header
809 fScGeo = (fBuffer & 0xf8000000)>>27;
810 fScNWords = (fBuffer & 0x00fc0000)>>18;
811 fScTriggerSource = (fBuffer & 0x00030000)>>16;
812 fScTriggerNumber = (fBuffer & 0x0000ffff);
813 fIsScHeaderRead = kTRUE;
814 fScStartCounter = fPosition;
816 //printf(" AliZDCRawStream -> VME SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n",
817 // fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber);
819 else if(!(fBuffer & 0x04000000)){
820 fIsScEventGood = kFALSE;
823 // *********************************** PATTERN UNIT ***********************************
824 else if(fADCModule == kPUGeo){
825 // still to be implemented!!! Not yet in data!!!
826 fDetPattern = (fBuffer & 0x0000003f);
828 //printf(" AliZDCRawStream -> Pattern Unit\n");
831 // ******************************** TRIGGER CARD COUNTS ********************************
832 else if(fADCModule == kTrigScales){
833 if(fIsTriggerScaler == kFALSE){
834 fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
835 fTrigCountStart = fPosition;
836 fIsTriggerScaler = kTRUE;
839 //printf(" AliZDCRawStream -> Trigger Scaler header\n");
841 // ********************************** TRIGGER HISTORY **********************************
842 else if(fADCModule == kTrigHistory){
843 if(fIsTriggerHistory == kFALSE){
844 fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
845 fTrigHistStart = fPosition;
846 fIsTriggerHistory = kTRUE;
849 //printf(" AliZDCRawStream -> Trigger History header\n");
852 // ********************************** VME SCALER DATA **********************************
853 // Reading VME scaler data
854 if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
855 fADCModule=kScalerGeo; fIsADCDataWord=kFALSE; fIsScalerWord=kTRUE;
856 fScEvCounter = fBuffer;
857 Int_t nWords = (Int_t) (fScNWords);
858 if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
860 //printf(" AliZDCRawStream -> scaler datum %d", fScEvCounter);
862 // ********************************** ZDC TDC DATA **********************************
864 if(fIsTDCHeaderRead && fPosition>=fTDCStartCounter+1){
865 fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
866 //printf(" AliZDCRawStream -> ...skipping ZDC TDC datum\n");
867 // For the moment we skip the TDC data
868 if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
869 fIsTDCHeaderRead = kFALSE;
871 //printf(" AliZDCRawStream -> ZDC TDC trailer\n");
874 // ******************************** TRIGGER SCALER DATA ********************************
875 // Reading trigger scaler data
876 if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
877 fADCModule = kTrigScales; fIsADCDataWord = kFALSE;
878 if(fPosition == fTrigCountStart+1) fMBTrigInput = fBuffer;
879 else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;
880 else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
881 else if(fPosition == fTrigCountStart+4) fEMDTrigInput = fBuffer;
882 else if(fPosition == fTrigCountStart+5) fL0Received = fBuffer;
883 else if(fPosition == fTrigCountStart+6) fMBtrig2CTP = fBuffer;
884 else if(fPosition == fTrigCountStart+7) fCentralTrig2CTP = fBuffer;
885 else if(fPosition == fTrigCountStart+8) fSCentralTrig2CTP = fBuffer;
886 else if(fPosition == fTrigCountStart+9){
887 fEMDTrig2CTP = fBuffer;
888 fIsTriggerScaler = kFALSE;
891 //printf(" AliZDCRawStream -> Trigger Scaler datum %d\n", fPosition-fTrigCountStart);
893 // ******************************* TRIGGER HISTORY WORDS ******************************
894 // Reading trigger history
895 if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
896 fADCModule = kTrigHistory; fIsADCDataWord = kFALSE;
897 if(fPosition == fTrigHistStart+1){
898 fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
899 fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;
900 fCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
901 fMBTrigHist = (fBuffer & 0x00007fff);
903 fCPTInput[0] = (fBuffer & 0x00000080) >> 6; // MB bit
904 fCPTInput[1] = (fBuffer & 0x00400000) >> 21; // CENTRAL bit
907 else if(fPosition == fTrigHistStart+fTrigHistNWords){
908 fPileUpBit2ndWord = (fBuffer & 0x80000000) >> 31;
909 fL0Bit2ndWord = (fBuffer & 0x40000000) >> 30;
910 fSCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
911 fEMDTrigHist = (fBuffer & 0x00007fff);
913 fCPTInput[2] = (fBuffer & 0x00000080) >> 6; // SEMICENTRAL bit
914 fCPTInput[3] = (fBuffer & 0x00400000) >> 21; // EMD bit
916 fIsTriggerHistory = kFALSE;
918 // Checking if the event is good
919 // (1) both history word pile up bits must be = 0
920 if(fPileUpBit1stWord==0 && fPileUpBit2ndWord==0) fIsPileUpEvent = kFALSE;
922 fIsPileUpEvent = kTRUE;
923 printf(" AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
924 fPileUpBit1stWord, fPileUpBit2ndWord);
926 // (2) both history word L0 bits must be = 1
927 if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
929 fIsL0BitSet = kFALSE;
930 printf(" AliZDCRawStream -> L0 wrongly set: bitL0word0 %d bitL0word1 %d\n",
931 fL0Bit1stWord, fL0Bit2ndWord);
935 //printf(" AliZDCRawStream -> Trigger history word %d\n", fPosition-fTrigHistStart);
945 //_____________________________________________________________________________
946 AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri)
948 // Setting the storage
950 AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri);
956 //_____________________________________________________________________________
957 AliZDCChMap* AliZDCRawStream::GetChMap() const
960 // Getting calibration object for ZDC
962 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
963 if(!entry) AliFatal("No calibration data loaded!");
965 AliZDCChMap *calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
966 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");