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