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