]>
Commit | Line | Data |
---|---|---|
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 | ||
36 | ClassImp(AliZDCRawStream) | |
37 | ||
38 | ||
39 | //_____________________________________________________________________________ | |
40 | AliZDCRawStream::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 | fReadCDH(kFALSE), | |
56 | fDeadfaceOffset(-1), | |
57 | fDeadbeefOffset(-1), | |
58 | fDataOffset(0), | |
59 | fModType(-1), | |
60 | fADCModule(-1), | |
61 | fADCNChannels(-1), | |
62 | fADCChannel(-1), | |
63 | fADCValue(-1), | |
64 | fADCGain(-1), | |
65 | fIsUnderflow(kFALSE), | |
66 | fIsOverflow(kFALSE), | |
67 | fScGeo(0), | |
68 | fScNWords(0), | |
69 | fScTriggerSource(0), | |
70 | fScTriggerNumber(0), | |
71 | fIsScEventGood(kTRUE), | |
72 | fIsScHeaderRead(kFALSE), | |
73 | fScStartCounter(0), | |
74 | fScEvCounter(0), | |
75 | fIsScalerWord(kFALSE), | |
76 | fDetPattern(0), | |
77 | fTrigCountNWords(0), | |
78 | fIsTriggerScaler(kFALSE), | |
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), | |
90 | fIsTriggerHistory(kFALSE), | |
91 | fTrigHistStart(0), | |
92 | fPileUpBit1stWord(0), | |
93 | fL0Bit1stWord(0), | |
94 | fCentralTrigHist(0), | |
95 | fMBTrigHist(0), | |
96 | fPileUpBit2ndWord(0), | |
97 | fL0Bit2ndWord(0), | |
98 | fSCentralTrigHist(0), | |
99 | fEMDTrigHist(0), | |
100 | fNChannelsOn(0), | |
101 | fCurrentCh(-1), | |
102 | fCabledSignal(-1), | |
103 | fCurrScCh(-1), | |
104 | fCurrTDCCh(-1), | |
105 | fIsADCEventGood(kTRUE), | |
106 | fIsL0BitSet(kTRUE), | |
107 | fIsPileUpEvent(kFALSE), | |
108 | fIsADDChannel(kFALSE), | |
109 | fADDADCdatum(0), | |
110 | fIsTDCHeaderRead(kFALSE), | |
111 | fTDCStartCounter(0), | |
112 | fIsZDCTDCHeader(kFALSE), | |
113 | fIsZDCTDCdatum(kFALSE), | |
114 | fZDCTDCdatum(0), | |
115 | fIsADDTDCHeader(kFALSE), | |
116 | fIsADDTDCdatum(kFALSE), | |
117 | fADDTDCdatum(0) | |
118 | { | |
119 | // Create an object to read ZDC raw digits | |
120 | fRawReader->Reset(); | |
121 | fRawReader->Select("ZDC"); | |
122 | // | |
123 | const int kNch = 48; | |
124 | for(Int_t i=0; i<kNch; i++){ | |
125 | for(Int_t j=0; j<5; j++){ | |
126 | fMapADC[i][j]=-1; | |
127 | if(i<32){ | |
128 | fScalerMap[i][j]=-1; | |
129 | if(j<3) fTDCMap[i][j]=-1; | |
130 | } | |
131 | } | |
132 | } | |
133 | ||
134 | for(Int_t k=0; k<4; k++) fCPTInput[k] = 0; | |
135 | ||
136 | } | |
137 | ||
138 | //_____________________________________________________________________________ | |
139 | AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) : | |
140 | TObject(stream), | |
141 | fRawReader(stream.fRawReader), | |
142 | fBuffer(stream.GetRawBuffer()), | |
143 | fReadOutCard(stream.GetReadOutCard()), | |
144 | fEvType(stream.fEvType), | |
145 | fPosition(stream.fPosition), | |
146 | fIsCalib(stream.fIsCalib), | |
147 | fIsDARCHeader(stream.fIsDARCHeader), | |
148 | fIsHeaderMapping(stream.fIsHeaderMapping), | |
149 | fIsChMapping(stream.fIsChMapping), | |
150 | fIsADCDataWord(stream.fIsADCDataWord), | |
151 | fIsADCHeader(stream.fIsADCHeader), | |
152 | fIsADCEOB(stream.fIsADCEOB), | |
153 | fSODReading(stream.fSODReading), | |
154 | fIsMapRead(stream.fIsMapRead), | |
155 | fReadCDH(stream.fReadCDH), | |
156 | fDeadfaceOffset(stream.GetDeadfaceOffset()), | |
157 | fDeadbeefOffset(stream.GetDeadbeefOffset()), | |
158 | fDataOffset(stream.GetDataOffset()), | |
159 | fModType(stream.GetModType()), | |
160 | fADCModule(stream.GetADCModule()), | |
161 | fADCNChannels(stream.GetADCNChannels()), | |
162 | fADCChannel(stream.GetADCChannel()), | |
163 | fADCValue(stream.GetADCValue()), | |
164 | fADCGain(stream.GetADCGain()), | |
165 | fIsUnderflow(stream.fIsUnderflow), | |
166 | fIsOverflow(stream.fIsOverflow), | |
167 | fScGeo(stream.GetScGeo()), | |
168 | fScNWords(stream.GetScNWords()), | |
169 | fScTriggerSource(stream.GetScTriggerSource()), | |
170 | fScTriggerNumber(stream.fScTriggerNumber), | |
171 | fIsScEventGood(stream.fIsScEventGood), | |
172 | fIsScHeaderRead(stream.fIsScHeaderRead), | |
173 | fScStartCounter(stream.fScStartCounter), | |
174 | fScEvCounter(stream.fScEvCounter), | |
175 | fIsScalerWord(stream.fIsScalerWord), | |
176 | fDetPattern(stream.fDetPattern), | |
177 | fTrigCountNWords(stream.fTrigCountNWords), | |
178 | fIsTriggerScaler(stream.fIsTriggerScaler), | |
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), | |
190 | fIsTriggerHistory(stream.fIsTriggerHistory), | |
191 | fTrigHistStart(stream.fTrigHistStart), | |
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), | |
200 | fNChannelsOn(stream.fNChannelsOn), | |
201 | fCurrentCh(stream.fCurrentCh), | |
202 | fCabledSignal(stream.GetCabledSignal()), | |
203 | fCurrScCh(stream.fCurrScCh), | |
204 | fCurrTDCCh(stream.fCurrTDCCh), | |
205 | fIsADCEventGood(stream.fIsADCEventGood), | |
206 | fIsL0BitSet(stream.fIsL0BitSet), | |
207 | fIsPileUpEvent(stream.fIsPileUpEvent), | |
208 | fIsADDChannel(stream.fIsADDChannel), | |
209 | fADDADCdatum(stream.fADDADCdatum), | |
210 | fIsTDCHeaderRead(stream.fIsTDCHeaderRead), | |
211 | fTDCStartCounter(stream.fTDCStartCounter), | |
212 | fIsZDCTDCHeader(stream.fIsZDCTDCHeader), | |
213 | fIsZDCTDCdatum(stream.fIsZDCTDCdatum), | |
214 | fZDCTDCdatum(stream.fZDCTDCdatum), | |
215 | fIsADDTDCHeader(stream.fIsADDTDCHeader), | |
216 | fIsADDTDCdatum(stream.fIsADDTDCdatum), | |
217 | fADDTDCdatum(stream.fADDTDCdatum) | |
218 | { | |
219 | // Copy constructor | |
220 | const int kNch = 48; | |
221 | for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j); | |
222 | for(Int_t i=0; i<kNch; i++){ | |
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 | } | |
227 | } | |
228 | ||
229 | for(Int_t k=0; k<4; k++) fCPTInput[k] = stream.fCPTInput[k]; | |
230 | } | |
231 | ||
232 | //_____________________________________________________________________________ | |
233 | AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream& | |
234 | /* stream */) | |
235 | { | |
236 | // Assignment operator | |
237 | Fatal("operator =", "assignment operator not implemented"); | |
238 | return *this; | |
239 | } | |
240 | ||
241 | //_____________________________________________________________________________ | |
242 | AliZDCRawStream::~AliZDCRawStream() | |
243 | { | |
244 | // Destructor | |
245 | ||
246 | } | |
247 | ||
248 | //_____________________________________________________________________________ | |
249 | void AliZDCRawStream::ReadChMap() | |
250 | { | |
251 | // Reading channel map | |
252 | const int kNch = 48; | |
253 | AliDebug(2,"\t Reading ZDC ADC mapping from OCDB\n"); | |
254 | AliZDCChMap * chMap = GetChMap(); | |
255 | //chMap->Print(""); | |
256 | for(Int_t i=0; i<kNch; i++){ | |
257 | fMapADC[i][0] = chMap->GetADCModule(i); | |
258 | fMapADC[i][1] = chMap->GetADCChannel(i); | |
259 | fMapADC[i][2] = chMap->GetADCSignalCode(i); | |
260 | fMapADC[i][3] = chMap->GetDetector(i); | |
261 | fMapADC[i][4] = chMap->GetSector(i); | |
262 | } | |
263 | fIsMapRead = kTRUE; | |
264 | } | |
265 | ||
266 | //_____________________________________________________________________________ | |
267 | void AliZDCRawStream::ReadCDHHeader() | |
268 | { | |
269 | // Reading CDH | |
270 | const AliRawDataHeader* header = fRawReader->GetDataHeader(); | |
271 | const AliRawDataHeaderV3* headerV3 = fRawReader->GetDataHeaderV3(); | |
272 | if(!header && !headerV3) { | |
273 | AliError(" No CDH in raw data streaming"); | |
274 | fRawReader->AddMajorErrorLog(kCDHError); | |
275 | return; | |
276 | } | |
277 | ||
278 | //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize()); | |
279 | ||
280 | UChar_t message = header ? header->GetAttributes() : headerV3->GetAttributes(); | |
281 | //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message); | |
282 | ||
283 | if((message & 0xf0) == 0x0){ // PHYSICS RUN | |
284 | //printf("\t PHYSICS RUN raw data found\n"); | |
285 | } | |
286 | else if((message & 0xf0) == 0x10){ // COSMIC RUN | |
287 | //printf("\t STANDALONE_COSMIC RUN raw data found\n"); | |
288 | } | |
289 | else if((message & 0xf0) == 0x20){ // PEDESTAL RUN | |
290 | //printf("\t STANDALONE_PEDESTAL RUN raw data found\n"); | |
291 | } | |
292 | else if((message & 0xf0) == 0x30){ // LASER RUN | |
293 | //printf("\t STANDALONE_LASER RUN raw data found\n"); | |
294 | } | |
295 | else if((message & 0xf0) == 0x40){ // CALIBRATION_CENTRAL RUN | |
296 | //printf("\t CALIBRATION_CENTRAL RUN raw data found\n"); | |
297 | } | |
298 | else if((message & 0xf0) == 0x50){ // CALIBRATION_SEMICENTRAL | |
299 | //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n"); | |
300 | } | |
301 | else if((message & 0xf0) == 0x60){ // CALIBRATION_MB | |
302 | //printf("\t CALIBRATION_MB RUN raw data found\n"); | |
303 | } | |
304 | else if((message & 0xf0) == 0x70){ // CALIBRATION_EMD | |
305 | //printf("\t CALIBRATION_EMD RUN raw data found\n"); | |
306 | } | |
307 | // *** Checking the bit indicating the used readout card | |
308 | // (the payload is different in the 2 cases!) | |
309 | if((message & 0x08) == 0){ // ** DARC card | |
310 | fReadOutCard = 0; | |
311 | fIsDARCHeader = kTRUE; | |
312 | //AliInfo("\t ZDC readout card used: DARC"); | |
313 | } | |
314 | else if((message & 0x08) == 0x08){ // ** ZRC card | |
315 | fReadOutCard = 1; | |
316 | //AliInfo("\t ZDC readout card used: ZRC"); | |
317 | } | |
318 | ||
319 | fIsCalib = (header ? header->GetL1TriggerMessage() : headerV3->GetL1TriggerMessage()) & 0x1; | |
320 | ||
321 | //printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage()); | |
322 | //printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib); | |
323 | ||
324 | /* UInt_t status = header->GetStatus(); | |
325 | //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status); | |
326 | if((status & 0x000f) == 0x0001){ | |
327 | AliDebug(2,"CDH -> DARC trg0 overlap error"); | |
328 | fRawReader->AddMajorErrorLog(kDARCError); | |
329 | } | |
330 | if((status & 0x000f) == 0x0002){ | |
331 | AliDebug(2,"CDH -> DARC trg0 missing error"); | |
332 | fRawReader->AddMajorErrorLog(kDARCError); | |
333 | } | |
334 | if((status & 0x000f) == 0x0004){ | |
335 | AliDebug(2,"CDH -> DARC data parity error"); | |
336 | fRawReader->AddMajorErrorLog(kDARCError); | |
337 | } | |
338 | if((status & 0x000f) == 0x0008){ | |
339 | AliDebug(2,"CDH -> DARC ctrl parity error"); | |
340 | fRawReader->AddMajorErrorLog(kDARCError); | |
341 | } | |
342 | // | |
343 | if((status & 0x00f0) == 0x0010){ | |
344 | AliDebug(2,"CDH -> DARC trg unavailable"); | |
345 | fRawReader->AddMajorErrorLog(kDARCError); | |
346 | } | |
347 | if((status & 0x00f0) == 0x0020){ | |
348 | AliDebug(2,"CDH -> DARC FEE error"); | |
349 | fRawReader->AddMajorErrorLog(kDARCError); | |
350 | } | |
351 | // | |
352 | if((status & 0x0f00) == 0x0200){ | |
353 | AliDebug(2,"CDH -> DARC L1 time violation"); | |
354 | fRawReader->AddMajorErrorLog(kDARCError); | |
355 | } | |
356 | if((status & 0x0f00) == 0x0400){ | |
357 | AliDebug(2,"CDH -> DARC L2 time-out"); | |
358 | fRawReader->AddMajorErrorLog(kDARCError); | |
359 | } | |
360 | if((status & 0x0f00) == 0x0800){ | |
361 | AliDebug(2,"CDH -> DARC prepulse time violation"); | |
362 | fRawReader->AddMajorErrorLog(kDARCError); | |
363 | } | |
364 | // | |
365 | if((status & 0xf000) == 0x1000){ | |
366 | AliDebug(2,"CDH -> DARC other error"); | |
367 | fRawReader->AddMajorErrorLog(kDARCError); | |
368 | } | |
369 | */ | |
370 | ||
371 | } | |
372 | ||
373 | //_____________________________________________________________________________ | |
374 | Bool_t AliZDCRawStream::Next() | |
375 | { | |
376 | // Read the next raw digit | |
377 | // Returns kFALSE if there is no digit left | |
378 | ||
379 | if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE; | |
380 | const int kNch = 48; | |
381 | // | |
382 | fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE; | |
383 | fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE; | |
384 | fIsZDCTDCdatum = kFALSE; fIsADDChannel = kFALSE; fIsADDTDCdatum=kFALSE; | |
385 | fIsUnderflow = kFALSE; fIsOverflow = kFALSE; fIsScalerWord = kFALSE; | |
386 | fSector[0] = fSector[1] = -1; | |
387 | for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0; | |
388 | ||
389 | fEvType = fRawReader->GetType(); | |
390 | if(fPosition==0){ | |
391 | ReadCDHHeader(); | |
392 | // Needed to read simulated raw data (temporary solution?) | |
393 | if(!fReadCDH) fReadOutCard=1; | |
394 | fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;fNChannelsOn=0; | |
395 | // Ch. debug | |
396 | //printf("\n AliZDCRawStream::Next() - ev. type %d",fEvType); | |
397 | } | |
398 | // Ch. debug | |
399 | //printf("\n AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer); | |
400 | ||
401 | // *** End of ZDC event | |
402 | if(fBuffer == 0xcafefade){ | |
403 | //printf("\n AliZDCRawStream::Next() ***** End of ZDC event *****\n\n"); | |
404 | return kFALSE; | |
405 | } | |
406 | ||
407 | // ------------------------------------------- | |
408 | // --- DARC header | |
409 | // ------------------------------------------- | |
410 | // If the CDH has been read then | |
411 | // the DARC header must follow | |
412 | if(fReadOutCard==0 && fIsDARCHeader){ | |
413 | //printf("\t ---- DARC header ----\n"); | |
414 | if(fIsCalib){ | |
415 | fDeadfaceOffset = 9; | |
416 | fDeadbeefOffset = 25; | |
417 | } | |
418 | else{ | |
419 | fDeadfaceOffset = 1; | |
420 | fDeadbeefOffset = 7; | |
421 | } | |
422 | fDataOffset = 1+fDeadbeefOffset; | |
423 | fIsDARCHeader = kFALSE; | |
424 | } | |
425 | ||
426 | // --------------------------------------------- | |
427 | // --- Start of data event (SOD) --- | |
428 | // --- decoding mapping of connected ADC ch. --- | |
429 | // --------------------------------------------- | |
430 | // In the SOD event ADC ch. mapping is written | |
431 | if(fEvType==10){ | |
432 | if(fSODReading){ | |
433 | ||
434 | if(fPosition>=fDataOffset){ | |
435 | if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping | |
436 | // DARC 1st datum @ fDataOffset+1 \ ZRC 1st valid datum @ fDataOffset=0 | |
437 | if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){ | |
438 | printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n"); | |
439 | fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0; | |
440 | } | |
441 | else{ | |
442 | printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n"); | |
443 | fSODReading = kFALSE; | |
444 | return kFALSE; | |
445 | } | |
446 | } | |
447 | else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings | |
448 | fPosition++; | |
449 | return kFALSE; // !!!!!!!!!!!!!!!!!!!!! For the moment thresholds are not read | |
450 | } | |
451 | else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header | |
452 | fIsHeaderMapping = kTRUE; | |
453 | fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!! | |
454 | fModType = ((fBuffer & 0x7ff00)>>8); | |
455 | fADCNChannels = (fBuffer & 0xff); // # of channels following the header | |
456 | // | |
457 | printf(" ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels); | |
458 | } | |
459 | else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel | |
460 | fADCChannel = ((fBuffer & 0x3fff0000)>>16); | |
461 | fCabledSignal = (fBuffer&0xffff); | |
462 | // | |
463 | if(fModType == kV965){ // ******** ADCs ******************************** | |
464 | // Channel signal | |
465 | if((fBuffer&0x40000000)>>30==0 && fADCModule<=kLastADCGeo){ // *ZDC* high range chain ADC | |
466 | fIsChMapping = kTRUE; | |
467 | fMapADC[fCurrentCh][0] = fADCModule; | |
468 | fMapADC[fCurrentCh][1] = fADCChannel; | |
469 | fMapADC[fCurrentCh][2] = fCabledSignal; | |
470 | // - No. of channels on | |
471 | fNChannelsOn++; | |
472 | // | |
473 | // Determining detector and sector | |
474 | // ----------------------------------------- | |
475 | // For the decoding of the following lines | |
476 | // look the enum in AliZDCRawStream.h file | |
477 | // ----------------------------------------- | |
478 | if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30) | |
479 | || fCabledSignal==24 || fCabledSignal==48){ | |
480 | fMapADC[fCurrentCh][3] = 4; //ZNA | |
481 | // | |
482 | if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot) fMapADC[fCurrentCh][4]=0; | |
483 | else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1oot) fMapADC[fCurrentCh][4]=1; | |
484 | else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2oot) fMapADC[fCurrentCh][4]=2; | |
485 | else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3oot) fMapADC[fCurrentCh][4]=3; | |
486 | else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4oot) fMapADC[fCurrentCh][4]=4; | |
487 | else if(fCabledSignal==kZDCAMon || fCabledSignal==kZDCAMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM | |
488 | } | |
489 | else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){ | |
490 | fMapADC[fCurrentCh][3] = 5; //ZPA | |
491 | // | |
492 | if(fCabledSignal==kZPAC || fCabledSignal==kZPACoot) fMapADC[fCurrentCh][4]=0; | |
493 | else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1oot) fMapADC[fCurrentCh][4]=1; | |
494 | else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2oot) fMapADC[fCurrentCh][4]=2; | |
495 | else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3oot) fMapADC[fCurrentCh][4]=3; | |
496 | else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4oot) fMapADC[fCurrentCh][4]=4; | |
497 | } | |
498 | else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40) | |
499 | || fCabledSignal==25 || fCabledSignal==49){ | |
500 | fMapADC[fCurrentCh][3] = 1; //ZNC | |
501 | // | |
502 | if(fCabledSignal==kZNCC || fCabledSignal==kZNCCoot) fMapADC[fCurrentCh][4]=0; | |
503 | else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1oot) fMapADC[fCurrentCh][4]=1; | |
504 | else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2oot) fMapADC[fCurrentCh][4]=2; | |
505 | else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3oot) fMapADC[fCurrentCh][4]=3; | |
506 | else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4oot) fMapADC[fCurrentCh][4]=4; | |
507 | else if(fCabledSignal==kZDCCMon || fCabledSignal==kZDCCMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM | |
508 | } | |
509 | else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){ | |
510 | fMapADC[fCurrentCh][3] = 2; //ZPC | |
511 | // | |
512 | if(fCabledSignal==kZPCC || fCabledSignal==kZPCCoot) fMapADC[fCurrentCh][4]=0; | |
513 | else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1oot) fMapADC[fCurrentCh][4]=1; | |
514 | else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2oot) fMapADC[fCurrentCh][4]=2; | |
515 | else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3oot) fMapADC[fCurrentCh][4]=3; | |
516 | else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4oot) fMapADC[fCurrentCh][4]=4; | |
517 | } | |
518 | else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){ | |
519 | fMapADC[fCurrentCh][3] = 3; // ZEM | |
520 | // | |
521 | if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1oot) fMapADC[fCurrentCh][4]=1; | |
522 | else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2oot) fMapADC[fCurrentCh][4]=2; | |
523 | } | |
524 | //Ch. debug | |
525 | //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal); | |
526 | //printf(" det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]); | |
527 | // | |
528 | fCurrentCh++; | |
529 | // | |
530 | } // high range channels | |
531 | }// ModType=1 (ADC mapping) | |
532 | else if(fModType == kV830){ // ******** VME scaler ************************** | |
533 | fIsChMapping = kTRUE; | |
534 | fScalerMap[fCurrScCh][0] = fADCModule; | |
535 | fScalerMap[fCurrScCh][1] = fADCChannel; | |
536 | fScalerMap[fCurrScCh][2] = fCabledSignal; | |
537 | // | |
538 | // Determining detector and sector | |
539 | // ----------------------------------------- | |
540 | // For the decoding of the following lines | |
541 | // look the enum in AliZDCRawStream.h file | |
542 | // ----------------------------------------- | |
543 | // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!! | |
544 | if((fCabledSignal>=2 && fCabledSignal<=6) || | |
545 | (fCabledSignal>=61 && fCabledSignal<=65)){ | |
546 | fScalerMap[fCurrScCh][3] = 4; //ZNA | |
547 | // | |
548 | if(fCabledSignal==kZNAC || fCabledSignal==kZNACD) fScalerMap[fCurrScCh][4]=0; | |
549 | else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1D) fScalerMap[fCurrScCh][4]=1; | |
550 | else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2D) fScalerMap[fCurrScCh][4]=2; | |
551 | else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3D) fScalerMap[fCurrScCh][4]=3; | |
552 | else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4D) fScalerMap[fCurrScCh][4]=4; | |
553 | } | |
554 | else if((fCabledSignal>=7 && fCabledSignal<=11) || | |
555 | (fCabledSignal>=66 && fCabledSignal<=70)){ | |
556 | fScalerMap[fCurrScCh][3] = 5; //ZPA | |
557 | // | |
558 | if(fCabledSignal==kZPAC || fCabledSignal==kZPACD) fScalerMap[fCurrScCh][4]=0; | |
559 | else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1D) fScalerMap[fCurrScCh][4]=1; | |
560 | else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2D) fScalerMap[fCurrScCh][4]=2; | |
561 | else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3D) fScalerMap[fCurrScCh][4]=3; | |
562 | else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4D) fScalerMap[fCurrScCh][4]=4; | |
563 | } | |
564 | else if((fCabledSignal>=12 && fCabledSignal<=16) || | |
565 | (fCabledSignal>=71 && fCabledSignal<=75)){ | |
566 | fScalerMap[fCurrScCh][3] = 1; //ZNC | |
567 | // | |
568 | if(fCabledSignal==kZNCC || fCabledSignal==kZNCCD) fScalerMap[fCurrScCh][4]=0; | |
569 | else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1D) fScalerMap[fCurrScCh][4]=1; | |
570 | else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2D) fScalerMap[fCurrScCh][4]=2; | |
571 | else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3D) fScalerMap[fCurrScCh][4]=3; | |
572 | else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4D) fScalerMap[fCurrScCh][4]=4; | |
573 | } | |
574 | else if((fCabledSignal>=17 && fCabledSignal<=21) || | |
575 | (fCabledSignal>=76 && fCabledSignal<=80)){ | |
576 | fScalerMap[fCurrScCh][3] = 2; //ZPC | |
577 | // | |
578 | if(fCabledSignal==kZPCC || fCabledSignal==kZPCCD) fScalerMap[fCurrScCh][4]=0; | |
579 | else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1D) fScalerMap[fCurrScCh][4]=1; | |
580 | else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2D) fScalerMap[fCurrScCh][4]=2; | |
581 | else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3D) fScalerMap[fCurrScCh][4]=3; | |
582 | else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4D) fScalerMap[fCurrScCh][4]=4; | |
583 | } | |
584 | else if(fCabledSignal==22 || fCabledSignal==23 || | |
585 | fCabledSignal==81 || fCabledSignal==82){ | |
586 | fScalerMap[fCurrScCh][3] = 3; // ZEM | |
587 | // | |
588 | if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1D) fScalerMap[fCurrScCh][4]=1; | |
589 | else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2D) fScalerMap[fCurrScCh][4]=2; | |
590 | } | |
591 | // Ch debug. | |
592 | /*printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal); | |
593 | if(fCabledSignal!=0 && fCabledSignal!=1) printf(" det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]); | |
594 | else printf(" Signal void/not connected\n");*/ | |
595 | ||
596 | fCurrScCh++; | |
597 | } | |
598 | else if(fModType==KV1290 && fADCModule==kZDCTDCGeo){ // ******** ZDC TDC ************************** | |
599 | fIsChMapping = kTRUE; | |
600 | fTDCMap[fCurrTDCCh][0] = fADCModule; | |
601 | fTDCMap[fCurrTDCCh][1] = fADCChannel; | |
602 | fTDCMap[fCurrTDCCh][2] = fCabledSignal; | |
603 | ||
604 | fCurrTDCCh++; | |
605 | ||
606 | // Ch debug. | |
607 | //printf("\tZDC TDC: mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal); | |
608 | } | |
609 | /*else if(fModType == kTRG){ // **** scalers from trigger card | |
610 | //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal); | |
611 | } | |
612 | else if(fModType == kTRGI){ // **** trigger history from trigger card | |
613 | //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal); | |
614 | } | |
615 | else if(fModType == kPU){ // **** pattern unit | |
616 | //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal); | |
617 | }*/ | |
618 | }//reading channel mapping | |
619 | } | |
620 | } // if fSODREading | |
621 | fPosition++; | |
622 | return kTRUE; | |
623 | } // ------------------------------- SOD event | |
624 | ||
625 | // ------------------------------------------- | |
626 | // --- DARC data | |
627 | // ------------------------------------------- | |
628 | if(fPosition<fDeadfaceOffset && fReadOutCard==0){ | |
629 | fPosition++; | |
630 | return kTRUE; | |
631 | } | |
632 | else if(fPosition==fDeadfaceOffset && fReadOutCard==0){ | |
633 | if(fBuffer != 0xdeadface){ | |
634 | //AliWarning(" NO deadface after DARC data"); | |
635 | fRawReader->AddMajorErrorLog(kDARCError); | |
636 | } | |
637 | else{ | |
638 | fPosition++; | |
639 | return kTRUE; | |
640 | } | |
641 | } | |
642 | else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){ | |
643 | fPosition++; | |
644 | return kTRUE; | |
645 | } | |
646 | else if(fPosition==fDeadbeefOffset && fReadOutCard==0){ | |
647 | if(fBuffer != 0xdeadbeef){ | |
648 | //AliWarning(" NO deadbeef after DARC global data"); | |
649 | fRawReader->AddMajorErrorLog(kDARCError); | |
650 | fPosition++; | |
651 | return kFALSE; | |
652 | } | |
653 | else{ | |
654 | fPosition++; | |
655 | return kTRUE; | |
656 | } | |
657 | } // ------------------------------- End of DARC data | |
658 | ||
659 | // --------------------------------------------- | |
660 | // --- ZDC data | |
661 | // --- ADCs + VME scaler + trigger card + P.U. | |
662 | // --------------------------------------------- | |
663 | else if(fPosition>=fDataOffset){ | |
664 | ||
665 | if(!fSODReading && !fIsMapRead) ReadChMap(); | |
666 | ||
667 | // !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!! | |
668 | // Not valid datum before the event | |
669 | // there MUST be a NOT valid datum before the event!!! | |
670 | if(fReadOutCard==0){ | |
671 | if(fPosition==fDataOffset){ | |
672 | //printf("\t **** ZDC data begin ****\n"); | |
673 | if((fBuffer & 0x07000000) != 0x06000000){ | |
674 | fRawReader->AddMajorErrorLog(kZDCDataError); | |
675 | } | |
676 | //else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!! | |
677 | // fIsADCEventGood = kFALSE; | |
678 | //} | |
679 | } | |
680 | ||
681 | // If the not valid datum isn't followed by the 1st ADC header | |
682 | // the event is corrupted (i.e., 2 gates arrived before trigger) | |
683 | else if(fPosition==fDataOffset+1){ | |
684 | if((fBuffer & 0x07000000) != 0x02000000){ | |
685 | AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!"); | |
686 | fRawReader->AddMajorErrorLog(kZDCDataError); | |
687 | fIsADCEventGood = kFALSE; | |
688 | fPosition++; | |
689 | return kFALSE; | |
690 | } | |
691 | } | |
692 | } | |
693 | ||
694 | // Get geo address of current word | |
695 | if(fIsTDCHeaderRead && fIsZDCTDCHeader) fADCModule = kZDCTDCGeo; | |
696 | else if(fIsTDCHeaderRead && fIsADDTDCHeader) fADCModule = kADDTDCGeo; | |
697 | else fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27); | |
698 | ||
699 | // ************************************ ADC MODULES ************************************ | |
700 | if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo && | |
701 | !fIsTriggerHistory && !fIsScHeaderRead && !fIsTriggerScaler){ | |
702 | // *** ADC header | |
703 | if((fBuffer & 0x07000000) == 0x02000000){ | |
704 | fIsADCHeader = kTRUE; | |
705 | fADCNChannels = ((fBuffer & 0x00003f00)>>8); | |
706 | //printf(" AliZDCRawStream -> ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels); | |
707 | } | |
708 | // *** ADC data word | |
709 | else if((fBuffer & 0x07000000) == 0x00000000){ | |
710 | fIsADCDataWord = kTRUE; | |
711 | fADCChannel = ((fBuffer & 0x1e0000) >> 17); | |
712 | fADCGain = ((fBuffer & 0x10000) >> 16); | |
713 | fADCValue = (fBuffer & 0xfff); | |
714 | // | |
715 | //printf(" AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n", | |
716 | //fADCModule,fADCChannel,fADCGain,fADCValue); | |
717 | ||
718 | // Checking if the channel map for the ADCs has been provided/read | |
719 | if(fMapADC[0][0]==-1){ | |
720 | printf("\t ATTENTION!!! No ADC mapping has been found/provided!!!\n"); | |
721 | return kFALSE; | |
722 | } | |
723 | // | |
724 | /*for(Int_t ci=0; ci<kNch; ci++){ | |
725 | printf(" %d mod %d ch %d det %d sec %d\n",ci,fMapADC[ci][0], | |
726 | fMapADC[ci][1], fMapADC[ci][3], fMapADC[ci][4]); | |
727 | }*/ | |
728 | ||
729 | // Scan of the map to assign the correct volumes | |
730 | Int_t foundMapEntry = kFALSE; | |
731 | for(Int_t k=0; k<kNch; k++){ | |
732 | if(fADCModule==fMapADC[k][0] && fADCChannel==fMapADC[k][1]){ | |
733 | fSector[0] = fMapADC[k][3]; | |
734 | fSector[1] = fMapADC[k][4]; | |
735 | foundMapEntry = kTRUE; | |
736 | break; | |
737 | } | |
738 | } | |
739 | if(foundMapEntry==kFALSE && fEvType==7){ | |
740 | AliWarning(Form(" No valid entry in ADC mapping for raw data %d ADCmod. %d ch. %d\n", | |
741 | fPosition,fADCModule,fADCChannel)); | |
742 | } | |
743 | ||
744 | // Final checks | |
745 | if(foundMapEntry==kTRUE && fEvType==7){ | |
746 | if(fSector[0]<1 || fSector[0]>5){ | |
747 | AliWarning(Form(" No valid detector assignment: %d",fSector[0])); | |
748 | fRawReader->AddMajorErrorLog(kInvalidSector); | |
749 | } | |
750 | // | |
751 | if(fSector[1]<0 || fSector[1]>5){ | |
752 | AliWarning(Form(" No valid sector assignment: %d",fSector[1])); | |
753 | fRawReader->AddMajorErrorLog(kInvalidSector); | |
754 | } | |
755 | // | |
756 | if(fADCModule<0 || fADCModule>3){ | |
757 | AliError(Form(" No valid ADC module: %d",fADCModule)); | |
758 | fRawReader->AddMajorErrorLog(kInvalidADCModule); | |
759 | } | |
760 | } | |
761 | ||
762 | // Checking the underflow and overflow bits | |
763 | if(fBuffer & 0x1000) fIsUnderflow = kTRUE; | |
764 | else if (fBuffer & 0x2000) fIsOverflow = kTRUE; | |
765 | ||
766 | }//ADC data word | |
767 | // *** ADC EOB | |
768 | else if((fBuffer & 0x07000000) == 0x04000000){ | |
769 | fIsADCEOB = kTRUE; | |
770 | //printf(" AliZDCRawStream -> ADC EOB --------------------------\n"); | |
771 | } | |
772 | }//ADC module | |
773 | // ********************************* ADD ADC ********************************* | |
774 | else if(fADCModule == kADDADCGeo){ | |
775 | // *** ADC header | |
776 | if((fBuffer & 0x07000000) == 0x02000000){ | |
777 | fIsADCHeader = kTRUE; | |
778 | fADCNChannels = ((fBuffer & 0x00003f00)>>8); | |
779 | //printf(" AliZDCRawStream -> ADD ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels); | |
780 | } | |
781 | // *** ADC data word | |
782 | else if((fBuffer & 0x07000000) == 0x00000000){ | |
783 | fIsADDChannel = kTRUE; | |
784 | fADCChannel = ((fBuffer & 0x1e0000) >> 17); | |
785 | fADCGain = ((fBuffer & 0x10000) >> 16); | |
786 | fADCValue = (fBuffer & 0xfff); | |
787 | // | |
788 | //printf(" ADD ADC DATUM -> mod. %d ch. %d gain %d value %d\n", | |
789 | // fADCModule,fADCChannel,fADCGain,fADCValue); | |
790 | } | |
791 | // *** ADC EOB | |
792 | else if((fBuffer & 0x07000000) == 0x04000000){ | |
793 | fIsADCEOB = kTRUE; | |
794 | //printf(" AliZDCRawStream -> ADD ADC EOB --------------------------\n"); | |
795 | } | |
796 | } | |
797 | // ********************************* TDC ********************************* | |
798 | else if(fADCModule==kTDCFakeGeo && fIsTDCHeaderRead==kFALSE){ | |
799 | // *** TDC header | |
800 | fIsTDCHeaderRead = kTRUE; | |
801 | fTDCStartCounter = fPosition; | |
802 | // GEO address from TDC header | |
803 | fADCModule = (Int_t) (fBuffer & 0x1f); | |
804 | if(fADCModule==kZDCTDCGeo){ // *** ZDC TDC | |
805 | fIsZDCTDCHeader = kTRUE; | |
806 | //Ch. debug | |
807 | //printf(" AliZDCRawStream -> ZDC TDC header: mod.%d\n",fADCModule); | |
808 | } | |
809 | else if(fADCModule==kADDTDCGeo){ // *** ADD TDC | |
810 | fIsADDTDCHeader = kTRUE; | |
811 | //Ch. debug | |
812 | //printf(" AliZDCRawStream -> ADD TDC: mod.%d\n",fADCModule); | |
813 | } | |
814 | } | |
815 | // ********************************* VME SCALER HEADER ********************************* | |
816 | else if(fADCModule == kScalerGeo){ | |
817 | if(fBuffer & 0x04000000 && fIsScHeaderRead==kFALSE){ // *** Scaler header | |
818 | fScGeo = (fBuffer & 0xf8000000)>>27; | |
819 | fScNWords = (fBuffer & 0x00fc0000)>>18; | |
820 | fScTriggerSource = (fBuffer & 0x00030000)>>16; | |
821 | fScTriggerNumber = (fBuffer & 0x0000ffff); | |
822 | fIsScHeaderRead = kTRUE; | |
823 | fScStartCounter = fPosition; | |
824 | //Ch. debug | |
825 | //printf(" AliZDCRawStream -> VME SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n", | |
826 | // fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber); | |
827 | } | |
828 | // Commented by C.O. & M.G. (23/09/2011) | |
829 | //else if(!(fBuffer & 0x04000000) && fIsScHeaderRead==kFALSE){ | |
830 | // fIsScEventGood = kFALSE; | |
831 | //} | |
832 | } | |
833 | // *********************************** PATTERN UNIT *********************************** | |
834 | else if(fADCModule == kPUGeo){ | |
835 | // still to be implemented!!! Not yet in data!!! | |
836 | fDetPattern = (fBuffer & 0x0000003f); | |
837 | // Ch. debug | |
838 | //printf(" AliZDCRawStream -> Pattern Unit\n"); | |
839 | ||
840 | } | |
841 | // ******************************** TRIGGER CARD COUNTS ******************************** | |
842 | else if(fADCModule == kTrigScales){ | |
843 | if(fIsTriggerScaler == kFALSE){ | |
844 | fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17); | |
845 | fTrigCountStart = fPosition; | |
846 | fIsTriggerScaler = kTRUE; | |
847 | } | |
848 | // Ch. debug | |
849 | //printf(" AliZDCRawStream -> Trigger Scaler header\n"); | |
850 | } | |
851 | // ********************************** TRIGGER HISTORY ********************************** | |
852 | else if(fADCModule == kTrigHistory){ | |
853 | if(fIsTriggerHistory == kFALSE){ | |
854 | fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17); | |
855 | fTrigHistStart = fPosition; | |
856 | fIsTriggerHistory = kTRUE; | |
857 | } | |
858 | // Ch. debug | |
859 | //printf(" AliZDCRawStream -> Trigger History header\n"); | |
860 | ||
861 | } | |
862 | // ********************************** VME SCALER DATA ********************************** | |
863 | // Reading VME scaler data | |
864 | if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word | |
865 | fADCModule=kScalerGeo; | |
866 | fIsADCDataWord=kFALSE; | |
867 | fIsScalerWord=kTRUE; | |
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 %x \n", fScEvCounter); | |
873 | } | |
874 | // ********************************** ZDC TDC DATA ********************************** | |
875 | // ZDC TDC data | |
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); | |
880 | fIsZDCTDCdatum = kTRUE; | |
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){ | |
895 | fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE; | |
896 | if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum | |
897 | fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21); | |
898 | fIsADDTDCdatum = kTRUE; | |
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 | } | |
903 | if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){ | |
904 | // Trailer | |
905 | fIsTDCHeaderRead = kFALSE; | |
906 | // Ch. debug | |
907 | //printf(" AliZDCRawStream -> ADD TDC global trailer\n"); | |
908 | } | |
909 | } | |
910 | // ******************************** TRIGGER SCALER DATA ******************************** | |
911 | // Reading trigger scaler data | |
912 | if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){ | |
913 | fADCModule = kTrigScales; fIsADCDataWord = kFALSE; | |
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){ | |
932 | fADCModule = kTrigHistory; fIsADCDataWord = kFALSE; | |
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", | |
960 | fPileUpBit1stWord, fPileUpBit2ndWord); | |
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] %x\n", fPosition, fBuffer); | |
972 | } | |
973 | ||
974 | } | |
975 | ||
976 | fPosition++; | |
977 | ||
978 | return kTRUE; | |
979 | } | |
980 | ||
981 | //_____________________________________________________________________________ | |
982 | AliCDBStorage* 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 | //_____________________________________________________________________________ | |
993 | AliZDCChMap* 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 | } |