]> 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
add functionality to locally fit the track using linear fit (for B=0T)
[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),
a27ef05f 55 fReadCDH(kTRUE),
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("");
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
1ee299a5 266//_____________________________________________________________________________
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();
a27ef05f 391 if(fPosition==0 && fReadCDH){
1ee299a5 392 //if(fEvType==7 || fEvType ==8){ //Physics or calibration event
1ee299a5 393 ReadCDHHeader();
394 //}
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 }
a27ef05f 399 // Needed to read simulated raw data (temporary solution?)
400 else if(fPosition==0 && !fReadCDH && fReadOutCard==-1) fReadOutCard=1;
ac84d2fc 401
c3986754 402 // Ch. debug
403 //printf("\n AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
404
9d0b658a 405 // *** End of ZDC event
ac84d2fc 406 if(fBuffer == 0xcafefade){
27afc0c8 407 //printf("\n AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
ac84d2fc 408 return kFALSE;
409 }
1ee299a5 410
411 // -------------------------------------------
1069e28d 412 // --- DARC header
1ee299a5 413 // -------------------------------------------
fee50699 414 // If the CDH has been read then
415 // the DARC header must follow
44455047 416 if(fReadOutCard==0 && fIsDARCHeader){
84d2abc2 417 //printf("\t ---- DARC header ----\n");
1ee299a5 418 if(fIsCalib){
419 fDeadfaceOffset = 9;
420 fDeadbeefOffset = 25;
421 }
422 else{
423 fDeadfaceOffset = 1;
424 fDeadbeefOffset = 7;
425 }
426 fDataOffset = 1+fDeadbeefOffset;
427 fIsDARCHeader = kFALSE;
abf60186 428 }
1ee299a5 429
44455047 430 // ---------------------------------------------
431 // --- Start of data event (SOD) ---
432 // --- decoding mapping of connected ADC ch. ---
433 // ---------------------------------------------
fee50699 434 // In the SOD event ADC ch. mapping is written
1e85619e 435 if(fEvType==10){
436 if(fSODReading){
fee50699 437
13390187 438 if(fPosition>=fDataOffset){
c3986754 439 if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
8700404e 440 // DARC 1st datum @ fDataOffset+1 \ ZRC 1st valid datum @ fDataOffset=0
13390187 441 if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){
1e85619e 442 printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
82dffa48 443 fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;
6006df88 444 }
1ee299a5 445 else{
1e85619e 446 printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
447 fSODReading = kFALSE;
fee50699 448 return kFALSE;
1ee299a5 449 }
450 }
c3986754 451 else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
452 fPosition++;
27afc0c8 453 return kFALSE; // !!!!!!!!!!!!!!!!!!!!! For the moment thresholds are not read
c3986754 454 }
455 else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
456 fIsHeaderMapping = kTRUE;
457 fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
458 fModType = ((fBuffer & 0x7ff00)>>8);
459 fADCNChannels = (fBuffer & 0xff); // # of channels following the header
1ee299a5 460 //
c083685e 461 printf(" ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
6006df88 462 }
c3986754 463 else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
464 fADCChannel = ((fBuffer & 0x3fff0000)>>16);
465 fCabledSignal = (fBuffer&0xffff);
466 //
27afc0c8 467 if(fModType == kV965){ // ******** ADCs ********************************
480ac371 468 // Channel signal
469 if((fBuffer&0x40000000)>>30==0 && fADCModule<=kLastADCGeo){ // *ZDC* high range chain ADC
c3986754 470 fIsChMapping = kTRUE;
471 fMapADC[fCurrentCh][0] = fADCModule;
472 fMapADC[fCurrentCh][1] = fADCChannel;
473 fMapADC[fCurrentCh][2] = fCabledSignal;
474 // - No. of channels on
475 fNChannelsOn++;
476 //
477 // Determining detector and sector
478 // -----------------------------------------
479 // For the decoding of the following lines
480 // look the enum in AliZDCRawStream.h file
481 // -----------------------------------------
482 if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
483 || fCabledSignal==24 || fCabledSignal==48){
484 fMapADC[fCurrentCh][3] = 4; //ZNA
485 //
8c76923f 486 if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot) fMapADC[fCurrentCh][4]=0;
487 else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1oot) fMapADC[fCurrentCh][4]=1;
488 else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2oot) fMapADC[fCurrentCh][4]=2;
489 else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3oot) fMapADC[fCurrentCh][4]=3;
490 else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4oot) fMapADC[fCurrentCh][4]=4;
491 else if(fCabledSignal==kZDCAMon || fCabledSignal==kZDCAMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
c3986754 492 }
493 else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
494 fMapADC[fCurrentCh][3] = 5; //ZPA
495 //
8c76923f 496 if(fCabledSignal==kZPAC || fCabledSignal==kZPACoot) fMapADC[fCurrentCh][4]=0;
497 else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1oot) fMapADC[fCurrentCh][4]=1;
498 else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2oot) fMapADC[fCurrentCh][4]=2;
499 else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3oot) fMapADC[fCurrentCh][4]=3;
500 else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4oot) fMapADC[fCurrentCh][4]=4;
c3986754 501 }
502 else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
503 || fCabledSignal==25 || fCabledSignal==49){
504 fMapADC[fCurrentCh][3] = 1; //ZNC
505 //
8c76923f 506 if(fCabledSignal==kZNCC || fCabledSignal==kZNCCoot) fMapADC[fCurrentCh][4]=0;
507 else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1oot) fMapADC[fCurrentCh][4]=1;
508 else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2oot) fMapADC[fCurrentCh][4]=2;
509 else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3oot) fMapADC[fCurrentCh][4]=3;
510 else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4oot) fMapADC[fCurrentCh][4]=4;
511 else if(fCabledSignal==kZDCCMon || fCabledSignal==kZDCCMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
c3986754 512 }
513 else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
514 fMapADC[fCurrentCh][3] = 2; //ZPC
515 //
8c76923f 516 if(fCabledSignal==kZPCC || fCabledSignal==kZPCCoot) fMapADC[fCurrentCh][4]=0;
517 else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1oot) fMapADC[fCurrentCh][4]=1;
518 else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2oot) fMapADC[fCurrentCh][4]=2;
519 else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3oot) fMapADC[fCurrentCh][4]=3;
520 else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4oot) fMapADC[fCurrentCh][4]=4;
c3986754 521 }
522 else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
523 fMapADC[fCurrentCh][3] = 3; // ZEM
524 //
8c76923f 525 if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1oot) fMapADC[fCurrentCh][4]=1;
526 else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2oot) fMapADC[fCurrentCh][4]=2;
c3986754 527 }
528 //Ch. debug
529 //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
530 //printf(" det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
531 //
532 fCurrentCh++;
533 //
534 } // high range channels
535 }// ModType=1 (ADC mapping)
27afc0c8 536 else if(fModType == kV830){ // ******** VME scaler **************************
c3986754 537 fIsChMapping = kTRUE;
538 fScalerMap[fCurrScCh][0] = fADCModule;
539 fScalerMap[fCurrScCh][1] = fADCChannel;
540 fScalerMap[fCurrScCh][2] = fCabledSignal;
c93c022b 541 //
542 // Determining detector and sector
543 // -----------------------------------------
544 // For the decoding of the following lines
545 // look the enum in AliZDCRawStream.h file
546 // -----------------------------------------
c3986754 547 // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
90936733 548 if((fCabledSignal>=2 && fCabledSignal<=6) ||
549 (fCabledSignal>=61 && fCabledSignal<=65)){
c3986754 550 fScalerMap[fCurrScCh][3] = 4; //ZNA
c93c022b 551 //
8c76923f 552 if(fCabledSignal==kZNAC || fCabledSignal==kZNACD) fScalerMap[fCurrScCh][4]=0;
553 else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1D) fScalerMap[fCurrScCh][4]=1;
554 else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2D) fScalerMap[fCurrScCh][4]=2;
555 else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3D) fScalerMap[fCurrScCh][4]=3;
556 else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4D) fScalerMap[fCurrScCh][4]=4;
c93c022b 557 }
90936733 558 else if((fCabledSignal>=7 && fCabledSignal<=11) ||
559 (fCabledSignal>=66 && fCabledSignal<=70)){
c3986754 560 fScalerMap[fCurrScCh][3] = 5; //ZPA
c93c022b 561 //
8c76923f 562 if(fCabledSignal==kZPAC || fCabledSignal==kZPACD) fScalerMap[fCurrScCh][4]=0;
563 else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1D) fScalerMap[fCurrScCh][4]=1;
564 else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2D) fScalerMap[fCurrScCh][4]=2;
565 else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3D) fScalerMap[fCurrScCh][4]=3;
566 else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4D) fScalerMap[fCurrScCh][4]=4;
c93c022b 567 }
90936733 568 else if((fCabledSignal>=12 && fCabledSignal<=16) ||
569 (fCabledSignal>=71 && fCabledSignal<=75)){
c3986754 570 fScalerMap[fCurrScCh][3] = 1; //ZNC
c93c022b 571 //
8c76923f 572 if(fCabledSignal==kZNCC || fCabledSignal==kZNCCD) fScalerMap[fCurrScCh][4]=0;
573 else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1D) fScalerMap[fCurrScCh][4]=1;
574 else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2D) fScalerMap[fCurrScCh][4]=2;
575 else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3D) fScalerMap[fCurrScCh][4]=3;
576 else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4D) fScalerMap[fCurrScCh][4]=4;
c93c022b 577 }
90936733 578 else if((fCabledSignal>=17 && fCabledSignal<=21) ||
579 (fCabledSignal>=76 && fCabledSignal<=80)){
c3986754 580 fScalerMap[fCurrScCh][3] = 2; //ZPC
c93c022b 581 //
8c76923f 582 if(fCabledSignal==kZPCC || fCabledSignal==kZPCCD) fScalerMap[fCurrScCh][4]=0;
583 else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1D) fScalerMap[fCurrScCh][4]=1;
584 else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2D) fScalerMap[fCurrScCh][4]=2;
585 else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3D) fScalerMap[fCurrScCh][4]=3;
586 else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4D) fScalerMap[fCurrScCh][4]=4;
c93c022b 587 }
480ac371 588 else if(fCabledSignal==22 || fCabledSignal==23 ||
589 fCabledSignal==81 || fCabledSignal==82){
c3986754 590 fScalerMap[fCurrScCh][3] = 3; // ZEM
c93c022b 591 //
8c76923f 592 if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1D) fScalerMap[fCurrScCh][4]=1;
593 else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2D) fScalerMap[fCurrScCh][4]=2;
c93c022b 594 }
c3986754 595 // Ch debug.
a27ef05f 596 /*printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
82dffa48 597 if(fCabledSignal!=0 && fCabledSignal!=1) printf(" det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
a27ef05f 598 else printf(" Signal void/not connected\n");*/
c3986754 599
600 fCurrScCh++;
601 }
82dffa48 602 else if(fModType==KV1290 && fADCModule==kZDCTDCGeo){ // ******** ZDC TDC **************************
603 fIsChMapping = kTRUE;
604 fTDCMap[fCurrTDCCh][0] = fADCModule;
605 fTDCMap[fCurrTDCCh][1] = fADCChannel;
606 fTDCMap[fCurrTDCCh][2] = fCabledSignal;
607
608 fCurrTDCCh++;
609
a27ef05f 610 // Ch debug.
611 //printf("\tZDC TDC: mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
82dffa48 612 }
27afc0c8 613 /*else if(fModType == kTRG){ // **** scalers from trigger card
c3986754 614 //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
615 }
27afc0c8 616 else if(fModType == kTRGI){ // **** trigger history from trigger card
c3986754 617 //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
618 }
27afc0c8 619 else if(fModType == kPU){ // **** pattern unit
c3986754 620 //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
27afc0c8 621 }*/
c3986754 622 }//reading channel mapping
1ee299a5 623 }
1e85619e 624 } // if fSODREading
625 fPosition++;
626 return kTRUE;
44455047 627 } // ------------------------------- SOD event
1ee299a5 628
629 // -------------------------------------------
630 // --- DARC data
631 // -------------------------------------------
a5747d8f 632 if(fPosition<fDeadfaceOffset && fReadOutCard==0){
633 fPosition++;
634 return kTRUE;
635 }
636 else if(fPosition==fDeadfaceOffset && fReadOutCard==0){
637 if(fBuffer != 0xdeadface){
a44b6e36 638 //AliWarning(" NO deadface after DARC data");
a5747d8f 639 fRawReader->AddMajorErrorLog(kDARCError);
640 }
641 else{
1ee299a5 642 fPosition++;
643 return kTRUE;
644 }
a5747d8f 645 }
646 else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){
647 fPosition++;
648 return kTRUE;
649 }
650 else if(fPosition==fDeadbeefOffset && fReadOutCard==0){
651 if(fBuffer != 0xdeadbeef){
a44b6e36 652 //AliWarning(" NO deadbeef after DARC global data");
a5747d8f 653 fRawReader->AddMajorErrorLog(kDARCError);
654 fPosition++;
655 return kFALSE;
1ee299a5 656 }
a5747d8f 657 else{
1ee299a5 658 fPosition++;
659 return kTRUE;
660 }
1e85619e 661 } // ------------------------------- End of DARC data
44455047 662
1e85619e 663 // ---------------------------------------------
1ee299a5 664 // --- ZDC data
c3986754 665 // --- ADCs + VME scaler + trigger card + P.U.
1e85619e 666 // ---------------------------------------------
1ee299a5 667 else if(fPosition>=fDataOffset){
fee50699 668
fee50699 669 if(!fSODReading && !fIsMapRead) ReadChMap();
670
44455047 671 // !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!!
1ee299a5 672 // Not valid datum before the event
673 // there MUST be a NOT valid datum before the event!!!
44455047 674 if(fReadOutCard==0){
a5747d8f 675 if(fPosition==fDataOffset){
44455047 676 //printf("\t **** ZDC data begin ****\n");
677 if((fBuffer & 0x07000000) != 0x06000000){
678 fRawReader->AddMajorErrorLog(kZDCDataError);
679 }
680 else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
681 fIsADCEventGood = kFALSE;
682 }
c3986754 683 }
1ee299a5 684
44455047 685 // If the not valid datum isn't followed by the 1st ADC header
686 // the event is corrupted (i.e., 2 gates arrived before trigger)
a5747d8f 687 else if(fPosition==fDataOffset+1){
44455047 688 if((fBuffer & 0x07000000) != 0x02000000){
689 AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
690 fRawReader->AddMajorErrorLog(kZDCDataError);
691 fIsADCEventGood = kFALSE;
692 fPosition++;
693 return kFALSE;
694 }
1ee299a5 695 }
696 }
697
c3986754 698 // Get geo address of current word
8c76923f 699 if(fIsTDCHeaderRead && fIsZDCTDCHeader) fADCModule = kZDCTDCGeo;
700 else if(fIsTDCHeaderRead && fIsADDTDCHeader) fADCModule = kADDTDCGeo;
701 else fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
c083685e 702
c3986754 703 // ************************************ ADC MODULES ************************************
704 if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo){
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",
84d2abc2 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 }
742 if(foundMapEntry==kFALSE){
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
6d653649 748 if(foundMapEntry==kTRUE){
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;
7fba2a9c 773 //printf(" AliZDCRawStream -> 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;
797 //printf(" AliZDCRawStream -> EOB --------------------------\n");
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
810 //printf(" AliZDCRawStream -> ZDC TDC: 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 }
831 else if(!(fBuffer & 0x04000000)){
832 fIsScEventGood = kFALSE;
833 }
c3986754 834 }
da090841 835 // *********************************** PATTERN UNIT ***********************************
c3986754 836 else if(fADCModule == kPUGeo){
837 // still to be implemented!!! Not yet in data!!!
da090841 838 fDetPattern = (fBuffer & 0x0000003f);
f70a5526 839 // Ch. debug
840 //printf(" AliZDCRawStream -> Pattern Unit\n");
841
c3986754 842 }
da090841 843 // ******************************** TRIGGER CARD COUNTS ********************************
c3986754 844 else if(fADCModule == kTrigScales){
f70a5526 845 if(fIsTriggerScaler == kFALSE){
846 fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
da090841 847 fTrigCountStart = fPosition;
f70a5526 848 fIsTriggerScaler = kTRUE;
da090841 849 }
f70a5526 850 // Ch. debug
851 //printf(" AliZDCRawStream -> Trigger Scaler header\n");
c3986754 852 }
da090841 853 // ********************************** TRIGGER HISTORY **********************************
c3986754 854 else if(fADCModule == kTrigHistory){
f70a5526 855 if(fIsTriggerHistory == kFALSE){
856 fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
857 fTrigHistStart = fPosition;
858 fIsTriggerHistory = kTRUE;
da090841 859 }
f70a5526 860 // Ch. debug
861 //printf(" AliZDCRawStream -> Trigger History header\n");
862
c3986754 863 }
da090841 864 // ********************************** VME SCALER DATA **********************************
c3986754 865 // Reading VME scaler data
c083685e 866 if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
ad3a602e 867 fADCModule=kScalerGeo; fIsADCDataWord=kFALSE; fIsScalerWord=kTRUE;
c083685e 868 fScEvCounter = fBuffer;
869 Int_t nWords = (Int_t) (fScNWords);
870 if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
871 //Ch. debug
872 //printf(" AliZDCRawStream -> scaler datum %d", fScEvCounter);
873 }
198f612a 874 // ********************************** ZDC TDC DATA **********************************
875 // ZDC TDC data
8c76923f 876 if(fIsTDCHeaderRead && fIsZDCTDCHeader && fPosition>=fTDCStartCounter+1){
877 fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
878 if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
879 fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
2d9c70ab 880 fIsZDCTDCdatum = kTRUE;
8c76923f 881 fZDCTDCdatum = (Int_t) (fBuffer & 0x1fffff);
882 // Ch. debug
883 //printf(" AliZDCRawStream -> ZDC TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fZDCTDCdatum);
884 }
885 if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
886 // Trailer
887 fIsTDCHeaderRead = kFALSE;
888 // Ch. debug
889 //printf(" AliZDCRawStream -> ZDC TDC global trailer\n");
890 }
891 }
892 // ********************************** ADD TDC DATA **********************************
893 // ADD TDC data
894 if(fIsTDCHeaderRead && fIsADDTDCHeader && fPosition>=fTDCStartCounter+1){
198f612a 895 fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
8c76923f 896 if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
897 fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
2d9c70ab 898 fIsADDTDCdatum = kTRUE;
8c76923f 899 fADDTDCdatum = (Int_t) (fBuffer & 0x1fffff);
900 // Ch. debug
901 //printf(" AliZDCRawStream -> ADD TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fADDTDCdatum);
902 }
198f612a 903 if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
8c76923f 904 // Trailer
198f612a 905 fIsTDCHeaderRead = kFALSE;
906 // Ch. debug
8c76923f 907 //printf(" AliZDCRawStream -> ADD TDC global trailer\n");
198f612a 908 }
909 }
f70a5526 910 // ******************************** TRIGGER SCALER DATA ********************************
911 // Reading trigger scaler data
912 if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
8700404e 913 fADCModule = kTrigScales; fIsADCDataWord = kFALSE;
f70a5526 914 if(fPosition == fTrigCountStart+1) fMBTrigInput = fBuffer;
915 else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;
916 else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
917 else if(fPosition == fTrigCountStart+4) fEMDTrigInput = fBuffer;
918 else if(fPosition == fTrigCountStart+5) fL0Received = fBuffer;
919 else if(fPosition == fTrigCountStart+6) fMBtrig2CTP = fBuffer;
920 else if(fPosition == fTrigCountStart+7) fCentralTrig2CTP = fBuffer;
921 else if(fPosition == fTrigCountStart+8) fSCentralTrig2CTP = fBuffer;
922 else if(fPosition == fTrigCountStart+9){
923 fEMDTrig2CTP = fBuffer;
924 fIsTriggerScaler = kFALSE;
925 }
926 // Ch. debug
927 //printf(" AliZDCRawStream -> Trigger Scaler datum %d\n", fPosition-fTrigCountStart);
928 }
929 // ******************************* TRIGGER HISTORY WORDS ******************************
930 // Reading trigger history
931 if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
8700404e 932 fADCModule = kTrigHistory; fIsADCDataWord = kFALSE;
f70a5526 933 if(fPosition == fTrigHistStart+1){
934 fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
935 fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;
936 fCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
937 fMBTrigHist = (fBuffer & 0x00007fff);
938 //
939 fCPTInput[0] = (fBuffer & 0x00000080) >> 6; // MB bit
940 fCPTInput[1] = (fBuffer & 0x00400000) >> 21; // CENTRAL bit
941 }
942
943 else if(fPosition == fTrigHistStart+fTrigHistNWords){
944 fPileUpBit2ndWord = (fBuffer & 0x80000000) >> 31;
945 fL0Bit2ndWord = (fBuffer & 0x40000000) >> 30;
946 fSCentralTrigHist = (fBuffer & 0x3fff8000) >> 14;
947 fEMDTrigHist = (fBuffer & 0x00007fff);
948 //
949 fCPTInput[2] = (fBuffer & 0x00000080) >> 6; // SEMICENTRAL bit
950 fCPTInput[3] = (fBuffer & 0x00400000) >> 21; // EMD bit
951 //
952 fIsTriggerHistory = kFALSE;
953
954 // Checking if the event is good
955 // (1) both history word pile up bits must be = 0
956 if(fPileUpBit1stWord==0 && fPileUpBit2ndWord==0) fIsPileUpEvent = kFALSE;
957 else{
958 fIsPileUpEvent = kTRUE;
959 printf(" AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
13390187 960 fPileUpBit1stWord, fPileUpBit2ndWord);
f70a5526 961 }
962 // (2) both history word L0 bits must be = 1
963 if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
964 else{
965 fIsL0BitSet = kFALSE;
966 printf(" AliZDCRawStream -> L0 wrongly set: bitL0word0 %d bitL0word1 %d\n",
967 fL0Bit1stWord, fL0Bit2ndWord);
968 }
969 }
970 // Ch. debug
971 //printf(" AliZDCRawStream -> Trigger history word %d\n", fPosition-fTrigHistStart);
972 }
1ee299a5 973
974 }
f70a5526 975
1ee299a5 976 fPosition++;
83347831 977
8309c1ab 978 return kTRUE;
979}
e42bdf10 980
fee50699 981//_____________________________________________________________________________
982AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri)
983{
984 // Setting the storage
985
986 AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri);
987
988 return storage;
989}
990
991
992//_____________________________________________________________________________
993AliZDCChMap* AliZDCRawStream::GetChMap() const
994{
995
996 // Getting calibration object for ZDC
997
998 AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
999 if(!entry) AliFatal("No calibration data loaded!");
1000
1001 AliZDCChMap *calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
1002 if(!calibdata) AliFatal("Wrong calibration object in calibration file!");
1003
1004 return calibdata;
1005}