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),
71 fIsScEventGood(kTRUE),
72 fIsScHeaderRead(kFALSE),
75 fIsScalerWord(kFALSE),
78 fIsTriggerScaler(kFALSE),
82 fSCentralTrigInput(0),
90 fIsTriggerHistory(kFALSE),
105 fIsADCEventGood(kTRUE),
107 fIsPileUpEvent(kFALSE),
108 fIsADDChannel(kFALSE),
110 fIsTDCHeaderRead(kFALSE),
112 fIsZDCTDCHeader(kFALSE),
113 fIsZDCTDCdatum(kFALSE),
115 fIsADDTDCHeader(kFALSE),
116 fIsADDTDCdatum(kFALSE),
119 // Create an object to read ZDC raw digits
121 fRawReader->Select("ZDC");
124 for(Int_t i=0; i<kNch; i++){
125 for(Int_t j=0; j<5; j++){
129 if(j<3) fTDCMap[i][j]=-1;
134 for(Int_t k=0; k<4; k++) fCPTInput[k] = 0;
138 //_____________________________________________________________________________
139 AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& 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)
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];
229 for(Int_t k=0; k<4; k++) fCPTInput[k] = stream.fCPTInput[k];
232 //_____________________________________________________________________________
233 AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream&
236 // Assignment operator
237 Fatal("operator =", "assignment operator not implemented");
241 //_____________________________________________________________________________
242 AliZDCRawStream::~AliZDCRawStream()
248 //_____________________________________________________________________________
249 void AliZDCRawStream::ReadChMap()
251 // Reading channel map
253 AliDebug(2,"\t Reading ZDC ADC mapping from OCDB\n");
254 AliZDCChMap * chMap = GetChMap();
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);
266 //_____________________________________________________________________________
267 void AliZDCRawStream::ReadCDHHeader()
270 const AliRawDataHeader* header = fRawReader->GetDataHeader();
272 AliError(" No CDH in raw data streaming");
273 fRawReader->AddMajorErrorLog(kCDHError);
277 //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
279 UChar_t message = header->GetAttributes();
280 //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
282 if((message & 0xf0) == 0x0){ // PHYSICS RUN
283 //printf("\t PHYSICS RUN raw data found\n");
285 else if((message & 0xf0) == 0x10){ // COSMIC RUN
286 //printf("\t STANDALONE_COSMIC RUN raw data found\n");
288 else if((message & 0xf0) == 0x20){ // PEDESTAL RUN
289 //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
291 else if((message & 0xf0) == 0x30){ // LASER RUN
292 //printf("\t STANDALONE_LASER RUN raw data found\n");
294 else if((message & 0xf0) == 0x40){ // CALIBRATION_CENTRAL RUN
295 //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
297 else if((message & 0xf0) == 0x50){ // CALIBRATION_SEMICENTRAL
298 //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
300 else if((message & 0xf0) == 0x60){ // CALIBRATION_MB
301 //printf("\t CALIBRATION_MB RUN raw data found\n");
303 else if((message & 0xf0) == 0x70){ // CALIBRATION_EMD
304 //printf("\t CALIBRATION_EMD RUN raw data found\n");
306 // *** Checking the bit indicating the used readout card
307 // (the payload is different in the 2 cases!)
308 if((message & 0x08) == 0){ // ** DARC card
310 fIsDARCHeader = kTRUE;
311 //AliInfo("\t ZDC readout card used: DARC");
313 else if((message & 0x08) == 0x08){ // ** ZRC card
315 //AliInfo("\t ZDC readout card used: ZRC");
318 if(header->GetL1TriggerMessage() & 0x1){ // Calibration bit set in CDH
321 //printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
322 //printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);
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);
330 if((status & 0x000f) == 0x0002){
331 AliDebug(2,"CDH -> DARC trg0 missing error");
332 fRawReader->AddMajorErrorLog(kDARCError);
334 if((status & 0x000f) == 0x0004){
335 AliDebug(2,"CDH -> DARC data parity error");
336 fRawReader->AddMajorErrorLog(kDARCError);
338 if((status & 0x000f) == 0x0008){
339 AliDebug(2,"CDH -> DARC ctrl parity error");
340 fRawReader->AddMajorErrorLog(kDARCError);
343 if((status & 0x00f0) == 0x0010){
344 AliDebug(2,"CDH -> DARC trg unavailable");
345 fRawReader->AddMajorErrorLog(kDARCError);
347 if((status & 0x00f0) == 0x0020){
348 AliDebug(2,"CDH -> DARC FEE error");
349 fRawReader->AddMajorErrorLog(kDARCError);
352 if((status & 0x0f00) == 0x0200){
353 AliDebug(2,"CDH -> DARC L1 time violation");
354 fRawReader->AddMajorErrorLog(kDARCError);
356 if((status & 0x0f00) == 0x0400){
357 AliDebug(2,"CDH -> DARC L2 time-out");
358 fRawReader->AddMajorErrorLog(kDARCError);
360 if((status & 0x0f00) == 0x0800){
361 AliDebug(2,"CDH -> DARC prepulse time violation");
362 fRawReader->AddMajorErrorLog(kDARCError);
365 if((status & 0xf000) == 0x1000){
366 AliDebug(2,"CDH -> DARC other error");
367 fRawReader->AddMajorErrorLog(kDARCError);
374 //_____________________________________________________________________________
375 Bool_t AliZDCRawStream::Next()
377 // Read the next raw digit
378 // Returns kFALSE if there is no digit left
380 if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
383 fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE;
384 fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
385 fIsZDCTDCdatum = kFALSE; fIsADDChannel = kFALSE; fIsADDTDCdatum=kFALSE;
386 fIsUnderflow = kFALSE; fIsOverflow = kFALSE; fIsScalerWord = kFALSE;
387 fSector[0] = fSector[1] = -1;
388 for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
390 fEvType = fRawReader->GetType();
393 // Needed to read simulated raw data (temporary solution?)
394 if(!fReadCDH) fReadOutCard=1;
395 fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;fNChannelsOn=0;
397 //printf("\n AliZDCRawStream::Next() - ev. type %d",fEvType);
400 //printf("\n AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
402 // *** End of ZDC event
403 if(fBuffer == 0xcafefade){
404 //printf("\n AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
408 // -------------------------------------------
410 // -------------------------------------------
411 // If the CDH has been read then
412 // the DARC header must follow
413 if(fReadOutCard==0 && fIsDARCHeader){
414 //printf("\t ---- DARC header ----\n");
417 fDeadbeefOffset = 25;
423 fDataOffset = 1+fDeadbeefOffset;
424 fIsDARCHeader = kFALSE;
427 // ---------------------------------------------
428 // --- Start of data event (SOD) ---
429 // --- decoding mapping of connected ADC ch. ---
430 // ---------------------------------------------
431 // In the SOD event ADC ch. mapping is written
435 if(fPosition>=fDataOffset){
436 if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
437 // DARC 1st datum @ fDataOffset+1 \ ZRC 1st valid datum @ fDataOffset=0
438 if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){
439 printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
440 fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;
443 printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
444 fSODReading = kFALSE;
448 else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
450 return kFALSE; // !!!!!!!!!!!!!!!!!!!!! For the moment thresholds are not read
452 else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
453 fIsHeaderMapping = kTRUE;
454 fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
455 fModType = ((fBuffer & 0x7ff00)>>8);
456 fADCNChannels = (fBuffer & 0xff); // # of channels following the header
458 printf(" ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
460 else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
461 fADCChannel = ((fBuffer & 0x3fff0000)>>16);
462 fCabledSignal = (fBuffer&0xffff);
464 if(fModType == kV965){ // ******** ADCs ********************************
466 if((fBuffer&0x40000000)>>30==0 && fADCModule<=kLastADCGeo){ // *ZDC* high range chain ADC
467 fIsChMapping = kTRUE;
468 fMapADC[fCurrentCh][0] = fADCModule;
469 fMapADC[fCurrentCh][1] = fADCChannel;
470 fMapADC[fCurrentCh][2] = fCabledSignal;
471 // - No. of channels on
474 // Determining detector and sector
475 // -----------------------------------------
476 // For the decoding of the following lines
477 // look the enum in AliZDCRawStream.h file
478 // -----------------------------------------
479 if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
480 || fCabledSignal==24 || fCabledSignal==48){
481 fMapADC[fCurrentCh][3] = 4; //ZNA
483 if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot) fMapADC[fCurrentCh][4]=0;
484 else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1oot) fMapADC[fCurrentCh][4]=1;
485 else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2oot) fMapADC[fCurrentCh][4]=2;
486 else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3oot) fMapADC[fCurrentCh][4]=3;
487 else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4oot) fMapADC[fCurrentCh][4]=4;
488 else if(fCabledSignal==kZDCAMon || fCabledSignal==kZDCAMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
490 else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
491 fMapADC[fCurrentCh][3] = 5; //ZPA
493 if(fCabledSignal==kZPAC || fCabledSignal==kZPACoot) fMapADC[fCurrentCh][4]=0;
494 else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1oot) fMapADC[fCurrentCh][4]=1;
495 else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2oot) fMapADC[fCurrentCh][4]=2;
496 else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3oot) fMapADC[fCurrentCh][4]=3;
497 else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4oot) fMapADC[fCurrentCh][4]=4;
499 else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
500 || fCabledSignal==25 || fCabledSignal==49){
501 fMapADC[fCurrentCh][3] = 1; //ZNC
503 if(fCabledSignal==kZNCC || fCabledSignal==kZNCCoot) fMapADC[fCurrentCh][4]=0;
504 else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1oot) fMapADC[fCurrentCh][4]=1;
505 else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2oot) fMapADC[fCurrentCh][4]=2;
506 else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3oot) fMapADC[fCurrentCh][4]=3;
507 else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4oot) fMapADC[fCurrentCh][4]=4;
508 else if(fCabledSignal==kZDCCMon || fCabledSignal==kZDCCMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
510 else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
511 fMapADC[fCurrentCh][3] = 2; //ZPC
513 if(fCabledSignal==kZPCC || fCabledSignal==kZPCCoot) fMapADC[fCurrentCh][4]=0;
514 else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1oot) fMapADC[fCurrentCh][4]=1;
515 else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2oot) fMapADC[fCurrentCh][4]=2;
516 else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3oot) fMapADC[fCurrentCh][4]=3;
517 else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4oot) fMapADC[fCurrentCh][4]=4;
519 else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
520 fMapADC[fCurrentCh][3] = 3; // ZEM
522 if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1oot) fMapADC[fCurrentCh][4]=1;
523 else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2oot) fMapADC[fCurrentCh][4]=2;
526 //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
527 //printf(" det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
531 } // high range channels
532 }// ModType=1 (ADC mapping)
533 else if(fModType == kV830){ // ******** VME scaler **************************
534 fIsChMapping = kTRUE;
535 fScalerMap[fCurrScCh][0] = fADCModule;
536 fScalerMap[fCurrScCh][1] = fADCChannel;
537 fScalerMap[fCurrScCh][2] = fCabledSignal;
539 // Determining detector and sector
540 // -----------------------------------------
541 // For the decoding of the following lines
542 // look the enum in AliZDCRawStream.h file
543 // -----------------------------------------
544 // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
545 if((fCabledSignal>=2 && fCabledSignal<=6) ||
546 (fCabledSignal>=61 && fCabledSignal<=65)){
547 fScalerMap[fCurrScCh][3] = 4; //ZNA
549 if(fCabledSignal==kZNAC || fCabledSignal==kZNACD) fScalerMap[fCurrScCh][4]=0;
550 else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1D) fScalerMap[fCurrScCh][4]=1;
551 else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2D) fScalerMap[fCurrScCh][4]=2;
552 else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3D) fScalerMap[fCurrScCh][4]=3;
553 else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4D) fScalerMap[fCurrScCh][4]=4;
555 else if((fCabledSignal>=7 && fCabledSignal<=11) ||
556 (fCabledSignal>=66 && fCabledSignal<=70)){
557 fScalerMap[fCurrScCh][3] = 5; //ZPA
559 if(fCabledSignal==kZPAC || fCabledSignal==kZPACD) fScalerMap[fCurrScCh][4]=0;
560 else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1D) fScalerMap[fCurrScCh][4]=1;
561 else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2D) fScalerMap[fCurrScCh][4]=2;
562 else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3D) fScalerMap[fCurrScCh][4]=3;
563 else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4D) fScalerMap[fCurrScCh][4]=4;
565 else if((fCabledSignal>=12 && fCabledSignal<=16) ||
566 (fCabledSignal>=71 && fCabledSignal<=75)){
567 fScalerMap[fCurrScCh][3] = 1; //ZNC
569 if(fCabledSignal==kZNCC || fCabledSignal==kZNCCD) fScalerMap[fCurrScCh][4]=0;
570 else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1D) fScalerMap[fCurrScCh][4]=1;
571 else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2D) fScalerMap[fCurrScCh][4]=2;
572 else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3D) fScalerMap[fCurrScCh][4]=3;
573 else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4D) fScalerMap[fCurrScCh][4]=4;
575 else if((fCabledSignal>=17 && fCabledSignal<=21) ||
576 (fCabledSignal>=76 && fCabledSignal<=80)){
577 fScalerMap[fCurrScCh][3] = 2; //ZPC
579 if(fCabledSignal==kZPCC || fCabledSignal==kZPCCD) fScalerMap[fCurrScCh][4]=0;
580 else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1D) fScalerMap[fCurrScCh][4]=1;
581 else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2D) fScalerMap[fCurrScCh][4]=2;
582 else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3D) fScalerMap[fCurrScCh][4]=3;
583 else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4D) fScalerMap[fCurrScCh][4]=4;
585 else if(fCabledSignal==22 || fCabledSignal==23 ||
586 fCabledSignal==81 || fCabledSignal==82){
587 fScalerMap[fCurrScCh][3] = 3; // ZEM
589 if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1D) fScalerMap[fCurrScCh][4]=1;
590 else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2D) fScalerMap[fCurrScCh][4]=2;
593 /*printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
594 if(fCabledSignal!=0 && fCabledSignal!=1) printf(" det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
595 else printf(" Signal void/not connected\n");*/
599 else if(fModType==KV1290 && fADCModule==kZDCTDCGeo){ // ******** ZDC TDC **************************
600 fIsChMapping = kTRUE;
601 fTDCMap[fCurrTDCCh][0] = fADCModule;
602 fTDCMap[fCurrTDCCh][1] = fADCChannel;
603 fTDCMap[fCurrTDCCh][2] = fCabledSignal;
608 //printf("\tZDC TDC: mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
610 /*else if(fModType == kTRG){ // **** scalers from trigger card
611 //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
613 else if(fModType == kTRGI){ // **** trigger history from trigger card
614 //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
616 else if(fModType == kPU){ // **** pattern unit
617 //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
619 }//reading channel mapping
624 } // ------------------------------- SOD event
626 // -------------------------------------------
628 // -------------------------------------------
629 if(fPosition<fDeadfaceOffset && fReadOutCard==0){
633 else if(fPosition==fDeadfaceOffset && fReadOutCard==0){
634 if(fBuffer != 0xdeadface){
635 //AliWarning(" NO deadface after DARC data");
636 fRawReader->AddMajorErrorLog(kDARCError);
643 else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){
647 else if(fPosition==fDeadbeefOffset && fReadOutCard==0){
648 if(fBuffer != 0xdeadbeef){
649 //AliWarning(" NO deadbeef after DARC global data");
650 fRawReader->AddMajorErrorLog(kDARCError);
658 } // ------------------------------- End of DARC data
660 // ---------------------------------------------
662 // --- ADCs + VME scaler + trigger card + P.U.
663 // ---------------------------------------------
664 else if(fPosition>=fDataOffset){
666 if(!fSODReading && !fIsMapRead) ReadChMap();
668 // !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!!
669 // Not valid datum before the event
670 // there MUST be a NOT valid datum before the event!!!
672 if(fPosition==fDataOffset){
673 //printf("\t **** ZDC data begin ****\n");
674 if((fBuffer & 0x07000000) != 0x06000000){
675 fRawReader->AddMajorErrorLog(kZDCDataError);
677 //else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
678 // fIsADCEventGood = kFALSE;
682 // If the not valid datum isn't followed by the 1st ADC header
683 // the event is corrupted (i.e., 2 gates arrived before trigger)
684 else if(fPosition==fDataOffset+1){
685 if((fBuffer & 0x07000000) != 0x02000000){
686 AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
687 fRawReader->AddMajorErrorLog(kZDCDataError);
688 fIsADCEventGood = kFALSE;
695 // Get geo address of current word
696 if(fIsTDCHeaderRead && fIsZDCTDCHeader) fADCModule = kZDCTDCGeo;
697 else if(fIsTDCHeaderRead && fIsADDTDCHeader) fADCModule = kADDTDCGeo;
698 else fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
700 // ************************************ ADC MODULES ************************************
701 if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo){
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);
709 else if((fBuffer & 0x07000000) == 0x00000000){
710 fIsADCDataWord = kTRUE;
711 fADCChannel = ((fBuffer & 0x1e0000) >> 17);
712 fADCGain = ((fBuffer & 0x10000) >> 16);
713 fADCValue = (fBuffer & 0xfff);
715 //printf(" AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n",
716 // fADCModule,fADCChannel,fADCGain,fADCValue);
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");
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]);
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;
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));
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);
751 if(fSector[1]<0 || fSector[1]>5){
752 AliWarning(Form(" No valid sector assignment: %d",fSector[1]));
753 fRawReader->AddMajorErrorLog(kInvalidSector);
756 if(fADCModule<0 || fADCModule>3){
757 AliError(Form(" No valid ADC module: %d",fADCModule));
758 fRawReader->AddMajorErrorLog(kInvalidADCModule);
762 // Checking the underflow and overflow bits
763 if(fBuffer & 0x1000) fIsUnderflow = kTRUE;
764 else if (fBuffer & 0x2000) fIsOverflow = kTRUE;
768 else if((fBuffer & 0x07000000) == 0x04000000){
770 //printf(" AliZDCRawStream -> EOB --------------------------\n");
773 // ********************************* ADD ADC *********************************
774 else if(fADCModule == kADDADCGeo){
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);
782 else if((fBuffer & 0x07000000) == 0x00000000){
783 fIsADDChannel = kTRUE;
784 fADCChannel = ((fBuffer & 0x1e0000) >> 17);
785 fADCGain = ((fBuffer & 0x10000) >> 16);
786 fADCValue = (fBuffer & 0xfff);
788 //printf(" ADD ADC DATUM -> mod. %d ch. %d gain %d value %d\n",
789 // fADCModule,fADCChannel,fADCGain,fADCValue);
792 else if((fBuffer & 0x07000000) == 0x04000000){
794 //printf(" AliZDCRawStream -> EOB --------------------------\n");
797 // ********************************* TDC *********************************
798 else if(fADCModule==kTDCFakeGeo && fIsTDCHeaderRead==kFALSE){
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;
807 //printf(" AliZDCRawStream -> ZDC TDC: mod.%d\n",fADCModule);
809 else if(fADCModule==kADDTDCGeo){ // *** ADD TDC
810 fIsADDTDCHeader = kTRUE;
812 //printf(" AliZDCRawStream -> ADD TDC: mod.%d\n",fADCModule);
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;
825 //printf(" AliZDCRawStream -> VME SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n",
826 // fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber);
828 else if(!(fBuffer & 0x04000000)){
829 fIsScEventGood = kFALSE;
832 // *********************************** PATTERN UNIT ***********************************
833 else if(fADCModule == kPUGeo){
834 // still to be implemented!!! Not yet in data!!!
835 fDetPattern = (fBuffer & 0x0000003f);
837 //printf(" AliZDCRawStream -> Pattern Unit\n");
840 // ******************************** TRIGGER CARD COUNTS ********************************
841 else if(fADCModule == kTrigScales){
842 if(fIsTriggerScaler == kFALSE){
843 fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
844 fTrigCountStart = fPosition;
845 fIsTriggerScaler = kTRUE;
848 //printf(" AliZDCRawStream -> Trigger Scaler header\n");
850 // ********************************** TRIGGER HISTORY **********************************
851 else if(fADCModule == kTrigHistory){
852 if(fIsTriggerHistory == kFALSE){
853 fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
854 fTrigHistStart = fPosition;
855 fIsTriggerHistory = kTRUE;
858 //printf(" AliZDCRawStream -> Trigger History header\n");
861 // ********************************** VME SCALER DATA **********************************
862 // Reading VME scaler data
863 if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
864 fADCModule=kScalerGeo; fIsADCDataWord=kFALSE; fIsScalerWord=kTRUE;
865 fScEvCounter = fBuffer;
866 Int_t nWords = (Int_t) (fScNWords);
867 if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
869 //printf(" AliZDCRawStream -> scaler datum %d", fScEvCounter);
871 // ********************************** ZDC TDC DATA **********************************
873 if(fIsTDCHeaderRead && fIsZDCTDCHeader && fPosition>=fTDCStartCounter+1){
874 fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
875 if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
876 fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
877 fIsZDCTDCdatum = kTRUE;
878 fZDCTDCdatum = (Int_t) (fBuffer & 0x1fffff);
880 //printf(" AliZDCRawStream -> ZDC TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fZDCTDCdatum);
882 if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
884 fIsTDCHeaderRead = kFALSE;
886 //printf(" AliZDCRawStream -> ZDC TDC global trailer\n");
889 // ********************************** ADD TDC DATA **********************************
891 if(fIsTDCHeaderRead && fIsADDTDCHeader && fPosition>=fTDCStartCounter+1){
892 fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
893 if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
894 fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
895 fIsADDTDCdatum = kTRUE;
896 fADDTDCdatum = (Int_t) (fBuffer & 0x1fffff);
898 //printf(" AliZDCRawStream -> ADD TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fADDTDCdatum);
900 if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
902 fIsTDCHeaderRead = kFALSE;
904 //printf(" AliZDCRawStream -> ADD TDC global trailer\n");
907 // ******************************** TRIGGER SCALER DATA ********************************
908 // Reading trigger scaler data
909 if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
910 fADCModule = kTrigScales; fIsADCDataWord = kFALSE;
911 if(fPosition == fTrigCountStart+1) fMBTrigInput = fBuffer;
912 else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;
913 else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
914 else if(fPosition == fTrigCountStart+4) fEMDTrigInput = fBuffer;
915 else if(fPosition == fTrigCountStart+5) fL0Received = fBuffer;
916 else if(fPosition == fTrigCountStart+6) fMBtrig2CTP = fBuffer;
917 else if(fPosition == fTrigCountStart+7) fCentralTrig2CTP = fBuffer;
918 else if(fPosition == fTrigCountStart+8) fSCentralTrig2CTP = fBuffer;
919 else if(fPosition == fTrigCountStart+9){
920 fEMDTrig2CTP = fBuffer;
921 fIsTriggerScaler = kFALSE;
924 //printf(" AliZDCRawStream -> Trigger Scaler datum %d\n", fPosition-fTrigCountStart);
926 // ******************************* TRIGGER HISTORY WORDS ******************************
927 // Reading trigger history
928 if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
929 fADCModule = kTrigHistory; fIsADCDataWord = kFALSE;
930 if(fPosition == fTrigHistStart+1){
931 fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
932 fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;
933 fCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
934 fMBTrigHist = (fBuffer & 0x00007fff);
936 fCPTInput[0] = (fBuffer & 0x00000080) >> 6; // MB bit
937 fCPTInput[1] = (fBuffer & 0x00400000) >> 21; // CENTRAL bit
940 else if(fPosition == fTrigHistStart+fTrigHistNWords){
941 fPileUpBit2ndWord = (fBuffer & 0x80000000) >> 31;
942 fL0Bit2ndWord = (fBuffer & 0x40000000) >> 30;
943 fSCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
944 fEMDTrigHist = (fBuffer & 0x00007fff);
946 fCPTInput[2] = (fBuffer & 0x00000080) >> 6; // SEMICENTRAL bit
947 fCPTInput[3] = (fBuffer & 0x00400000) >> 21; // EMD bit
949 fIsTriggerHistory = kFALSE;
951 // Checking if the event is good
952 // (1) both history word pile up bits must be = 0
953 if(fPileUpBit1stWord==0 && fPileUpBit2ndWord==0) fIsPileUpEvent = kFALSE;
955 fIsPileUpEvent = kTRUE;
956 printf(" AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
957 fPileUpBit1stWord, fPileUpBit2ndWord);
959 // (2) both history word L0 bits must be = 1
960 if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
962 fIsL0BitSet = kFALSE;
963 printf(" AliZDCRawStream -> L0 wrongly set: bitL0word0 %d bitL0word1 %d\n",
964 fL0Bit1stWord, fL0Bit2ndWord);
968 //printf(" AliZDCRawStream -> Trigger history word %d\n", fPosition-fTrigHistStart);
978 //_____________________________________________________________________________
979 AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri)
981 // Setting the storage
983 AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri);
989 //_____________________________________________________________________________
990 AliZDCChMap* AliZDCRawStream::GetChMap() const
993 // Getting calibration object for ZDC
995 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
996 if(!entry) AliFatal("No calibration data loaded!");
998 AliZDCChMap *calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
999 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");