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