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