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