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();
271 const AliRawDataHeaderV3* headerV3 = fRawReader->GetDataHeaderV3();
272 if(!header && !headerV3) {
273 AliError(" No CDH in raw data streaming");
274 fRawReader->AddMajorErrorLog(kCDHError);
278 //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
280 UChar_t message = header ? header->GetAttributes() : headerV3->GetAttributes();
281 //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
283 if((message & 0xf0) == 0x0){ // PHYSICS RUN
284 //printf("\t PHYSICS RUN raw data found\n");
286 else if((message & 0xf0) == 0x10){ // COSMIC RUN
287 //printf("\t STANDALONE_COSMIC RUN raw data found\n");
289 else if((message & 0xf0) == 0x20){ // PEDESTAL RUN
290 //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
292 else if((message & 0xf0) == 0x30){ // LASER RUN
293 //printf("\t STANDALONE_LASER RUN raw data found\n");
295 else if((message & 0xf0) == 0x40){ // CALIBRATION_CENTRAL RUN
296 //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
298 else if((message & 0xf0) == 0x50){ // CALIBRATION_SEMICENTRAL
299 //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
301 else if((message & 0xf0) == 0x60){ // CALIBRATION_MB
302 //printf("\t CALIBRATION_MB RUN raw data found\n");
304 else if((message & 0xf0) == 0x70){ // CALIBRATION_EMD
305 //printf("\t CALIBRATION_EMD RUN raw data found\n");
307 // *** Checking the bit indicating the used readout card
308 // (the payload is different in the 2 cases!)
309 if((message & 0x08) == 0){ // ** DARC card
311 fIsDARCHeader = kTRUE;
312 //AliInfo("\t ZDC readout card used: DARC");
314 else if((message & 0x08) == 0x08){ // ** ZRC card
316 //AliInfo("\t ZDC readout card used: ZRC");
319 fIsCalib = (header ? header->GetL1TriggerMessage() : headerV3->GetL1TriggerMessage()) & 0x1;
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);
373 //_____________________________________________________________________________
374 Bool_t AliZDCRawStream::Next()
376 // Read the next raw digit
377 // Returns kFALSE if there is no digit left
379 if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
382 fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE;
383 fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
384 fIsZDCTDCdatum = kFALSE; fIsADDChannel = kFALSE; fIsADDTDCdatum=kFALSE;
385 fIsUnderflow = kFALSE; fIsOverflow = kFALSE; fIsScalerWord = kFALSE;
386 fSector[0] = fSector[1] = -1;
387 for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
389 fEvType = fRawReader->GetType();
392 // Needed to read simulated raw data (temporary solution?)
393 if(!fReadCDH) fReadOutCard=1;
394 fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;fNChannelsOn=0;
396 //printf("\n AliZDCRawStream::Next() - ev. type %d",fEvType);
399 //printf("\n AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
401 // *** End of ZDC event
402 if(fBuffer == 0xcafefade){
403 //printf("\n AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
407 // -------------------------------------------
409 // -------------------------------------------
410 // If the CDH has been read then
411 // the DARC header must follow
412 if(fReadOutCard==0 && fIsDARCHeader){
413 //printf("\t ---- DARC header ----\n");
416 fDeadbeefOffset = 25;
422 fDataOffset = 1+fDeadbeefOffset;
423 fIsDARCHeader = kFALSE;
426 // ---------------------------------------------
427 // --- Start of data event (SOD) ---
428 // --- decoding mapping of connected ADC ch. ---
429 // ---------------------------------------------
430 // In the SOD event ADC ch. mapping is written
434 if(fPosition>=fDataOffset){
435 if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
436 // DARC 1st datum @ fDataOffset+1 \ ZRC 1st valid datum @ fDataOffset=0
437 if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){
438 printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
439 fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;
442 printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
443 fSODReading = kFALSE;
447 else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
449 return kFALSE; // !!!!!!!!!!!!!!!!!!!!! For the moment thresholds are not read
451 else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
452 fIsHeaderMapping = kTRUE;
453 fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
454 fModType = ((fBuffer & 0x7ff00)>>8);
455 fADCNChannels = (fBuffer & 0xff); // # of channels following the header
457 printf(" ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
459 else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
460 fADCChannel = ((fBuffer & 0x3fff0000)>>16);
461 fCabledSignal = (fBuffer&0xffff);
463 if(fModType == kV965){ // ******** ADCs ********************************
465 if((fBuffer&0x40000000)>>30==0 && fADCModule<=kLastADCGeo){ // *ZDC* high range chain ADC
466 fIsChMapping = kTRUE;
467 fMapADC[fCurrentCh][0] = fADCModule;
468 fMapADC[fCurrentCh][1] = fADCChannel;
469 fMapADC[fCurrentCh][2] = fCabledSignal;
470 // - No. of channels on
473 // Determining detector and sector
474 // -----------------------------------------
475 // For the decoding of the following lines
476 // look the enum in AliZDCRawStream.h file
477 // -----------------------------------------
478 if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
479 || fCabledSignal==24 || fCabledSignal==48){
480 fMapADC[fCurrentCh][3] = 4; //ZNA
482 if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot) fMapADC[fCurrentCh][4]=0;
483 else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1oot) fMapADC[fCurrentCh][4]=1;
484 else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2oot) fMapADC[fCurrentCh][4]=2;
485 else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3oot) fMapADC[fCurrentCh][4]=3;
486 else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4oot) fMapADC[fCurrentCh][4]=4;
487 else if(fCabledSignal==kZDCAMon || fCabledSignal==kZDCAMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
489 else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
490 fMapADC[fCurrentCh][3] = 5; //ZPA
492 if(fCabledSignal==kZPAC || fCabledSignal==kZPACoot) fMapADC[fCurrentCh][4]=0;
493 else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1oot) fMapADC[fCurrentCh][4]=1;
494 else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2oot) fMapADC[fCurrentCh][4]=2;
495 else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3oot) fMapADC[fCurrentCh][4]=3;
496 else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4oot) fMapADC[fCurrentCh][4]=4;
498 else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
499 || fCabledSignal==25 || fCabledSignal==49){
500 fMapADC[fCurrentCh][3] = 1; //ZNC
502 if(fCabledSignal==kZNCC || fCabledSignal==kZNCCoot) fMapADC[fCurrentCh][4]=0;
503 else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1oot) fMapADC[fCurrentCh][4]=1;
504 else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2oot) fMapADC[fCurrentCh][4]=2;
505 else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3oot) fMapADC[fCurrentCh][4]=3;
506 else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4oot) fMapADC[fCurrentCh][4]=4;
507 else if(fCabledSignal==kZDCCMon || fCabledSignal==kZDCCMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
509 else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
510 fMapADC[fCurrentCh][3] = 2; //ZPC
512 if(fCabledSignal==kZPCC || fCabledSignal==kZPCCoot) fMapADC[fCurrentCh][4]=0;
513 else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1oot) fMapADC[fCurrentCh][4]=1;
514 else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2oot) fMapADC[fCurrentCh][4]=2;
515 else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3oot) fMapADC[fCurrentCh][4]=3;
516 else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4oot) fMapADC[fCurrentCh][4]=4;
518 else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
519 fMapADC[fCurrentCh][3] = 3; // ZEM
521 if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1oot) fMapADC[fCurrentCh][4]=1;
522 else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2oot) fMapADC[fCurrentCh][4]=2;
525 //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
526 //printf(" det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
530 } // high range channels
531 }// ModType=1 (ADC mapping)
532 else if(fModType == kV830){ // ******** VME scaler **************************
533 fIsChMapping = kTRUE;
534 fScalerMap[fCurrScCh][0] = fADCModule;
535 fScalerMap[fCurrScCh][1] = fADCChannel;
536 fScalerMap[fCurrScCh][2] = fCabledSignal;
538 // Determining detector and sector
539 // -----------------------------------------
540 // For the decoding of the following lines
541 // look the enum in AliZDCRawStream.h file
542 // -----------------------------------------
543 // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
544 if((fCabledSignal>=2 && fCabledSignal<=6) ||
545 (fCabledSignal>=61 && fCabledSignal<=65)){
546 fScalerMap[fCurrScCh][3] = 4; //ZNA
548 if(fCabledSignal==kZNAC || fCabledSignal==kZNACD) fScalerMap[fCurrScCh][4]=0;
549 else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1D) fScalerMap[fCurrScCh][4]=1;
550 else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2D) fScalerMap[fCurrScCh][4]=2;
551 else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3D) fScalerMap[fCurrScCh][4]=3;
552 else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4D) fScalerMap[fCurrScCh][4]=4;
554 else if((fCabledSignal>=7 && fCabledSignal<=11) ||
555 (fCabledSignal>=66 && fCabledSignal<=70)){
556 fScalerMap[fCurrScCh][3] = 5; //ZPA
558 if(fCabledSignal==kZPAC || fCabledSignal==kZPACD) fScalerMap[fCurrScCh][4]=0;
559 else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1D) fScalerMap[fCurrScCh][4]=1;
560 else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2D) fScalerMap[fCurrScCh][4]=2;
561 else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3D) fScalerMap[fCurrScCh][4]=3;
562 else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4D) fScalerMap[fCurrScCh][4]=4;
564 else if((fCabledSignal>=12 && fCabledSignal<=16) ||
565 (fCabledSignal>=71 && fCabledSignal<=75)){
566 fScalerMap[fCurrScCh][3] = 1; //ZNC
568 if(fCabledSignal==kZNCC || fCabledSignal==kZNCCD) fScalerMap[fCurrScCh][4]=0;
569 else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1D) fScalerMap[fCurrScCh][4]=1;
570 else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2D) fScalerMap[fCurrScCh][4]=2;
571 else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3D) fScalerMap[fCurrScCh][4]=3;
572 else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4D) fScalerMap[fCurrScCh][4]=4;
574 else if((fCabledSignal>=17 && fCabledSignal<=21) ||
575 (fCabledSignal>=76 && fCabledSignal<=80)){
576 fScalerMap[fCurrScCh][3] = 2; //ZPC
578 if(fCabledSignal==kZPCC || fCabledSignal==kZPCCD) fScalerMap[fCurrScCh][4]=0;
579 else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1D) fScalerMap[fCurrScCh][4]=1;
580 else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2D) fScalerMap[fCurrScCh][4]=2;
581 else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3D) fScalerMap[fCurrScCh][4]=3;
582 else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4D) fScalerMap[fCurrScCh][4]=4;
584 else if(fCabledSignal==22 || fCabledSignal==23 ||
585 fCabledSignal==81 || fCabledSignal==82){
586 fScalerMap[fCurrScCh][3] = 3; // ZEM
588 if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1D) fScalerMap[fCurrScCh][4]=1;
589 else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2D) fScalerMap[fCurrScCh][4]=2;
592 /*printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
593 if(fCabledSignal!=0 && fCabledSignal!=1) printf(" det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
594 else printf(" Signal void/not connected\n");*/
598 else if(fModType==KV1290 && fADCModule==kZDCTDCGeo){ // ******** ZDC TDC **************************
599 fIsChMapping = kTRUE;
600 fTDCMap[fCurrTDCCh][0] = fADCModule;
601 fTDCMap[fCurrTDCCh][1] = fADCChannel;
602 fTDCMap[fCurrTDCCh][2] = fCabledSignal;
607 //printf("\tZDC TDC: mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
609 /*else if(fModType == kTRG){ // **** scalers from trigger card
610 //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
612 else if(fModType == kTRGI){ // **** trigger history from trigger card
613 //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
615 else if(fModType == kPU){ // **** pattern unit
616 //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
618 }//reading channel mapping
623 } // ------------------------------- SOD event
625 // -------------------------------------------
627 // -------------------------------------------
628 if(fPosition<fDeadfaceOffset && fReadOutCard==0){
632 else if(fPosition==fDeadfaceOffset && fReadOutCard==0){
633 if(fBuffer != 0xdeadface){
634 //AliWarning(" NO deadface after DARC data");
635 fRawReader->AddMajorErrorLog(kDARCError);
642 else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){
646 else if(fPosition==fDeadbeefOffset && fReadOutCard==0){
647 if(fBuffer != 0xdeadbeef){
648 //AliWarning(" NO deadbeef after DARC global data");
649 fRawReader->AddMajorErrorLog(kDARCError);
657 } // ------------------------------- End of DARC data
659 // ---------------------------------------------
661 // --- ADCs + VME scaler + trigger card + P.U.
662 // ---------------------------------------------
663 else if(fPosition>=fDataOffset){
665 if(!fSODReading && !fIsMapRead) ReadChMap();
667 // !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!!
668 // Not valid datum before the event
669 // there MUST be a NOT valid datum before the event!!!
671 if(fPosition==fDataOffset){
672 //printf("\t **** ZDC data begin ****\n");
673 if((fBuffer & 0x07000000) != 0x06000000){
674 fRawReader->AddMajorErrorLog(kZDCDataError);
676 //else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
677 // fIsADCEventGood = kFALSE;
681 // If the not valid datum isn't followed by the 1st ADC header
682 // the event is corrupted (i.e., 2 gates arrived before trigger)
683 else if(fPosition==fDataOffset+1){
684 if((fBuffer & 0x07000000) != 0x02000000){
685 AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
686 fRawReader->AddMajorErrorLog(kZDCDataError);
687 fIsADCEventGood = kFALSE;
694 // Get geo address of current word
695 if(fIsTDCHeaderRead && fIsZDCTDCHeader) fADCModule = kZDCTDCGeo;
696 else if(fIsTDCHeaderRead && fIsADDTDCHeader) fADCModule = kADDTDCGeo;
697 else fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
699 // ************************************ ADC MODULES ************************************
700 if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo &&
701 !fIsTriggerHistory && !fIsScHeaderRead && !fIsTriggerScaler){
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 -> ADC 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 -> ADD ADC 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 header: 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 // Commented by C.O. & M.G. (23/09/2011)
829 //else if(!(fBuffer & 0x04000000) && fIsScHeaderRead==kFALSE){
830 // fIsScEventGood = kFALSE;
833 // *********************************** PATTERN UNIT ***********************************
834 else if(fADCModule == kPUGeo){
835 // still to be implemented!!! Not yet in data!!!
836 fDetPattern = (fBuffer & 0x0000003f);
838 //printf(" AliZDCRawStream -> Pattern Unit\n");
841 // ******************************** TRIGGER CARD COUNTS ********************************
842 else if(fADCModule == kTrigScales){
843 if(fIsTriggerScaler == kFALSE){
844 fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
845 fTrigCountStart = fPosition;
846 fIsTriggerScaler = kTRUE;
849 //printf(" AliZDCRawStream -> Trigger Scaler header\n");
851 // ********************************** TRIGGER HISTORY **********************************
852 else if(fADCModule == kTrigHistory){
853 if(fIsTriggerHistory == kFALSE){
854 fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
855 fTrigHistStart = fPosition;
856 fIsTriggerHistory = kTRUE;
859 //printf(" AliZDCRawStream -> Trigger History header\n");
862 // ********************************** VME SCALER DATA **********************************
863 // Reading VME scaler data
864 if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
865 fADCModule=kScalerGeo;
866 fIsADCDataWord=kFALSE;
868 fScEvCounter = fBuffer;
869 Int_t nWords = (Int_t) (fScNWords);
870 if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
872 //printf(" AliZDCRawStream -> scaler datum %x \n", fScEvCounter);
874 // ********************************** ZDC TDC DATA **********************************
876 if(fIsTDCHeaderRead && fIsZDCTDCHeader && fPosition>=fTDCStartCounter+1){
877 fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
878 if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
879 fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
880 fIsZDCTDCdatum = kTRUE;
881 fZDCTDCdatum = (Int_t) (fBuffer & 0x1fffff);
883 //printf(" AliZDCRawStream -> ZDC TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fZDCTDCdatum);
885 if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
887 fIsTDCHeaderRead = kFALSE;
889 //printf(" AliZDCRawStream -> ZDC TDC global trailer\n");
892 // ********************************** ADD TDC DATA **********************************
894 if(fIsTDCHeaderRead && fIsADDTDCHeader && fPosition>=fTDCStartCounter+1){
895 fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
896 if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
897 fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
898 fIsADDTDCdatum = kTRUE;
899 fADDTDCdatum = (Int_t) (fBuffer & 0x1fffff);
901 //printf(" AliZDCRawStream -> ADD TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fADDTDCdatum);
903 if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
905 fIsTDCHeaderRead = kFALSE;
907 //printf(" AliZDCRawStream -> ADD TDC global trailer\n");
910 // ******************************** TRIGGER SCALER DATA ********************************
911 // Reading trigger scaler data
912 if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
913 fADCModule = kTrigScales; fIsADCDataWord = kFALSE;
914 if(fPosition == fTrigCountStart+1) fMBTrigInput = fBuffer;
915 else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;
916 else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
917 else if(fPosition == fTrigCountStart+4) fEMDTrigInput = fBuffer;
918 else if(fPosition == fTrigCountStart+5) fL0Received = fBuffer;
919 else if(fPosition == fTrigCountStart+6) fMBtrig2CTP = fBuffer;
920 else if(fPosition == fTrigCountStart+7) fCentralTrig2CTP = fBuffer;
921 else if(fPosition == fTrigCountStart+8) fSCentralTrig2CTP = fBuffer;
922 else if(fPosition == fTrigCountStart+9){
923 fEMDTrig2CTP = fBuffer;
924 fIsTriggerScaler = kFALSE;
927 //printf(" AliZDCRawStream -> Trigger Scaler datum %d\n", fPosition-fTrigCountStart);
929 // ******************************* TRIGGER HISTORY WORDS ******************************
930 // Reading trigger history
931 if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
932 fADCModule = kTrigHistory; fIsADCDataWord = kFALSE;
933 if(fPosition == fTrigHistStart+1){
934 fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
935 fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;
936 fCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
937 fMBTrigHist = (fBuffer & 0x00007fff);
939 fCPTInput[0] = (fBuffer & 0x00000080) >> 6; // MB bit
940 fCPTInput[1] = (fBuffer & 0x00400000) >> 21; // CENTRAL bit
943 else if(fPosition == fTrigHistStart+fTrigHistNWords){
944 fPileUpBit2ndWord = (fBuffer & 0x80000000) >> 31;
945 fL0Bit2ndWord = (fBuffer & 0x40000000) >> 30;
946 fSCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
947 fEMDTrigHist = (fBuffer & 0x00007fff);
949 fCPTInput[2] = (fBuffer & 0x00000080) >> 6; // SEMICENTRAL bit
950 fCPTInput[3] = (fBuffer & 0x00400000) >> 21; // EMD bit
952 fIsTriggerHistory = kFALSE;
954 // Checking if the event is good
955 // (1) both history word pile up bits must be = 0
956 if(fPileUpBit1stWord==0 && fPileUpBit2ndWord==0) fIsPileUpEvent = kFALSE;
958 fIsPileUpEvent = kTRUE;
959 printf(" AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
960 fPileUpBit1stWord, fPileUpBit2ndWord);
962 // (2) both history word L0 bits must be = 1
963 if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
965 fIsL0BitSet = kFALSE;
966 printf(" AliZDCRawStream -> L0 wrongly set: bitL0word0 %d bitL0word1 %d\n",
967 fL0Bit1stWord, fL0Bit2ndWord);
971 //printf(" AliZDCRawStream -> Trigger history word[%d] %x\n", fPosition, fBuffer);
981 //_____________________________________________________________________________
982 AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri)
984 // Setting the storage
986 AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri);
992 //_____________________________________________________________________________
993 AliZDCChMap* AliZDCRawStream::GetChMap() const
996 // Getting calibration object for ZDC
998 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
999 if(!entry) AliFatal("No calibration data loaded!");
1001 AliZDCChMap *calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
1002 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");