Sigma0 has been missing from the list of stable particles.
[u/mrichter/AliRoot.git] / ZDC / AliZDCRawStream.cxx
CommitLineData
8309c1ab 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
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 **************************************************************************/
15
16/* $Id$ */
17
18///////////////////////////////////////////////////////////////////////////////
83347831 19// //
20// This class provides access to ZDC digits in raw data. //
21// //
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. //
26// //
8309c1ab 27///////////////////////////////////////////////////////////////////////////////
28
11b06725 29#include <TSystem.h>
8309c1ab 30#include "AliZDCRawStream.h"
31#include "AliRawReader.h"
1ee299a5 32#include "AliRawDataHeader.h"
33#include "AliRawEventHeaderBase.h"
cc2abffd 34#include "AliLog.h"
8309c1ab 35
36ClassImp(AliZDCRawStream)
37
38
39//_____________________________________________________________________________
40AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
41 fRawReader(rawReader),
1ee299a5 42 fBuffer(0),
44455047 43 fReadOutCard(-1),
1ee299a5 44 fEvType(0),
45 fPosition(0),
46 fIsCalib(kFALSE),
47 fIsDARCHeader(kFALSE),
c3986754 48 fIsHeaderMapping(kFALSE),
1ee299a5 49 fIsChMapping(kFALSE),
50 fIsADCDataWord(kFALSE),
51 fIsADCHeader(kFALSE),
52 fIsADCEOB(kFALSE),
fee50699 53 fSODReading(kFALSE),
54 fIsMapRead(kFALSE),
44455047 55 fDeadfaceOffset(-1),
56 fDeadbeefOffset(-1),
1ee299a5 57 fDataOffset(0),
58 fModType(-1),
59 fADCModule(-1),
60 fADCNChannels(-1),
786b72f5 61 fADCChannel(-1),
cc2abffd 62 fADCValue(-1),
1ee299a5 63 fADCGain(-1),
c33b6ca6 64 fIsUnderflow(kFALSE),
65 fIsOverflow(kFALSE),
fee50699 66 fScGeo(0),
c083685e 67 fScNWords(0),
68 fScTriggerSource(0),
e42bdf10 69 fScTriggerNumber(0),
c083685e 70 fIsScEventGood(kTRUE),
71 fIsScHeaderRead(kFALSE),
72 fScStartCounter(0),
73 fScEvCounter(0),
ad3a602e 74 fIsScalerWord(kFALSE),
da090841 75 fDetPattern(0),
76 fTrigCountNWords(0),
f70a5526 77 fIsTriggerScaler(kFALSE),
da090841 78 fTrigCountStart(0),
79 fMBTrigInput(0),
80 fCentralTrigInput(0),
81 fSCentralTrigInput(0),
82 fEMDTrigInput(0),
83 fL0Received(0),
84 fMBtrig2CTP(0),
85 fCentralTrig2CTP(0),
86 fSCentralTrig2CTP(0),
87 fEMDTrig2CTP(0),
88 fTrigHistNWords(0),
f70a5526 89 fIsTriggerHistory(kFALSE),
90 fTrigHistStart(0),
da090841 91 fPileUpBit1stWord(0),
92 fL0Bit1stWord(0),
93 fCentralTrigHist(0),
94 fMBTrigHist(0),
95 fPileUpBit2ndWord(0),
96 fL0Bit2ndWord(0),
97 fSCentralTrigHist(0),
98 fEMDTrigHist(0),
58671297 99 fNChannelsOn(0),
c3986754 100 fCurrentCh(-1),
101 fCabledSignal(-1),
102 fCurrScCh(-1),
da090841 103 fIsADCEventGood(kTRUE),
c3986754 104 fIsL0BitSet(kTRUE),
da090841 105 fIsPileUpEvent(kFALSE)
8309c1ab 106{
abf60186 107 // Create an object to read ZDC raw digits
1ee299a5 108 fRawReader->Reset();
362c9d61 109 fRawReader->Select("ZDC");
1ee299a5 110 //
58671297 111 const int kNch = 48;
112 for(Int_t i=0; i<kNch; i++){
c3986754 113 for(Int_t j=0; j<5; j++){
114 fMapADC[i][j]=-1;
115 if(i<32) fScalerMap[i][j]=-1;
116 }
1ee299a5 117 }
da090841 118
119 for(Int_t k=0; k<4; k++) fCPTInput[k] = 0;
1ee299a5 120
8309c1ab 121}
122
123//_____________________________________________________________________________
124AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
a718c993 125 TObject(stream),
c61a7285 126 fRawReader(stream.fRawReader),
1ee299a5 127 fBuffer(stream.GetRawBuffer()),
44455047 128 fReadOutCard(stream.GetReadOutCard()),
1ee299a5 129 fEvType(stream.fEvType),
130 fPosition(stream.fPosition),
131 fIsCalib(stream.fIsCalib),
132 fIsDARCHeader(stream.fIsDARCHeader),
c3986754 133 fIsHeaderMapping(stream.fIsHeaderMapping),
1ee299a5 134 fIsChMapping(stream.fIsChMapping),
135 fIsADCDataWord(stream.fIsADCDataWord),
136 fIsADCHeader(stream.fIsADCHeader),
137 fIsADCEOB(stream.fIsADCEOB),
fee50699 138 fSODReading(stream.fSODReading),
139 fIsMapRead(stream.fIsMapRead),
1ee299a5 140 fDeadfaceOffset(stream.GetDeadfaceOffset()),
141 fDeadbeefOffset(stream.GetDeadbeefOffset()),
142 fDataOffset(stream.GetDataOffset()),
143 fModType(stream.GetModType()),
a718c993 144 fADCModule(stream.GetADCModule()),
1ee299a5 145 fADCNChannels(stream.GetADCNChannels()),
a718c993 146 fADCChannel(stream.GetADCChannel()),
147 fADCValue(stream.GetADCValue()),
148 fADCGain(stream.GetADCGain()),
c33b6ca6 149 fIsUnderflow(stream.fIsUnderflow),
150 fIsOverflow(stream.fIsOverflow),
e42bdf10 151 fScGeo(stream.GetScGeo()),
c083685e 152 fScNWords(stream.GetScNWords()),
153 fScTriggerSource(stream.GetScTriggerSource()),
22fe5e66 154 fScTriggerNumber(stream.fScTriggerNumber),
e42bdf10 155 fIsScEventGood(stream.fIsScEventGood),
c083685e 156 fIsScHeaderRead(stream.fIsScHeaderRead),
157 fScStartCounter(stream.fScStartCounter),
158 fScEvCounter(stream.fScEvCounter),
ad3a602e 159 fIsScalerWord(stream.fIsScalerWord),
da090841 160 fDetPattern(stream.fDetPattern),
161 fTrigCountNWords(stream.fTrigCountNWords),
f70a5526 162 fIsTriggerScaler(stream.fIsTriggerScaler),
da090841 163 fTrigCountStart(stream.fTrigCountStart),
164 fMBTrigInput(stream.fMBTrigInput),
165 fCentralTrigInput(stream.fCentralTrigInput),
166 fSCentralTrigInput(stream.fSCentralTrigInput),
167 fEMDTrigInput(stream.fEMDTrigInput),
168 fL0Received(stream.fL0Received),
169 fMBtrig2CTP(stream.fMBtrig2CTP),
170 fCentralTrig2CTP(stream.fCentralTrig2CTP),
171 fSCentralTrig2CTP(stream.fSCentralTrig2CTP),
172 fEMDTrig2CTP(stream.fEMDTrig2CTP),
173 fTrigHistNWords(stream.fTrigHistNWords),
f70a5526 174 fIsTriggerHistory(stream.fIsTriggerHistory),
175 fTrigHistStart(stream.fTrigHistStart),
da090841 176 fPileUpBit1stWord(stream.fPileUpBit1stWord),
177 fL0Bit1stWord(stream.fL0Bit1stWord),
178 fCentralTrigHist(stream.fCentralTrigHist),
179 fMBTrigHist(stream.fMBTrigHist),
180 fPileUpBit2ndWord(stream.fPileUpBit2ndWord),
181 fL0Bit2ndWord(stream.fL0Bit2ndWord),
182 fSCentralTrigHist(stream.fSCentralTrigHist),
183 fEMDTrigHist(stream.fEMDTrigHist),
9d0b658a 184 fNChannelsOn(stream.fNChannelsOn),
c3986754 185 fCurrentCh(stream.fCurrentCh),
186 fCabledSignal(stream.GetCabledSignal()),
187 fCurrScCh(stream.fCurrScCh),
da090841 188 fIsADCEventGood(stream.fIsADCEventGood),
c3986754 189 fIsL0BitSet(stream.fIsL0BitSet),
da090841 190 fIsPileUpEvent(stream.fIsPileUpEvent)
c3986754 191
8309c1ab 192{
abf60186 193 // Copy constructor
58671297 194 const int kNch = 48;
c0aec6f6 195 for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j);
58671297 196 for(Int_t i=0; i<kNch; i++){
c3986754 197 for(Int_t j=0; j<5; j++){
198 fMapADC[i][j] = stream.fMapADC[i][j];
199 if(i<32) fScalerMap[i][j] = stream.fMapADC[i][j];
200 }
1ee299a5 201 }
da090841 202
203 for(Int_t k=0; k<4; k++) fCPTInput[k] = stream.fCPTInput[k];
8309c1ab 204}
205
206//_____________________________________________________________________________
207AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream&
208 /* stream */)
209{
abf60186 210 // Assignment operator
8309c1ab 211 Fatal("operator =", "assignment operator not implemented");
212 return *this;
213}
214
215//_____________________________________________________________________________
216AliZDCRawStream::~AliZDCRawStream()
217{
abf60186 218// Destructor
8309c1ab 219
220}
221
1ee299a5 222//_____________________________________________________________________________
c93c022b 223void AliZDCRawStream::ReadChMap()
224{
225 // Reading channel map
58671297 226 const int kNch = 48;
27afc0c8 227 AliDebug(2,"\t Reading ZDC ADC mapping from OCDB\n");
fee50699 228 AliZDCChMap * chMap = GetChMap();
6d653649 229 //chMap->Print("");
58671297 230 for(Int_t i=0; i<kNch; i++){
fee50699 231 fMapADC[i][0] = chMap->GetADCModule(i);
232 fMapADC[i][1] = chMap->GetADCChannel(i);
233 fMapADC[i][2] = -1;
234 fMapADC[i][3] = chMap->GetDetector(i);
235 fMapADC[i][4] = chMap->GetSector(i);
236 }
237 fIsMapRead = kTRUE;
c93c022b 238}
239
240//_____________________________________________________________________________
1ee299a5 241void AliZDCRawStream::ReadCDHHeader()
242{
243 // Reading CDH
244 const AliRawDataHeader* header = fRawReader->GetDataHeader();
245 if(!header) {
9d0b658a 246 AliError(" No CDH in raw data streaming");
1ee299a5 247 fRawReader->AddMajorErrorLog(kCDHError);
fee50699 248 return;
1ee299a5 249 }
250 else{
27afc0c8 251 //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
1ee299a5 252
ac84d2fc 253 UChar_t message = header->GetAttributes();
27afc0c8 254 //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
1ee299a5 255
910216a3 256 if((message & 0xf0) == 0x0){ // PHYSICS RUN
58671297 257 //printf("\t PHYSICS RUN raw data found\n");
258 }
910216a3 259 else if((message & 0xf0) == 0x10){ // COSMIC RUN
65448375 260 //printf("\t STANDALONE_COSMIC RUN raw data found\n");
1ee299a5 261 }
910216a3 262 else if((message & 0xf0) == 0x20){ // PEDESTAL RUN
65448375 263 //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
1ee299a5 264 }
910216a3 265 else if((message & 0xf0) == 0x30){ // LASER RUN
65448375 266 //printf("\t STANDALONE_LASER RUN raw data found\n");
ac84d2fc 267 }
910216a3 268 else if((message & 0xf0) == 0x40){ // CALIBRATION_CENTRAL RUN
58671297 269 //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
270 }
910216a3 271 else if((message & 0xf0) == 0x50){ // CALIBRATION_SEMICENTRAL
58671297 272 //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
273 }
910216a3 274 else if((message & 0xf0) == 0x60){ // CALIBRATION_MB
58671297 275 //printf("\t CALIBRATION_MB RUN raw data found\n");
276 }
910216a3 277 else if((message & 0xf0) == 0x70){ // CALIBRATION_EMD
58671297 278 //printf("\t CALIBRATION_EMD RUN raw data found\n");
279 }
44455047 280 // *** Checking the bit indicating the used readout card
281 // (the payload is different in the 2 cases!)
282 if((message & 0x08) == 0){ // ** DARC card
283 fReadOutCard = 0;
284 fIsDARCHeader = kTRUE;
27afc0c8 285 AliInfo("\t ZDC readout card used: DARC");
44455047 286 }
13390187 287 else if((message & 0x08) == 0x08){ // ** ZRC card
44455047 288 fReadOutCard = 1;
27afc0c8 289 AliInfo("\t ZDC readout card used: ZRC");
44455047 290 }
291
1ee299a5 292 if(header->GetL1TriggerMessage() & 0x1){ // Calibration bit set in CDH
293 fIsCalib = kTRUE;
294 }
27afc0c8 295 //printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
296 //printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);
1ee299a5 297
298 UInt_t status = header->GetStatus();
299 //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status);
f9f99efb 300 if((status & 0x000f) == 0x0001){
c083685e 301 AliDebug(2,"CDH -> DARC trg0 overlap error");
1ee299a5 302 fRawReader->AddMajorErrorLog(kDARCError);
303 }
f9f99efb 304 if((status & 0x000f) == 0x0002){
c083685e 305 AliDebug(2,"CDH -> DARC trg0 missing error");
1ee299a5 306 fRawReader->AddMajorErrorLog(kDARCError);
307 }
f9f99efb 308 if((status & 0x000f) == 0x0004){
c083685e 309 AliDebug(2,"CDH -> DARC data parity error");
1ee299a5 310 fRawReader->AddMajorErrorLog(kDARCError);
311 }
f9f99efb 312 if((status & 0x000f) == 0x0008){
c083685e 313 AliDebug(2,"CDH -> DARC ctrl parity error");
1ee299a5 314 fRawReader->AddMajorErrorLog(kDARCError);
315 }
316 //
f9f99efb 317 if((status & 0x00f0) == 0x0010){
c083685e 318 AliDebug(2,"CDH -> DARC trg unavailable");
1ee299a5 319 fRawReader->AddMajorErrorLog(kDARCError);
320 }
f9f99efb 321 if((status & 0x00f0) == 0x0020){
c3986754 322 AliDebug(2,"CDH -> DARC FEE error");
1ee299a5 323 fRawReader->AddMajorErrorLog(kDARCError);
324 }
325 //
f9f99efb 326 if((status & 0x0f00) == 0x0200){
c083685e 327 AliDebug(2,"CDH -> DARC L1 time violation");
1ee299a5 328 fRawReader->AddMajorErrorLog(kDARCError);
329 }
f9f99efb 330 if((status & 0x0f00) == 0x0400){
c3986754 331 AliDebug(2,"CDH -> DARC L2 time-out");
1ee299a5 332 fRawReader->AddMajorErrorLog(kDARCError);
333 }
f9f99efb 334 if((status & 0x0f00) == 0x0800){
c3986754 335 AliDebug(2,"CDH -> DARC prepulse time violation");
1ee299a5 336 fRawReader->AddMajorErrorLog(kDARCError);
337 }
338 //
f9f99efb 339 if((status & 0xf000) == 0x1000){
c083685e 340 AliDebug(2,"CDH -> DARC other error");
1ee299a5 341 fRawReader->AddMajorErrorLog(kDARCError);
342 }
343 }
44455047 344
1ee299a5 345}
346
8309c1ab 347//_____________________________________________________________________________
348Bool_t AliZDCRawStream::Next()
349{
abf60186 350 // Read the next raw digit
351 // Returns kFALSE if there is no digit left
8309c1ab 352
1ee299a5 353 if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
58671297 354 const int kNch = 48;
c3986754 355 Int_t kFirstADCGeo=0, kLastADCGeo=3, kScalerGeo=8, kPUGeo=29, kTrigScales=30, kTrigHistory=31;
356 fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE;
357 fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
ad3a602e 358 fIsUnderflow = kFALSE; fIsOverflow = kFALSE; fIsScalerWord = kFALSE;
58671297 359 fSector[0] = fSector[1] = -1;
f70a5526 360// fTrigCountNWords = 9; fTrigHistNWords = 2;
da090841 361 for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
362
1ee299a5 363 fEvType = fRawReader->GetType();
1ee299a5 364 if(fPosition==0){
365 //if(fEvType==7 || fEvType ==8){ //Physics or calibration event
1ee299a5 366 ReadCDHHeader();
367 //}
c3986754 368 fCurrentCh=0; fCurrScCh=0; fNChannelsOn=0;
369 // Ch. debug
370 //printf("\n AliZDCRawStream::Next() - ev. type %d",fEvType);
1ee299a5 371 }
ac84d2fc 372
c3986754 373 // Ch. debug
374 //printf("\n AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
375
9d0b658a 376 // *** End of ZDC event
ac84d2fc 377 if(fBuffer == 0xcafefade){
27afc0c8 378 //printf("\n AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
ac84d2fc 379 return kFALSE;
380 }
1ee299a5 381
382 // -------------------------------------------
1069e28d 383 // --- DARC header
1ee299a5 384 // -------------------------------------------
fee50699 385 // If the CDH has been read then
386 // the DARC header must follow
44455047 387 if(fReadOutCard==0 && fIsDARCHeader){
84d2abc2 388 //printf("\t ---- DARC header ----\n");
1ee299a5 389 if(fIsCalib){
390 fDeadfaceOffset = 9;
391 fDeadbeefOffset = 25;
392 }
393 else{
394 fDeadfaceOffset = 1;
395 fDeadbeefOffset = 7;
396 }
397 fDataOffset = 1+fDeadbeefOffset;
398 fIsDARCHeader = kFALSE;
abf60186 399 }
1ee299a5 400
44455047 401 // ---------------------------------------------
402 // --- Start of data event (SOD) ---
403 // --- decoding mapping of connected ADC ch. ---
404 // ---------------------------------------------
fee50699 405 // In the SOD event ADC ch. mapping is written
1e85619e 406 if(fEvType==10){
407 if(fSODReading){
fee50699 408
13390187 409 if(fPosition>=fDataOffset){
c3986754 410 if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
8700404e 411 // DARC 1st datum @ fDataOffset+1 \ ZRC 1st valid datum @ fDataOffset=0
13390187 412 if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){
1e85619e 413 printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
c3986754 414 fCurrentCh=0; fCurrScCh=0;
6006df88 415 }
1ee299a5 416 else{
1e85619e 417 printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
418 fSODReading = kFALSE;
fee50699 419 return kFALSE;
1ee299a5 420 }
421 }
c3986754 422 else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
423 fPosition++;
27afc0c8 424 return kFALSE; // !!!!!!!!!!!!!!!!!!!!! For the moment thresholds are not read
c3986754 425 }
426 else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
427 fIsHeaderMapping = kTRUE;
428 fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
429 fModType = ((fBuffer & 0x7ff00)>>8);
430 fADCNChannels = (fBuffer & 0xff); // # of channels following the header
1ee299a5 431 //
c083685e 432 printf(" ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
6006df88 433 }
c3986754 434 else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
435 fADCChannel = ((fBuffer & 0x3fff0000)>>16);
436 fCabledSignal = (fBuffer&0xffff);
437 //
27afc0c8 438 if(fModType == kV965){ // ******** ADCs ********************************
480ac371 439 // Channel signal
440 if((fBuffer&0x40000000)>>30==0 && fADCModule<=kLastADCGeo){ // *ZDC* high range chain ADC
c3986754 441 fIsChMapping = kTRUE;
442 fMapADC[fCurrentCh][0] = fADCModule;
443 fMapADC[fCurrentCh][1] = fADCChannel;
444 fMapADC[fCurrentCh][2] = fCabledSignal;
445 // - No. of channels on
446 fNChannelsOn++;
447 //
448 // Determining detector and sector
449 // -----------------------------------------
450 // For the decoding of the following lines
451 // look the enum in AliZDCRawStream.h file
452 // -----------------------------------------
453 if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
454 || fCabledSignal==24 || fCabledSignal==48){
455 fMapADC[fCurrentCh][3] = 4; //ZNA
456 //
27afc0c8 457 if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot) fMapADC[fCurrentCh][4]=0;
c3986754 458 else if(fCabledSignal==3 || fCabledSignal==27) fMapADC[fCurrentCh][4]=1;
459 else if(fCabledSignal==4 || fCabledSignal==28) fMapADC[fCurrentCh][4]=2;
460 else if(fCabledSignal==5 || fCabledSignal==29) fMapADC[fCurrentCh][4]=3;
461 else if(fCabledSignal==6 || fCabledSignal==30) fMapADC[fCurrentCh][4]=4;
462 else if(fCabledSignal==24 || fCabledSignal==48) fMapADC[fCurrentCh][4]=5; //Reference PTM
463 }
464 else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
465 fMapADC[fCurrentCh][3] = 5; //ZPA
466 //
467 if(fCabledSignal==7 || fCabledSignal==31) fMapADC[fCurrentCh][4]=0;
468 else if(fCabledSignal==8 || fCabledSignal==32) fMapADC[fCurrentCh][4]=1;
469 else if(fCabledSignal==9 || fCabledSignal==33) fMapADC[fCurrentCh][4]=2;
470 else if(fCabledSignal==10 || fCabledSignal==34) fMapADC[fCurrentCh][4]=3;
471 else if(fCabledSignal==11 || fCabledSignal==35) fMapADC[fCurrentCh][4]=4;
472 }
473 else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
474 || fCabledSignal==25 || fCabledSignal==49){
475 fMapADC[fCurrentCh][3] = 1; //ZNC
476 //
477 if(fCabledSignal==12 || fCabledSignal==36) fMapADC[fCurrentCh][4]=0;
478 else if(fCabledSignal==13 || fCabledSignal==37) fMapADC[fCurrentCh][4]=1;
479 else if(fCabledSignal==14 || fCabledSignal==38) fMapADC[fCurrentCh][4]=2;
480 else if(fCabledSignal==15 || fCabledSignal==39) fMapADC[fCurrentCh][4]=3;
481 else if(fCabledSignal==16 || fCabledSignal==40) fMapADC[fCurrentCh][4]=4;
482 else if(fCabledSignal==25 || fCabledSignal==49) fMapADC[fCurrentCh][4]=5; //Reference PTM
483 }
484 else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
485 fMapADC[fCurrentCh][3] = 2; //ZPC
486 //
487 if(fCabledSignal==17 || fCabledSignal==41) fMapADC[fCurrentCh][4]=0;
488 else if(fCabledSignal==18 || fCabledSignal==42) fMapADC[fCurrentCh][4]=1;
489 else if(fCabledSignal==19 || fCabledSignal==43) fMapADC[fCurrentCh][4]=2;
490 else if(fCabledSignal==20 || fCabledSignal==44) fMapADC[fCurrentCh][4]=3;
491 else if(fCabledSignal==21 || fCabledSignal==45) fMapADC[fCurrentCh][4]=4;
492 }
493 else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
494 fMapADC[fCurrentCh][3] = 3; // ZEM
495 //
496 if(fCabledSignal==22 || fCabledSignal==46) fMapADC[fCurrentCh][4]=1;
497 else if(fCabledSignal==23 || fCabledSignal==47) fMapADC[fCurrentCh][4]=2;
498 }
499 //Ch. debug
500 //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
501 //printf(" det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
502 //
503 fCurrentCh++;
504 //
505 } // high range channels
506 }// ModType=1 (ADC mapping)
27afc0c8 507 else if(fModType == kV830){ // ******** VME scaler **************************
c3986754 508 fIsChMapping = kTRUE;
509 fScalerMap[fCurrScCh][0] = fADCModule;
510 fScalerMap[fCurrScCh][1] = fADCChannel;
511 fScalerMap[fCurrScCh][2] = fCabledSignal;
c93c022b 512 //
513 // Determining detector and sector
514 // -----------------------------------------
515 // For the decoding of the following lines
516 // look the enum in AliZDCRawStream.h file
517 // -----------------------------------------
c3986754 518 // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
480ac371 519 if(fCabledSignal>=2 && fCabledSignal<=6 ||
520 fCabledSignal>=61 && fCabledSignal<=65){
c3986754 521 fScalerMap[fCurrScCh][3] = 4; //ZNA
c93c022b 522 //
480ac371 523 if(fCabledSignal==2 || fCabledSignal==61) fScalerMap[fCurrScCh][4]=0;
524 else if(fCabledSignal==3 || fCabledSignal==62) fScalerMap[fCurrScCh][4]=1;
525 else if(fCabledSignal==4 || fCabledSignal==63) fScalerMap[fCurrScCh][4]=2;
526 else if(fCabledSignal==5 || fCabledSignal==64) fScalerMap[fCurrScCh][4]=3;
527 else if(fCabledSignal==6 || fCabledSignal==65) fScalerMap[fCurrScCh][4]=4;
c93c022b 528 }
480ac371 529 else if(fCabledSignal>=7 && fCabledSignal<=11 ||
530 fCabledSignal>=66 && fCabledSignal<=70){
c3986754 531 fScalerMap[fCurrScCh][3] = 5; //ZPA
c93c022b 532 //
480ac371 533 if(fCabledSignal==7 || fCabledSignal==66) fScalerMap[fCurrScCh][4]=0;
534 else if(fCabledSignal==8 || fCabledSignal==67) fScalerMap[fCurrScCh][4]=1;
535 else if(fCabledSignal==9 || fCabledSignal==68) fScalerMap[fCurrScCh][4]=2;
536 else if(fCabledSignal==10 || fCabledSignal==69) fScalerMap[fCurrScCh][4]=3;
537 else if(fCabledSignal==11 || fCabledSignal==70) fScalerMap[fCurrScCh][4]=4;
c93c022b 538 }
480ac371 539 else if(fCabledSignal>=12 && fCabledSignal<=16 ||
540 fCabledSignal>=71 && fCabledSignal<=75){
c3986754 541 fScalerMap[fCurrScCh][3] = 1; //ZNC
c93c022b 542 //
480ac371 543 if(fCabledSignal==12 || fCabledSignal==71) fScalerMap[fCurrScCh][4]=0;
544 else if(fCabledSignal==13 || fCabledSignal==72) fScalerMap[fCurrScCh][4]=1;
545 else if(fCabledSignal==14 || fCabledSignal==73) fScalerMap[fCurrScCh][4]=2;
546 else if(fCabledSignal==15 || fCabledSignal==74) fScalerMap[fCurrScCh][4]=3;
547 else if(fCabledSignal==16 || fCabledSignal==75) fScalerMap[fCurrScCh][4]=4;
c93c022b 548 }
480ac371 549 else if(fCabledSignal>=17 && fCabledSignal<=21 ||
550 fCabledSignal>=76 && fCabledSignal<=80){
c3986754 551 fScalerMap[fCurrScCh][3] = 2; //ZPC
c93c022b 552 //
480ac371 553 if(fCabledSignal==17 || fCabledSignal==76) fScalerMap[fCurrScCh][4]=0;
554 else if(fCabledSignal==18 || fCabledSignal==77) fScalerMap[fCurrScCh][4]=1;
555 else if(fCabledSignal==19 || fCabledSignal==78) fScalerMap[fCurrScCh][4]=2;
556 else if(fCabledSignal==20 || fCabledSignal==79) fScalerMap[fCurrScCh][4]=3;
557 else if(fCabledSignal==21 || fCabledSignal==80) fScalerMap[fCurrScCh][4]=4;
c93c022b 558 }
480ac371 559 else if(fCabledSignal==22 || fCabledSignal==23 ||
560 fCabledSignal==81 || fCabledSignal==82){
c3986754 561 fScalerMap[fCurrScCh][3] = 3; // ZEM
c93c022b 562 //
480ac371 563 if(fCabledSignal==22 || fCabledSignal==81) fScalerMap[fCurrScCh][4]=1;
564 else if(fCabledSignal==23 || fCabledSignal==82) fScalerMap[fCurrScCh][4]=2;
c93c022b 565 }
c3986754 566 // Ch debug.
567 //printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
568 //if(fCabledSignal!=0 && fCabledSignal!=1) printf(" det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
569 //else printf(" Signal void/not connected\n");
570
571 fCurrScCh++;
572 }
27afc0c8 573 /*else if(fModType == kTRG){ // **** scalers from trigger card
c3986754 574 //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
575 }
27afc0c8 576 else if(fModType == kTRGI){ // **** trigger history from trigger card
c3986754 577 //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
578 }
27afc0c8 579 else if(fModType == kPU){ // **** pattern unit
c3986754 580 //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
27afc0c8 581 }*/
c3986754 582 }//reading channel mapping
1ee299a5 583 }
1e85619e 584 } // if fSODREading
585 fPosition++;
586 return kTRUE;
44455047 587 } // ------------------------------- SOD event
1ee299a5 588
589 // -------------------------------------------
590 // --- DARC data
591 // -------------------------------------------
a5747d8f 592 if(fPosition<fDeadfaceOffset && fReadOutCard==0){
593 fPosition++;
594 return kTRUE;
595 }
596 else if(fPosition==fDeadfaceOffset && fReadOutCard==0){
597 if(fBuffer != 0xdeadface){
a44b6e36 598 //AliWarning(" NO deadface after DARC data");
a5747d8f 599 fRawReader->AddMajorErrorLog(kDARCError);
600 }
601 else{
1ee299a5 602 fPosition++;
603 return kTRUE;
604 }
a5747d8f 605 }
606 else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){
607 fPosition++;
608 return kTRUE;
609 }
610 else if(fPosition==fDeadbeefOffset && fReadOutCard==0){
611 if(fBuffer != 0xdeadbeef){
a44b6e36 612 //AliWarning(" NO deadbeef after DARC global data");
a5747d8f 613 fRawReader->AddMajorErrorLog(kDARCError);
614 fPosition++;
615 return kFALSE;
1ee299a5 616 }
a5747d8f 617 else{
1ee299a5 618 fPosition++;
619 return kTRUE;
620 }
1e85619e 621 } // ------------------------------- End of DARC data
44455047 622
1e85619e 623 // ---------------------------------------------
1ee299a5 624 // --- ZDC data
c3986754 625 // --- ADCs + VME scaler + trigger card + P.U.
1e85619e 626 // ---------------------------------------------
1ee299a5 627 else if(fPosition>=fDataOffset){
fee50699 628
629 //printf("AliZDCRawStream: fSODReading = %d\n", fSODReading);
630 if(!fSODReading && !fIsMapRead) ReadChMap();
631
44455047 632 // !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!!
1ee299a5 633 // Not valid datum before the event
634 // there MUST be a NOT valid datum before the event!!!
44455047 635 if(fReadOutCard==0){
a5747d8f 636 if(fPosition==fDataOffset){
44455047 637 //printf("\t **** ZDC data begin ****\n");
638 if((fBuffer & 0x07000000) != 0x06000000){
639 fRawReader->AddMajorErrorLog(kZDCDataError);
640 }
641 else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
642 fIsADCEventGood = kFALSE;
643 }
c3986754 644 }
1ee299a5 645
44455047 646 // If the not valid datum isn't followed by the 1st ADC header
647 // the event is corrupted (i.e., 2 gates arrived before trigger)
a5747d8f 648 else if(fPosition==fDataOffset+1){
44455047 649 if((fBuffer & 0x07000000) != 0x02000000){
650 AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
651 fRawReader->AddMajorErrorLog(kZDCDataError);
652 fIsADCEventGood = kFALSE;
653 fPosition++;
654 return kFALSE;
655 }
1ee299a5 656 }
657 }
658
c3986754 659 // Get geo address of current word
660 // - ADC GEO = 0, 1, 2, 3
661 // - VME scaler GEO = 8
662 // - PU GEO = 29
663 // - Trigger card scales GEO = 30
664 // - Trigger card history GEO = 31
c083685e 665 fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
c083685e 666
c3986754 667 // ************************************ ADC MODULES ************************************
668 if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo){
1ee299a5 669 // *** ADC header
ac84d2fc 670 if((fBuffer & 0x07000000) == 0x02000000){
1ee299a5 671 fIsADCHeader = kTRUE;
672 fADCNChannels = ((fBuffer & 0x00003f00)>>8);
58671297 673 //printf(" AliZDCRawStream -> ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
1ee299a5 674 }
675 // *** ADC data word
676 else if((fBuffer & 0x07000000) == 0x00000000){
677 fIsADCDataWord = kTRUE;
678 fADCChannel = ((fBuffer & 0x1e0000) >> 17);
679 fADCGain = ((fBuffer & 0x10000) >> 16);
680 fADCValue = (fBuffer & 0xfff);
c3986754 681 //
682 //printf(" AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n",
84d2abc2 683 // fADCModule,fADCChannel,fADCGain,fADCValue);
c93c022b 684
c33b6ca6 685 // Checking if the channel map for the ADCs has been provided/read
686 if(fMapADC[0][0]==-1){
687 printf("\t ATTENTION!!! No ADC mapping has been found/provided!!!\n");
688 return kFALSE;
689 }
690 //
58671297 691 /*for(Int_t ci=0; ci<kNch; ci++){
9d0b658a 692 printf(" %d mod %d ch %d det %d sec %d\n",ci,fMapADC[ci][0],
c33b6ca6 693 fMapADC[ci][1], fMapADC[ci][3], fMapADC[ci][4]);
694 }*/
695
696 // Scan of the map to assign the correct volumes
697 Int_t foundMapEntry = kFALSE;
58671297 698 for(Int_t k=0; k<kNch; k++){
c33b6ca6 699 if(fADCModule==fMapADC[k][0] && fADCChannel==fMapADC[k][1]){
700 fSector[0] = fMapADC[k][3];
701 fSector[1] = fMapADC[k][4];
702 foundMapEntry = kTRUE;
703 break;
704 }
705 }
706 if(foundMapEntry==kFALSE){
c3986754 707 AliWarning(Form(" No valid entry in ADC mapping for raw data %d ADCmod. %d ch. %d\n",
708 fPosition,fADCModule,fADCChannel));
c33b6ca6 709 }
710 //
c3986754 711 //printf("AliZDCRawStream -> ADCmod. %d ch. %d -> det %d sec %d\n",
712 // fADCModule,fADCChannel,fSector[0],fSector[1]);
c33b6ca6 713
714 // Final checks
6d653649 715 if(foundMapEntry==kTRUE){
716 if(fSector[0]<1 || fSector[0]>5){
717 AliWarning(Form(" No valid detector assignment: %d",fSector[0]));
718 fRawReader->AddMajorErrorLog(kInvalidSector);
719 }
720 //
721 if(fSector[1]<0 || fSector[1]>5){
722 AliWarning(Form(" No valid sector assignment: %d",fSector[1]));
723 fRawReader->AddMajorErrorLog(kInvalidSector);
724 }
725 //
726 if(fADCModule<0 || fADCModule>3){
727 AliError(Form(" No valid ADC module: %d",fADCModule));
728 fRawReader->AddMajorErrorLog(kInvalidADCModule);
729 }
c33b6ca6 730 }
1ee299a5 731
c33b6ca6 732 // Checking the underflow and overflow bits
733 if(fBuffer & 0x1000) fIsUnderflow = kTRUE;
734 else if (fBuffer & 0x2000) fIsOverflow = kTRUE;
735
1ee299a5 736 }//ADC data word
737 // *** ADC EOB
738 else if((fBuffer & 0x07000000) == 0x04000000){
739 fIsADCEOB = kTRUE;
740 //printf(" AliZDCRawStream -> EOB --------------------------\n");
741 }
c083685e 742 }//ADC module
da090841 743 // ********************************* VME SCALER HEADER *********************************
c3986754 744 else if(fADCModule == kScalerGeo){
c083685e 745 if(fBuffer & 0x04000000 && fIsScHeaderRead==kFALSE){ // *** Scaler header
746 fScGeo = (fBuffer & 0xf8000000)>>27;
747 fScNWords = (fBuffer & 0x00fc0000)>>18;
748 fScTriggerSource = (fBuffer & 0x00030000)>>16;
749 fScTriggerNumber = (fBuffer & 0x0000ffff);
750 fIsScHeaderRead = kTRUE;
f70a5526 751 fScStartCounter = fPosition;
c083685e 752 //Ch. debug
f70a5526 753 //printf(" AliZDCRawStream -> VME SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n",
c083685e 754 // fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber);
755 }
756 else if(!(fBuffer & 0x04000000)){
757 fIsScEventGood = kFALSE;
758 }
c3986754 759 }
da090841 760 // *********************************** PATTERN UNIT ***********************************
c3986754 761 else if(fADCModule == kPUGeo){
762 // still to be implemented!!! Not yet in data!!!
da090841 763 fDetPattern = (fBuffer & 0x0000003f);
f70a5526 764 // Ch. debug
765 //printf(" AliZDCRawStream -> Pattern Unit\n");
766
c3986754 767 }
da090841 768 // ******************************** TRIGGER CARD COUNTS ********************************
c3986754 769 else if(fADCModule == kTrigScales){
f70a5526 770 if(fIsTriggerScaler == kFALSE){
771 fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
da090841 772 fTrigCountStart = fPosition;
f70a5526 773 fIsTriggerScaler = kTRUE;
da090841 774 }
f70a5526 775 // Ch. debug
776 //printf(" AliZDCRawStream -> Trigger Scaler header\n");
c3986754 777 }
da090841 778 // ********************************** TRIGGER HISTORY **********************************
c3986754 779 else if(fADCModule == kTrigHistory){
f70a5526 780 if(fIsTriggerHistory == kFALSE){
781 fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
782 fTrigHistStart = fPosition;
783 fIsTriggerHistory = kTRUE;
da090841 784 }
f70a5526 785 // Ch. debug
786 //printf(" AliZDCRawStream -> Trigger History header\n");
787
c3986754 788 }
da090841 789 // ********************************** VME SCALER DATA **********************************
c3986754 790 // Reading VME scaler data
c083685e 791 if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
ad3a602e 792 fADCModule=kScalerGeo; fIsADCDataWord=kFALSE; fIsScalerWord=kTRUE;
c083685e 793 fScEvCounter = fBuffer;
794 Int_t nWords = (Int_t) (fScNWords);
795 if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
796 //Ch. debug
797 //printf(" AliZDCRawStream -> scaler datum %d", fScEvCounter);
798 }
f70a5526 799 // ******************************** TRIGGER SCALER DATA ********************************
800 // Reading trigger scaler data
801 if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
8700404e 802 fADCModule = kTrigScales; fIsADCDataWord = kFALSE;
f70a5526 803 if(fPosition == fTrigCountStart+1) fMBTrigInput = fBuffer;
804 else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;
805 else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
806 else if(fPosition == fTrigCountStart+4) fEMDTrigInput = fBuffer;
807 else if(fPosition == fTrigCountStart+5) fL0Received = fBuffer;
808 else if(fPosition == fTrigCountStart+6) fMBtrig2CTP = fBuffer;
809 else if(fPosition == fTrigCountStart+7) fCentralTrig2CTP = fBuffer;
810 else if(fPosition == fTrigCountStart+8) fSCentralTrig2CTP = fBuffer;
811 else if(fPosition == fTrigCountStart+9){
812 fEMDTrig2CTP = fBuffer;
813 fIsTriggerScaler = kFALSE;
814 }
815 // Ch. debug
816 //printf(" AliZDCRawStream -> Trigger Scaler datum %d\n", fPosition-fTrigCountStart);
817 }
818 // ******************************* TRIGGER HISTORY WORDS ******************************
819 // Reading trigger history
820 if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
8700404e 821 fADCModule = kTrigHistory; fIsADCDataWord = kFALSE;
f70a5526 822 if(fPosition == fTrigHistStart+1){
823 fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
824 fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;
825 fCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
826 fMBTrigHist = (fBuffer & 0x00007fff);
827 //
828 fCPTInput[0] = (fBuffer & 0x00000080) >> 6; // MB bit
829 fCPTInput[1] = (fBuffer & 0x00400000) >> 21; // CENTRAL bit
830 }
831
832 else if(fPosition == fTrigHistStart+fTrigHistNWords){
833 fPileUpBit2ndWord = (fBuffer & 0x80000000) >> 31;
834 fL0Bit2ndWord = (fBuffer & 0x40000000) >> 30;
835 fSCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
836 fEMDTrigHist = (fBuffer & 0x00007fff);
837 //
838 fCPTInput[2] = (fBuffer & 0x00000080) >> 6; // SEMICENTRAL bit
839 fCPTInput[3] = (fBuffer & 0x00400000) >> 21; // EMD bit
840 //
841 fIsTriggerHistory = kFALSE;
842
843 // Checking if the event is good
844 // (1) both history word pile up bits must be = 0
845 if(fPileUpBit1stWord==0 && fPileUpBit2ndWord==0) fIsPileUpEvent = kFALSE;
846 else{
847 fIsPileUpEvent = kTRUE;
848 printf(" AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
13390187 849 fPileUpBit1stWord, fPileUpBit2ndWord);
f70a5526 850 }
851 // (2) both history word L0 bits must be = 1
852 if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
853 else{
854 fIsL0BitSet = kFALSE;
855 printf(" AliZDCRawStream -> L0 wrongly set: bitL0word0 %d bitL0word1 %d\n",
856 fL0Bit1stWord, fL0Bit2ndWord);
857 }
858 }
859 // Ch. debug
860 //printf(" AliZDCRawStream -> Trigger history word %d\n", fPosition-fTrigHistStart);
861 }
1ee299a5 862
863 }
f70a5526 864
1ee299a5 865 fPosition++;
83347831 866
8309c1ab 867 return kTRUE;
868}
e42bdf10 869
870//_____________________________________________________________________________
fee50699 871AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri)
872{
873 // Setting the storage
874
875 AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri);
876
877 return storage;
878}
879
880
881//_____________________________________________________________________________
882AliZDCChMap* AliZDCRawStream::GetChMap() const
883{
884
885 // Getting calibration object for ZDC
886
887 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
888 if(!entry) AliFatal("No calibration data loaded!");
889
890 AliZDCChMap *calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
891 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");
892
893 return calibdata;
894}