]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - ZDC/AliZDCRawStream.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Moving reconstruction settings to the reco params, new cosmics reco param OCDB entry...
[u/mrichter/AliRoot.git] / ZDC / AliZDCRawStream.cxx
... / ...
CommitLineData
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///////////////////////////////////////////////////////////////////////////////
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// //
27///////////////////////////////////////////////////////////////////////////////
28
29#include <TSystem.h>
30#include "AliZDCRawStream.h"
31#include "AliRawReader.h"
32#include "AliRawDataHeader.h"
33#include "AliRawEventHeaderBase.h"
34#include "AliLog.h"
35
36ClassImp(AliZDCRawStream)
37
38
39//_____________________________________________________________________________
40AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
41 fRawReader(rawReader),
42 fBuffer(0),
43 fReadOutCard(-1),
44 fEvType(0),
45 fPosition(0),
46 fIsCalib(kFALSE),
47 fIsDARCHeader(kFALSE),
48 fIsHeaderMapping(kFALSE),
49 fIsChMapping(kFALSE),
50 fIsADCDataWord(kFALSE),
51 fIsADCHeader(kFALSE),
52 fIsADCEOB(kFALSE),
53 fSODReading(kFALSE),
54 fIsMapRead(kFALSE),
55 fDeadfaceOffset(-1),
56 fDeadbeefOffset(-1),
57 fDataOffset(0),
58 fModType(-1),
59 fADCModule(-1),
60 fADCNChannels(-1),
61 fADCChannel(-1),
62 fADCValue(-1),
63 fADCGain(-1),
64 fIsUnderflow(kFALSE),
65 fIsOverflow(kFALSE),
66 fScGeo(0),
67 fScNWords(0),
68 fScTriggerSource(0),
69 fScTriggerNumber(0),
70 fIsScEventGood(kTRUE),
71 fIsScHeaderRead(kFALSE),
72 fScStartCounter(0),
73 fScEvCounter(0),
74 fDetPattern(0),
75 fTrigCountNWords(0),
76 fIsTriggerScaler(kFALSE),
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),
88 fIsTriggerHistory(kFALSE),
89 fTrigHistStart(0),
90 fPileUpBit1stWord(0),
91 fL0Bit1stWord(0),
92 fCentralTrigHist(0),
93 fMBTrigHist(0),
94 fPileUpBit2ndWord(0),
95 fL0Bit2ndWord(0),
96 fSCentralTrigHist(0),
97 fEMDTrigHist(0),
98 fNChannelsOn(0),
99 fCurrentCh(-1),
100 fCabledSignal(-1),
101 fCurrScCh(-1),
102 fIsADCEventGood(kTRUE),
103 fIsL0BitSet(kTRUE),
104 fIsPileUpEvent(kFALSE)
105{
106 // Create an object to read ZDC raw digits
107 fRawReader->Reset();
108 fRawReader->Select("ZDC");
109 //
110 const int kNch = 48;
111 for(Int_t i=0; i<kNch; i++){
112 for(Int_t j=0; j<5; j++){
113 fMapADC[i][j]=-1;
114 if(i<32) fScalerMap[i][j]=-1;
115 }
116 }
117
118 for(Int_t k=0; k<4; k++) fCPTInput[k] = 0;
119
120}
121
122//_____________________________________________________________________________
123AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
124 TObject(stream),
125 fRawReader(stream.fRawReader),
126 fBuffer(stream.GetRawBuffer()),
127 fReadOutCard(stream.GetReadOutCard()),
128 fEvType(stream.fEvType),
129 fPosition(stream.fPosition),
130 fIsCalib(stream.fIsCalib),
131 fIsDARCHeader(stream.fIsDARCHeader),
132 fIsHeaderMapping(stream.fIsHeaderMapping),
133 fIsChMapping(stream.fIsChMapping),
134 fIsADCDataWord(stream.fIsADCDataWord),
135 fIsADCHeader(stream.fIsADCHeader),
136 fIsADCEOB(stream.fIsADCEOB),
137 fSODReading(stream.fSODReading),
138 fIsMapRead(stream.fIsMapRead),
139 fDeadfaceOffset(stream.GetDeadfaceOffset()),
140 fDeadbeefOffset(stream.GetDeadbeefOffset()),
141 fDataOffset(stream.GetDataOffset()),
142 fModType(stream.GetModType()),
143 fADCModule(stream.GetADCModule()),
144 fADCNChannels(stream.GetADCNChannels()),
145 fADCChannel(stream.GetADCChannel()),
146 fADCValue(stream.GetADCValue()),
147 fADCGain(stream.GetADCGain()),
148 fIsUnderflow(stream.fIsUnderflow),
149 fIsOverflow(stream.fIsOverflow),
150 fScGeo(stream.GetScGeo()),
151 fScNWords(stream.GetScNWords()),
152 fScTriggerSource(stream.GetScTriggerSource()),
153 fScTriggerNumber(stream.fScTriggerNumber),
154 fIsScEventGood(stream.fIsScEventGood),
155 fIsScHeaderRead(stream.fIsScHeaderRead),
156 fScStartCounter(stream.fScStartCounter),
157 fScEvCounter(stream.fScEvCounter),
158 fDetPattern(stream.fDetPattern),
159 fTrigCountNWords(stream.fTrigCountNWords),
160 fIsTriggerScaler(stream.fIsTriggerScaler),
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),
172 fIsTriggerHistory(stream.fIsTriggerHistory),
173 fTrigHistStart(stream.fTrigHistStart),
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),
182 fNChannelsOn(stream.fNChannelsOn),
183 fCurrentCh(stream.fCurrentCh),
184 fCabledSignal(stream.GetCabledSignal()),
185 fCurrScCh(stream.fCurrScCh),
186 fIsADCEventGood(stream.fIsADCEventGood),
187 fIsL0BitSet(stream.fIsL0BitSet),
188 fIsPileUpEvent(stream.fIsPileUpEvent)
189
190{
191 // Copy constructor
192 const int kNch = 48;
193 for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j);
194 for(Int_t i=0; i<kNch; i++){
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 }
199 }
200
201 for(Int_t k=0; k<4; k++) fCPTInput[k] = stream.fCPTInput[k];
202}
203
204//_____________________________________________________________________________
205AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream&
206 /* stream */)
207{
208 // Assignment operator
209 Fatal("operator =", "assignment operator not implemented");
210 return *this;
211}
212
213//_____________________________________________________________________________
214AliZDCRawStream::~AliZDCRawStream()
215{
216// Destructor
217
218}
219
220//_____________________________________________________________________________
221void AliZDCRawStream::ReadChMap()
222{
223 // Reading channel map
224 const int kNch = 48;
225 //printf("\t Reading ZDC ADC mapping from OCDB\n");
226 AliZDCChMap * chMap = GetChMap();
227 //chMap->Print("");
228 for(Int_t i=0; i<kNch; i++){
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;
236}
237
238//_____________________________________________________________________________
239void AliZDCRawStream::ReadCDHHeader()
240{
241 // Reading CDH
242 const AliRawDataHeader* header = fRawReader->GetDataHeader();
243 if(!header) {
244 AliError(" No CDH in raw data streaming");
245 fRawReader->AddMajorErrorLog(kCDHError);
246 return;
247 }
248 else{
249 printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
250
251 UChar_t message = header->GetAttributes();
252 printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
253
254 if(message == 0x0){ // PHYSICS RUN
255 //printf("\t PHYSICS RUN raw data found\n");
256 }
257 else if(message == 0x10){ // COSMIC RUN
258 //printf("\t STANDALONE_COSMIC RUN raw data found\n");
259 }
260 else if(message == 0x20){ // PEDESTAL RUN
261 //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
262 }
263 else if(message == 0x30){ // LASER RUN
264 //printf("\t STANDALONE_LASER RUN raw data found\n");
265 }
266 else if(message == 0x40){ // CALIBRATION_CENTRAL RUN
267 //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
268 }
269 else if(message == 0x50){ // CALIBRATION_SEMICENTRAL
270 //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
271 }
272 else if(message == 0x60){ // CALIBRATION_MB
273 //printf("\t CALIBRATION_MB RUN raw data found\n");
274 }
275 else if(message == 0x70){ // CALIBRATION_EMD
276 //printf("\t CALIBRATION_EMD RUN raw data found\n");
277 }
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;
283 }
284 else if((message & 0x08) == 1){ // ** ZRC card
285 fReadOutCard = 1;
286 }
287
288 if(header->GetL1TriggerMessage() & 0x1){ // Calibration bit set in CDH
289 fIsCalib = kTRUE;
290 }
291 printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
292 printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);
293
294 UInt_t status = header->GetStatus();
295 //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status);
296 if((status & 0x000f) == 0x0001){
297 AliDebug(2,"CDH -> DARC trg0 overlap error");
298 fRawReader->AddMajorErrorLog(kDARCError);
299 }
300 if((status & 0x000f) == 0x0002){
301 AliDebug(2,"CDH -> DARC trg0 missing error");
302 fRawReader->AddMajorErrorLog(kDARCError);
303 }
304 if((status & 0x000f) == 0x0004){
305 AliDebug(2,"CDH -> DARC data parity error");
306 fRawReader->AddMajorErrorLog(kDARCError);
307 }
308 if((status & 0x000f) == 0x0008){
309 AliDebug(2,"CDH -> DARC ctrl parity error");
310 fRawReader->AddMajorErrorLog(kDARCError);
311 }
312 //
313 if((status & 0x00f0) == 0x0010){
314 AliDebug(2,"CDH -> DARC trg unavailable");
315 fRawReader->AddMajorErrorLog(kDARCError);
316 }
317 if((status & 0x00f0) == 0x0020){
318 AliDebug(2,"CDH -> DARC FEE error");
319 fRawReader->AddMajorErrorLog(kDARCError);
320 }
321 //
322 if((status & 0x0f00) == 0x0200){
323 AliDebug(2,"CDH -> DARC L1 time violation");
324 fRawReader->AddMajorErrorLog(kDARCError);
325 }
326 if((status & 0x0f00) == 0x0400){
327 AliDebug(2,"CDH -> DARC L2 time-out");
328 fRawReader->AddMajorErrorLog(kDARCError);
329 }
330 if((status & 0x0f00) == 0x0800){
331 AliDebug(2,"CDH -> DARC prepulse time violation");
332 fRawReader->AddMajorErrorLog(kDARCError);
333 }
334 //
335 if((status & 0xf000) == 0x1000){
336 AliDebug(2,"CDH -> DARC other error");
337 fRawReader->AddMajorErrorLog(kDARCError);
338 }
339 }
340
341}
342
343//_____________________________________________________________________________
344Bool_t AliZDCRawStream::Next()
345{
346 // Read the next raw digit
347 // Returns kFALSE if there is no digit left
348
349 if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
350 const int kNch = 48;
351 Int_t kFirstADCGeo=0, kLastADCGeo=3, kScalerGeo=8, kPUGeo=29, kTrigScales=30, kTrigHistory=31;
352 fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE;
353 fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
354 fIsUnderflow = kFALSE; fIsOverflow = kFALSE;
355 fSector[0] = fSector[1] = -1;
356// fTrigCountNWords = 9; fTrigHistNWords = 2;
357 for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
358
359 fEvType = fRawReader->GetType();
360 if(fPosition==0){
361 //if(fEvType==7 || fEvType ==8){ //Physics or calibration event
362 //ReadEventHeader();
363 ReadCDHHeader();
364 //}
365 fCurrentCh=0; fCurrScCh=0; fNChannelsOn=0;
366 // Ch. debug
367 //printf("\n AliZDCRawStream::Next() - ev. type %d",fEvType);
368 }
369
370 // Ch. debug
371 //printf("\n AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
372
373 // *** End of ZDC event
374 if(fBuffer == 0xcafefade){
375 //printf("\n-> AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
376 return kFALSE;
377 }
378
379 // -------------------------------------------
380 // --- DARC header
381 // -------------------------------------------
382 // If the CDH has been read then
383 // the DARC header must follow
384 if(fReadOutCard==0 && fIsDARCHeader){
385 //printf("\t ---- DARC header ----\n");
386 if(fIsCalib){
387 fDeadfaceOffset = 9;
388 fDeadbeefOffset = 25;
389 }
390 else{
391 fDeadfaceOffset = 1;
392 fDeadbeefOffset = 7;
393 }
394 fDataOffset = 1+fDeadbeefOffset;
395 fIsDARCHeader = kFALSE;
396 }
397
398
399 // ---------------------------------------------
400 // --- Start of data event (SOD) ---
401 // --- decoding mapping of connected ADC ch. ---
402 // ---------------------------------------------
403 // In the SOD event ADC ch. mapping is written
404 if(fEvType==10 && fSODReading){
405 //printf("\n-> AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
406
407 if(fPosition>fDataOffset){
408 if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
409 if(fPosition==(fDataOffset+1)){
410 printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
411 fCurrentCh=0; fCurrScCh=0;
412 }
413 else{
414 printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
415 //printf("AliZDCRawStream: fSODReading after SOD reading set to %d\n", fSODReading);
416 return kFALSE;
417 }
418 }
419 else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
420 fPosition++;
421 return kFALSE;
422 }
423 else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
424 fIsHeaderMapping = kTRUE;
425 fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
426 fModType = ((fBuffer & 0x7ff00)>>8);
427 fADCNChannels = (fBuffer & 0xff); // # of channels following the header
428 //
429 printf(" ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
430 }
431 else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
432 fADCChannel = ((fBuffer & 0x3fff0000)>>16);
433 fCabledSignal = (fBuffer&0xffff);
434 //
435 if(fModType==1){ // ******** ADCs ********************************
436 // Channel signal
437 if((fBuffer&0x40000000)>>30==0){ // high range chain ADC
438 fIsChMapping = kTRUE;
439 fMapADC[fCurrentCh][0] = fADCModule;
440 fMapADC[fCurrentCh][1] = fADCChannel;
441 fMapADC[fCurrentCh][2] = fCabledSignal;
442 // - No. of channels on
443 fNChannelsOn++;
444 //
445 // Determining detector and sector
446 // -----------------------------------------
447 // For the decoding of the following lines
448 // look the enum in AliZDCRawStream.h file
449 // -----------------------------------------
450 if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
451 || fCabledSignal==24 || fCabledSignal==48){
452 fMapADC[fCurrentCh][3] = 4; //ZNA
453 //
454 if(fCabledSignal==2 || fCabledSignal==26) fMapADC[fCurrentCh][4]=0;
455 else if(fCabledSignal==3 || fCabledSignal==27) fMapADC[fCurrentCh][4]=1;
456 else if(fCabledSignal==4 || fCabledSignal==28) fMapADC[fCurrentCh][4]=2;
457 else if(fCabledSignal==5 || fCabledSignal==29) fMapADC[fCurrentCh][4]=3;
458 else if(fCabledSignal==6 || fCabledSignal==30) fMapADC[fCurrentCh][4]=4;
459 else if(fCabledSignal==24 || fCabledSignal==48) fMapADC[fCurrentCh][4]=5; //Reference PTM
460 }
461 else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
462 fMapADC[fCurrentCh][3] = 5; //ZPA
463 //
464 if(fCabledSignal==7 || fCabledSignal==31) fMapADC[fCurrentCh][4]=0;
465 else if(fCabledSignal==8 || fCabledSignal==32) fMapADC[fCurrentCh][4]=1;
466 else if(fCabledSignal==9 || fCabledSignal==33) fMapADC[fCurrentCh][4]=2;
467 else if(fCabledSignal==10 || fCabledSignal==34) fMapADC[fCurrentCh][4]=3;
468 else if(fCabledSignal==11 || fCabledSignal==35) fMapADC[fCurrentCh][4]=4;
469 }
470 else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
471 || fCabledSignal==25 || fCabledSignal==49){
472 fMapADC[fCurrentCh][3] = 1; //ZNC
473 //
474 if(fCabledSignal==12 || fCabledSignal==36) fMapADC[fCurrentCh][4]=0;
475 else if(fCabledSignal==13 || fCabledSignal==37) fMapADC[fCurrentCh][4]=1;
476 else if(fCabledSignal==14 || fCabledSignal==38) fMapADC[fCurrentCh][4]=2;
477 else if(fCabledSignal==15 || fCabledSignal==39) fMapADC[fCurrentCh][4]=3;
478 else if(fCabledSignal==16 || fCabledSignal==40) fMapADC[fCurrentCh][4]=4;
479 else if(fCabledSignal==25 || fCabledSignal==49) fMapADC[fCurrentCh][4]=5; //Reference PTM
480 }
481 else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
482 fMapADC[fCurrentCh][3] = 2; //ZPC
483 //
484 if(fCabledSignal==17 || fCabledSignal==41) fMapADC[fCurrentCh][4]=0;
485 else if(fCabledSignal==18 || fCabledSignal==42) fMapADC[fCurrentCh][4]=1;
486 else if(fCabledSignal==19 || fCabledSignal==43) fMapADC[fCurrentCh][4]=2;
487 else if(fCabledSignal==20 || fCabledSignal==44) fMapADC[fCurrentCh][4]=3;
488 else if(fCabledSignal==21 || fCabledSignal==45) fMapADC[fCurrentCh][4]=4;
489 }
490 else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
491 fMapADC[fCurrentCh][3] = 3; // ZEM
492 //
493 if(fCabledSignal==22 || fCabledSignal==46) fMapADC[fCurrentCh][4]=1;
494 else if(fCabledSignal==23 || fCabledSignal==47) fMapADC[fCurrentCh][4]=2;
495 }
496 //Ch. debug
497 //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
498 //printf(" det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
499 //
500 fCurrentCh++;
501 //
502 } // high range channels
503 }// ModType=1 (ADC mapping)
504 else if(fModType==2){ // ******** VME scaler **************************
505 fIsChMapping = kTRUE;
506 fScalerMap[fCurrScCh][0] = fADCModule;
507 fScalerMap[fCurrScCh][1] = fADCChannel;
508 fScalerMap[fCurrScCh][2] = fCabledSignal;
509 //
510 // Determining detector and sector
511 // -----------------------------------------
512 // For the decoding of the following lines
513 // look the enum in AliZDCRawStream.h file
514 // -----------------------------------------
515 // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
516 if(fCabledSignal>=2 && fCabledSignal<=6){
517 fScalerMap[fCurrScCh][3] = 4; //ZNA
518 //
519 if(fCabledSignal==2 ) fScalerMap[fCurrScCh][4]=0;
520 else if(fCabledSignal==3) fScalerMap[fCurrScCh][4]=1;
521 else if(fCabledSignal==4) fScalerMap[fCurrScCh][4]=2;
522 else if(fCabledSignal==5) fScalerMap[fCurrScCh][4]=3;
523 else if(fCabledSignal==6) fScalerMap[fCurrScCh][4]=4;
524 }
525 else if(fCabledSignal>=7 && fCabledSignal<=11){
526 fScalerMap[fCurrScCh][3] = 5; //ZPA
527 //
528 if(fCabledSignal==7 ) fScalerMap[fCurrScCh][4]=0;
529 else if(fCabledSignal==8) fScalerMap[fCurrScCh][4]=1;
530 else if(fCabledSignal==9) fScalerMap[fCurrScCh][4]=2;
531 else if(fCabledSignal==10) fScalerMap[fCurrScCh][4]=3;
532 else if(fCabledSignal==11) fScalerMap[fCurrScCh][4]=4;
533 }
534 else if(fCabledSignal>=12 && fCabledSignal<=16){
535 fScalerMap[fCurrScCh][3] = 1; //ZNC
536 //
537 if(fCabledSignal==12) fScalerMap[fCurrScCh][4]=0;
538 else if(fCabledSignal==13) fScalerMap[fCurrScCh][4]=1;
539 else if(fCabledSignal==14) fScalerMap[fCurrScCh][4]=2;
540 else if(fCabledSignal==15) fScalerMap[fCurrScCh][4]=3;
541 else if(fCabledSignal==16) fScalerMap[fCurrScCh][4]=4;
542 }
543 else if(fCabledSignal>=17 && fCabledSignal<=21){
544 fScalerMap[fCurrScCh][3] = 2; //ZPC
545 //
546 if(fCabledSignal==17) fScalerMap[fCurrScCh][4]=0;
547 else if(fCabledSignal==18) fScalerMap[fCurrScCh][4]=1;
548 else if(fCabledSignal==19) fScalerMap[fCurrScCh][4]=2;
549 else if(fCabledSignal==20) fScalerMap[fCurrScCh][4]=3;
550 else if(fCabledSignal==21) fScalerMap[fCurrScCh][4]=4;
551 }
552 else if(fCabledSignal==22 || fCabledSignal==23){
553 fScalerMap[fCurrScCh][3] = 3; // ZEM
554 //
555 if(fCabledSignal==22 ) fScalerMap[fCurrScCh][4]=1;
556 else if(fCabledSignal==23) fScalerMap[fCurrScCh][4]=2;
557 }
558 // Ch debug.
559 //printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
560 //if(fCabledSignal!=0 && fCabledSignal!=1) printf(" det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
561 //else printf(" Signal void/not connected\n");
562
563 fCurrScCh++;
564 }
565 else if(fModType==3){ // **** scalers from trigger card
566 //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
567 }
568 else if(fModType==4){ // **** trigger history from trigger card
569 //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
570 }
571 else if(fModType==5){ // **** pattern unit
572 //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
573 }
574 }//reading channel mapping
575 }
576 fPosition++;
577 return kTRUE;
578 } // ------------------------------- SOD event
579
580 // -------------------------------------------
581 // --- DARC data
582 // -------------------------------------------
583 if(fReadOutCard == 0){
584 if(fPosition<fDeadfaceOffset){
585 fPosition++;
586 return kTRUE;
587 }
588 else if(fPosition==fDeadfaceOffset){
589 if(fBuffer != 0xdeadface){
590 AliWarning(" NO deadface after DARC data");
591 fRawReader->AddMajorErrorLog(kDARCError);
592 }
593 else{
594 fPosition++;
595 return kTRUE;
596 }
597 }
598 else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset){
599 fPosition++;
600 return kTRUE;
601 }
602 else if(fPosition==fDeadbeefOffset){
603 if(fBuffer != 0xdeadbeef){
604 AliWarning(" NO deadbeef after DARC global data");
605 fRawReader->AddMajorErrorLog(kDARCError);
606 fPosition++;
607 return kFALSE;
608 }
609 else{
610 fPosition++;
611 return kTRUE;
612 }
613 }
614 } // ------------------------------- DARC data
615
616 // -------------------------------------------
617 // --- ZDC data
618 // --- ADCs + VME scaler + trigger card + P.U.
619 // -------------------------------------------
620 else if(fPosition>=fDataOffset){
621
622 //printf("AliZDCRawStream: fSODReading = %d\n", fSODReading);
623 if(!fSODReading && !fIsMapRead) ReadChMap();
624
625 // !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!!
626 // Not valid datum before the event
627 // there MUST be a NOT valid datum before the event!!!
628 if(fReadOutCard==0){
629 if(fPosition==fDataOffset){ // and con la darc
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 }
637 }
638
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)
641 else if(fPosition==fDataOffset+1){ // and con la darc
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 }
649 }
650 }
651
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
658 fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
659
660 // ************************************ ADC MODULES ************************************
661 if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo){
662 // *** ADC header
663 if((fBuffer & 0x07000000) == 0x02000000){
664 fIsADCHeader = kTRUE;
665 fADCNChannels = ((fBuffer & 0x00003f00)>>8);
666 //printf(" AliZDCRawStream -> ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
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);
674 //
675 //printf(" AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n",
676 // fADCModule,fADCChannel,fADCGain,fADCValue);
677
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 //
684 /*for(Int_t ci=0; ci<kNch; ci++){
685 printf(" %d mod %d ch %d det %d sec %d\n",ci,fMapADC[ci][0],
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;
691 for(Int_t k=0; k<kNch; k++){
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){
700 AliWarning(Form(" No valid entry in ADC mapping for raw data %d ADCmod. %d ch. %d\n",
701 fPosition,fADCModule,fADCChannel));
702 }
703 //
704 //printf("AliZDCRawStream -> ADCmod. %d ch. %d -> det %d sec %d\n",
705 // fADCModule,fADCChannel,fSector[0],fSector[1]);
706
707 // Final checks
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 }
723 }
724
725 // Checking the underflow and overflow bits
726 if(fBuffer & 0x1000) fIsUnderflow = kTRUE;
727 else if (fBuffer & 0x2000) fIsOverflow = kTRUE;
728
729 }//ADC data word
730 // *** ADC EOB
731 else if((fBuffer & 0x07000000) == 0x04000000){
732 fIsADCEOB = kTRUE;
733 //printf(" AliZDCRawStream -> EOB --------------------------\n");
734 }
735 }//ADC module
736 // ********************************* VME SCALER HEADER *********************************
737 else if(fADCModule == kScalerGeo){
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;
744 fScStartCounter = fPosition;
745 //Ch. debug
746 //printf(" AliZDCRawStream -> VME SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n",
747 // fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber);
748 }
749 else if(!(fBuffer & 0x04000000)){
750 fIsScEventGood = kFALSE;
751 }
752 }
753 // *********************************** PATTERN UNIT ***********************************
754 else if(fADCModule == kPUGeo){
755 // still to be implemented!!! Not yet in data!!!
756 fDetPattern = (fBuffer & 0x0000003f);
757 // Ch. debug
758 //printf(" AliZDCRawStream -> Pattern Unit\n");
759
760 }
761 // ******************************** TRIGGER CARD COUNTS ********************************
762 else if(fADCModule == kTrigScales){
763 if(fIsTriggerScaler == kFALSE){
764 fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
765 fTrigCountStart = fPosition;
766 fIsTriggerScaler = kTRUE;
767 }
768 // Ch. debug
769 //printf(" AliZDCRawStream -> Trigger Scaler header\n");
770 }
771 // ********************************** TRIGGER HISTORY **********************************
772 else if(fADCModule == kTrigHistory){
773 if(fIsTriggerHistory == kFALSE){
774 fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
775 fTrigHistStart = fPosition;
776 fIsTriggerHistory = kTRUE;
777 }
778 // Ch. debug
779 //printf(" AliZDCRawStream -> Trigger History header\n");
780
781 }
782 // ********************************** VME SCALER DATA **********************************
783 // Reading VME scaler data
784 if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
785 fADCModule = kScalerGeo;
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 }
792 // ******************************** TRIGGER SCALER DATA ********************************
793 // Reading trigger scaler data
794 if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
795 fADCModule = kTrigScales;
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){
814 fADCModule = kTrigHistory;
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",
842 fPileUpBit1stWord, fPileUpBit2ndWord);
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 }
855
856 }
857
858 fPosition++;
859
860 return kTRUE;
861}
862
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}