ZDC/AliZDCRawStream.cxx

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