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