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 : ///////////////////////////////////////////////////////////////////////////////
17 : ///
18 : /// This is a class for reading the HMPID raw data
19 : /// The format of the raw data corresponds to the one
20 : /// which was documented by Paolo Martinengo.
21 : ///
22 : ///////////////////////////////////////////////////////////////////////////////
23 :
24 : #include "AliHMPIDRawStream.h"
25 : #include "AliRawReader.h"
26 : #include "AliLog.h"
27 :
28 16 : ClassImp(AliHMPIDRawStream)
29 :
30 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
31 4 : AliHMPIDRawStream::AliHMPIDRawStream(AliRawReader* rawReader) :
32 4 : fNPads(0),
33 4 : fCharge(0x0),
34 4 : fPad(0x0),
35 4 : fDDLNumber(-1),
36 4 : fnDDLInStream(0x0),
37 4 : fnDDLOutStream(0x0),
38 4 : fLDCNumber( 0),
39 4 : fTimeStamp( 0),
40 4 : fRawReader(rawReader),
41 4 : fData(0x0),
42 4 : fNumOfErr(0x0),
43 4 : fPosition(-1),
44 4 : fWord(0),
45 4 : fZeroSup(kTRUE),
46 4 : fPos(0x0),
47 4 : fiPos(0),
48 4 : fTurbo(kFALSE),
49 4 : fRawDataSize(0)
50 20 : {
51 : //
52 : // Constructor
53 : //
54 8 : fNumOfErr = new Int_t*[kNDDL]; // Store the numner of errors for a given error type and a given DD
55 120 : for(Int_t i=0;i<kNDDL;i++) {
56 112 : fNumOfErr[i] = new Int_t [kSumErr];
57 : }
58 :
59 8 : fnDDLInStream=new Int_t[kNDDL];
60 8 : fnDDLOutStream=new Int_t[kNDDL];
61 120 : for(Int_t iddl=0;iddl<kNDDL;iddl++) { fnDDLInStream[iddl]=-1;fnDDLOutStream[iddl]=-1;}
62 :
63 120 : for(Int_t iddl=0;iddl<kNDDL;iddl++)
64 1568 : for(Int_t ierr=0; ierr < kSumErr; ierr++) fNumOfErr[iddl][ierr]=0; //reset errors
65 4 : fRawReader->Reset();
66 4 : fRawReader->Select("HMPID");
67 :
68 :
69 :
70 8 : }
71 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72 0 : AliHMPIDRawStream::AliHMPIDRawStream() :
73 0 : fNPads(0),
74 0 : fCharge(0x0),
75 0 : fPad(0x0),
76 0 : fDDLNumber(-1),
77 0 : fnDDLInStream(0x0),
78 0 : fnDDLOutStream(0x0),
79 0 : fLDCNumber( 0),
80 0 : fTimeStamp( 0),
81 0 : fRawReader(0x0),
82 0 : fData(0x0),
83 0 : fNumOfErr(0x0),
84 0 : fPosition(-1),
85 0 : fWord(0),
86 0 : fZeroSup(kTRUE),
87 0 : fPos(0x0),
88 0 : fiPos(0),
89 0 : fTurbo(kFALSE) ,
90 0 : fRawDataSize(0)
91 0 : {
92 : //
93 : // Constructor
94 : //
95 0 : fNumOfErr = new Int_t*[kNDDL]; // Store the numner of errors for a given error type and a given DD
96 0 : for(Int_t i=0;i<kNDDL;i++) {
97 0 : fNumOfErr[i] = new Int_t [kSumErr];
98 : }
99 0 : fnDDLInStream=new Int_t[kNDDL];
100 0 : fnDDLOutStream=new Int_t[kNDDL];
101 0 : for(Int_t iddl=0;iddl<kNDDL;iddl++) { fnDDLInStream[iddl]=-1;fnDDLOutStream[iddl]=-1;}
102 :
103 :
104 0 : for(Int_t iddl=0;iddl<kNDDL;iddl++)
105 0 : for(Int_t ierr=0; ierr < kSumErr; ierr++) fNumOfErr[iddl][ierr]=0; //reset errors
106 :
107 :
108 0 : }
109 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
110 : AliHMPIDRawStream::~AliHMPIDRawStream()
111 16 : {
112 : //
113 : // destructor
114 : //
115 4 : DelVars();
116 :
117 :
118 4 : fDDLNumber=0;
119 4 : fLDCNumber=0;
120 4 : fTimeStamp=0;
121 4 : fPosition=0;
122 4 : fWord=0;
123 4 : fZeroSup=0;
124 4 : fTurbo=0;
125 4 : fRawDataSize=0;
126 232 : for(Int_t i=0;i<kNDDL;i++) delete [] fNumOfErr[i];
127 8 : delete [] fNumOfErr;
128 :
129 8 : delete [] fnDDLInStream;
130 8 : delete [] fnDDLOutStream;
131 8 : }
132 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
133 : void AliHMPIDRawStream::Reset()
134 : {
135 : // reset raw stream params
136 : // Reinitalize the containers
137 0 : fDDLNumber = -1;
138 0 : fLDCNumber = 0;
139 0 : fTimeStamp = 0;
140 0 : fPosition = -1;
141 0 : fData = NULL;
142 0 : if (fRawReader) fRawReader->Reset();
143 0 : }
144 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
145 : Bool_t AliHMPIDRawStream::Turbo()
146 : {
147 :
148 : Int_t row,dilogic;UInt_t pad;
149 0 : Int_t cntGlob = fRawReader->GetDataSize()/4;
150 0 : fPosition=0;
151 0 : fNPads=0;
152 : // Int_t gw=0;
153 0 : for(Int_t i=1;i<cntGlob;i++) {
154 0 : if(!GetWord(1)) return kFALSE;
155 0 : if (((fWord >> kbit27) & 1)) continue;
156 : UInt_t statusControlRow = 0x32a8;
157 0 : UInt_t rowControlWord = fWord >> kbit0 & 0xfbff;
158 0 : if(rowControlWord == statusControlRow) continue;
159 :
160 0 : row = (fWord >> kbit22) & 0x1f;
161 0 : dilogic = (fWord >> kbit18) & 0xf; //dilogic info in raw word is between bits: 18...21
162 :
163 0 : pad = (fWord >> kbit12) & 0x3f; //pad info in raw word is between bits: 12...17
164 0 : if(!CheckPad(pad)) continue;
165 0 : Int_t charge = fWord & 0xfff;
166 0 : if(GetPad(fDDLNumber,row,dilogic,pad)<0) continue;
167 0 : fPad[fNPads] = GetPad(fDDLNumber,row,dilogic,pad);
168 0 : fCharge[fNPads] = charge;
169 0 : fNPads++;
170 0 : if(charge==0) fNumOfErr[fDDLNumber][kPedQZero]++;
171 0 : }//word loop
172 : //Printf("Size: %i DDL %i row %i dilogic %i pad %i fPos %i fNPads: %i Charge: %d Word %4.4x GoodW: %i",cntGlob,fDDLNumber,row,dilogic,pad,fPosition,fNPads,fCharge[fNPads-1],fWord,gw++);
173 0 : return kTRUE;
174 0 : }//Turbo()
175 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
176 : Bool_t AliHMPIDRawStream::Next()
177 : {
178 : // read next DDL raw data from the HMPID raw data stream
179 : // return kFALSE in case of error or no data left
180 240 : AliDebug(1,"Start.");
181 : do {
182 64 : if (!fRawReader->ReadNextData(fData)) return kFALSE;
183 56 : } while (fRawReader->GetDataSize() == 0);
184 :
185 56 : Int_t runNumber = fRawReader->GetRunNumber();
186 :
187 56 : Int_t ddlArray[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13};
188 :
189 : // next line: fix for link chamber2 cables inversion for period LHC11d, LHC11e, LHC11f and LHC11h.
190 :
191 56 : if(runNumber>=156620 && runNumber<=170593) {ddlArray[4] = 5; ddlArray[5] = 4;}
192 56 : else {ddlArray[4] = 4; ddlArray[5] = 5;}
193 :
194 : /*
195 : Event type is selected as in $ALICE_ROOT/RAW/event.h
196 : #define START_OF_RUN ((eventTypeType) 1)
197 : #define END_OF_RUN ((eventTypeType) 2)
198 : #define START_OF_RUN_FILES ((eventTypeType) 3)
199 : #define END_OF_RUN_FILES ((eventTypeType) 4)
200 : #define START_OF_BURST ((eventTypeType) 5)
201 : #define END_OF_BURST ((eventTypeType) 6)
202 : #define PHYSICS_EVENT ((eventTypeType) 7) <<---------------
203 : #define CALIBRATION_EVENT ((eventTypeType) 8)
204 : #define EVENT_FORMAT_ERROR ((eventTypeType) 9)
205 : #define START_OF_DATA ((eventTypeType)10)
206 : #define END_OF_DATA ((eventTypeType)11)
207 : #define SYSTEM_SOFTWARE_TRIGGER_EVENT ((eventTypeType)12)
208 : #define DETECTOR_SOFTWARE_TRIGGER_EVENT ((eventTypeType)13)
209 : #define EVENT_TYPE_MIN 1
210 : #define EVENT_TYPE_MAX 13
211 : */
212 :
213 56 : fPosition = 0;
214 : Bool_t status=kFALSE;
215 56 : fRawDataSize=0;
216 56 : fDDLNumber = -1;
217 56 : if (fRawReader->GetDDLID()>=0)
218 56 : fDDLNumber = ddlArray[fRawReader->GetDDLID()];
219 :
220 56 : if(fDDLNumber<0) {
221 0 : AliWarning(Form("fDDLNumber not a acceptable value %i",fDDLNumber));
222 0 : return kFALSE;
223 : }
224 :
225 56 : if(fRawReader->GetType() == 7 || fRawReader->GetType() == 8 ) { //New: Select Physics events, Old: Raw data size is not 0 and not 47148 (pedestal)
226 56 : fnDDLInStream[fDDLNumber]=1; fnDDLOutStream[fDDLNumber]=0;
227 :
228 56 : fLDCNumber = fRawReader->GetLDCId();
229 56 : fTimeStamp = fRawReader->GetTimestamp();
230 :
231 168 : AliDebug(1,Form("DDL %i started to be decoded!",fDDLNumber));
232 56 : fRawDataSize=fRawReader->GetDataSize()/4;
233 56 : DelVars(); //We have to delete the variables initialized in the InitVars before recall IntiVars!!!
234 56 : InitVars(fRawDataSize); //To read the charge and pads we cannot delete before the status return
235 :
236 56 : if(fTurbo==kTRUE) status=Turbo();
237 56 : else status = ReadHMPIDRawData();
238 :
239 224 : if(status) AliDebug(1,Form("Event DDL %i successfully decoded!.",fDDLNumber));
240 0 : else AliDebug(1,Form("Event DDL %i ERROR in decoding!.",fDDLNumber));
241 : //DumpData(fRawReader->GetDataSize());
242 :
243 :
244 : }
245 112 : if(status==kTRUE) {fnDDLOutStream[fDDLNumber]++; }//Printf("fnDDLOutStream[%d]=%d",fDDLNumber,fnDDLOutStream[fDDLNumber]); } //Count the number of events when the DDL was succesfully decoded
246 :
247 : // return status; // temporary solution...
248 56 : return kTRUE;
249 116 : }
250 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
251 : void AliHMPIDRawStream::InitVars(Int_t n)
252 : {
253 : //
254 : //
255 : //
256 112 : fNPads = 0;
257 56 : fCharge = new Int_t[n];
258 56 : fPad = new Int_t[n];
259 : //for debug purpose
260 56 : fPos = new Int_t[4*n+4]; //reset debug
261 126664 : for(Int_t ie = 0 ; ie < 4*n+4; ie++) fPos[ie] = 0; //initialize for 0, otherwise the position is considered filled and will not be updated for the dump
262 56 : fiPos = 0;
263 56 : }
264 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
265 : void AliHMPIDRawStream::DelVars()
266 : {
267 : //
268 : //
269 : //
270 : //Clean the initvars!!!!!!!!
271 120 : fNPads = 0;
272 228 : if (fCharge) { delete [] fCharge; fCharge = 0x0; }
273 228 : if (fPad) { delete [] fPad; fPad = 0x0; }
274 228 : if (fPos) { delete [] fPos; fPos = 0x0; }
275 :
276 60 : fiPos=0;
277 :
278 :
279 60 : }
280 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
281 : Bool_t AliHMPIDRawStream::ReadHMPIDRawData()
282 : {
283 : //Here the loop on the decoding the raw bank
284 : //for one ddl starts.
285 : //It returns: kFALSE if any error occurs
286 : // kTRUE if all OK
287 112 : Int_t cntGlob = fRawReader->GetDataSize()/4;
288 56 : if(cntGlob==0) {fNumOfErr[fDDLNumber][kRawDataSizeErr]++; return kFALSE; }
289 :
290 : Int_t cnt = cntGlob;
291 : Int_t nwSeg;
292 56 : Int_t cntSegment;
293 :
294 56 : if(!GetWord(cnt)) return kFALSE;
295 56 : cnt--;
296 :
297 :
298 448 : while (cnt>20) { //counter limit is changed from 0 to 20 to take into account (skipp) the 5 extra words in the equipment header
299 168 : nwSeg = (fWord >> kbit8) & 0xfff;
300 168 : if(!CheckSegment()) return kFALSE;
301 168 : if(!ReadSegment(cntSegment)) return kFALSE;
302 :
303 168 : if(nwSeg != cntSegment) {AliDebug(1,Form("Error in Segment counters: %i different wrt %i",nwSeg,cntSegment)); return kFALSE;}
304 168 : if(!GetWord(cntSegment+1,kBwd)) return kFALSE;
305 168 : cnt-=cntSegment+1;
306 : }
307 :
308 56 : return kTRUE;
309 :
310 112 : }
311 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
312 : Bool_t AliHMPIDRawStream::ReadSegment(Int_t &cntSegment)
313 : {
314 : //Read the segment
315 : //It returns: kFALSE if any error occurs
316 : // kTRUE if all OK
317 336 : cntSegment = (fWord >> kbit8) & 0xfff;
318 : Int_t cnt = cntSegment;
319 : Int_t cntRow;
320 168 : Int_t nwRow;
321 :
322 168 : if(!GetWord(cnt,kBwd)) return kFALSE;
323 :
324 2856 : while (cnt>0) {
325 :
326 1344 : cntRow = (fWord >> kbit16) & 0xfff;
327 1344 : if(!CheckRowMarker()) return kFALSE;
328 1344 : if(!ReadRow(nwRow)) return kFALSE;
329 :
330 1344 : if(nwRow != cntRow) {AliDebug(1,Form("Error in Row counters: %i different wrt %i",nwRow,cntRow)); return kFALSE;}
331 1344 : if(!GetWord(cntRow+1)) return kFALSE;
332 1344 : cnt -= cntRow+1;
333 :
334 : }
335 :
336 168 : cntSegment -= cnt;
337 :
338 168 : return kTRUE;
339 :
340 168 : }
341 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
342 : Bool_t AliHMPIDRawStream::ReadRow(Int_t &cntRow)
343 : {
344 : // Read the row
345 : //It returns: kFALSE if any error occurs
346 : // kTRUE if all OK
347 :
348 : Int_t cnt;
349 2688 : Int_t cntDilogic;
350 1344 : Int_t nwDil;
351 :
352 1344 : cntRow = (fWord >> kbit16) & 0xfff;
353 : cnt = cntRow;
354 :
355 1344 : if(!GetWord(cntRow)) return kFALSE;
356 :
357 28224 : while (cnt>0) {
358 :
359 13440 : if(!CheckEoE(nwDil)) return kFALSE;
360 13440 : if(!ReadDilogic(cntDilogic)) return kFALSE;
361 :
362 13440 : if(nwDil != cntDilogic) {AliDebug(1,Form("Error in Dilogic counters: %i different wrt %i",nwDil,cntDilogic));return kFALSE;}
363 13440 : cnt -= cntDilogic;
364 13440 : if(!GetWord(1,kBwd)) return kFALSE; // go to next Dilogic bank...
365 13440 : cnt--;
366 : // Printf(" cnt %i cntDilogic %i ",cnt,cntDilogic);
367 : }
368 :
369 1344 : cntRow -= cnt;
370 :
371 1344 : return kTRUE;
372 :
373 1344 : }
374 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
375 : Bool_t AliHMPIDRawStream::ReadDilogic(Int_t &cntDilogic)
376 : {
377 : // Read the dilogic bank
378 : //It returns: kFALSE if any error occurs
379 : // kTRUE if all OK
380 :
381 26880 : cntDilogic = fWord & 0x7f;
382 :
383 : Int_t cnt = cntDilogic;
384 :
385 : // Printf(" cnt DILOGIC %i at %i word %08X",cnt,fPosition,fWord);
386 :
387 41382 : for(Int_t iDil=0;iDil<cntDilogic;iDil++) {
388 : UInt_t dilogic = 0, row = 0;
389 531 : if(!GetWord(1,kBwd)) return kFALSE;
390 : //check on row number
391 531 : cnt--;
392 531 : row = (fWord >> kbit22) & 0x1f;
393 531 : if(!CheckRow(row)) continue;
394 : //check dilogic number
395 531 : dilogic = (fWord >> kbit18) & 0xf; //dilogic info in raw word is between bits: 18...21
396 531 : if(!CheckDilogic(dilogic)) continue;
397 : //check pad number
398 531 : UInt_t pad = (fWord >> kbit12) & 0x3f; //pad info in raw word is between bits: 12...17
399 531 : if(!CheckPad(pad)) continue;
400 531 : Int_t charge = fWord & 0xfff;
401 531 : if(GetPad(fDDLNumber,row,dilogic,pad)<0) continue;
402 531 : fPad[fNPads] = GetPad(fDDLNumber,row,dilogic,pad);
403 531 : fCharge[fNPads] = charge;
404 531 : fNPads++;
405 :
406 531 : if(charge==0)
407 : {
408 24 : AliDebug(1,Form("If PEDESTAL run -> WARNING: ZERO charge is read from DDL: %d row: %d dil: %d pad: %d",fDDLNumber,row,dilogic,pad));
409 8 : fNumOfErr[fDDLNumber][kPedQZero]++;
410 8 : }
411 :
412 531 : }//iDil
413 :
414 13440 : cntDilogic -= cnt;
415 13440 : return kTRUE;
416 13440 : }
417 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
418 : Bool_t AliHMPIDRawStream::CheckSegment()
419 : {
420 : // Check the segment marker
421 : //It returns: kFALSE if any error occurs
422 : // kTRUE if all OK
423 :
424 : UInt_t markSegment = 0xAB0;
425 : /*
426 : if (iRow%8 == 0) {
427 : UInt_t segWord = GetWord();
428 : if ((segWord >> 20) != statusSegWord) {
429 : fRawReader->AddMajorErrorLog(kBadSegWordErr);
430 : AliDebug(1,Form("Wrong segment word signature: %x, expected 0xab0!",(segWord >> 20)));
431 : fNumOfErr[kBadSegWordErr]++;
432 : return kTRUE;
433 : }
434 : */
435 336 : UInt_t segMarker = (fWord >> kbit20) & 0xfff;
436 168 : if (segMarker != markSegment ) {
437 : //fRawReader->AddMajorErrorLog(kWrongSegErr,Form("Segment marker %0X wrong (expected %0X) at %i in word %0X!",segMarker,markSegment,fPosition,fWord));
438 0 : AliDebug(1,Form("Segment marker %X wrong (expected %0X)! at %i in word %0X!",segMarker,markSegment,fPosition,fWord));
439 0 : fNumOfErr[fDDLNumber][kWrongSegErr]++;
440 0 : return kFALSE;
441 : }
442 :
443 168 : UInt_t segAddress = fWord & 0xff;
444 168 : if (segAddress<1 ||segAddress>3) {
445 : //fRawReader->AddMajorErrorLog(kWrongSegErr,Form("Segment address %d not in the valid range [1-3] at %i in word %0X",segAddress,fPosition,fWord));
446 0 : AliDebug(1,Form("Segment address %d not in the valid range [1-3]",segAddress));
447 0 : fNumOfErr[fDDLNumber][kWrongSegErr]++;
448 0 : return kFALSE;
449 : }
450 : // Printf("Segment Marker found at %i! Number of segment is %i",fPosition,segAddress);
451 168 : return kTRUE;
452 168 : }
453 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
454 : Bool_t AliHMPIDRawStream::CheckRow(UInt_t row)
455 : {
456 : //check on row number
457 : //It returns: kFALSE if any error occurs
458 : // kTRUE if all OK
459 : // Printf("ROW %i word %0X",row,fWord);
460 1593 : if(row>=1 && row <=kNRows) return kTRUE;
461 :
462 : //fRawReader->AddMajorErrorLog(kWrongRowErr,Form("row %d",row));
463 0 : AliDebug(1,Form("Wrong row index: %d, expected (1 -> %d) word %0X at %i...",row,kNRows,fWord,fPosition));
464 0 : fNumOfErr[fDDLNumber][kWrongRowErr]++;
465 0 : return kFALSE;
466 531 : }
467 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
468 : Bool_t AliHMPIDRawStream::CheckDilogic(UInt_t dilogic)
469 : {
470 : //check dilogic number
471 : //It returns: kFALSE if any error occurs
472 : // kTRUE if all OK
473 1593 : if (dilogic>= 1 && dilogic <=kNDILOGICAdd) return kTRUE;
474 :
475 : //fRawReader->AddMajorErrorLog(kWrongDilogicErr,Form("dil %d",dilogic));
476 0 : AliDebug(1,Form("Wrong DILOGIC index: %d, expected (1 -> %d)!",dilogic,kNDILOGICAdd));
477 0 : fNumOfErr[fDDLNumber][kWrongDilogicErr]++;
478 : //dilogic = iDILOGIC;
479 0 : return kFALSE;
480 531 : }
481 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
482 : Bool_t AliHMPIDRawStream::CheckPad(UInt_t pad)
483 : {
484 : //check pad number
485 : //It returns: kFALSE if any error occurs
486 : // kTRUE if all OK
487 1593 : if (pad < kNPadAdd) return kTRUE;
488 :
489 : //fRawReader->AddMajorErrorLog(kWrongPadErr,Form("pad %d",pad));
490 0 : AliDebug(1,Form("Wrong pad index: %d, expected (0 -> %d)!",pad,kNPadAdd));
491 0 : fNumOfErr[fDDLNumber][kWrongPadErr]++;
492 0 : return kFALSE;
493 531 : }
494 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
495 : Bool_t AliHMPIDRawStream::CheckEoE(Int_t &nDil)
496 : {
497 : //check the End of Event
498 : //It returns: kFALSE if any error occurs
499 : // kTRUE if all OK
500 26880 : if (!((fWord >> kbit27) & 0x1)) { //check 27th bit in EoE. It must be 1!
501 : //fRawReader->AddMajorErrorLog(kEoEFlagErr);
502 0 : AliDebug(1,Form("Missing end-of-event flag! (%08X) at %i",fWord,fPosition));
503 0 : fNumOfErr[fDDLNumber][kEoEFlagErr]++;
504 0 : return kFALSE;
505 : }
506 13440 : nDil = fWord & 0x7f; //nDil=EoE word count
507 26880 : if(nDil < 0 || nDil > 48 ) {
508 :
509 : //fRawReader->AddMajorErrorLog(kEoESizeErr,Form("EoE size=%d",nDil));
510 0 : AliDebug(1,Form("Wrong end-of-event word-count: %08X",fWord));
511 0 : fNumOfErr[fDDLNumber][kEoESizeErr]++;
512 0 : return kFALSE;
513 : }
514 : // UInt_t da = (eOfEvent >> 18) & 0xf;
515 : // if (cntData!=0 && da != dilogic) {
516 : // fRawReader->AddMajorErrorLog(kEoEDILOGICErr,Form("eoe dil %d != %d",da,dilogic));
517 : // AliDebug(1,Form("Wrong DILOGIC address found in end-of-event: %d, expected %d!",da,dilogic));
518 : // fNumOfErr[kEoEDILOGICErr]++;
519 : // return kFALSE; AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, obj) ;
520 :
521 : // }
522 : // UInt_t ca = (eOfEvent >> 22) & 0x1f;
523 : // if (cntData!=0 && ca != row) {
524 : // fRawReader->AddMajorErrorLog(kEoERowErr,Form("eoe row %d != %d",ca,row));
525 : // AliDebug(1,Form("Wrong row index found in end-of-event: %d, expected %d!",ca,row));
526 : // fNumOfErr[kEoERowErr]++;
527 : // return kFALSE;
528 : // }
529 13440 : return kTRUE;
530 13440 : }
531 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
532 : Bool_t AliHMPIDRawStream::CheckRowMarker()
533 : {
534 : //check the row marker
535 : //It returns: kFALSE if any error occurs
536 : // kTRUE if all OK
537 : UInt_t nMAXwordsInRow = 0x1EA;
538 : UInt_t statusControlRow = 0x32a8; // 0x36a8 for zero suppression
539 : //First check on row marker
540 2688 : UInt_t rowControlWord = fWord >> kbit0 & 0xfbff;
541 :
542 1344 : if(rowControlWord != statusControlRow) {
543 : //fRawReader->AddMajorErrorLog(kRowMarkerErr);
544 0 : AliDebug(1,Form("Wrong row marker %x expected 0x32a8!",rowControlWord));
545 0 : fNumOfErr[fDDLNumber][kRowMarkerErr]++;
546 0 : return kFALSE;
547 : }
548 : //Second check on row marker
549 1344 : UInt_t wordsInRow = fWord >> kbit16 & 0x0fff; // Number of words after the row marker, bit 10 is skipped in this check
550 :
551 1344 : if (wordsInRow > nMAXwordsInRow) {
552 : //fRawReader->AddMajorErrorLog(kRowMarkerSizeErr);
553 0 : AliDebug(1,Form(" FATAL: Number of words %x in a row exceeds the expected value: 0x1EA !",wordsInRow));
554 0 : fNumOfErr[fDDLNumber][kRowMarkerSizeErr]++;
555 0 : return kFALSE;
556 : }
557 :
558 1344 : return kTRUE;
559 1344 : }
560 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
561 : Bool_t AliHMPIDRawStream::GetWord(Int_t n,EDirection dir)
562 : {
563 : // This method returns the n-th 32 bit word
564 : // inside the raw data payload.
565 : // The method is supposed to be endian (platform)
566 : // independent.
567 :
568 34102 : fWord = 0;
569 17051 : if (fPosition < 0) {
570 0 : AliError("fPosition < 0 !!! Event skipped.");
571 0 : fRawReader->AddMajorErrorLog(kRawDataSizeErr,"fPosition<0");
572 0 : return kFALSE;
573 : }
574 :
575 31358 : if(dir==kBwd) n = -n;
576 17051 : fPosition+=4*n-4;
577 :
578 17051 : if(fPosition==-4) return kTRUE;
579 :
580 34102 : if(fPosition<0 || fPosition > fRawReader->GetDataSize()) {
581 0 : AliWarning(Form("fPosition out of boundaries %i",fPosition));
582 0 : return kFALSE;
583 : }
584 :
585 17051 : StorePosition();
586 :
587 17051 : fWord |= fData[fPosition++];
588 17051 : fWord |= fData[fPosition++] << 8;
589 17051 : fWord |= fData[fPosition++] << 16;
590 17051 : fWord |= fData[fPosition++] << 24;
591 :
592 17051 : return kTRUE;
593 17051 : }
594 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
595 : void AliHMPIDRawStream::DumpData(Int_t nw)
596 : {
597 : //just a simple raw data dump
598 : // in () is the position in bytes
599 : //--
600 0 : for(Int_t i=0;i<nw;i+=4) {
601 0 : if(!(i%16)) printf(" \n %8i) ",i);
602 0 : printf("%02X%02X%02X%02X [ %06i ] ",fData[i+3],fData[i+2],fData[i+1],fData[i+0],fPos[i]);
603 : }
604 0 : Printf(" \n -----end of dump ----------- ");
605 0 : }
606 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
607 : void AliHMPIDRawStream::StorePosition()
608 : {
609 : //just for debug purpose
610 : // it stores the position
611 : //read for the first time
612 : // Printf("@@@@@@@@@ fPos: %x fPosition: %d",fPos,fPosition);
613 34102 : if(fPos[fPosition]!=0) {
614 : // Printf("Position already stored!!! Value %i at address %i",fPos[fPosition],fPosition);
615 : return;
616 : }
617 15539 : fiPos++;
618 15539 : fPos[fPosition] = fiPos;
619 : // if(stDeb)Printf("%i - Actual position %i",iPos,fPosition);
620 32590 : }
621 : //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
