]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ZDC/AliZDCRawStream.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Error in EMD run types corrected
[u/mrichter/AliRoot.git] / ZDC / AliZDCRawStream.cxx
CommitLineData
8309c1ab 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
18///////////////////////////////////////////////////////////////////////////////
83347831 19// //
20// This class provides access to ZDC digits in raw data. //
21// //
22// It loops over all ZDC digits in the raw data given by the AliRawReader. //
23// The Next method goes to the next digit. If there are no digits left //
24// it returns kFALSE. //
25// Getters provide information about the current digit. //
26// //
8309c1ab 27///////////////////////////////////////////////////////////////////////////////
28
11b06725 29#include <TSystem.h>
8309c1ab 30#include "AliZDCRawStream.h"
31#include "AliRawReader.h"
1ee299a5 32#include "AliRawDataHeader.h"
33#include "AliRawEventHeaderBase.h"
cc2abffd 34#include "AliLog.h"
8309c1ab 35
36ClassImp(AliZDCRawStream)
37
38
39//_____________________________________________________________________________
40AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
41 fRawReader(rawReader),
1ee299a5 42 fBuffer(0),
43 fEvType(0),
44 fPosition(0),
45 fIsCalib(kFALSE),
46 fIsDARCHeader(kFALSE),
47 fIsChMapping(kFALSE),
48 fIsADCDataWord(kFALSE),
49 fIsADCHeader(kFALSE),
50 fIsADCEOB(kFALSE),
51 fDARCEvBlockLenght(0),
52 fDARCBlockAttributes(0),
53 fDeadfaceOffset(0),
54 fDeadbeefOffset(0),
55 fDataOffset(0),
56 fModType(-1),
57 fADCModule(-1),
58 fADCNChannels(-1),
786b72f5 59 fADCChannel(-1),
cc2abffd 60 fADCValue(-1),
1ee299a5 61 fADCGain(-1),
62 fNConnCh(-1),
63 fCabledSignal(-1)
8309c1ab 64{
abf60186 65 // Create an object to read ZDC raw digits
1ee299a5 66 fRawReader->Reset();
362c9d61 67 fRawReader->Select("ZDC");
1ee299a5 68 //
69 for(Int_t i=0; i<48; i++){
c93c022b 70 for(Int_t j=0; j<5; j++) fMapADC[i][j]=-1;
1ee299a5 71 }
72
8309c1ab 73}
74
75//_____________________________________________________________________________
76AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
a718c993 77 TObject(stream),
c61a7285 78 fRawReader(stream.fRawReader),
1ee299a5 79 fBuffer(stream.GetRawBuffer()),
80 fEvType(stream.fEvType),
81 fPosition(stream.fPosition),
82 fIsCalib(stream.fIsCalib),
83 fIsDARCHeader(stream.fIsDARCHeader),
84 fIsChMapping(stream.fIsChMapping),
85 fIsADCDataWord(stream.fIsADCDataWord),
86 fIsADCHeader(stream.fIsADCHeader),
87 fIsADCEOB(stream.fIsADCEOB),
88 fDARCEvBlockLenght(stream.fDARCEvBlockLenght),
89 fDARCBlockAttributes(stream.fDARCBlockAttributes),
90 fDeadfaceOffset(stream.GetDeadfaceOffset()),
91 fDeadbeefOffset(stream.GetDeadbeefOffset()),
92 fDataOffset(stream.GetDataOffset()),
93 fModType(stream.GetModType()),
a718c993 94 fADCModule(stream.GetADCModule()),
1ee299a5 95 fADCNChannels(stream.GetADCNChannels()),
a718c993 96 fADCChannel(stream.GetADCChannel()),
97 fADCValue(stream.GetADCValue()),
98 fADCGain(stream.GetADCGain()),
1ee299a5 99 fNConnCh(stream.fNConnCh),
100 fCabledSignal(stream.GetCabledSignal())
8309c1ab 101{
abf60186 102 // Copy constructor
c0aec6f6 103 for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j);
1ee299a5 104 for(Int_t i=0; i<48; i++){
c93c022b 105 for(Int_t j=0; j<5; j++) fMapADC[i][j] = stream.fMapADC[i][j];
1ee299a5 106 }
8309c1ab 107}
108
109//_____________________________________________________________________________
110AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream&
111 /* stream */)
112{
abf60186 113 // Assignment operator
8309c1ab 114 Fatal("operator =", "assignment operator not implemented");
115 return *this;
116}
117
118//_____________________________________________________________________________
119AliZDCRawStream::~AliZDCRawStream()
120{
abf60186 121// Destructor
8309c1ab 122
123}
124
c93c022b 125//_____________________________________________________________________________
126void AliZDCRawStream::ReadChMap()
127{
128 // Reading channel map
129}
130
1ee299a5 131//_____________________________________________________________________________
132void AliZDCRawStream::ReadCDHHeader()
133{
134 // Reading CDH
135 const AliRawDataHeader* header = fRawReader->GetDataHeader();
136 if(!header) {
137 AliError("\t No CDH in raw data streaming\n");
138 fRawReader->AddMajorErrorLog(kCDHError);
139 //
140 // For the moment to debug the classe the event is read
141 // also if the CDH is not present in the data buffer
142 // ******* TO BE CHANGED!!! ***************************
143 //return;
144 }
145 else{
146 //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %d\n",fRawReader->GetDataSize());
147
148 fDARCEvBlockLenght = header->fSize;
149 //printf("\t AliZDCRawStream::ReadCDHHeader -> fDARCEvBlockLenght = %d\n",fDARCEvBlockLenght);
150
151 //UChar_t message = header->GetAttributes();
152 //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
153
154 /*if(message & 0x10){ // COSMIC RUN
155 printf("\t STANDALONE_COSMIC RUN raw data found\n");
156 }
157 else if(message & 0x20){ // PEDESTAL RUN
158 printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
159 }
160 else if(message & 0x30){ // LASER RUN
161 printf("\t STANDALONE_LASER RUN raw data found\n");
162 }*/
163
164 if(header->GetL1TriggerMessage() & 0x1){ // Calibration bit set in CDH
165 fIsCalib = kTRUE;
166 }
167 //printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
c93c022b 168 //printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);
1ee299a5 169
170 UInt_t status = header->GetStatus();
171 //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status);
172 if(status & 0x000f == 0x0001){
173 AliWarning("CDH -> DARC trg0 overlap error\n");
174 fRawReader->AddMajorErrorLog(kDARCError);
175 }
176 if(status & 0x000f == 0x0002){
177 AliWarning("CDH -> DARC trg0 missing error\n");
178 fRawReader->AddMajorErrorLog(kDARCError);
179 }
180 if(status & 0x000f == 0x0004){
181 AliWarning("CDH -> DARC data parity error\n");
182 fRawReader->AddMajorErrorLog(kDARCError);
183 }
184 if(status & 0x000f == 0x0008){
185 AliWarning("CDH -> DARC ctrl parity error\n");
186 fRawReader->AddMajorErrorLog(kDARCError);
187 }
188 //
189 if(status & 0x00f0 == 0x0010){
190 AliWarning("CDH -> DARC trg unavailable\n");
191 fRawReader->AddMajorErrorLog(kDARCError);
192 }
193 if(status & 0x00f0 == 0x0020){
194 AliWarning("CDH -> DARC FEE error\n");
195 fRawReader->AddMajorErrorLog(kDARCError);
196 }
197 //
198 if(status & 0x0f00 == 0x0200){
199 AliWarning("CDH -> DARC L1 time violation\n");
200 fRawReader->AddMajorErrorLog(kDARCError);
201 }
202 if(status & 0x0f00 == 0x0400){
203 AliWarning("CDH -> DARC L2 time-out\n");
204 fRawReader->AddMajorErrorLog(kDARCError);
205 }
206 if(status & 0x0f00 == 0x0800){
207 AliWarning("CDH -> DARC prepulse time violation\n");
208 fRawReader->AddMajorErrorLog(kDARCError);
209 }
210 //
211 if(status & 0xf000 == 0x1000){
212 AliWarning("CDH -> DARC other error\n");
213 fRawReader->AddMajorErrorLog(kDARCError);
214 }
215 }
216 //
217 fIsDARCHeader = kTRUE;
218}
219
8309c1ab 220
221//_____________________________________________________________________________
222Bool_t AliZDCRawStream::Next()
223{
abf60186 224 // Read the next raw digit
225 // Returns kFALSE if there is no digit left
8309c1ab 226
1ee299a5 227 if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
228 fIsChMapping = kFALSE; fIsADCHeader = kFALSE;
229 fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
230
231 fEvType = fRawReader->GetType();
232 //printf("\n\t AliZDCRawStream::Next() -> ev. type %d\n",fEvType);
233
234 if(fPosition==0){
235 //if(fEvType==7 || fEvType ==8){ //Physics or calibration event
236 //ReadEventHeader();
237 ReadCDHHeader();
238 //}
239 fNConnCh=0;
240 }
241 //printf("\n AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
242
243 // -------------------------------------------
1069e28d 244 // --- DARC header
1ee299a5 245 // -------------------------------------------
246 if(fIsDARCHeader){
84d2abc2 247 //printf("\t ---- DARC header ----\n");
1ee299a5 248 if(fIsCalib){
249 fDeadfaceOffset = 9;
250 fDeadbeefOffset = 25;
251 }
252 else{
253 fDeadfaceOffset = 1;
254 fDeadbeefOffset = 7;
255 }
256 fDataOffset = 1+fDeadbeefOffset;
257 fIsDARCHeader = kFALSE;
abf60186 258 }
1ee299a5 259
260
261 // -------------------------------------------
262 // --- Start of data event
263 // --- decoding mapping of connected ADC ch.
264 // -------------------------------------------
265 if(fEvType==10){
266 if(fPosition>fDataOffset){
267 if((fBuffer&0xff000000) == 0xff000000){
268 if(fPosition==(fDataOffset+1)){
269 printf("\n\n\t Reading ZDC mapping from StartOfData event\n");
270 fNConnCh=0;
6006df88 271 }
1ee299a5 272 else{
84d2abc2 273 //printf("\n\t End of StartOfData event\n\n");
1ee299a5 274 return kTRUE;
275 }
276 }
277 else if((fBuffer&0x80000000)>>31 == 1){
278 // Mapping identification
279 fADCModule = ((fBuffer & 0x7f000000)>>24);
280 fModType = ((fBuffer & 0xfff000)>>8);
281 fADCNChannels = (fBuffer & 0xff);
282 //
283 //printf("\tGEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
6006df88 284 }
1ee299a5 285 else if(fModType==0 && (fBuffer&0x80000000)>>31 == 0){
286 // Channel signal
287 if((fBuffer&0x40000000)>>30==0){ // high range chain ADC
288 fIsChMapping = kTRUE;
289 fADCChannel = ((fBuffer & 0x3fff0000)>>16);
290 fCabledSignal = (fBuffer&0xffff);
291 fMapADC[fNConnCh][0] = fADCModule;
292 fMapADC[fNConnCh][1] = fADCChannel;
293 fMapADC[fNConnCh][2] = fCabledSignal;
c93c022b 294 //
295 // Determining detector and sector
296 // -----------------------------------------
297 // For the decoding of the following lines
298 // look the enum in AliZDCRawStream.h file
299 // -----------------------------------------
300 if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
301 || fCabledSignal==24 || fCabledSignal==48){
c677d80e 302 fMapADC[fNConnCh][3] = 4; //ZNA
c93c022b 303 //
304 if(fCabledSignal==2 || fCabledSignal==26) fMapADC[fNConnCh][4]=0;
305 else if(fCabledSignal==3 || fCabledSignal==27) fMapADC[fNConnCh][4]=1;
306 else if(fCabledSignal==4 || fCabledSignal==28) fMapADC[fNConnCh][4]=2;
307 else if(fCabledSignal==5 || fCabledSignal==29) fMapADC[fNConnCh][4]=3;
308 else if(fCabledSignal==6 || fCabledSignal==30) fMapADC[fNConnCh][4]=4;
309 else if(fCabledSignal==24 || fCabledSignal==48) fMapADC[fNConnCh][4]=5;
310 }
311 else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
c677d80e 312 fMapADC[fNConnCh][3] = 5; //ZPA
c93c022b 313 //
314 if(fCabledSignal==7 || fCabledSignal==31) fMapADC[fNConnCh][4]=0;
315 else if(fCabledSignal==8 || fCabledSignal==32) fMapADC[fNConnCh][4]=1;
316 else if(fCabledSignal==9 || fCabledSignal==33) fMapADC[fNConnCh][4]=2;
317 else if(fCabledSignal==10 || fCabledSignal==34) fMapADC[fNConnCh][4]=3;
318 else if(fCabledSignal==11 || fCabledSignal==35) fMapADC[fNConnCh][4]=4;
319 }
320 else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
321 || fCabledSignal==25 || fCabledSignal==49){
c677d80e 322 fMapADC[fNConnCh][3] = 1; //ZNC
c93c022b 323 //
324 if(fCabledSignal==12 || fCabledSignal==36) fMapADC[fNConnCh][4]=0;
325 else if(fCabledSignal==13 || fCabledSignal==37) fMapADC[fNConnCh][4]=1;
326 else if(fCabledSignal==14 || fCabledSignal==38) fMapADC[fNConnCh][4]=2;
327 else if(fCabledSignal==15 || fCabledSignal==39) fMapADC[fNConnCh][4]=3;
328 else if(fCabledSignal==16 || fCabledSignal==40) fMapADC[fNConnCh][4]=4;
329 else if(fCabledSignal==25 || fCabledSignal==49) fMapADC[fNConnCh][4]=5;
330 }
331 else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
c677d80e 332 fMapADC[fNConnCh][3] = 2; //ZPC
c93c022b 333 //
334 if(fCabledSignal==17 || fCabledSignal==41) fMapADC[fNConnCh][4]=0;
335 else if(fCabledSignal==18 || fCabledSignal==42) fMapADC[fNConnCh][4]=1;
336 else if(fCabledSignal==19 || fCabledSignal==43) fMapADC[fNConnCh][4]=2;
337 else if(fCabledSignal==20 || fCabledSignal==44) fMapADC[fNConnCh][4]=3;
338 else if(fCabledSignal==21 || fCabledSignal==45) fMapADC[fNConnCh][4]=4;
339 }
340 else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
c677d80e 341 fMapADC[fNConnCh][3] = 3;
c93c022b 342 //
343 if(fCabledSignal==22 || fCabledSignal==46) fMapADC[fNConnCh][4]=1;
344 else if(fCabledSignal==23 || fCabledSignal==47) fMapADC[fNConnCh][4]=2;
345 }
346 //
347 //printf("AliZDCRawStream -> datum %d mod. %d ch. %d signal %d, det %d, tow %d\n",
348 // fNConnCh,fADCModule,fADCChannel,fBuffer&0xffff,fMapADC[fNConnCh][3],fMapADC[fNConnCh][4]);
1ee299a5 349 //
350 fNConnCh++;
351 if(fNConnCh>48){
352 // Protection manually set since it returns:
353 // RawData48 mod. 3 ch. 2048 signal 515
354 // to be checked with Pietro!!!!!!!!!!!!!!!!!!!!!!!
355 AliWarning("\t AliZDCRawStream -> ERROR: no. of cabled channels > 48!!!\n");
356 return kFALSE;
357 }
358 }
1069e28d 359 }
1ee299a5 360 }
361 fPosition++;
362 return kTRUE;
363 }
364
365 // -------------------------------------------
366 // --- DARC data
367 // -------------------------------------------
368 if(fPosition<fDeadfaceOffset){
369 fPosition++;
370 return kTRUE;
371 }
372 else if(fPosition==fDeadfaceOffset){
373 if(fBuffer != 0xdeadface){
374 AliWarning("AliZDCRawStream -> NO deadface after DARC data\n");
375 fRawReader->AddMajorErrorLog(kDARCError);
376 }
377 else{
378 fPosition++;
379 return kTRUE;
380 }
381 }
382
383 // -------------------------------------------
384 // --- DARC global data
385 // -------------------------------------------
386 else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset){
387 fPosition++;
388 return kTRUE;
389 }
390 else if(fPosition==fDeadbeefOffset){
391 if(fBuffer != 0xdeadbeef){
392 AliWarning("AliZDCRawStream -> NO deadbeef after DARC global data\n");
393 fRawReader->AddMajorErrorLog(kDARCError);
394 }
395 else{
396 fPosition++;
397 return kTRUE;
398 }
399 }
400
401 // -------------------------------------------
402 // --- ZDC data
403 // --- ADC buffer + scaler
404 // -------------------------------------------
405 else if(fPosition>=fDataOffset){
406
407 // Not valid datum before the event
408 // there MUST be a NOT valid datum before the event!!!
409 if(fPosition==fDataOffset){
84d2abc2 410 //printf("\t **** ZDC data begin ****\n");
1ee299a5 411 if((fBuffer & 0x07000000) == 0x06000000){
412 //printf(" AliZDCRawStream -> Not valid datum in ADC %d,"
413 // "position %d in word data buffer\n",fADCModule,fPosition);
414 }
415 else fRawReader->AddMajorErrorLog(kZDCDataError);
416 }
417
418 // If the not valid datum isn't followed by the 1st ADC header
419 // the event is corrupted (i.e., 2 gates arrived before trigger)
420 else if(fPosition==fDataOffset+1){
421 if((fBuffer & 0x07000000) != 0x02000000){
422 AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!\n");
423 fRawReader->AddMajorErrorLog(kZDCDataError);
424 }
425 }
426
427 // Get geo address of current word to determine
428 // if it is a scaler word (geo address == kScalerAddress)
429 // if it is an ADC word (geo address != 8)
430 Int_t kScalerAddress=8;
431 fADCModule = ((fBuffer & 0xf8000000)>>27);
432 if(fADCModule == kScalerAddress){
433 DecodeScaler();
434 }
435 else{//ADC module
436 // *** End of event
437 if(fBuffer == 0xcafefade){
84d2abc2 438 //printf(" AliZDCRawStream -> End of ZDC event!\n");
1ee299a5 439 }
440 // *** ADC header
441 else if((fBuffer & 0x07000000) == 0x02000000){
442 fIsADCHeader = kTRUE;
443 fADCNChannels = ((fBuffer & 0x00003f00)>>8);
84d2abc2 444 //printf(" AliZDCRawStream -> HEADER: ADC mod.%d has %d ch. \n",fADCModule,fADCNChannels);
1ee299a5 445 }
446 // *** ADC data word
447 else if((fBuffer & 0x07000000) == 0x00000000){
448 fIsADCDataWord = kTRUE;
449 fADCChannel = ((fBuffer & 0x1e0000) >> 17);
450 fADCGain = ((fBuffer & 0x10000) >> 16);
451 fADCValue = (fBuffer & 0xfff);
452
84d2abc2 453 //printf(" AliZDCRawStream -> DATA: ADC mod. %d ch. %d gain %d value %d\n",
454 // fADCModule,fADCChannel,fADCGain,fADCValue);
1ee299a5 455
456 // Valid ADC data (not underflow nor overflow)
457 if(!(fBuffer & 0x1000) && !(fBuffer & 0x2000)){
c93c022b 458
459 // Checking if the channel map for the ADCs has been provided/read
460 if(fMapADC[0][0]==-1){
11b06725 461 // Temporary solution (to be changed!!!!)
462 //printf("\t ATTENTION!!! No ADC mapping has been found/provided!!!\n");
463 //return kFALSE;
464 char * mapFileName=gSystem->ExpandPathName("$ALICE_ROOT/ZDC/ShuttleInput/ZDCChMapping.dat");
465 FILE *file;
466 Int_t ival[48][6];
467 if((file = fopen(mapFileName,"r")) != NULL){
468 for(Int_t j=0; j<48; j++){
469 for(Int_t k=0; k<6; k++){
470 fscanf(file,"%d",&ival[j][k]);
471 }
472 fMapADC[j][0] = ival[j][1];
473 fMapADC[j][1] = ival[j][2];
474 fMapADC[j][2] = ival[j][3];
475 fMapADC[j][3] = ival[j][4];
476 fMapADC[j][4] = ival[j][5];
477 }
478 }
479 else{
480 printf("File %s not found\n",mapFileName);
481 return kFALSE;
482 }
483
c93c022b 484 }
485 //
486 //printf("\n Reading map!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
487 /*for(Int_t ci=0; ci<48; ci++){
488 printf(" %d mod. %d ch. %d signal %d\n",ci,fMapADC[ci][0],
489 fMapADC[ci][1], fMapADC[ci][2]);
490 }
491 */
1ee299a5 492 for(Int_t k=0; k<48; k++){
c93c022b 493 if(fADCModule==fMapADC[k][0] && fADCChannel==fMapADC[k][1]){
494 fSector[0] = fMapADC[k][3];
495 fSector[1] = fMapADC[k][4];
1ee299a5 496 break;
497 }
498 }
1ee299a5 499 //
c93c022b 500 //printf("AliZDCRawStream -> ADCmod. %d ADCch %d det %d, sec %d\n",
501 // fADCModule,fADCChannel,fSector[0],fSector[1]);
1ee299a5 502
503 if(fADCModule<0 || fADCModule>3){
504 AliWarning(Form(" AliZDCRawStream -> No valid ADC module: %d\n",fADCModule));
505 fRawReader->AddMajorErrorLog(kInvalidADCModule);
506 }
507
508 }//No underflow nor overflow
509 }//ADC data word
510 // *** ADC EOB
511 else if((fBuffer & 0x07000000) == 0x04000000){
512 fIsADCEOB = kTRUE;
513 //printf(" AliZDCRawStream -> EOB --------------------------\n");
514 }
515 }//ADC module
516
517
518 }
519 fPosition++;
83347831 520
8309c1ab 521 return kTRUE;
522}